Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Support ordered profile fillet chains and loops

Yuechen Lid1d375ebf031
diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.cs
index cc1d1922..56438466 100644
--- a/Aetheris.CLI/CliRunner.cs
+++ b/Aetheris.CLI/CliRunner.cs
@@ -3228,7 +3228,7 @@ public static class CliRunner
string Classification, bool SelectedByEdgeFinish, IReadOnlyList<string> GeneratedDescendants);
private sealed record ProfileStraightEdgeFilletInspection(
- bool Succeeded, string? Diagnostic, string? EdgeFinishId, string? ProfileId, string? LoopId, string? SegmentId,
+ bool Succeeded, string? Diagnostic, string? EdgeFinishId, string? ProfileId, string? LoopId, string? TargetKind, IReadOnlyList<string> SegmentIds,
string? Side, double? Radius, double? EndClearance, string? EndpointPolicy,
double[]? CylinderAxis, double[]? CylinderCenterlineStart, double[]? CylinderCenterlineEnd,
double[]? CapContactStart, double[]? CapContactEnd, double[]? SideContactStart, double[]? SideContactEnd,
@@ -3238,14 +3238,14 @@ public static class CliRunner
{
if (!ProfileBoundaryChamferSourceBinder.HasProfileBoundaryFillet(source)) return null;
if (!ProfileBoundaryChamferSourceBinder.TryBindFillet(source, profile, hostBodyId, out var target, out var radius, out var clearance, out var diagnostic))
- return new(false, diagnostic, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, "RejectedBeforePlan", [], []);
+ return new(false, diagnostic, null, null, null, null, [], null, null, null, null, null, null, null, null, null, null, null, "RejectedBeforePlan", [], []);
var result = ProfileStraightEdgeFilletPlanner.TryPlan(profile, target!, radius, clearance);
if (!result.Succeeded || result.Plan is null)
- return new(false, result.Diagnostics.FirstOrDefault(), target!.StableId, target.ProfileId, target.LoopId, target.SegmentIds.Single(), target.Side.ToString(), radius, clearance, null, null, null, null, null, null, null, null, "RejectedBeforeTopology", [], []);
+ return new(false, result.Diagnostics.FirstOrDefault(), target!.StableId, target.ProfileId, target.LoopId, target.ChainKind.ToString(), target.SegmentIds, target.Side.ToString(), radius, clearance, null, null, null, null, null, null, null, null, "RejectedBeforeTopology", [], []);
var plan = result.Plan;
static double[] V(Direction3D value) => [value.ToVector().X, value.ToVector().Y, value.ToVector().Z];
static double[] P(Point3D value) => [value.X, value.Y, value.Z];
- return new(true, null, target!.StableId, target.ProfileId, target.LoopId, target.SegmentIds.Single(), target.Side.ToString(), radius, clearance, plan.EndpointPolicy,
+ return new(true, null, target!.StableId, target.ProfileId, target.LoopId, target.ChainKind.ToString(), target.SegmentIds, target.Side.ToString(), radius, clearance, plan.EndpointPolicy,
V(plan.Tangent), P(plan.CylinderCenterlineStart), P(plan.CylinderCenterlineEnd), P(plan.CapContactStart), P(plan.CapContactEnd), P(plan.SideContactStart), P(plan.SideContactEnd),
"DisjointNoCavitiesInBareProfileM1", result.Correspondence?.Descendants.Select(x => x.StableId).OrderBy(x => x, StringComparer.Ordinal).ToArray() ?? [], result.Correspondence?.ProvenanceChain ?? []);
}
diff --git a/Aetheris.Kernel.Firmament.Tests/Integration/ProfileBoundaryChamferFixtureTests.cs b/Aetheris.Kernel.Firmament.Tests/Integration/ProfileBoundaryChamferFixtureTests.cs
index e5143ee3..b74c4180 100644
--- a/Aetheris.Kernel.Firmament.Tests/Integration/ProfileBoundaryChamferFixtureTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/Integration/ProfileBoundaryChamferFixtureTests.cs
@@ -94,7 +94,7 @@ public sealed class ProfileBoundaryChamferFixtureTests
[InlineData("profile-compose-reflex-chamfer-shaft-collision.firmament", "ProfileBoundaryChamferIntersectsShaft")]
[InlineData("profile-compose-reflex-chamfer-counterbore-collision.firmament", "ProfileBoundaryChamferIntersectsCounterbore")]
[InlineData("profile-chamfer-reflex-inset-collapse.firmament", "ProfileBoundaryChamferInsetCollapse")]
- [InlineData("profile-fillet-reflex-junction-not-materialized.firmament", "ProfileBoundaryFilletNotMaterialized")]
+ [InlineData("profile-fillet-reflex-junction-not-materialized.firmament", "ProfileBoundaryFilletJunctionTopologyNotMaterialized")]
[InlineData("profile-straight-edge-fillet-shaft-collision.firmament", "ProfileBoundaryFilletIntersectsShaft")]
public void InvalidFixture_ProducesTypedProfileBoundaryDiagnostic(string fixtureName, string diagnostic)
{
diff --git a/Aetheris.Kernel.Firmament.Tests/Integration/ProfileBoundaryChamferTests.cs b/Aetheris.Kernel.Firmament.Tests/Integration/ProfileBoundaryChamferTests.cs
index 29aee911..2ab3c4fe 100644
--- a/Aetheris.Kernel.Firmament.Tests/Integration/ProfileBoundaryChamferTests.cs
+++ b/Aetheris.Kernel.Firmament.Tests/Integration/ProfileBoundaryChamferTests.cs
@@ -73,13 +73,29 @@ public sealed class ProfileBoundaryChamferTests
}
[Fact]
- public void RejectsProfileFilletAtMaterializationBoundary()
+ public void BindsWholeLoopProfileFilletBeforeReportingTheSpecificMaterializationBoundary()
{
const string source = "Modify Body { EdgeFinish TopRound { Target: Bracket.Outer On: Top Kind: Fillet Radius: 2mm } }";
- Assert.False(ProfileBoundaryChamferSourceBinder.TryBind(source, Profile(), "Bracket", out _, out _, out var diagnostic));
+ Assert.True(ProfileBoundaryChamferSourceBinder.TryBindFillet(source, Profile(), "Bracket", out var target, out var radius, out var clearance, out var diagnostic), diagnostic);
+ Assert.Equal(ProfileBoundaryChamferChainKind.ClosedLoop, target!.ChainKind);
+ var plan = ProfileStraightEdgeFilletPlanner.TryPlan(Profile(), target, radius, clearance);
+
+ Assert.False(plan.Succeeded);
+ Assert.Contains("ProfileBoundaryFilletLoopTopologyNotMaterialized", plan.Diagnostics);
+ }
- Assert.Equal("ProfileBoundaryFilletNotMaterialized", diagnostic);
+ [Fact]
+ public void BindsConnectedFilletSelectionInProfileOrderAndRejectsDisconnectedSelection()
+ {
+ const string chain = "Selection Corner { Source: Bracket.Outer.[East, South] Require: ConnectedChain } Modify Body { EdgeFinish CornerRound { Target: Corner On: Top Kind: Fillet Radius: 2mm } }";
+ Assert.True(ProfileBoundaryChamferSourceBinder.TryBindFillet(chain, Profile(), "Bracket", out var target, out _, out _, out var diagnostic), diagnostic);
+ Assert.Equal(ProfileBoundaryChamferChainKind.OpenConnectedChain, target!.ChainKind);
+ Assert.Equal(["South", "East"], target.SegmentIds);
+
+ const string disconnected = "Selection Bad { Source: Bracket.Outer.[South, North] Require: ConnectedChain } Modify Body { EdgeFinish BadRound { Target: Bad On: Top Kind: Fillet Radius: 2mm } }";
+ Assert.False(ProfileBoundaryChamferSourceBinder.TryBindFillet(disconnected, Profile(), "Bracket", out _, out _, out _, out diagnostic));
+ Assert.Equal("ProfileBoundaryFilletDisconnectedChain", diagnostic);
}
[Theory]
@@ -111,8 +127,8 @@ public sealed class ProfileBoundaryChamferTests
Assert.False(ProfileBoundaryChamferSourceBinder.TryBindFillet("Modify Body { EdgeFinish Bad { Target: Bracket.Outer.South On: Top Kind: Fillet Radius: 0mm } }", Profile(), "Bracket", out _, out _, out _, out diagnostic));
Assert.Equal("ProfileBoundaryFilletRadiusMustBePositive", diagnostic);
- Assert.False(ProfileBoundaryChamferSourceBinder.TryBindFillet("Modify Body { EdgeFinish Bad { Target: Bracket.Outer On: Top Kind: Fillet Radius: 2mm } }", Profile(), "Bracket", out _, out _, out _, out diagnostic));
- Assert.Equal("ProfileBoundaryFilletWholeLoopUnsupported", diagnostic);
+ Assert.True(ProfileBoundaryChamferSourceBinder.TryBindFillet("Modify Body { EdgeFinish Bad { Target: Bracket.Outer On: Top Kind: Fillet Radius: 2mm } }", Profile(), "Bracket", out var loopTarget, out var loopRadius, out var loopClearance, out diagnostic), diagnostic);
+ Assert.Contains("ProfileBoundaryFilletLoopTopologyNotMaterialized", ProfileStraightEdgeFilletPlanner.TryPlan(Profile(), loopTarget!, loopRadius, loopClearance).Diagnostics);
var tooShort = ProfileStraightEdgeFilletPlanner.TryPlan(Profile(), target!, 2d, 10d);
Assert.False(tooShort.Succeeded);
Assert.Contains("ProfileBoundaryFilletSegmentTooShort", tooShort.Diagnostics);
diff --git a/Aetheris.Kernel.Firmament/Materializer/ProfileBoundaryChamfer.cs b/Aetheris.Kernel.Firmament/Materializer/ProfileBoundaryChamfer.cs
index b2fbe916..429f653d 100644
--- a/Aetheris.Kernel.Firmament/Materializer/ProfileBoundaryChamfer.cs
+++ b/Aetheris.Kernel.Firmament/Materializer/ProfileBoundaryChamfer.cs
@@ -65,8 +65,12 @@ public static class ProfileBoundaryChamferSourceBinder
return body is not null && On.IsMatch(body) && string.Equals(Kind.Match(body).Groups["value"].Value, "Fillet", StringComparison.Ordinal);
});
- /// <summary>Parses M1's explicit source form. EndClearance defaults to Radius;
- /// the default is visible in inspection and therefore never silently changes span.</summary>
+ /// <summary>
+ /// Resolves the source-bound fillet target into Profile order. This is shared
+ /// target semantics with chamfer, not B-rep edge discovery: a direct segment,
+ /// named connected-chain selection, and an outer loop all produce one ordered
+ /// target. M1 materialization still only consumes the single-segment shape.
+ /// </summary>
public static bool TryBindFillet(string source, ResolvedProfile2D profile, string hostBodyId, out ProfileBoundaryChamferTarget? target, out double radius, out double endClearance, out string? diagnostic)
{
target = null; radius = 0d; endClearance = 0d; diagnostic = null;
@@ -74,24 +78,57 @@ public static class ProfileBoundaryChamferSourceBinder
if (finish.Body is null) { diagnostic = "ProfileBoundaryFilletBoundaryRequired"; return false; }
var radiusMatch = Radius.Match(finish.Body); var clearanceMatch = EndClearance.Match(finish.Body);
if (!radiusMatch.Success || !double.TryParse(radiusMatch.Groups["value"].Value, NumberStyles.Float, CultureInfo.InvariantCulture, out radius) || !double.IsFinite(radius) || radius <= 0d) { diagnostic = "ProfileBoundaryFilletRadiusMustBePositive"; return false; }
- endClearance = clearanceMatch.Success && double.TryParse(clearanceMatch.Groups["value"].Value, NumberStyles.Float, CultureInfo.InvariantCulture, out var explicitClearance) ? explicitClearance : radius;
- if (!double.IsFinite(endClearance) || endClearance <= 0d) { diagnostic = "ProfileBoundaryFilletEndClearanceMustBePositive"; return false; }
-
var targetMatch = Target.Match(finish.Body); var on = On.Match(finish.Body);
if (!targetMatch.Success || !on.Success) { diagnostic = "ProfileBoundaryFilletDeclarationInvalid"; return false; }
- var rawTarget = targetMatch.Groups["value"].Value; var parts = rawTarget.Split('.');
- // A named Selection can denote a connected chain. M1 intentionally keeps
- // that historical materialization boundary rather than pretending it is a
- // single segment; direct Profile.Loop remains a precise whole-loop error.
- if (parts.Length != 3) { diagnostic = parts.Length == 2 ? "ProfileBoundaryFilletWholeLoopUnsupported" : "ProfileBoundaryFilletNotMaterialized"; return false; }
- if (!string.Equals(parts[0], profile.Name, StringComparison.Ordinal)) { diagnostic = "ProfileBoundaryFilletProfileUnknown"; return false; }
- var loop = profile.Loops.SingleOrDefault(x => string.Equals(x.Name, parts[1], StringComparison.Ordinal));
+ var rawTarget = targetMatch.Groups["value"].Value;
+ string requestedProfile; string requestedLoop; IReadOnlyList<string> requestedSegments;
+ ProfileBoundaryChamferChainKind chainKind; string provenance;
+ var parts = rawTarget.Split('.');
+ if (parts.Length is 2 or 3)
+ {
+ requestedProfile = parts[0]; requestedLoop = parts[1];
+ requestedSegments = parts.Length == 3 ? [parts[2]] : [];
+ chainKind = parts.Length == 3 ? ProfileBoundaryChamferChainKind.SingleSegment : ProfileBoundaryChamferChainKind.ClosedLoop;
+ provenance = "DirectProfileBoundaryTarget";
+ }
+ else
+ {
+ var selection = SelectionHeader.Matches(source).Cast<Match>()
+ .Select(match => (Match: match, Body: Block(source, match.Index + match.Length - 1)))
+ .FirstOrDefault(x => string.Equals(x.Match.Groups["name"].Value, rawTarget, StringComparison.Ordinal));
+ if (selection.Body is null) { diagnostic = "ProfileBoundaryFilletTargetUnknown"; return false; }
+ var canonical = CanonicalSelection.Match(selection.Body); var historical = HistoricalSelection.Match(selection.Body);
+ var selectionSource = canonical.Success ? canonical : historical; var requirement = Require.Match(selection.Body);
+ if (!selectionSource.Success || !requirement.Success) { diagnostic = "ProfileBoundaryFilletSelectionKindUnsupported"; return false; }
+ requestedProfile = selectionSource.Groups["profile"].Value;
+ requestedLoop = canonical.Success ? canonical.Groups["loop"].Value : "Outer";
+ requestedSegments = selectionSource.Groups["segments"].Value.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+ chainKind = string.Equals(requirement.Groups["value"].Value, "ClosedLoop", StringComparison.Ordinal)
+ ? ProfileBoundaryChamferChainKind.ClosedLoop : ProfileBoundaryChamferChainKind.OpenConnectedChain;
+ provenance = $"Selection:{rawTarget}";
+ }
+ if (!string.Equals(requestedProfile, profile.Name, StringComparison.Ordinal)) { diagnostic = "ProfileBoundaryFilletProfileUnknown"; return false; }
+ var loop = profile.Loops.SingleOrDefault(x => string.Equals(x.Name, requestedLoop, StringComparison.Ordinal));
if (loop is null) { diagnostic = "ProfileBoundaryFilletLoopUnknown"; return false; }
if (!loop.IsOuter) { diagnostic = "ProfileBoundaryFilletInnerLoopUnsupported"; return false; }
- var segment = loop.Segments.SingleOrDefault(x => string.Equals(x.Name, parts[2], StringComparison.Ordinal));
- if (segment is null) { diagnostic = "ProfileBoundaryFilletSegmentUnknown"; return false; }
- if (segment.Geometry is not LineArcLineSegment2D) { diagnostic = "ProfileBoundaryFilletSegmentKindUnsupported"; return false; }
- target = new($"edgefinish:{finish.Match.Groups["name"].Value}", hostBodyId, profile.Name, loop.Name, [segment.Name], Enum.Parse<ProfileBoundaryChamferSide>(on.Groups["value"].Value), ProfileBoundaryChamferChainKind.SingleSegment, $"offset:{finish.Match.Index}", "DirectProfileBoundaryTarget");
+ if (requestedSegments.Count == 0) requestedSegments = loop.Segments.Select(segment => segment.Name).ToArray();
+ if (requestedSegments.Distinct(StringComparer.Ordinal).Count() != requestedSegments.Count) { diagnostic = "ProfileBoundaryFilletDuplicateSegment"; return false; }
+ var indices = requestedSegments.Select(id => IndexOf(loop, id)).ToArray();
+ if (indices.Any(index => index < 0)) { diagnostic = "ProfileBoundaryFilletSegmentUnknown"; return false; }
+ var ordered = NormalizeConnectedOrder(loop, indices, out var closed);
+ if (ordered is null) { diagnostic = "ProfileBoundaryFilletDisconnectedChain"; return false; }
+ if (chainKind == ProfileBoundaryChamferChainKind.ClosedLoop && !closed) { diagnostic = "ProfileBoundaryFilletSelectionMustClose"; return false; }
+ if (chainKind == ProfileBoundaryChamferChainKind.OpenConnectedChain && closed) { diagnostic = "ProfileBoundaryFilletSelectionMustBeOpen"; return false; }
+ if (closed) chainKind = ProfileBoundaryChamferChainKind.ClosedLoop;
+ else if (ordered.Count == 1) chainKind = ProfileBoundaryChamferChainKind.SingleSegment;
+ var orderedSegments = ordered.Select(index => loop.Segments[index]).ToArray();
+ if (orderedSegments.Any(segment => segment.Geometry is not LineArcLineSegment2D)) { diagnostic = "ProfileBoundaryFilletSegmentKindUnsupported"; return false; }
+
+ endClearance = clearanceMatch.Success && double.TryParse(clearanceMatch.Groups["value"].Value, NumberStyles.Float, CultureInfo.InvariantCulture, out var explicitClearance) ? explicitClearance : radius;
+ if (!double.IsFinite(endClearance) || endClearance <= 0d) { diagnostic = "ProfileBoundaryFilletEndClearanceMustBePositive"; return false; }
+ target = new($"edgefinish:{finish.Match.Groups["name"].Value}", hostBodyId, profile.Name, loop.Name,
+ orderedSegments.Select(segment => segment.Name).ToArray(), Enum.Parse<ProfileBoundaryChamferSide>(on.Groups["value"].Value),
+ chainKind, $"offset:{finish.Match.Index}", provenance);
return true;
}
@@ -441,7 +478,8 @@ public static class ProfileStraightEdgeFilletPlanner
var loop = profile.Loops.SingleOrDefault(x => x.Name == target.LoopId);
if (loop is null) return Fail("ProfileBoundaryFilletLoopUnknown");
if (!loop.IsOuter || profile.Loops.Count != 1) return Fail("ProfileBoundaryFilletInnerLoopUnsupported");
- if (target.ChainKind != ProfileBoundaryChamferChainKind.SingleSegment || target.SegmentIds.Count != 1) return Fail("ProfileBoundaryFilletConnectedChainUnsupported");
+ if (target.ChainKind == ProfileBoundaryChamferChainKind.ClosedLoop) return Fail("ProfileBoundaryFilletLoopTopologyNotMaterialized");
+ if (target.ChainKind == ProfileBoundaryChamferChainKind.OpenConnectedChain || target.SegmentIds.Count != 1) return Fail("ProfileBoundaryFilletJunctionTopologyNotMaterialized");
if (loop.Segments.Any(x => x.Geometry is not LineArcLineSegment2D)) return Fail("ProfileBoundaryFilletEndpointTerminationUnsupported");
var index = loop.Segments.Select((x, i) => (x, i)).Where(x => x.x.Name == target.SegmentIds[0]).Select(x => x.i).DefaultIfEmpty(-1).Single();
if (index < 0) return Fail("ProfileBoundaryFilletSegmentUnknown");
diff --git a/docs/firmament/profile-edgefinish-convex-concave-audit-x1.md b/docs/firmament/profile-edgefinish-convex-concave-audit-x1.md
index 3b13bf89..f0368aa9 100644
--- a/docs/firmament/profile-edgefinish-convex-concave-audit-x1.md
+++ b/docs/firmament/profile-edgefinish-convex-concave-audit-x1.md
@@ -83,7 +83,7 @@ larger entry radius is checked and reports
| Profile chamfer | source Profile outer line loop/chain, Top/Bottom | planar section transition | supported |
| Compose Profile chamfer | Top whole outer line loop, disjoint cavities | planar variable-outer transition | supported |
| Profile fillet, one straight outer segment | authored `Profile.Outer.Segment`, Top/Bottom | quarter cylinder + planar end faces | supported (M1) |
-| Profile fillet chain / loop / convex junction / reflex junction | source Profile boundary | no junction rolling-surface plan | unsupported: `ProfileBoundaryFilletNotMaterialized` |
+| Profile fillet chain / loop / convex junction / reflex junction | ordered source Profile boundary | no junction rolling-surface plan | binding is supported; materialization reports `ProfileBoundaryFilletJunctionTopologyNotMaterialized` or `ProfileBoundaryFilletLoopTopologyNotMaterialized` |
Primitive internal/reflex fillet support is not evidence of a Profile fillet:
the former is a bounded primitive/cell planner. M1 instead has an authoritative
diff --git a/docs/firmament/profile-fillet-common-cases-x2.md b/docs/firmament/profile-fillet-common-cases-x2.md
new file mode 100644
index 00000000..9c4ceb72
--- /dev/null
+++ b/docs/firmament/profile-fillet-common-cases-x2.md
@@ -0,0 +1,60 @@
+# Profile fillet common cases X2 — current implementation boundary
+
+X2 normalizes authored Profile fillet targets before topology materialization.
+The target is source-bound and deterministic:
+
+`Profile ID + outer loop ID + Profile-ordered source segment IDs + Top/Bottom
++ radius + endpoint policy + source provenance`.
+
+Supported target spelling is deliberately the same as existing Profile chamfer
+selection spelling:
+
+```firmament
+Selection OutsideCorner {
+ Source: Bracket.Outer.[South, East]
+ Require: ConnectedChain
+}
+Modify Body {
+ EdgeFinish Round { Target: OutsideCorner On: Top Kind: Fillet Radius: 2mm }
+}
+```
+
+`Target: Bracket.Outer.South` is a `SingleSegment`; `Target: Bracket.Outer` is
+a `ClosedLoop`; a `ConnectedChain` selection is normalized in resolved Profile
+order even when its source list is reversed. Duplicate and disconnected source
+sets fail before planning with `ProfileBoundaryFilletDuplicateSegment` and
+`ProfileBoundaryFilletDisconnectedChain`. Inner loops and line/arc targets
+remain explicitly unsupported.
+
+## Materialized geometry
+
+The only materialized topology remains M1's finite straight segment. It has an
+exact quarter-cylinder, two straight cap/side contact curves, two exact
+quarter-circle endpoint arcs, and planar endpoint termination faces. Its local
+Top/Bottom frame comes from the Profile construction plane, never global Z.
+The radius must be positive, below host thickness, and leave the requested
+finite span after both endpoint clearances.
+
+For a 90-degree Profile junction, the required continuous rolling construction
+is not two M1 cylinders meeting at the original Profile vertex. The cylinder
+centre lines terminate on a radius-offset corner, and a sphere of the same
+radius supplies the trihedral cylinder/cap/side transition at a convex corner.
+The cylinder/sphere trim is a circle; cap/sphere and side/sphere contacts are
+also circular arcs. Reflex material corners have the opposite material-side
+selection and require a separately oriented internal spherical trim patch plus
+notch-width and local-medial-space admission. Reusing convex face orientation
+for a reflex vertex would invert material side, so neither patch is emitted by
+M1.
+
+Accordingly, an admitted chain currently reports
+`ProfileBoundaryFilletJunctionTopologyNotMaterialized`; a complete loop reports
+`ProfileBoundaryFilletLoopTopologyNotMaterialized`. This is an intentional
+honest stop, not a geometry fallback. Composed hosts keep M1's conservative
+single-roll Shaft/Counterbore corridor check and report the feature-specific
+collision diagnostics before the separate compose-materialization boundary.
+
+The next bounded implementation must create one authoritative
+`ProfileBoundaryFilletPlan` with typed straight-roll, convex-junction,
+reflex-junction, and endpoint-termination subplans, then emit the complete
+shell from that plan. It cannot be obtained safely by stitching M1 endpoint
+faces or by generic B-rep edge editing.
diff --git a/docs/firmament/profile-straight-edge-fillet-m1.md b/docs/firmament/profile-straight-edge-fillet-m1.md
index 2c479d7e..8d96e234 100644
--- a/docs/firmament/profile-straight-edge-fillet-m1.md
+++ b/docs/firmament/profile-straight-edge-fillet-m1.md
@@ -2,7 +2,11 @@
M1 materializes one authored `Line2` segment on the outer loop of a prismatic
Profile extrusion. It is a source-bound operation: `Target` names
-`Profile.Loop.Segment`; no B-rep edge lookup is performed.
+`Profile.Loop.Segment`; no B-rep edge lookup is performed. The X2 target
+resolver also accepts an outer loop and the existing typed `ConnectedChain`
+Selection syntax, normalizing all source segments to Profile order before a
+planner sees them. This removes target-binding archaeology, but it does not
+claim that M1 has continuous junction topology.
```firmament
Modify Body {
@@ -34,8 +38,12 @@ untouched. Typed descendants include `FilletSurface`, both contact edges, both
endpoint arcs, both termination faces, and both retained sharp edges.
The implementation rejects non-positive radii/clearances, a radius at or above
-host thickness, non-Line2 sources, inner loops, loop/chain targets, and spans
-that cannot retain both endpoint clearances. For a Compose source, M1 first
+host thickness, non-Line2 sources, inner loops, duplicate/disconnected chain
+selections, and spans that cannot retain both endpoint clearances. Loop and
+connected-chain targets bind successfully but stop at the explicit M1 topology
+boundary with `ProfileBoundaryFilletLoopTopologyNotMaterialized` or
+`ProfileBoundaryFilletJunctionTopologyNotMaterialized`; this is deliberately
+more specific than a generic materialization error. For a Compose source, M1 first
tests an exact finite-span/axial corridor conservatively against Shaft and
Counterbore circles. Touching or overlap reports
`ProfileBoundaryFilletIntersectsShaft` or
diff --git a/docs/firmament/v2-canonical-authoring.md b/docs/firmament/v2-canonical-authoring.md
index dcc5c07b..874a5b45 100644
--- a/docs/firmament/v2-canonical-authoring.md
+++ b/docs/firmament/v2-canonical-authoring.md
@@ -216,9 +216,12 @@ Modify Body { EdgeFinish SouthBottomRound {
```
It emits one exact quarter-cylinder with planar endpoint termination faces.
-`EndClearance` defaults to `Radius`. Multi-segment convex/reflex junction
-fillets, chains, and whole loops remain unsupported; a Concept Path `Arc` only
-changes a 2D outline and is not a substitute for this 3D edge finish.
+`EndClearance` defaults to `Radius`. The target grammar now also accepts the
+same connected-chain Selection syntax used by chamfers and a direct outer-loop
+target, so authors receive a source-specific topology diagnostic instead of a
+selection failure. Continuous multi-segment convex/reflex junction fillets,
+chains, and whole loops remain unmaterialized; a Concept Path `Arc` only changes
+a 2D outline and is not a substitute for this 3D edge finish.
## Canonical examples