Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add Firmament A2.3 DFM template doctrine
Yuechen Li9a5b76f73f20
diff --git a/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.cs b/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.csindex 631bed5b..74c2a5db 100644--- a/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.cs+++ b/Aetheris.CLI.Tests/FirmamentFixtureCorpusTests.cs@@ -9,6 +9,7 @@ public sealed class FirmamentFixtureCorpusTestsprivate 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 V22DoctrinePath = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../docs/air-firmament-a2-2-record-derivation-with.md"));+ private static readonly string V23DoctrinePath = Path.GetFullPath(Path.Combine(AppContext.BaseDirectory, "../../../../docs/air-firmament-a2-3-dfm-templates-concepts-pmi.md"));private static readonly string[] RequiredMetadata = ["fixture-id", "case", "category", "validity", "implementation", "expected", "expected-stage"];[Fact]@@ -117,6 +118,14 @@ public sealed class FirmamentFixtureCorpusTestsAssert.Contains(fixtures, p => p.EndsWith("RecordDerivation/invalid/with-degenerate-box-v2.invalid.firmfixture", StringComparison.Ordinal));Assert.Contains(fixtures, p => p.EndsWith("RecordDerivation/invalid/with-selector-target-v2.invalid.firmfixture", StringComparison.Ordinal));Assert.Contains(fixtures, p => p.EndsWith("RecordDerivation/invalid/with-unknown-field-v2.invalid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("Templates/valid/cnc-template-min-tool-radius-v2.valid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("Templates/valid/fdm-template-wall-overhang-v2.valid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("Templates/valid/sheet-metal-template-v2.valid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("Templates/invalid/template-concept-unit-mismatch-v2.invalid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("Templates/invalid/template-unknown-process-v2.invalid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("PMI/future/pmi-datum-flatness-position-v2.valid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("PMI/future/pmi-material-surface-finish-v2.valid.firmfixture", StringComparison.Ordinal));+ Assert.Contains(fixtures, p => p.EndsWith("PMI/invalid/pmi-raw-brep-id-target-v2.invalid.firmfixture", StringComparison.Ordinal));foreach (var path in fixtures){@@ -283,6 +292,91 @@ public sealed class FirmamentFixtureCorpusTestsAssert.Contains("=>", doc, StringComparison.Ordinal);}++ [Fact]+ public void FirmamentV2Templates_MetadataRecognized()+ {+ var fixtures = DiscoverV2Fixtures().Where(p => p.Contains("/Templates/", StringComparison.Ordinal)).ToArray();+ Assert.Equal(5, fixtures.Length);+ foreach (var path in fixtures)+ {+ var fixture = LoadMetadata(path);+ Assert.Equal("FirmamentV2", fixture["syntax-version"]);+ Assert.Equal("Templates", fixture["category"]);+ Assert.True(fixture.ContainsKey("expected-diagnostic"), path);+ }+ }++ [Fact]+ public void FirmamentV2Templates_NotV1ParseFailures()+ {+ foreach (var path in DiscoverV2Fixtures().Where(p => p.Contains("/Templates/", 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.True(doc.RootElement.GetProperty("fixture").GetProperty("expectationSatisfied").GetBoolean(), path);+ Assert.DoesNotContain("air-x11-firmament-parse-failed", diagnostics);+ }+ }++ [Fact]+ public void FirmamentV2Templates_InvalidFixtures_ReportExpectedDiagnostics()+ {+ var expected = new[]+ {+ (Path: "Templates/invalid/template-concept-unit-mismatch-v2.invalid.firmfixture", Diagnostic: "firmament-concept-unit-mismatch"),+ (Path: "Templates/invalid/template-unknown-process-v2.invalid.firmfixture", Diagnostic: "firmament-template-process-unknown")+ };++ 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 FirmamentV2PMI_MetadataRecognized()+ {+ var fixtures = DiscoverV2Fixtures().Where(p => p.Contains("/PMI/", StringComparison.Ordinal)).ToArray();+ Assert.Equal(3, fixtures.Length);+ foreach (var path in fixtures)+ {+ var fixture = LoadMetadata(path);+ Assert.Equal("FirmamentV2", fixture["syntax-version"]);+ Assert.Equal("PMI", fixture["category"]);+ Assert.True(fixture.ContainsKey("expected-diagnostic"), path);+ }+ }++ [Fact]+ public void FirmamentV2PMI_InvalidFixtures_ReportExpectedDiagnostics()+ {+ using var doc = Trace(Path.Combine(V2CorpusRoot, "PMI/invalid/pmi-raw-brep-id-target-v2.invalid.firmfixture"));+ var diagnostics = doc.RootElement.GetProperty("diagnostics").EnumerateArray().Select(x => x.GetString()).ToArray();+ Assert.True(doc.RootElement.GetProperty("fixture").GetProperty("expectationSatisfied").GetBoolean());+ Assert.Contains("firmament-raw-backend-id-reference-forbidden", diagnostics);+ }++ [Fact]+ public void FirmamentV2Doctrine_DocsMentionTemplatesConceptsPMI()+ {+ Assert.True(File.Exists(V23DoctrinePath), V23DoctrinePath);+ var doc = File.ReadAllText(V23DoctrinePath);+ Assert.Contains("template<Process>", doc, StringComparison.Ordinal);+ Assert.Contains("concept", doc, StringComparison.OrdinalIgnoreCase);+ Assert.Contains("PMI", doc, StringComparison.Ordinal);+ Assert.Contains("GD&T is one category inside PMI", doc, StringComparison.Ordinal);+ Assert.Contains("material", doc, StringComparison.OrdinalIgnoreCase);+ Assert.Contains("surface finish", doc, StringComparison.OrdinalIgnoreCase);+ Assert.Contains("not C++-style metaprogramming", doc, StringComparison.OrdinalIgnoreCase);+ Assert.Contains("not hidden Excel tables", doc, StringComparison.OrdinalIgnoreCase);+ Assert.Contains("no STEP PMI export in A2.3", 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 3a795c0f..23f59474 100644--- a/docs/air-a0-aetheris-v2-compiler-ir-constitution.md+++ b/docs/air-a0-aetheris-v2-compiler-ir-constitution.md@@ -1,5 +1,7 @@# AIR-A0 — Aetheris V2 compiler IR constitution+Firmament V2 `template<Process>`, `concept`, and PMI records are source/semantic manufacturing-intent layers. They may later lower toward Feature AIR / PMI AIR and semantic role attachments, but A2.3 introduces no STEP PMI export, no BRep topology behavior change, and no CIR topology authority. See `docs/air-firmament-a2-3-dfm-templates-concepts-pmi.md`.+## 1. Executive summaryAetheris is a compiler for BRep.diff --git a/docs/air-firmament-a1-firmament-fixture-corpus.md b/docs/air-firmament-a1-firmament-fixture-corpus.mdindex 63e63aaf..e1dd1bf6 100644--- a/docs/air-firmament-a1-firmament-fixture-corpus.md+++ b/docs/air-firmament-a1-firmament-fixture-corpus.md@@ -1,5 +1,7 @@# AIR-FIRMAMENT-A1 — Firmament fixture corpus and lowering-stage taxonomy+AIR-FIRMAMENT-A2.3 extends the V2 metadata-only design fixture taxonomy with `fixtures/FirmamentV2/Templates/` for `template<Process>`/`concept` doctrine and `fixtures/FirmamentV2/PMI/` for product/manufacturing information examples. These fixtures remain parser-not-ready or metadata-rejected contracts and must not be treated as V1 parse failures.+## PurposeAIR-FIRMAMENT-A1 formalizes Firmament as Aetheris' source-language corpus. `.firmfixture` files are compiler-style fixtures: they record authoring intent, expected validity, expected implementation state, expected lowering stage, and stable diagnostics before geometry support is broadened.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.mdindex dfbb158f..6c3de879 100644--- a/docs/air-firmament-a2-1-semantic-references-admissibility-surface-doctrine.md+++ b/docs/air-firmament-a2-1-semantic-references-admissibility-surface-doctrine.md@@ -1,5 +1,7 @@# AIR-FIRMAMENT-A2.1 — Semantic references, admissibility, and surface doctrine+A2.3 extends this admissibility doctrine with manufacturing/process contexts: `template<Process>` supplies typed DFM concepts, and PMI records attach product/manufacturing annotations to semantic selectors and feature outputs rather than backend IDs. See `docs/air-firmament-a2-3-dfm-templates-concepts-pmi.md`.+## 1. PurposeA2.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.diff --git a/docs/air-firmament-a2-2-record-derivation-with.md b/docs/air-firmament-a2-2-record-derivation-with.mdindex a3a3aba8..a2e9fbe5 100644--- a/docs/air-firmament-a2-2-record-derivation-with.md+++ b/docs/air-firmament-a2-2-record-derivation-with.md@@ -1,5 +1,7 @@# AIR-FIRMAMENT-A2.2 — Firmament V2 record derivation with `with`+A2.3 applies the same immutable `with` doctrine to manufacturing templates/configs: derived `template<Process>` records may override typed `concept` facts, are revalidated, and do not mutate the original template. See `docs/air-firmament-a2-3-dfm-templates-concepts-pmi.md`.+## 1. PurposeA2.2 defines `with` as Firmament V2's record derivation and configuration mechanism. Firmament V2 is a typed declarative record language, so configuration should remain data-shaped: named records are authored once, then immutable derived records express variants by overriding selected fields.diff --git a/docs/air-firmament-a2-3-dfm-templates-concepts-pmi.md b/docs/air-firmament-a2-3-dfm-templates-concepts-pmi.mdnew file mode 100644index 00000000..510e7042--- /dev/null+++ b/docs/air-firmament-a2-3-dfm-templates-concepts-pmi.md@@ -0,0 +1,376 @@+# AIR-FIRMAMENT-A2.3 — Firmament V2 DFM templates, concepts, and PMI doctrine++## 1. Purpose++A2.3 defines Firmament V2's manufacturing/process doctrine before parser work. Firmament V2 is a typed declarative record language for CAD construction intent and manufacturable design intent, so manufacturing constraints should be source-level typed records and concepts rather than hidden spreadsheets or tribal-knowledge tables.++This milestone covers DFM templates, typed concepts, PMI as the umbrella product/manufacturing information term, the relationship to `with`, the future relationship to `where`, admissibility, later STEP/PMI lowering, and explicit non-goals. It is design, documentation, and metadata-fixture work only.++A2.3 does not implement a full V2 parser, backend behavior, STEP PMI export, GD&T geometry checks, material/FEA behavior, new geometry features, corpus migration, or production route replacement.++## 2. Terminology++```text+template<Process>:+ a manufacturing/process context, written with C++-style generic-looking syntax on purpose,+ but not C++ metaprogramming.++concept:+ a named typed manufacturing/admissibility fact used by DFM checks, feature admissibility, or later lowering policy.++PMI:+ Product and Manufacturing Information attached to source-level semantic geometry/features/materials.+ PMI includes GD&T, material, surface finish, process notes, inspection notes, and related manufacturing annotations.+```++PMI is not just GD&T. GD&T is one category inside PMI alongside material, surface finish, inspection notes, manufacturing notes, datum/tolerance-related annotations, and feature-linked manufacturing metadata.++## 3. Firmament template doctrine++Firmament V2 uses `template<Process>` syntax for manufacturing templates.++Templates are typed DFM/admissibility contexts. They are not C++-style metaprogramming. They do not generate arbitrary source code. They do not introduce loops, conditionals, macros, or templates-as-computation. They do not mutate geometry. They do not bypass AIR lowering.++```firmament+template<CNC> ShopDefault {+ concept minimumToolRadius: 0.1 mm+ concept minimumWallThickness: 0.8 mm+ concept minimumHoleDiameter: 0.8 mm+}+```++## 4. Why `template<Process>` syntax is allowed++Firmament V2 intentionally uses `template<Process>` syntax for manufacturing process templates. This borrows the familiar generic-looking shape while giving it a narrower and safer meaning: manufacturing context, not code generation.++```text+C++ template:+ compile-time metaprogramming / type-level code generation.++Firmament template:+ typed manufacturing/process context for admissibility and PMI.+```++The syntax is admitted as a source-language aesthetic, not as permission for arbitrary compile-time execution.++## 5. Template declaration and use++The following are long-term design examples, not parser promises.++Reusable template declaration:++```firmament+template<CNC> ShopDefault {+ concept minimumToolRadius: 0.1 mm+ concept minimumWallThickness: 0.8 mm+ concept preferredInsideCorner: Fillet+}+```++Model application:++```firmament+model Bracket {+ units mm++ use ShopDefault++ solid base: Box {+ size: [80, 40, 10]+ }+}+```++Alternative inline template context:++```firmament+model Bracket {+ units mm++ template<CNC> {+ concept minimumToolRadius: 0.1 mm+ concept minimumWallThickness: 0.8 mm+ }++ solid base: Box {+ size: [80, 40, 10]+ }+}+```++Model-level template style, design-only:++```firmament+model Bracket template<CNC> {+ units mm++ concept minimumToolRadius: 0.1 mm+ concept minimumWallThickness: 0.8 mm++ solid base: Box {+ size: [80, 40, 10]+ }+}+```++## 6. Concept doctrine++Concepts are typed named facts.++```firmament+concept minimumToolRadius: 0.1 mm+concept minimumWallThickness: 0.8 mm+concept maximumAspectRatio: 4+concept minimumDraftAngle: 2 deg+concept preferredInsideCorner: Fillet+concept allowedMaterials: [Aluminum6061, Steel1018]+```++Rules:++- concepts are typed;+- concepts are unit-aware;+- concepts are source-level manufacturing facts;+- concepts may participate in feature admissibility diagnostics;+- concepts do not construct geometry by themselves.++Suggested diagnostics:++- `firmament-concept-type-mismatch`+- `firmament-concept-unit-mismatch`+- `firmament-concept-unknown`+- `firmament-concept-duplicate`+- `firmament-template-process-unknown`+- `firmament-template-concept-missing`+- `firmament-dfm-constraint-violation`++## 7. DFM admissibility examples++CNC example, design-only:++```firmament+template<CNC> ShopDefault {+ concept minimumToolRadius: 0.1 mm+}++model PocketExample {+ units mm++ use ShopDefault++ solid base: Box {+ size: [80, 40, 10]+ }++ modify base {+ feature pocket: Pocket {+ on: face(+Z)+ depth: 4+ cornerRadius: 0.05+ }+ }+}+```++Expected future diagnostic:++```text+firmament-dfm-minimum-tool-radius-violation+```++because `cornerRadius < minimumToolRadius`.++FDM example, design-only:++```firmament+template<FDM> PrinterDefault {+ concept nozzleDiameter: 0.4 mm+ concept minimumWallThickness: 0.8 mm+ concept maximumUnsupportedOverhang: 45 deg+ concept layerHeight: 0.2 mm+}+```++Sheet metal example, design-only:++```firmament+template<SheetMetal> ShopDefault {+ concept thickness: 1.5 mm+ concept minimumBendRadius: 1.5 mm+ concept kFactor: 0.42+}+```++## 8. `with` and templates++Templates/configs can be derived with `with`. Canonical design-only example:++```firmament+template<CNC> ShopDefault {+ concept minimumToolRadius: 0.1 mm+ concept minimumWallThickness: 0.8 mm+}++template<CNC> RoughingOnly = ShopDefault with {+ concept minimumToolRadius: 0.5 mm+}+```++Doctrine:++- `with` remains immutable record derivation;+- derived templates/concepts are revalidated;+- derived templates do not mutate the original template.++## 9. PMI doctrine++```text+PMI is source-level product/manufacturing information attached to semantic model entities.++PMI includes:+ GD&T;+ datum definitions;+ tolerances;+ material assignments/specifications;+ surface finish;+ heat treatment/process notes;+ inspection notes;+ manufacturing notes;+ feature-level semantic annotations.+```++PMI is not geometry construction. PMI may affect admissibility, manufacturing validation, inspection, STEP export later, and documentation/artifacts.++## 10. PMI examples++The following are design examples, not parser promises.++GD&T-style / datum example:++```firmament+pmi BracketInspection {+ datum A: base.face(+Z)+ datum B: base.face(+X)++ flatness base.face(+Z) {+ tolerance: 0.05 mm+ }++ position sideHole.axis {+ tolerance: 0.10 mm+ datums: [A, B]+ }+}+```++Material PMI example:++```firmament+material aluminum: Isotropic {+ youngs: 69 GPa+ poisson: 0.33+}++pmi MaterialSpec {+ assign aluminum to base++ note {+ text: "Material: Aluminum 6061-T6"+ }+}+```++Surface finish PMI example:++```firmament+pmi FinishSpec {+ surfaceFinish base.face(+Z) {+ roughnessRa: 1.6 um+ }+}+```++Manufacturing note example:++```firmament+pmi ManufacturingNotes {+ note {+ target: sideHole.wallFace+ text: "Deburr bore after machining."+ }+}+```++## 11. Relationship between concepts and PMI++```text+concept:+ typed process/admissibility fact in a template.++PMI:+ product/manufacturing annotation or requirement attached to model entities.++A concept may constrain whether geometry is manufacturable.+PMI may record the manufacturing/inspection requirement that should later appear in artifacts.+```++For example, `concept minimumToolRadius: 0.1 mm` constrains pocket/chamfer admissibility, while `surfaceFinish face(+Z) { roughnessRa: 1.6 um }` records a manufacturing requirement.++## 12. Relationship to `where`++```text+where:+ local record/config constraints.++template<Process> + concept:+ manufacturing/process context and DFM constraints.++PMI:+ product/manufacturing annotation/tolerance information.+```++No `where` implementation, constraint solver, or GD&T checker is introduced in A2.3.++## 13. Relationship to AIR/BRep/STEP/CIR++```text+Firmament V2 template/concept/PMI source+ -> semantic manufacturing intent+ -> Feature AIR / PMI AIR later+ -> BRepPlan/BRep role attachment where applicable+ -> STEP PMI export later if admitted+```++There is no STEP PMI export in A2.3. There are no BRep topology behavior changes. CIR remains analysis-only and not topology authority. PMI may later attach to semantic roles and BRep entities, but Firmament source should reference semantic selectors/feature outputs, not backend IDs.++## 14. Non-spreadsheet doctrine++```text+Firmament configs are records, not spreadsheets.+Manufacturing templates are source records, not hidden Excel tables.+External spreadsheets/CSV may be imported/exported by tooling later, but they are not the canonical language semantics.+```++Examples:++- customer/product variants use records + `with`;+- manufacturing constraints use `template<Process>` + `concept`;+- PMI uses `pmi` records.++## 15. Pilot metadata/design fixtures++A2.3 adds metadata-only Firmament V2 fixtures under `fixtures/FirmamentV2/Templates/` and `fixtures/FirmamentV2/PMI/`. Because no V2 parser exists, valid examples are classified as future design / parser-not-ready / not-implemented by metadata, invalid examples report metadata diagnostics, and none are sent through the V1 parser as random parse failures.++Valid future examples use `firmament-v2-parser-not-ready`. Invalid examples use diagnostics such as `firmament-concept-unit-mismatch`, `firmament-template-process-unknown`, and `firmament-raw-backend-id-reference-forbidden`.++## 16. Tests++Focused tests should discover A2.3 template and PMI fixtures, assert `syntax-version: FirmamentV2`, assert metadata classification, assert invalid fixture expected diagnostics, assert V2 template/concept/PMI fixtures are not V1 parse failures, verify this doctrine mentions templates/concepts/PMI and non-goals, and keep existing V1 box and side-hole golden path fixtures green.++## 17. Docs updates++A2.3 is referenced from the A2, A2.1, A2.2, A1 fixture-corpus, and AIR-A0 constitution docs as source/semantic doctrine. The references do not imply parser, backend, STEP PMI export, material/FEA, or geometry implementation.++## 18. Non-goals++A2.3 explicitly preserves: no parser implementation; no backend implementation; no geometry implementation; no STEP PMI export; no GD&T checker; no material/FEA behavior; no constraint solver; no source evaluator; no conditionals; no loops; no functions; no macros; no shell implementation; no fillet implementation; no surfacing implementation; no pattern 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 Boolean invocation; 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 87a3e0fb..1d66b363 100644--- a/docs/air-firmament-a2-firmament-v2-source-language-design.md+++ b/docs/air-firmament-a2-firmament-v2-source-language-design.md@@ -1,5 +1,7 @@# AIR-FIRMAMENT-A2 — Firmament V2 source language design audit+A2.3 adds manufacturing/process doctrine: `template<Process>` records for DFM contexts, typed `concept` facts for admissibility, and PMI records for product/manufacturing annotations with GD&T as one PMI category rather than the umbrella. See `docs/air-firmament-a2-3-dfm-templates-concepts-pmi.md`.+## PurposeFirmament V2 is the next canonical human-facing Aetheris source language. It is a source language for authoring construction intent: names, units, selections, profiles, regions, feature operations, materials, and traceable feature history. It is not a serialized IR and it is not a backend topology language.diff --git a/fixtures/FirmamentV2/PMI/future/pmi-datum-flatness-position-v2.valid.firmfixture b/fixtures/FirmamentV2/PMI/future/pmi-datum-flatness-position-v2.valid.firmfixturenew file mode 100644index 00000000..24e5a065--- /dev/null+++ b/fixtures/FirmamentV2/PMI/future/pmi-datum-flatness-position-v2.valid.firmfixture@@ -0,0 +1,18 @@+// fixture-id: pmi-datum-flatness-position-v2+// case: firmament-v2-pmi-datum-flatness-position+// category: PMI+// 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.3 metadata-only PMI datum/GD&T fixture; not parser-backed.++pmi BracketInspection {+ datum A: base.face(+Z)+ datum B: base.face(+X)++ flatness base.face(+Z) { tolerance: 0.05 mm }+ position sideHole.axis { tolerance: 0.10 mm datums: [A, B] }+}diff --git a/fixtures/FirmamentV2/PMI/future/pmi-material-surface-finish-v2.valid.firmfixture b/fixtures/FirmamentV2/PMI/future/pmi-material-surface-finish-v2.valid.firmfixturenew file mode 100644index 00000000..ba29d739--- /dev/null+++ b/fixtures/FirmamentV2/PMI/future/pmi-material-surface-finish-v2.valid.firmfixture@@ -0,0 +1,16 @@+// fixture-id: pmi-material-surface-finish-v2+// case: firmament-v2-pmi-material-surface-finish+// category: PMI+// 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.3 metadata-only PMI material/surface finish fixture; not parser-backed.++pmi MaterialAndFinish {+ assign Aluminum6061T6 to base+ surfaceFinish base.face(+Z) { roughnessRa: 1.6 um }+ note { target: sideHole.wallFace text: "Deburr bore after machining." }+}diff --git a/fixtures/FirmamentV2/PMI/invalid/pmi-raw-brep-id-target-v2.invalid.firmfixture b/fixtures/FirmamentV2/PMI/invalid/pmi-raw-brep-id-target-v2.invalid.firmfixturenew file mode 100644index 00000000..b9595d6d--- /dev/null+++ b/fixtures/FirmamentV2/PMI/invalid/pmi-raw-brep-id-target-v2.invalid.firmfixture@@ -0,0 +1,14 @@+// fixture-id: pmi-raw-brep-id-target-v2+// case: firmament-v2-pmi-raw-brep-id-target+// category: PMI+// syntax-version: FirmamentV2+// validity: invalid+// implementation: rejected+// expected: invalid+// expected-stage: rejected+// expected-diagnostic: firmament-raw-backend-id-reference-forbidden+// notes: AIR-FIRMAMENT-A2.3 metadata-only invalid PMI backend-ID fixture; not parser-backed.++pmi BadBackendReference {+ flatness brep.face#42 { tolerance: 0.05 mm }+}diff --git a/fixtures/FirmamentV2/Templates/invalid/template-concept-unit-mismatch-v2.invalid.firmfixture b/fixtures/FirmamentV2/Templates/invalid/template-concept-unit-mismatch-v2.invalid.firmfixturenew file mode 100644index 00000000..ae1d4f1b--- /dev/null+++ b/fixtures/FirmamentV2/Templates/invalid/template-concept-unit-mismatch-v2.invalid.firmfixture@@ -0,0 +1,14 @@+// fixture-id: template-concept-unit-mismatch-v2+// case: firmament-v2-template-concept-unit-mismatch+// category: Templates+// syntax-version: FirmamentV2+// validity: invalid+// implementation: rejected+// expected: invalid+// expected-stage: rejected+// expected-diagnostic: firmament-concept-unit-mismatch+// notes: AIR-FIRMAMENT-A2.3 metadata-only invalid concept unit fixture; not parser-backed.++template<CNC> BadShop {+ concept minimumToolRadius: 2 deg+}diff --git a/fixtures/FirmamentV2/Templates/invalid/template-unknown-process-v2.invalid.firmfixture b/fixtures/FirmamentV2/Templates/invalid/template-unknown-process-v2.invalid.firmfixturenew file mode 100644index 00000000..13f87930--- /dev/null+++ b/fixtures/FirmamentV2/Templates/invalid/template-unknown-process-v2.invalid.firmfixture@@ -0,0 +1,14 @@+// fixture-id: template-unknown-process-v2+// case: firmament-v2-template-unknown-process+// category: Templates+// syntax-version: FirmamentV2+// validity: invalid+// implementation: rejected+// expected: invalid+// expected-stage: rejected+// expected-diagnostic: firmament-template-process-unknown+// notes: AIR-FIRMAMENT-A2.3 metadata-only invalid process fixture; not parser-backed.++template<MagicUnicornProcess> ShopDefault {+ concept minimumToolRadius: 0.1 mm+}diff --git a/fixtures/FirmamentV2/Templates/valid/cnc-template-min-tool-radius-v2.valid.firmfixture b/fixtures/FirmamentV2/Templates/valid/cnc-template-min-tool-radius-v2.valid.firmfixturenew file mode 100644index 00000000..b5d93190--- /dev/null+++ b/fixtures/FirmamentV2/Templates/valid/cnc-template-min-tool-radius-v2.valid.firmfixture@@ -0,0 +1,16 @@+// fixture-id: cnc-template-min-tool-radius-v2+// case: firmament-v2-cnc-template-min-tool-radius+// category: Templates+// 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.3 metadata-only CNC template/concept fixture; not parser-backed.++template<CNC> ShopDefault {+ concept minimumToolRadius: 0.1 mm+ concept minimumWallThickness: 0.8 mm+ concept minimumHoleDiameter: 0.8 mm+}diff --git a/fixtures/FirmamentV2/Templates/valid/fdm-template-wall-overhang-v2.valid.firmfixture b/fixtures/FirmamentV2/Templates/valid/fdm-template-wall-overhang-v2.valid.firmfixturenew file mode 100644index 00000000..87a9ded2--- /dev/null+++ b/fixtures/FirmamentV2/Templates/valid/fdm-template-wall-overhang-v2.valid.firmfixture@@ -0,0 +1,17 @@+// fixture-id: fdm-template-wall-overhang-v2+// case: firmament-v2-fdm-template-wall-overhang+// category: Templates+// 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.3 metadata-only FDM template/concept fixture; not parser-backed.++template<FDM> PrinterDefault {+ concept nozzleDiameter: 0.4 mm+ concept minimumWallThickness: 0.8 mm+ concept maximumUnsupportedOverhang: 45 deg+ concept layerHeight: 0.2 mm+}diff --git a/fixtures/FirmamentV2/Templates/valid/sheet-metal-template-v2.valid.firmfixture b/fixtures/FirmamentV2/Templates/valid/sheet-metal-template-v2.valid.firmfixturenew file mode 100644index 00000000..7d2253cd--- /dev/null+++ b/fixtures/FirmamentV2/Templates/valid/sheet-metal-template-v2.valid.firmfixture@@ -0,0 +1,16 @@+// fixture-id: sheet-metal-template-v2+// case: firmament-v2-sheet-metal-template+// category: Templates+// 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.3 metadata-only sheet metal template/concept fixture; not parser-backed.++template<SheetMetal> ShopDefault {+ concept thickness: 1.5 mm+ concept minimumBendRadius: 1.5 mm+ concept kFactor: 0.42+}