Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add geometric span inspection to the CLI

Yuechen Lie920321ed5ff
diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.cs
index f8e5b16b..7fd2d79d 100644
--- a/Aetheris.CLI/CliRunner.cs
+++ b/Aetheris.CLI/CliRunner.cs
@@ -137,6 +137,7 @@ public static class CliRunner
private const string MeshUsage = "Usage: aetheris mesh <file.firmament|file.firmfixture|file.step> [--format stl|obj] [--output <path>] [--debug-ir <path>] [--json]";
private const string ValidateUsage = "Usage: aetheris validate <file.firmament|file.firmfixture> [--forge-pack <path>] [--json]";
private const string InspectProfileUsage = "Usage: aetheris inspect-profile <file.firmament> [--json]";
+ private const string InspectSpansUsage = "Usage: aetheris inspect-spans <file.firmament> --json";
private const string InspectComposeUsage = "Usage: aetheris inspect-compose <file.firmament> --json [--materialize]";
private const string InspectSelectionsUsage = "Usage: aetheris inspect-selections <file.firmament> --json";
private const string AnalyzeUsage = "Usage: aetheris analyze <file.step> [--face <id>] [--edge <id>] [--vertex <id>] [--json]";
@@ -216,6 +217,7 @@ public static class CliRunner
"validate" => RunValidate(args.Skip(1).ToArray(), stdout, stderr),
"inspect" => RunInspect(args.Skip(1).ToArray(), stdout, stderr),
"inspect-profile" => RunInspectProfile(args.Skip(1).ToArray(), stdout, stderr),
+ "inspect-spans" => RunInspectSpans(args.Skip(1).ToArray(), stdout, stderr),
"inspect-compose" => RunInspectCompose(args.Skip(1).ToArray(), stdout, stderr),
"inspect-selections" => RunInspectSelections(args.Skip(1).ToArray(), stdout, stderr),
"sections" => RunSections(args.Skip(1).ToArray(), stdout, stderr),
@@ -1664,6 +1666,7 @@ Model CanonicalPanel {
{
parsed.Profile.Name, parsed.Profile.PlaneFrame,
constructionPlane = DescribeConstructionPlane(parsed.Profile.EffectiveConstructionPlane),
+ spans = ProfileAuthoringParser.InspectGeometricSpans(source).Spans,
conceptPaths = ProfileAuthoringParser.InspectConceptPaths(source),
loops = parsed.Profile.Loops.Count,
segments = parsed.Profile.Loops.SelectMany(x => x.Segments).Select(x =>
@@ -1693,6 +1696,16 @@ Model CanonicalPanel {
return validation.IsValid ? 0 : 1;
}
+ private static int RunInspectSpans(string[] args, TextWriter stdout, TextWriter stderr)
+ {
+ if (args.Length == 0 || IsHelpFlag(args[0])) { stdout.WriteLine(InspectSpansUsage); return args.Length == 0 ? 1 : 0; }
+ if (args.Length != 2 || args[1] != "--json") { stderr.WriteLine(InspectSpansUsage); return 1; }
+ if (!File.Exists(args[0])) { stderr.WriteLine($"Span source was not found: {args[0]}"); return 1; }
+ var inspection = ProfileAuthoringParser.InspectGeometricSpans(File.ReadAllText(args[0]));
+ stdout.WriteLine(JsonSerializer.Serialize(new { command = "inspect-spans", success = inspection.Diagnostics.Count == 0, spans = inspection.Spans, diagnostics = inspection.Diagnostics }, JsonOptions));
+ return inspection.Diagnostics.Count == 0 ? 0 : 1;
+ }
+
private static object DescribeConstructionPlane(ConstructionPlane plane) => new
{
plane.StableId, plane.SourceConceptId,
diff --git a/Aetheris.Kernel.Firmament.Tests/GeometricSpanX1Tests.cs b/Aetheris.Kernel.Firmament.Tests/GeometricSpanX1Tests.cs
new file mode 100644
index 00000000..c867c547
--- /dev/null
+++ b/Aetheris.Kernel.Firmament.Tests/GeometricSpanX1Tests.cs
@@ -0,0 +1,73 @@
+using Aetheris.Kernel.Firmament.FirmamentV2;
+using Aetheris.Kernel.Firmament.Materializer;
+
+namespace Aetheris.Kernel.Firmament.Tests;
+
+public sealed class GeometricSpanX1Tests
+{
+ [Fact]
+ public void LineSpan_IsAParentPreservingView_AndPipelinesWithoutHelperGeometry()
+ {
+ var source = """
+ Rect2 Stock { Center: [50mm, 20mm]; Size: [100mm, 40mm] }
+ Point2 MountLeft { Position: [30mm, 0mm] } Point2 MountRight { Position: [70mm, 0mm] }
+ Point2 UpperRight { Position: [70mm, 20mm] } Point2 UpperLeft { Position: [30mm, 20mm] }
+ Line2 Rise { From: MountRight; To: UpperRight } Line2 Top { From: UpperRight; To: UpperLeft } Line2 Down { From: UpperLeft; To: MountLeft }
+ Span<Line> MountingEdge { On: Stock.Bottom; From: MountLeft; To: MountRight }
+ Profile Plate { Loop Outer { MountingEdge |> Rise |> Top |> Down |> Close } }
+ Extrude Solid { Profile: Plate; From: 0mm; To: 2mm }
+ """;
+
+ var span = Assert.Single(ProfileAuthoringParser.InspectGeometricSpans(source).Spans);
+ Assert.Equal(("MountingEdge", "Stock.Bottom", "Line", "Forward"), (span.SpanId, span.ParentId, span.ParentType, span.Orientation));
+ Assert.Equal(40d, span.Length!.Value, 9);
+ Assert.Contains("parent:Stock.Bottom", span.Provenance, StringComparison.Ordinal);
+
+ var parsed = ProfileAuthoringParser.Parse(source);
+ Assert.Empty(parsed.Diagnostics);
+ Assert.Contains("MountingEdge", parsed.Profile!.Loops.Single().Segments.Select(x => x.Provenance.TracedFrom));
+ Assert.True(ResolvedProfile2DValidator.Validate(parsed.Profile).IsValid);
+ }
+
+ [Fact]
+ public void ArcSpan_HasNativeParameterDomain_AndExplicitReverseDoesNotCopyCarrier()
+ {
+ var source = """
+ Point2 C { Position: [0mm, 0mm] } Point2 A { Position: [10mm, 0mm] } Point2 B { Position: [0mm, 10mm] }
+ Circle2 Guide { Center: C; Radius: 10mm }
+ Span<Arc> Quarter { On: Guide; From: A; To: B; Sweep: CounterClockwise; Orientation: Reverse }
+ """;
+ var span = Assert.Single(ProfileAuthoringParser.InspectGeometricSpans(source).Spans);
+ Assert.Equal("Arc", span.ParentType); Assert.Equal("Reverse", span.Orientation);
+ Assert.StartsWith("NativeRadians:", span.Domain, StringComparison.Ordinal);
+ Assert.Equal(Math.PI * 5d, span.Length!.Value, 9);
+ Assert.IsType<LineArcCircularArc2D>(span.Geometry);
+ }
+
+ [Theory]
+ [InlineData("Span<Material> Bad { On: Stock.Bottom; From: A; To: B }", "firmament-span-type-invalid:Material")]
+ [InlineData("Span<Line> Bad { On: Stock.Bottom; From: A; To: A }", "firmament-span-zero-length:Bad")]
+ [InlineData("Span<Line> Bad { On: Stock.Bottom; From: A; To: C }", "profile-endpoint-not-on-guide:Bad:Stock.Bottom")]
+ public void InvalidCurveSpans_AreTyped(string declaration, string expected)
+ {
+ var inspection = ProfileAuthoringParser.InspectGeometricSpans($$"""
+ Point2 A { Position: [0mm, 0mm] } Point2 B { Position: [10mm, 0mm] } Point2 C { Position: [0mm, 2mm] }
+ Line2 Base { From: A; To: B } Rect2 Stock { Center: [5mm, 2mm]; Size: [10mm, 4mm] }
+ {{declaration}}
+ """);
+ Assert.Contains(expected, inspection.Diagnostics);
+ }
+
+ [Fact]
+ public void PlaneSpan_PreservesPlaneAndBoundaryIdentity_WithoutCreatingAFace()
+ {
+ var source = """
+ Construction Plane MountPlane { Trace: Plate.TopPlane }
+ Profile MountBoundary { Loop Outer { } }
+ Span<Plane> MountArea { On: MountPlane; Boundary: MountBoundary }
+ """;
+ var span = Assert.Single(ProfileAuthoringParser.InspectGeometricSpans(source).Spans);
+ Assert.Equal(("Plane", "MountPlane", "MountBoundary"), (span.SpanType, span.ParentId, span.BoundaryProfile));
+ Assert.Null(span.Geometry); Assert.Null(span.Length);
+ }
+}
diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/GeometricSpan.cs b/Aetheris.Kernel.Firmament/FirmamentV2/GeometricSpan.cs
new file mode 100644
index 00000000..2c961786
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/FirmamentV2/GeometricSpan.cs
@@ -0,0 +1,27 @@
+using Aetheris.Kernel.Firmament.Materializer;
+using System.Text.Json.Serialization;
+
+namespace Aetheris.Kernel.Firmament.FirmamentV2;
+
+/// <summary>
+/// A named, non-owning bounded view of an existing geometric guide. This is deliberately
+/// closed over Firmament's current planar guide families; it is not a general generic value.
+/// Geometry is evaluated from <see cref="ParentId"/> and the authored constraints each time.
+/// </summary>
+public sealed record GeometricSpanView(
+ string SpanId,
+ string SpanType,
+ string ParentId,
+ string ParentType,
+ string Domain,
+ string Orientation,
+ string? From,
+ string? To,
+ string? BoundaryProfile,
+ double? Length,
+ string Provenance,
+ [property: JsonIgnore] LineArcProfileCurve2D? Geometry = null);
+
+public sealed record GeometricSpanInspection(
+ IReadOnlyList<GeometricSpanView> Spans,
+ IReadOnlyList<string> Diagnostics);
diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/ProfileAuthoringParser.cs b/Aetheris.Kernel.Firmament/FirmamentV2/ProfileAuthoringParser.cs
index e233e7da..aefd1603 100644
--- a/Aetheris.Kernel.Firmament/FirmamentV2/ProfileAuthoringParser.cs
+++ b/Aetheris.Kernel.Firmament/FirmamentV2/ProfileAuthoringParser.cs
@@ -19,11 +19,24 @@ public static class ProfileAuthoringParser
private static readonly Regex Rect = new(@"\bRect2\s+(?<n>[A-Za-z_]\w*)\s*\{\s*Center\s*:\s*(?:\[|Point2\s*\()\s*(?<x>[-+.\deE]+)mm\s*,\s*(?<y>[-+.\deE]+)mm\s*(?:\]|\))\s*;?\s*Size\s*:\s*\[(?<w>[-+.\deE]+)mm\s*,\s*(?<h>[-+.\deE]+)mm\]", RegexOptions.Singleline | RegexOptions.CultureInvariant);
private static readonly Regex ConstructionPlaneDeclaration = new(@"\bConstruction\s+Plane\s+(?<name>\w+)\s*\{\s*Trace\s*:\s*(?<trace>[\w.]+)\s*;?\s*\}", RegexOptions.Singleline | RegexOptions.CultureInvariant);
private static readonly Regex Segment = new(@"\bSegment\s+(?<n>\w+)\s*\{\s*Trace\s*:\s*(?<trace>[\w.]+)\s*;?\s*From\s*:\s*(?<from>[\w.]+)\s*;?\s*To\s*:\s*(?<to>[\w.]+)(?:\s*;?\s*Sweep\s*:\s*(?<sweep>Clockwise|CounterClockwise))?", RegexOptions.Singleline | RegexOptions.CultureInvariant);
+ private static readonly Regex SpanHeader = new(@"\bSpan\s*<\s*(?<type>[A-Za-z_]\w*)\s*>\s+(?<name>[A-Za-z_]\w*)\s*\{", RegexOptions.CultureInvariant);
private static readonly Regex Pipeline = new(@"(?<expression>(?:Reverse\s+)?[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\s+As\s+[A-Za-z_]\w*)?\s*(?:\|>\s*(?:(?:Reverse\s+)?[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*(?:\s+As\s+[A-Za-z_]\w*)?|Close|TraceLoop)\s*)+)", RegexOptions.CultureInvariant);
private static readonly Regex Extrude = new(@"\bExtrude\s+\w+\s*\{\s*Profile\s*:\s*(?<p>\w+)\s*;?\s*From\s*:\s*(?<a>[-+.\deE]+)mm\s*;?\s*To\s*:\s*(?<b>[-+.\deE]+)mm", RegexOptions.Singleline | RegexOptions.CultureInvariant);
public static bool IsProfileSource(string source) => Regex.IsMatch(source, @"\bProfile\s+[A-Za-z_]\w*", RegexOptions.CultureInvariant);
+ /// <summary>Inspects first-class geometric views without materializing independent guides.</summary>
+ public static GeometricSpanInspection InspectGeometricSpans(string source)
+ {
+ ArgumentNullException.ThrowIfNull(source);
+ var diagnostics = new List<string>();
+ var points = new Dictionary<string, (double X, double Y)>(StringComparer.Ordinal);
+ var guides = new Dictionary<string, LineArcProfileCurve2D>(StringComparer.Ordinal);
+ AddOrdinaryGuides(source, points, guides, diagnostics, applySpans: false);
+ var spans = ApplyGeometricSpans(source, points, guides, diagnostics, addGuides: false);
+ return new(spans, diagnostics.Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal).ToArray());
+ }
+
internal static IReadOnlyList<string> ValidatePipelineContexts(string source)
{
var allowed = FindBlocks(source, @"\b(?:Profile\s+[A-Za-z_]\w*(?:\s+Using\s+[A-Za-z_]\w*)?|Concept\s+Path\s+[A-Za-z_]\w*)\s*\{").ToArray();
@@ -158,7 +171,7 @@ public static class ProfileAuthoringParser
internal static ConstructionPlane? ResolveNamedConstructionPlane(string source, string frame, List<string> diagnostics)
=> ResolveConstructionPlane(source, frame, diagnostics);
- private static void AddOrdinaryGuides(string source, Dictionary<string, (double X, double Y)> points, Dictionary<string, LineArcProfileCurve2D> guides, List<string> diagnostics)
+ private static void AddOrdinaryGuides(string source, Dictionary<string, (double X, double Y)> points, Dictionary<string, LineArcProfileCurve2D> guides, List<string> diagnostics, bool applySpans = true)
{
foreach (Match match in Point.Matches(source))
if (TryNumber(match.Groups["x"].Value, out var x) && TryNumber(match.Groups["y"].Value, out var y))
@@ -194,8 +207,79 @@ public static class ProfileAuthoringParser
// A circle remains a guide; segments choose its directed arc below.
guides[match.Groups["n"].Value] = new LineArcFullCircle2D(center, radius);
}
+ if (applySpans) ApplyGeometricSpans(source, points, guides, diagnostics, addGuides: true);
}
+ private static IReadOnlyList<GeometricSpanView> ApplyGeometricSpans(
+ string source,
+ IReadOnlyDictionary<string, (double X, double Y)> points,
+ IDictionary<string, LineArcProfileCurve2D> guides,
+ List<string> diagnostics,
+ bool addGuides)
+ {
+ var result = new List<GeometricSpanView>();
+ var names = new HashSet<string>(StringComparer.Ordinal);
+ foreach (Match header in SpanHeader.Matches(source))
+ {
+ var open = source.IndexOf('{', header.Index, header.Length);
+ var close = FindMatchingBrace(source, open);
+ var name = header.Groups["name"].Value;
+ var type = header.Groups["type"].Value;
+ if (close < 0) { diagnostics.Add($"firmament-span-domain-invalid:{name}"); continue; }
+ if (!names.Add(name) || guides.ContainsKey(name)) { diagnostics.Add($"firmament-span-duplicate:{name}"); continue; }
+ var body = source[(open + 1)..close];
+ var parent = Property(body, "On");
+ if (parent is null) { diagnostics.Add($"firmament-span-parent-not-found:{name}"); continue; }
+
+ // Plane spans are semantic surface views only in X1: a named, already-authored
+ // Profile is their boundary authority. They intentionally do not create a face.
+ if (type == "Plane")
+ {
+ var boundary = Property(body, "Boundary");
+ var knownPlanes = ConstructionPlaneDeclaration.Matches(source).Cast<Match>()
+ .Select(match => match.Groups["name"].Value).ToHashSet(StringComparer.Ordinal);
+ if (!knownPlanes.Contains(parent)) { diagnostics.Add($"firmament-span-parent-not-found:{name}"); continue; }
+ if (boundary is null || !FindProfiles(source).Any(profile => profile.Name == boundary))
+ { diagnostics.Add($"firmament-span-boundary-not-closed:{name}"); continue; }
+ result.Add(new(name, type, parent, "Plane", $"Boundary:{boundary}", "Forward", null, null, boundary, null, $"span:{name};parent:{parent};boundary:{boundary}"));
+ continue;
+ }
+
+ if (type is not ("Line" or "Arc" or "Curve")) { diagnostics.Add($"firmament-span-type-invalid:{type}"); continue; }
+ if (!guides.TryGetValue(parent, out var parentGeometry)) { diagnostics.Add($"firmament-span-parent-not-found:{name}"); continue; }
+ var parentType = parentGeometry switch { LineArcLineSegment2D => "Line", LineArcFullCircle2D => "Arc", LineArcCircularArc2D => "Arc", _ => parentGeometry.GetType().Name };
+ if ((type == "Line" && parentGeometry is not LineArcLineSegment2D) || (type == "Arc" && parentGeometry is not LineArcFullCircle2D and not LineArcCircularArc2D))
+ { diagnostics.Add($"firmament-span-type-invalid:{type}"); continue; }
+ var fromName = Property(body, "From"); var toName = Property(body, "To");
+ if (fromName is null || toName is null || !points.TryGetValue(fromName, out var from) || !points.TryGetValue(toName, out var to))
+ { diagnostics.Add($"firmament-span-domain-invalid:{name}"); continue; }
+ var sweep = Property(body, "Sweep") ?? "CounterClockwise";
+ var curve = SelectGuide(parentGeometry, from, to, sweep, name, parent, diagnostics);
+ if (curve is null) continue;
+ var length = CurveLength(curve);
+ if (!double.IsFinite(length) || length <= Tolerance) { diagnostics.Add($"firmament-span-zero-length:{name}"); continue; }
+ var reverse = string.Equals(Property(body, "Orientation"), "Reverse", StringComparison.Ordinal);
+ if (reverse) curve = Reverse(curve);
+ var domain = curve switch
+ {
+ LineArcLineSegment2D => $"Endpoints:{fromName}..{toName}",
+ LineArcCircularArc2D arc => $"NativeRadians:{arc.StartAngleRadians:R}..{(arc.StartAngleRadians + arc.SweepAngleRadians):R}",
+ _ => "Endpoints"
+ };
+ var view = new GeometricSpanView(name, type, parent, parentType, domain, reverse ? "Reverse" : "Forward", fromName, toName, null, length, $"span:{name};parent:{parent};parentType:{parentType}", curve);
+ result.Add(view);
+ if (addGuides) guides[name] = curve;
+ }
+ return result;
+ }
+
+ private static double CurveLength(LineArcProfileCurve2D curve) => curve switch
+ {
+ LineArcLineSegment2D line => Distance(line.Start, line.End),
+ LineArcCircularArc2D arc => Math.Abs(arc.Radius * arc.SweepAngleRadians),
+ _ => double.NaN
+ };
+
private static IReadOnlyDictionary<string, BoundPath> BindPaths(string source, Dictionary<string, (double X, double Y)> points, Dictionary<string, LineArcProfileCurve2D> guides, List<string> diagnostics)
{
var result = new Dictionary<string, BoundPath>(StringComparer.Ordinal);
@@ -762,6 +846,17 @@ public static class ProfileAuthoringParser
}
}
+ private static int FindMatchingBrace(string source, int open)
+ {
+ var depth = 0;
+ for (var index = open; index >= 0 && index < source.Length; index++)
+ {
+ if (source[index] == '{') depth++;
+ else if (source[index] == '}' && --depth == 0) return index;
+ }
+ return -1;
+ }
+
private static IEnumerable<PathStep> FindPathSteps(string body)
{
var entries = new List<PathStep>();
diff --git a/docs/public/firmament/spans.md b/docs/public/firmament/spans.md
new file mode 100644
index 00000000..ecb5d6b6
--- /dev/null
+++ b/docs/public/firmament/spans.md
@@ -0,0 +1,28 @@
+# Geometric spans
+
+`Span<T>` is a named, bounded, oriented view of existing parameterized geometry. It preserves its parent's semantic identity and does not copy geometry.
+
+The X1 curve lane admits `Span<Line>`, `Span<Arc>`, and `Span<Curve>`. It uses named endpoints, so the bounds remain attached to the parent guide rather than to newly authored helper geometry.
+
+```firmament
+Span<Line> MountingEdge {
+ On: Stock.Bottom
+ From: MountLeft
+ To: MountRight
+}
+```
+
+Use the resulting name wherever a normal pipeline guide is accepted. `Orientation: Reverse` reverses traversal; it does not change the bounded domain. Curve inspection reports the parent, endpoint domain, orientation, length, and provenance through `aetheris inspect-spans part.firmament --json`.
+
+`Span<Plane>` is the bounded surface lane. Its boundary is a named Profile and it remains a semantic view: X1 does not create an independent face, infer a boundary from BRep edges, accept holes, or support arbitrary trimmed/freeform surfaces.
+
+```firmament
+Span<Plane> MountArea {
+ On: MountPlane
+ Boundary: MountBoundary
+}
+```
+
+`MountPlane` must be a named `Construction Plane`; a span never finds a nearby BRep face to replace a missing parent.
+
+`Span<T>` is a built-in closed language type, not Template generic programming. Other types—including `Material`, `Body`, and `Feature`—are rejected during binding. A Span is contiguous; use separate named spans for separate intervals.
diff --git a/docs/release/LANG-SPAN-X1.md b/docs/release/LANG-SPAN-X1.md
new file mode 100644
index 00000000..9a0ac5db
--- /dev/null
+++ b/docs/release/LANG-SPAN-X1.md
@@ -0,0 +1,28 @@
+# LANG-SPAN-X1 — geometric span views
+
+## Verdict
+
+**Meaningful progression.** Firmament can now name a bounded curve view over an existing planar line or circle guide and compose that view into the established Profile/Path pipeline without creating a copied guide. It also has a semantic `Span<Plane>` declaration that retains a named boundary Profile, but planar support validation and feature/FEA consumption are intentionally not claimed yet.
+
+## Existing seam audit
+
+`Segment { Trace; From; To }` already created an owner-local bounded curve for a Profile; Concept Path and `|>` already consume named guides; `ResolvedProfileSegment2D` preserves source provenance. Those mechanisms are retained. BRep trim loops, `SurfacePatch`, Regions, imported topology selectors, PMI, and FEA selections stay distinct: they are not a second Span implementation and are not rebound by nearest geometry.
+
+## Admitted types
+
+| Span type | Domain representation | Orientation | Consumers | Status |
+| --- | --- | --- | --- | --- |
+| `Span<Line>` | named endpoints on a Line2/Rect edge | Forward/Reverse | Profile pipeline, Concept Path pipeline | qualified |
+| `Span<Arc>` | named endpoints on a Circle2, inspected as native radians | Forward/Reverse | guide binding; pipeline-compatible | qualified |
+| `Span<Curve>` | the same currently admitted planar line/arc guides | Forward/Reverse | guide binding | qualified |
+| `Span<Plane>` | named Profile boundary | Forward | semantic inspection only | deferred consumer |
+
+The CLI command `aetheris inspect-spans <file> --json` reports stable span identity, parent identity/type, domain, endpoints/boundary, orientation, length when available, and provenance.
+
+## Evidence and limits
+
+`fixtures/Canonical/Span/line-pipeline.firmament` gives the middle 40 mm of `Stock.Bottom` the identity `MountingEdge`; the Profile pipeline consumes that name without a helper line. The focused tests prove parent provenance, arc domain/length and reverse traversal, diagnostics for invalid type/off-parent/zero length, and the planar semantic view.
+
+An upstream parent edit is re-evaluated because the span resolves from its parent and named endpoints on every bind. It is rejected rather than clamped when an endpoint no longer lies on the parent. No STEP parity or packaged-CLI claim is made for curve or planar spans in this X1 increment; neither arbitrary trim nor a feature-support materializer was added.
+
+Future work: explicit normalized range syntax, finite arc parent carriers, `Span<Plane>` boundary/inside validation for Hole and FEA support, then cylindrical/freeform parameter spans and composite Regions.
diff --git a/fixtures/Canonical/Span/line-pipeline.firmament b/fixtures/Canonical/Span/line-pipeline.firmament
new file mode 100644
index 00000000..293eff7a
--- /dev/null
+++ b/fixtures/Canonical/Span/line-pipeline.firmament
@@ -0,0 +1,20 @@
+// LANG-SPAN-X1: MountingEdge is a view of Stock.Bottom, not helper geometry.
+Rect2 Stock { Center: [50mm, 20mm]; Size: [100mm, 40mm] }
+Point2 MountLeft { Position: [30mm, 0mm] }
+Point2 MountRight { Position: [70mm, 0mm] }
+Point2 UpperRight { Position: [70mm, 20mm] }
+Point2 UpperLeft { Position: [30mm, 20mm] }
+Line2 Rise { From: MountRight; To: UpperRight }
+Line2 Top { From: UpperRight; To: UpperLeft }
+Line2 Down { From: UpperLeft; To: MountLeft }
+
+Span<Line> MountingEdge {
+ On: Stock.Bottom
+ From: MountLeft
+ To: MountRight
+}
+
+Profile MountingPlate {
+ Loop Outer { MountingEdge |> Rise |> Top |> Down |> Close }
+}
+Extrude Plate { Profile: MountingPlate; From: 0mm; To: 2mm }