Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Document Firmament V2 semantic reference doctrine
Yuechen Lif8e731b4c105
diff --git a/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.cs b/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.csindex 9b254023..827e09dc 100644--- a/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.cs+++ b/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.cs@@ -7,6 +7,7 @@ public sealed class FirmamentFixtureCorpusTestsprivate static readonly string CorpusRoot = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../fixtures/Firmament"));private static readonly string V2CorpusRoot = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../fixtures/FirmamentV2"));private static readonly string V2DoctrinePath = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../docs/air-firmament-a2-firmament-v2-source-language-design.md"));+ private static readonly string V21DoctrinePath = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../docs/air-firmament-a2-1-semantic-references-admissibility-surface-doctrine.md"));private static readonly string[] RequiredMetadata = ["fixture-id", "case", "category", "validity", "implementation", "expected", "expected-stage"];[Fact]@@ -101,6 +102,14 @@ public sealed class FirmamentFixtureCorpusTestsAssert.Contains(fixtures, p => p.EndsWith("Shell/future/open-top-box-shell-v2.valid.firmfixture", StringComparison.Ordinal));Assert.Contains(fixtures, p => p.EndsWith("Fillet/future/single-edge-fillet-v2.valid.firmfixture", StringComparison.Ordinal));Assert.Contains(fixtures, p => p.EndsWith("Invalid/invalid-missing-units-v2.invalid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("SemanticRefs/valid/named-box-faces-v2.valid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("SemanticRefs/valid/side-hole-feature-output-aliases-v2.valid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("SemanticRefs/invalid/raw-brep-id-reference-v2.invalid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("Admissibility/invalid/degenerate-box-zero-dimension-v2.invalid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("Admissibility/invalid/shell-thickness-collapse-v2.invalid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("Surface/future/ruled-surface-rails-v2.valid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("Surface/future/offset-surface-detail-v2.valid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("Pattern/future/linear-pattern-v2.valid.firmfixture", StringComparison.Ordinal));foreach (var path in fixtures){@@ -143,6 +152,66 @@ public sealed class FirmamentFixtureCorpusTestsAssert.Contains("not the core language model", doc, StringComparison.OrdinalIgnoreCase);}+ [Fact]+ public void FirmamentV2SemanticRefs_MetadataRecognized()+ {+ var semanticRefs = DiscoverV2Fixtures().Where(p => p.Contains("/SemanticRefs/", StringComparison.Ordinal)).ToArray();+ Assert.NotEmpty(semanticRefs);+ foreach (var path in semanticRefs)+ {+ var fixture = LoadMetadata(path);+ Assert.Equal("FirmamentV2", fixture["syntax-version"]);+ Assert.Equal("SemanticRefs", fixture["category"]);+ Assert.True(fixture.ContainsKey("expected-diagnostic"), path);+ }+ }++ [Fact]+ public void FirmamentV2SemanticRefs_NotV1ParseFailures()+ {+ foreach (var path in DiscoverV2Fixtures().Where(p => p.Contains("/SemanticRefs/", StringComparison.Ordinal)))+ {+ using var doc = Trace(path);+ var diagnostics = doc.RootElement.GetProperty("diagnostics").EnumerateArray().Select(x => x.GetString()).ToArray();+ Assert.False(doc.RootElement.GetProperty("fixture").GetProperty("parserBacked").GetBoolean());+ Assert.DoesNotContain("air-x11-firmament-parse-failed", diagnostics);+ }+ }++ [Fact]+ public void FirmamentV2Admissibility_InvalidFixtures_ReportExpectedDiagnostics()+ {+ var expected = new[]+ {+ (Path: "SemanticRefs/invalid/raw-brep-id-reference-v2.invalid.firmfixture", Diagnostic: "firmament-raw-backend-id-reference-forbidden"),+ (Path: "Admissibility/invalid/degenerate-box-zero-dimension-v2.invalid.firmfixture", Diagnostic: "firmament-degenerate-dimension"),+ (Path: "Admissibility/invalid/shell-thickness-collapse-v2.invalid.firmfixture", Diagnostic: "firmament-shell-thickness-collapses-body")+ };++ foreach (var item in expected)+ {+ using var doc = Trace(Path.Combine(V2CorpusRoot, item.Path));+ var diagnostics = doc.RootElement.GetProperty("diagnostics").EnumerateArray().Select(x => x.GetString()).ToArray();+ Assert.True(doc.RootElement.GetProperty("fixture").GetProperty("expectationSatisfied").GetBoolean(), item.Path);+ Assert.Contains(item.Diagnostic, diagnostics);+ }+ }++ [Fact]+ public void FirmamentV2Doctrine_DocsMentionAdmissibilityAndRuledSurfacePolicy()+ {+ Assert.True(File.Exists(V21DoctrinePath), V21DoctrinePath);+ var doc = File.ReadAllText(V21DoctrinePath);+ Assert.Contains("degenerate geometry", doc, StringComparison.OrdinalIgnoreCase);+ Assert.Contains("compile errors", doc, StringComparison.OrdinalIgnoreCase);+ Assert.Contains("ruled/sweep/offset-first", doc, StringComparison.OrdinalIgnoreCase);+ Assert.Contains("Spline/NURBS limited admission", doc, StringComparison.OrdinalIgnoreCase);+ Assert.Contains("no loops", doc, StringComparison.OrdinalIgnoreCase);+ Assert.Contains("no conditionals", doc, StringComparison.OrdinalIgnoreCase);+ Assert.Contains("=>", doc, StringComparison.Ordinal);+ Assert.Contains("not BRep IDs", doc, StringComparison.OrdinalIgnoreCase);+ }+[Fact]public void FirmamentFixtureCorpus_DoesNotRequireFeatureImplementation(){diff --git a/docs/air-a0-aetheris-v2-compiler-ir-constitution.md b/docs/air-a0-aetheris-v2-compiler-ir-constitution.mdindex df24a57f..557d184a 100644--- a/docs/air-a0-aetheris-v2-compiler-ir-constitution.md+++ b/docs/air-a0-aetheris-v2-compiler-ir-constitution.md@@ -819,3 +819,7 @@ AIR-REGION-X7 consumes the controlled side-hole placeholder plan for the `+X` fi## AIR-FIRMAMENT-A1 Firmament source fixture corpus noteAIR-FIRMAMENT-A1 establishes `fixtures/Firmament/` as the source-language corpus for compiler-style development: Firmament source fixture -> parse -> semantic intent -> Feature AIR -> Constructive/Compositional AIR -> BRepPlan -> BRep -> STEP/artifacts -> trace/diagnostics -> regression corpus. Valid source intent can be tracked before implementation with `implementation: not-implemented` or `deferred`; such fixtures are not syntax-invalid and must report deliberate metadata-backed diagnostics instead of random parser/materialization failure. CIR remains analysis/evaluation mirror only and is not topology authority.++## Firmament V2 admissibility note++AIR-FIRMAMENT-A2.1 makes degeneracy rejection part of the Firmament V2 source-language contract. When source/semantic analysis can prove that construction intent necessarily creates degenerate, impossible, ambiguous, or unsupported geometry within the admitted lowering route, the compiler should reject it before backend emission with a bounded diagnostic rather than letting invalid intent leak into BRep. If source analysis cannot prove the condition, AIR/BRepPlan/BRep may still return a bounded blocker; the compiler should not fake certainty.diff --git a/docs/air-firmament-a1-firmament-fixture-corpus.md b/docs/air-firmament-a1-firmament-fixture-corpus.mdindex 2111cfbb..76dd1e30 100644--- a/docs/air-firmament-a1-firmament-fixture-corpus.md+++ b/docs/air-firmament-a1-firmament-fixture-corpus.md@@ -148,8 +148,16 @@ fixtures/FirmamentV2/Fillet/Shell/Surfacing/+ Surface/+ SemanticRefs/+ Admissibility/+ Pattern/Material/Invalid/```Future features should be written in V2 syntax first, marked not implemented/future-design, and then advanced through parser, semantic intent, Feature AIR, Constructive/Compositional AIR, BRepPlan, BRep, STEP/artifact, and trace stages in narrow milestones. Existing V1 fixtures remain valid in `fixtures/Firmament/` and do not require migration.++## A2.1 semantic-reference and admissibility fixture expansion++A2.1 expands the `fixtures/FirmamentV2/` metadata-only taxonomy with semantic-reference, admissibility, surface-doctrine, and pattern-as-record pilot fixtures. These fixtures remain `syntax-version: FirmamentV2` and are deliberately classified by metadata rather than by the V1 parser. Valid design examples use `implementation: not-implemented`, `expected-stage: not-implemented`, and `expected-diagnostic: firmament-v2-parser-not-ready`; invalid doctrine examples use `implementation: rejected` with stable diagnostics such as `firmament-raw-backend-id-reference-forbidden`, `firmament-degenerate-dimension`, and `firmament-shell-thickness-collapses-body`.diff --git a/docs/air-firmament-a2-1-semantic-references-admissibility-surface-doctrine.md b/docs/air-firmament-a2-1-semantic-references-admissibility-surface-doctrine.mdnew file mode 100644index 00000000..78174d8c--- /dev/null+++ b/docs/air-firmament-a2-1-semantic-references-admissibility-surface-doctrine.md@@ -0,0 +1,386 @@+# AIR-FIRMAMENT-A2.1 — Semantic references, admissibility, and surface doctrine++## 1. Purpose++A2.1 defines the Firmament V2 semantic contract before parser implementation. It closes the source-language design gaps left after A2 by specifying source-level references, exposure/binding, compile-time admissibility, degeneracy rejection, ruled/sweep/offset-first surface modeling, limited spline/NURBS admission, and feature-output roles.++This is a design/audit milestone. It does not implement a full V2 parser, new geometry features, backend behavior, corpus migration, or production route replacement.++## 2. Firmament V2 identity++```text+Firmament V2 is a typed declarative record language for CAD construction intent.++It is intentionally not Turing-complete.+It has no loops, no conditionals, no user-defined functions, and no arbitrary computation.++All repetition, branching, and construction strategy belong to explicit records, AIR lowering, compiler passes, or later admitted feature families — not source-language control flow.+```++Firmament V2 expresses named construction objects, typed records, semantic selectors, feature operations, scoped regions, materials, patterns as data, admissibility constraints, and lowering expectations.++## 3. Semantic subobject references++Initial source-level reference types are:++```text+FaceRef+EdgeRef+VertexRef+LoopRef+ProfileRef+RegionRef+FeatureRef+FeatureOutputRef+MaterialRef+```++These are source-level semantic references, not BRep IDs. Firmament V2 explicitly forbids raw BRep face IDs, raw edge IDs, coedge IDs, STEP entity IDs, backend-generated GUIDs as source references, and direct references to incidental topology ordering.++```text+Firmament V2 references authoring-level meaning.+BRepPlan/BRep may later materialize those references as topology roles/entities.+Firmament source must not depend on backend emission IDs.+```++## 4. Selector expression model++Initial selector examples include:++```firmament+base.face(+X)+base.face(-Z)+base.face(+Z).outerLoop+base.edge(+X, +Z)+base.vertex(-X, -Y, +Z)+profile.outerLoop+profile.segment("left")+feature.entryLoop+feature.exitLoop+feature.wallFace+feature.createdFaces+feature.affectedFaces+```++Selectors are typed. They resolve against the semantic body state at the relevant source point. They may lower to AIR selectors and BRepPlan roles. Selector ambiguity, unresolved selection, or selection that depends on incidental backend topology ordering is a compile error or a deliberate bounded blocker.++## 5. Fat-arrow exposure syntax++`=>` is reserved for semantic exposure/binding only.++```text+`=>` binds a selector or feature-output role to a source-level alias.++It does not mean mutation, control flow, lowering, Boolean composition, or execution order.+```++```firmament+solid base = box {+ size: [10, 8, 6]++ expose {+ face(+Z) => top+ face(+Z).outerLoop => topRim+ face(+X) => right+ }+}+```++Feature outputs may also be exposed:++```firmament+modify base {+ feature sideHole: Cut {+ on: face(+X)++ tool: Cylinder {+ radius: 1+ through: face(-X)+ }++ expose {+ entryLoop => inlet+ exitLoop => outlet+ wallFace => bore+ }+ }++ feature entryChamfer: Chamfer {+ target: sideHole.inlet+ distance: 0.2+ }+}+```++`sideHole.inlet` is a `FeatureOutputRef` alias. The canonical feature-output role remains `entryLoop`; the alias is source-level convenience and traceability.++## 6. Binding and versioning rules++```text+A modify block is source-order scoped.+Selectors inside a modify block resolve against the current semantic body state at that point.+Internally, the compiler may model body versions, but source syntax does not expose body version numbers by default.+Features may expose role outputs for later features.+```++```firmament+modify base {+ feature sideHole: Cut { ... }++ feature inletChamfer: Chamfer {+ target: sideHole.entryLoop+ distance: 0.2+ }+}+```++Downstream features should use feature outputs when referencing geometry created by prior features. This keeps the source tied to authoring meaning rather than later topology emission order.++## 7. Degenerate geometry as compile errors++```text+Firmament V2 rejects source that necessarily creates degenerate geometry in the admitted lowering route.+```++Compile errors include zero dimension box, negative radius cylinder, zero-height extrude, deterministically detectable self-intersecting profile, shell thickness that collapses a body, fillet radius exceeding admitted local clearance, chamfer distance collapsing selected geometry, ruled transition between incompatible sections without an admitted bridge rule, ambiguous selector, and impossible through target.++Suggested diagnostics:++```text+firmament-degenerate-dimension+firmament-negative-radius+firmament-zero-height-extrude+firmament-profile-self-intersection+firmament-shell-thickness-collapses-body+firmament-fillet-radius-exceeds-local-clearance+firmament-chamfer-distance-collapses-selection+firmament-ruled-sections-incompatible+firmament-selector-ambiguous+firmament-selector-unresolved+firmament-feature-not-admitted+firmament-feature-not-implemented+firmament-raw-backend-id-reference-forbidden+```++If the compiler cannot prove degeneracy at the source/semantic stage, later AIR/BRepPlan/BRep stages may return a bounded blocker. The compiler must not fake certainty.++## 8. Feature admissibility contracts++Every feature family should own an admissibility contract.++- Box: size components > 0.+- Cylinder: radius > 0; height > 0 for finite cylinders; explicit axis nonzero.+- Extrude: profile closed; profile non-self-intersecting when deterministically checked; height > 0; direction nonzero.+- RuledTransition: source and target sections admitted; sections compatible or bridge policy explicit; zero-area transition rejected.+- Shell: thickness > 0; direction admitted; removed face resolvable if required; inward shell must not collapse admitted body; offset self-intersection rejected or blocked.+- Chamfer: distance > 0; target selection admitted; distance must not collapse target under admitted local route; arbitrary graph rejected unless supported.+- Fillet: radius > 0; target selection admitted; radius must fit local clearance under admitted route; variable/mixed radii deferred unless supported.+- Pattern: seed feature exists; count > 0; spacing/direction admitted; pattern collisions may be compile errors or blockers if deterministically detected.+- Material: material properties have correct dimensions; assignment target must be resolvable; material field independence preserved.++## 9. Sweep / ruled / offset-first surface doctrine++Firmament V2 should prefer profiles, sweeps, ruled transitions, section transitions, analytic ruled surfaces, surface offsets, and normal/offset detail fields over raw primitive CSG-first authoring and spline/NURBS-first surfacing.++```text+Firmament V2 treats sweeps, profile extrusions, ruled transitions, and surface offsets as first-class construction intent.++Spline/NURBS surfaces are admitted detail/adaptation surfaces, not the default representation for ordinary sheet, ruled, or transition-like design intent.+```++Sheet metal and many Class-A-like surfaces should often be modeled as ruled/transition surfaces with optional normal/offset detail, not as one giant spline/NURBS patch. Ruled surfaces are exact construction intent when applicable. NURBS and splines are historical/editability tools and should not become the default ontology.++## 10. Ruled surface examples++These are design examples, not parser promises.++```firmament+solid body: RuledTransition {+ from: profileA at z: 0+ to: profileB at z: 6+}+```++```firmament+surface skin: RuledSurface {+ railA: Line {+ from: [0, 0, 0]+ to: [10, 0, 2]+ }++ railB: Line {+ from: [0, 8, 2]+ to: [10, 8, 0]+ }+}+```++```firmament+surface saddle: HyperbolicParaboloid {+ bounds: Rectangle { size: [10, 8] }+ height: 2+}+```++## 11. Surface offset doctrine++Surface offset is a first-class detailing operation, guarded by admissibility.++```firmament+surface outer: OffsetSurface {+ base: skin+ distance: 0.8+ direction: normal+}+```++```firmament+solid shell: Shell {+ target: base+ thickness: 1+ remove: face(+Z)+ direction: inward+}+```++```firmament+feature emboss: SurfaceOffsetDetail {+ target: base.face(+Z)++ offset: HeightField {+ source: ribPattern+ scale: 0.2+ }+}+```++```text+Surface offsets that self-intersect, collapse thickness, or create ambiguous topology are compile errors when deterministically provable, or bounded lowering blockers otherwise.+```++## 12. Spline/NURBS limited admission++```text+Spline/NURBS surfaces are not the default shape model for Firmament V2.++They may be admitted for:+ localized detail;+ imported compatibility;+ human-authored freeform styling where no ruled/analytic construction is available;+ normal/offset correction fields;+ bounded surfacing features.++They should not displace ruled/sweep/offset construction as the primary representation.+```++Future design examples, not parser promises:++```firmament+surface detail: SplineSurface {+ usage: detail+ control: ...+}+```++```firmament+surface styled: SplineOffset {+ base: ruledSkin+ normalOffset: detailMap+}+```++## 13. Pattern-as-record doctrine++Firmament V2 has no loops. Patterning is explicit data:++```firmament+feature holes: LinearPattern {+ seed: sideHole+ count: 6+ spacing: 10+ direction: +Y+}+```++Not:++```text+for i in 0..6 { ... }+```++Patterns are feature records. Repetition is declarative. AIR lowering decides expansion/materialization. Pattern collision/admissibility must be checked.++## 14. Variant/configuration-as-record doctrine++Firmament V2 has no conditionals. If variants are needed, represent them as explicit data. This is future design, not parser support:++```firmament+variant size: VariantSet {+ options: {+ small: { width: 10 height: 6 }+ large: { width: 20 height: 12 }+ }++ selected: small+}+```++## 15. Units and quantities++Firmament V2 examples may use inherited units:++```firmament+units mm++solid base: Box {+ size: [10, 8, 6]+}+```++or explicit quantities:++```firmament+solid base: Box {+ size: [10 mm, 8 mm, 6 mm]+}+```++Units are typed quantities internally. Dimensions must match expected fields. Invalid dimension usage is a compile error: `radius: -1 mm` is invalid; `youngs: 120 mm` is invalid; `distance: 0.5` under `units mm` is a valid length; `youngs: 120 GPa` is a valid stress/material quantity.++## 16. Feature-output role vocabulary++Initial canonical semantic roles are:++- Cut / side-hole: `entryLoop`, `exitLoop`, `wallFace`, `affectedFace`, `integrationPatch`, `createdFaces`, `affectedFaces`.+- Chamfer: `chamferFace`, `targetLoop`, `startLoop`, `endLoop`, `affectedEdges`.+- Fillet: `filletFace`, `spine`, `affectedEdges`, `cornerPatch`.+- Shell: `outerFaces`, `innerFaces`, `rimFaces`, `removedFaces`, `innerLoops`, `outerLoops`.+- Ruled transition: `startSection`, `endSection`, `transitionFaces`, `railEdges`.+- Pattern: `seed`, `instances`, `instanceTransforms`.+- Material: `assignedRegion`, `materialField`, `orientationField`, `authorityField`.++These are semantic roles, not raw backend IDs.++## 17. Firmasm note++```text+Firmament V2 is the human source language.+Firmasm remains a normalized machine-facing representation and may stay JSON/record-like.+A2.1 does not redesign Firmasm.+```++## 18. Pilot metadata/design fixtures++A2.1 adds metadata-only design fixtures under `fixtures/FirmamentV2/` for semantic references, feature-output aliases, forbidden backend IDs, degenerate dimensions, shell collapse, ruled/offset surface examples, and pattern-as-record examples. Until a V2 parser exists, valid future examples are classified as `not-implemented` with `firmament-v2-parser-not-ready`, and invalid examples are classified by metadata diagnostics such as `firmament-degenerate-dimension`, `firmament-shell-thickness-collapses-body`, and `firmament-raw-backend-id-reference-forbidden`. They must not be run through the V1 parser as random parse failures.++## 19. Tests++A2.1 tests should verify that metadata is recognized, V2 semantic-reference fixtures are not V1 parse failures, invalid admissibility fixtures report their expected metadata diagnostics, doctrine text mentions admissibility and ruled/sweep/offset-first policy, and existing V1 box and side-hole fixtures remain valid.++## 20. Docs update++A2.1 extends A2 rather than replacing it. A2 remains the broader V2 source-language audit; this document is the semantic-reference, admissibility, and surface-doctrine addendum. The A1 fixture-corpus doc records the expanded V2 metadata-only taxonomy. The A0 compiler IR constitution records that Firmament V2 rejects provable degenerate construction intent before backend emission when possible.++## 21. Non-goals++A2.1 explicitly preserves: no parser implementation; no backend implementation; no shell implementation; no fillet implementation; no surfacing implementation; no pattern implementation; no material implementation; no broad Boolean; no CIR topology authority; no STEP behavior change; no BRep topology behavior change; no Firmasm redesign; no corpus migration; no production route replacement; no general side-hole support; no arbitrary face/axis support; no production analyzer/map behavior changes; no CIR evaluator/tape behavior changes; no route-selection/JudgmentUtility production behavior changes; no AirEdgeSweep behavior changes; no BrepBoundedChamfer/BrepBoundedFillet behavior changes; no triangle migration; and no NURBS/freeform implementation.diff --git a/docs/air-firmament-a2-firmament-v2-source-language-design.md b/docs/air-firmament-a2-firmament-v2-source-language-design.mdindex b6e68497..4ddcfd08 100644--- a/docs/air-firmament-a2-firmament-v2-source-language-design.md+++ b/docs/air-firmament-a2-firmament-v2-source-language-design.md@@ -358,3 +358,7 @@ Recommended next milestones:4. Lower one profile extrusion fixture through Feature AIR and existing Constructive AIR/profile emission evidence.5. Promote side-hole V2 region syntax from design fixture to semantic intent only, then to AIR Region only, before any materialization expansion.6. Keep fillet, shell, surfacing, and material fixtures as future-design until their compiler stages are separately admitted.++## A2.1 semantic contract addendum++AIR-FIRMAMENT-A2.1 extends this source-language design with the semantic-reference and admissibility contract that must be settled before parser work begins. See `docs/air-firmament-a2-1-semantic-references-admissibility-surface-doctrine.md` for the typed source-level reference model, the reserved `=>` exposure/binding syntax, compile-time degeneracy/admissibility doctrine, ruled/sweep/offset-first surface policy, limited-admission spline/NURBS policy, pattern-as-record/no-control-flow doctrine, and feature-output role vocabulary. A2.1 remains design/audit only: no full V2 parser, backend behavior change, corpus migration, or geometry feature implementation is introduced.diff --git a/fixtures/FirmamentV2/Admissibility/invalid/degenerate-box-zero-dimension-v2.invalid.firmfixture b/fixtures/FirmamentV2/Admissibility/invalid/degenerate-box-zero-dimension-v2.invalid.firmfixturenew file mode 100644index 00000000..55467767--- /dev/null+++ b/fixtures/FirmamentV2/Admissibility/invalid/degenerate-box-zero-dimension-v2.invalid.firmfixture@@ -0,0 +1,15 @@+// fixture-id: degenerate-box-zero-dimension-v2+// case: firmament-v2-degenerate-box-zero-dimension+// category: Admissibility+// syntax-version: FirmamentV2+// validity: invalid+// implementation: rejected+// expected: invalid+// expected-stage: rejected+// expected-diagnostic: firmament-degenerate-dimension+// notes: AIR-FIRMAMENT-A2.1 zero-size box dimension is a compile-time degeneracy.++model DegenerateBox {+ units mm+ solid base = box { size: [10, 0, 6] }+}diff --git a/fixtures/FirmamentV2/Admissibility/invalid/shell-thickness-collapse-v2.invalid.firmfixture b/fixtures/FirmamentV2/Admissibility/invalid/shell-thickness-collapse-v2.invalid.firmfixturenew file mode 100644index 00000000..87766776--- /dev/null+++ b/fixtures/FirmamentV2/Admissibility/invalid/shell-thickness-collapse-v2.invalid.firmfixture@@ -0,0 +1,16 @@+// fixture-id: shell-thickness-collapse-v2+// case: firmament-v2-shell-thickness-collapse+// category: Admissibility+// syntax-version: FirmamentV2+// validity: invalid+// implementation: rejected+// expected: invalid+// expected-stage: rejected+// expected-diagnostic: firmament-shell-thickness-collapses-body+// notes: AIR-FIRMAMENT-A2.1 shell collapse is invalid design intent; no shell implementation is introduced.++model ShellCollapse {+ units mm+ solid base = box { size: [10, 8, 1] }+ solid shell: Shell { target: base thickness: 2 remove: face(+Z) direction: inward }+}diff --git a/fixtures/FirmamentV2/Pattern/future/linear-pattern-v2.valid.firmfixture b/fixtures/FirmamentV2/Pattern/future/linear-pattern-v2.valid.firmfixturenew file mode 100644index 00000000..f759d6d9--- /dev/null+++ b/fixtures/FirmamentV2/Pattern/future/linear-pattern-v2.valid.firmfixture@@ -0,0 +1,20 @@+// fixture-id: linear-pattern-v2+// case: firmament-v2-linear-pattern+// category: Pattern+// syntax-version: FirmamentV2+// validity: valid+// implementation: not-implemented+// expected: valid+// expected-stage: not-implemented+// expected-diagnostic: firmament-v2-parser-not-ready+// notes: AIR-FIRMAMENT-A2.1 pattern-as-record design; no pattern implementation.++model LinearPatternDesign {+ units mm+ feature holes: LinearPattern {+ seed: sideHole+ count: 6+ spacing: 10+ direction: +Y+ }+}diff --git a/fixtures/FirmamentV2/SemanticRefs/invalid/raw-brep-id-reference-v2.invalid.firmfixture b/fixtures/FirmamentV2/SemanticRefs/invalid/raw-brep-id-reference-v2.invalid.firmfixturenew file mode 100644index 00000000..d45690ef--- /dev/null+++ b/fixtures/FirmamentV2/SemanticRefs/invalid/raw-brep-id-reference-v2.invalid.firmfixture@@ -0,0 +1,18 @@+// fixture-id: raw-brep-id-reference-v2+// case: firmament-v2-raw-brep-id-reference+// category: SemanticRefs+// syntax-version: FirmamentV2+// validity: invalid+// implementation: rejected+// expected: invalid+// expected-stage: rejected+// expected-diagnostic: firmament-raw-backend-id-reference-forbidden+// notes: AIR-FIRMAMENT-A2.1 forbids backend topology IDs in source references.++model RawBRepIdReference {+ units mm+ solid base = box { size: [10, 8, 6] }+ modify base {+ feature bad: Chamfer { target: brep.face("F-00017") distance: 0.2 }+ }+}diff --git a/fixtures/FirmamentV2/SemanticRefs/valid/named-box-faces-v2.valid.firmfixture b/fixtures/FirmamentV2/SemanticRefs/valid/named-box-faces-v2.valid.firmfixturenew file mode 100644index 00000000..d3c3f44f--- /dev/null+++ b/fixtures/FirmamentV2/SemanticRefs/valid/named-box-faces-v2.valid.firmfixture@@ -0,0 +1,23 @@+// fixture-id: named-box-faces-v2+// case: firmament-v2-named-box-faces+// category: SemanticRefs+// syntax-version: FirmamentV2+// validity: valid+// implementation: not-implemented+// expected: valid+// expected-stage: not-implemented+// expected-diagnostic: firmament-v2-parser-not-ready+// notes: AIR-FIRMAMENT-A2.1 metadata-only semantic exposure fixture; not parser-backed.++model NamedBoxFaces {+ units mm++ solid base = box {+ size: [10, 8, 6]+ expose {+ face(+Z) => top+ face(+Z).outerLoop => topRim+ face(+X) => right+ }+ }+}diff --git a/fixtures/FirmamentV2/SemanticRefs/valid/side-hole-feature-output-aliases-v2.valid.firmfixture b/fixtures/FirmamentV2/SemanticRefs/valid/side-hole-feature-output-aliases-v2.valid.firmfixturenew file mode 100644index 00000000..e42222f0--- /dev/null+++ b/fixtures/FirmamentV2/SemanticRefs/valid/side-hole-feature-output-aliases-v2.valid.firmfixture@@ -0,0 +1,27 @@+// fixture-id: side-hole-feature-output-aliases-v2+// case: firmament-v2-side-hole-feature-output-aliases+// category: SemanticRefs+// syntax-version: FirmamentV2+// validity: valid+// implementation: not-implemented+// expected: valid+// expected-stage: not-implemented+// expected-diagnostic: firmament-v2-parser-not-ready+// notes: AIR-FIRMAMENT-A2.1 metadata-only FeatureOutputRef alias fixture; no general side-hole support.++model SideHoleAliases {+ units mm+ solid base = box { size: [10, 8, 6] }+ modify base {+ feature sideHole: Cut {+ on: face(+X)+ tool: Cylinder { radius: 1 through: face(-X) }+ expose {+ entryLoop => inlet+ exitLoop => outlet+ wallFace => bore+ }+ }+ feature entryChamfer: Chamfer { target: sideHole.inlet distance: 0.2 }+ }+}diff --git a/fixtures/FirmamentV2/Surface/future/offset-surface-detail-v2.valid.firmfixture b/fixtures/FirmamentV2/Surface/future/offset-surface-detail-v2.valid.firmfixturenew file mode 100644index 00000000..8d49e2ce--- /dev/null+++ b/fixtures/FirmamentV2/Surface/future/offset-surface-detail-v2.valid.firmfixture@@ -0,0 +1,18 @@+// fixture-id: offset-surface-detail-v2+// case: firmament-v2-offset-surface-detail+// category: Surface+// syntax-version: FirmamentV2+// validity: valid+// implementation: not-implemented+// expected: valid+// expected-stage: not-implemented+// expected-diagnostic: firmament-v2-parser-not-ready+// notes: AIR-FIRMAMENT-A2.1 future offset detail design; no surfacing implementation.++model OffsetSurfaceDetail {+ units mm+ feature emboss: SurfaceOffsetDetail {+ target: base.face(+Z)+ offset: HeightField { source: ribPattern scale: 0.2 }+ }+}diff --git a/fixtures/FirmamentV2/Surface/future/ruled-surface-rails-v2.valid.firmfixture b/fixtures/FirmamentV2/Surface/future/ruled-surface-rails-v2.valid.firmfixturenew file mode 100644index 00000000..ceeee5d3--- /dev/null+++ b/fixtures/FirmamentV2/Surface/future/ruled-surface-rails-v2.valid.firmfixture@@ -0,0 +1,18 @@+// fixture-id: ruled-surface-rails-v2+// case: firmament-v2-ruled-surface-rails+// category: Surface+// syntax-version: FirmamentV2+// validity: valid+// implementation: not-implemented+// expected: valid+// expected-stage: not-implemented+// expected-diagnostic: firmament-v2-parser-not-ready+// notes: AIR-FIRMAMENT-A2.1 future ruled surface design; no surfacing implementation.++model RuledSurfaceRails {+ units mm+ surface skin: RuledSurface {+ railA: Line { from: [0, 0, 0] to: [10, 0, 2] }+ railB: Line { from: [0, 8, 2] to: [10, 8, 0] }+ }+}