Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add datum seating contracts and expose feature provenance in CLI
Yuechen Li24c0bfc1a823
diff --git a/Aetheris.CLI.Tests/FeatureFunctionCliTests.cs b/Aetheris.CLI.Tests/FeatureFunctionCliTests.csindex a628549c..cc9ef0dc 100644--- a/Aetheris.CLI.Tests/FeatureFunctionCliTests.cs+++ b/Aetheris.CLI.Tests/FeatureFunctionCliTests.cs@@ -23,6 +23,24 @@ public sealed class FeatureFunctionCliTestsAssert.Equal("Hole<Counterbore> M8Counterbore__0", root.GetProperty("features")[0].GetString());}+ [Fact]+ public void InspectPickupPublishesNamedResultsAxesAndLinearPatternProvenance()+ {+ var output = new StringWriter(); var error = new StringWriter();+ var exit = CliRunner.Run(["inspect", Fixture("Canonical/Feature/pickup-functional.firmament"), "--json"], output, error);+ Assert.Equal(0, exit);+ Assert.Equal(string.Empty, error.ToString());+ using var json = JsonDocument.Parse(output.ToString());+ var root = json.RootElement;+ Assert.Equal("UpperCoil", root.GetProperty("featureInvocations")[0].GetProperty("resultIdentity").GetString());+ Assert.Equal(2, root.GetProperty("planarAxes").GetArrayLength());+ var pattern = Assert.Single(root.GetProperty("linearPatterns").EnumerateArray());+ Assert.Equal("PoleSeed", pattern.GetProperty("source").GetString());+ Assert.Equal("Layout.Longitudinal.Direction", pattern.GetProperty("direction").GetString());+ Assert.Equal(10.2, pattern.GetProperty("spacing").GetDouble());+ Assert.Equal(6, pattern.GetProperty("generatedFeatures").GetArrayLength());+ }+[Fact]public void Validate_ReturnsFailureAndFatalTypedFeatureDiagnostic(){diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.csindex 9310a0de..0903c956 100644--- a/Aetheris.CLI/CliRunner.cs+++ b/Aetheris.CLI/CliRunner.cs@@ -1668,6 +1668,8 @@ Model CanonicalPanel {pattern.Distribution,instanceTransforms = pattern.Instances}).ToArray() ?? [],+ linearPatterns = document?.StaticAuthoring?.LinearPatterns ?? [],+ planarAxes = document?.StaticAuthoring?.PlanarAxes ?? [],templateInstances = (document?.TemplateInstantiations ?? document?.ConceptIr?.TemplateInstantiations)?.Select(instance => new{instance.Template,@@ -1697,6 +1699,7 @@ Model CanonicalPanel {invocation.ReturnType,invocation.ExpandedSemanticKind,invocation.GeneratedByFeature,+ invocation.ResultIdentity,invocation.Status}).ToArray() ?? [],featureExpansion = document?.FeatureExpansion,diff --git a/Aetheris.Kernel.Core/Brep/Queries/BrepPlanarSeatQuery.cs b/Aetheris.Kernel.Core/Brep/Queries/BrepPlanarSeatQuery.csnew file mode 100644index 00000000..cfb564ff--- /dev/null+++ b/Aetheris.Kernel.Core/Brep/Queries/BrepPlanarSeatQuery.cs@@ -0,0 +1,60 @@+using Aetheris.Kernel.Core.Geometry;+using Aetheris.Kernel.Core.Math;+using Aetheris.Kernel.Core.Topology;+using Aetheris.Kernel.Core.Numerics;+using Aetheris.Kernel.Core.Brep.Tessellation;++namespace Aetheris.Kernel.Core.Brep.Queries;++/// <summary>Find admitted planar material faces containing an authored seating point.+/// Plane coincidence is analytic. Curved trim inclusion uses the existing admitted+/// boundary mesh and is approximate; no bounding-box fallback proves contact.</summary>+public sealed class BrepPlanarSeatQuery(BrepBody body)+{+ private DisplayTessellationResult? mesh;+ public IReadOnlyList<FaceId> FindFaces(Point3D point, Vector3D normal)+ {+ if (!normal.TryNormalize(out normal)) return [];+ var result = new List<FaceId>();+ foreach (var face in body.Topology.Faces)+ {+ if (!body.TryGetFaceSurfaceGeometry(face.Id, out var geometry) || geometry?.Plane is not { } plane) continue;+ var n = new Vector3D(plane.Normal.X, plane.Normal.Y, plane.Normal.Z);+ if (n.Cross(normal).Length > 1e-7 || System.Math.Abs((point - plane.Origin).Dot(n)) > 1e-7) continue;+ var edges = face.LoopIds.SelectMany(id => body.Topology.GetLoop(id).CoedgeIds)+ .Select(id => body.Topology.GetCoedge(id).EdgeId).ToArray();+ if (edges.All(id => body.TryGetEdgeCurveGeometry(id, out var c) && c?.Kind == CurveGeometryKind.Line3))+ {+ if (AnalyticPlanarFaceDomain.TryCreate(body, face.Id, plane, out var domain) && domain.Contains(point, ToleranceContext.Default)) result.Add(face.Id);+ continue;+ }+ if (mesh is null)+ {+ var options = new DisplayTessellationOptions(double.Pi / 32, .05, 6, 128);+ if (!RectangularSplineDisplayTessellator.TryTessellate(body, options, out mesh!))+ {+ var built = body.Topology.Faces.All(f => body.TryGetFaceSurfaceGeometry(f.Id, out var s) && s?.Kind is SurfaceGeometryKind.Plane or SurfaceGeometryKind.Cylinder or SurfaceGeometryKind.Torus)+ ? BrepDisplayTessellator.TessellateSurfaceMeshIr(body, options) : BrepDisplayTessellator.TessellateBounded(body, options);+ if (!built.IsSuccess) continue;+ mesh = built.Value;+ }+ }+ var patch = mesh.FacePatches.FirstOrDefault(p => p.FaceId == face.Id);+ if (patch is null) continue;+ for (var i = 0; i < patch.TriangleIndices.Count; i += 3)+ {+ var a = patch.Positions[patch.TriangleIndices[i]];+ var b = patch.Positions[patch.TriangleIndices[i + 1]];+ var c = patch.Positions[patch.TriangleIndices[i + 2]];+ var ab = b - a; var ac = c - a; var ap = point - a;+ var d00 = ab.Dot(ab); var d01 = ab.Dot(ac); var d11 = ac.Dot(ac);+ var determinant = d00*d11 - d01*d01;+ if (determinant <= 1e-20) continue;+ var u = (d11*ap.Dot(ab) - d01*ap.Dot(ac))/determinant;+ var v = (d00*ap.Dot(ac) - d01*ap.Dot(ab))/determinant;+ if (u >= -1e-9 && v >= -1e-9 && u + v <= 1 + 1e-9) { result.Add(face.Id); break; }+ }+ }+ return result;+ }+}diff --git a/Aetheris.Kernel.Firmament.Tests/Assembly/DatumSeatingTests.cs b/Aetheris.Kernel.Firmament.Tests/Assembly/DatumSeatingTests.csnew file mode 100644index 00000000..612ab793--- /dev/null+++ b/Aetheris.Kernel.Firmament.Tests/Assembly/DatumSeatingTests.cs@@ -0,0 +1,103 @@+using Aetheris.Kernel.Firmament.Assembly;++namespace Aetheris.Kernel.Firmament.Tests.Assembly;++public sealed class DatumSeatingTests+{+ private const string Source = """+ Concept Struct Layout {+ Plane Deck { Origin: [0mm,0mm,20mm]; Normal: [0,0,1]; Up: [0,1,0] }+ DatumFrame Base { On: Deck; At: [0mm,0mm]; X: [1,0] }+ DatumFrame Hardware { On: Deck; At: [4mm,0mm]; X: [1,0] }+ }+ Template<H: Length> Struct Pad {+ Expose { Semantic Bottom { DatumFrame Frame = [0mm,0mm,0mm] x [1,0,0] y [0,1,0] z [0,0,1]; }+ Semantic Top { DatumFrame Frame = [0mm,0mm,H] x [1,0,0] y [0,1,0] z [0,0,1]; } }+ Rect2 R { Center: [0mm,0mm]; Size: [20mm,20mm] }+ Profile P { Loop Outer { R |> TraceLoop } }+ Extrude Body { Profile: P From: 0mm To: H }+ }+ Interface<Fixed> Seating { Datum: Layout.Deck; Members: [Test.Base.Top,Test.Hardware.Bottom] }+ Assembly Test {+ <Assembly Test><Part Base = Pad<H:2mm>></Part><Part Hardware = Pad<H:1mm>></Part></Assembly>+ Anchor: Test;+ Mate BaseOnDeck: Seating { Member: Test.Base.Top; At: Layout.Base; Orientation: SameDirection; Support: true; }+ Mate HardwareOnDeck: Seating { Member: Test.Hardware.Bottom; At: Layout.Hardware; Orientation: SameDirection; }+ }+ """;++ [Fact]+ public void ConceptPlaneDrivesBothMaterialPartsWithoutSyntheticProductOccurrences()+ {+ using var session = new FirmamentCompilationSession();+ var first = session.Compile(Source);+ Assert.True(first.IsSuccess, string.Join("\n", first.Diagnostics.Select(d => d.Message)));+ Assert.Equal(3, first.Ir!.Instances.Count);+ Assert.All(first.Geometry!.Artifact.DatumSeats!, s => Assert.True(s.Passed));+ Assert.Equal(18, first.Ir.Instances.Single(i => i.Path.ToString() == "Test.Base").ResolvedTransform!.Matrix[14], 6);+ Assert.Equal(20, first.Ir.Instances.Single(i => i.Path.ToString() == "Test.Hardware").ResolvedTransform!.Matrix[14], 6);+ var shifted = session.Compile(Source.Replace("0mm,0mm,20mm", "0mm,0mm,25mm"));+ Assert.True(shifted.IsSuccess, string.Join("\n", shifted.Diagnostics.Select(d => d.Message)));+ Assert.Equal(2, shifted.Reuse!.ReusedDefinitions);+ Assert.All(shifted.Geometry!.Artifact.DatumSeats!, s => Assert.True(s.Passed));+ Assert.Equal(25, shifted.Ir!.Instances.Single(i => i.Path.ToString() == "Test.Hardware").ResolvedTransform!.Matrix[14], 6);+ }++ [Theory]+ [InlineData("Members: [Test.Base.Top,Test.Hardware.Bottom]", "Members: [Test.Base.Top]", "assembly-datum-member-outside-contract")]+ [InlineData("On: Deck", "On: Missing", "assembly-datum-plane-unresolved")]+ [InlineData("X: [1,0]", "X: [0,0]", "assembly-datum-invalid-direction")]+ [InlineData("At: Layout.Hardware", "At: Layout.Deck", "assembly-datum-target-invalid")]+ [InlineData("Orientation: SameDirection", "Orientation: Unknown", "assembly-datum-orientation-invalid")]+ [InlineData("Up: [0,1,0]", "Up: [0,0,1]", "assembly-frame-invalid-basis")]+ public void InvalidContractsFailClosed(string from, string to, string code)+ {+ var result = new AssemblyM1Pipeline().Compile(Source.Replace(from, to));+ Assert.False(result.IsSuccess);+ Assert.Contains(result.Diagnostics, d => d.Code == code);+ }++ [Fact]+ public void FrameWithoutMaterialSeatAndSeatOutsideSupportAreRejected()+ {+ var fake = new AssemblyM1Pipeline().Compile(Source.Replace("From: 0mm", "From: -1mm"));+ Assert.False(fake.IsSuccess);+ Assert.Contains(fake.Diagnostics, d => d.Code == "assembly-datum-material-seat-missing");+ var outside = new AssemblyM1Pipeline().Compile(Source.Replace("At: [4mm,0mm]", "At: [40mm,0mm]"));+ Assert.False(outside.IsSuccess);+ Assert.Contains(outside.Diagnostics, d => d.Code == "assembly-datum-support-contact-missing");+ }++ [Fact]+ public void DuplicatePlacementAuthorityIsRejected()+ {+ var source = Source.Replace("<Part Hardware = Pad<H:1mm>></Part>", "<Part Hardware = Pad<H:1mm>> Placement { From: Origin; To: World; } </Part>");+ var result = new AssemblyM1Pipeline().Compile(source);+ Assert.False(result.IsSuccess);+ Assert.Contains(result.Diagnostics, d => d.Code == "assembly-placement-authority-conflict");+ }++ [Fact]+ public void PartOwnedConceptGeometryIsNotConsumedByAssemblyLayoutBinding()+ {+ var source = Source.Replace("Template<H: Length> Struct Pad {", "Template<H: Length> Struct Pad { Concept Struct Private { Plane PrivatePlane { Origin: [0mm,0mm,0mm]; Normal: [0,0,1]; Up: [0,1,0] } }");+ var parsed = new AssemblyM0Parser().Parse(source);+ Assert.True(parsed.IsSuccess, string.Join("\n", parsed.Diagnostics.Select(d => d.Message)));+ Assert.Contains("Concept Struct Private", parsed.Source!.DefinitionSource);+ Assert.DoesNotContain("Concept Struct Layout", parsed.Source.DefinitionSource);+ }++ [Fact]+ public void GuitarBridgeAndPickupsHaveMaterialContactWithOneConceptDeck()+ {+ var result = new AssemblyM1Pipeline().CompileFile(FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Canonical/AssemblyInterfaces/GuitarX0/guitar.firmasm"));+ Assert.True(result.IsSuccess, string.Join("\n", result.Diagnostics.Select(d => d.Message)));+ var evidence = result.Geometry!.Artifact.DatumSeats!;+ Assert.Equal(4, evidence.Count);+ Assert.All(evidence, e => { Assert.True(e.Passed); Assert.NotEmpty(e.MaterialFaces); Assert.Equal("GuitarLayout.HardwareDeck", e.Datum); });+ var bridge = result.Ir!.Instances.Single(i => i.Path.ToString() == "GuitarX0.Bridge.Bridge");+ Assert.Equal(53, bridge.ResolvedTransform!.Matrix[14], 6);+ Assert.Contains("H:10mm", bridge.DefinitionIdentity);+ Assert.Equal(63, result.Geometry.Artifact.Instances.Single(i => i.InstanceStableId == bridge.StableId).Metrics.Maximum[2], 6);+ }+}diff --git a/Aetheris.Kernel.Firmament.Tests/Assembly/GuitarSurfacingWitnessTests.cs b/Aetheris.Kernel.Firmament.Tests/Assembly/GuitarSurfacingWitnessTests.csindex d4c2f79f..0c29830e 100644--- a/Aetheris.Kernel.Firmament.Tests/Assembly/GuitarSurfacingWitnessTests.cs+++ b/Aetheris.Kernel.Firmament.Tests/Assembly/GuitarSurfacingWitnessTests.cs@@ -13,8 +13,8 @@ public sealed class GuitarSurfacingWitnessTests.Append(root).Select(path => new KeyValuePair<string, string>(Path.GetFileName(path), File.ReadAllText(path))).ToArray();var result = new AssemblyM1Pipeline().CompileProject(new FirmamentProjectSnapshot("guitar.firmasm", documents));Assert.True(result.IsSuccess, string.Join("\n", result.Diagnostics));- Assert.Equal(55, result.Geometry!.DefinitionBodies.Count);- Assert.Equal(107, result.Geometry.InstanceBodies.Count);+ Assert.Equal(53, result.Geometry!.DefinitionBodies.Count);+ Assert.Equal(91, result.Geometry.InstanceBodies.Count);Assert.Equal(7, result.Ir!.AssemblyDefinitions!.Count);var neck = result.Ir.Instances.Single(i => i.Path.ToString() == "GuitarX0.Neck");Assert.True(neck.IsEncapsulatedDefinition);@@ -24,7 +24,7 @@ public sealed class GuitarSurfacingWitnessTestsAssert.Equal(660, nut.OriginY, 6);Assert.Equal(55, nut.OriginZ, 6);Assert.DoesNotContain("Headstock", neck.SemanticRoot.ExposedMembers.Keys);- Assert.Equal(13, result.Ir.SourceDependencies!.Count);+ Assert.Equal(15, result.Ir.SourceDependencies!.Count);Assert.Contains(result.Ir.SourceDependencies, d => d.Path == "tuners-assembly.firmament");}[Fact]@@ -35,8 +35,8 @@ public sealed class GuitarSurfacingWitnessTestsvar compiled = new AssemblyM1Pipeline().CompileFile(path);Assert.True(compiled.IsSuccess, string.Join("\n", compiled.Diagnostics.Select(d => d.Message)));var mesh = AssemblyDisplayMeshExporter.Export(compiled);- Assert.Equal(107, mesh.Occurrences.Count(o => o.DefinitionId is not null));- Assert.Equal(7, compiled.Ir!.Patterns!.Count);+ Assert.Equal(91, mesh.Occurrences.Count(o => o.DefinitionId is not null));+ Assert.Equal(4, compiled.Ir!.Patterns!.Count);Assert.Empty(compiled.Ir.Joints!);Assert.Equal(7, compiled.Ir.AssemblyDefinitions!.Count);Assert.Single(compiled.Ir.AssemblyDefinitions.Single(d => d.DefinitionIdentity == "GuitarNeck").LocalMates,@@ -44,6 +44,11 @@ public sealed class GuitarSurfacingWitnessTestsAssert.DoesNotContain(File.ReadAllText(path), "LegacyExplicit");Assert.Contains(compiled.Ir.Instances, i => i.Path.ToString() == "GuitarX0.Neck.Tuners.TunerPosts.TunerPost00.TunerPost"&& i.Provenance.Any(p => p.Stage == "assembly-pattern"));+ var pickups = compiled.Ir.Instances.Where(i => i.DefinitionIdentity.StartsWith("Humbucker<", StringComparison.Ordinal)).ToArray();+ Assert.Equal(2, pickups.Length);+ Assert.All(pickups, p => Assert.Equal(53, p.ResolvedTransform!.Matrix[14], 6));+ Assert.Contains(pickups, p => p.Path.ToString() == "GuitarX0.Electronics.Pickups.NeckPickup" && Math.Abs(p.ResolvedTransform!.Matrix[13] - 98) < 1e-9);+ Assert.Single(mesh.Definitions, d => d.Identity.StartsWith("Humbucker<", StringComparison.Ordinal));var head = compiled.Ir.Instances.Single(i => i.Path.ToString() == "GuitarX0.Neck.Headstock");Assert.Equal(660, head.ResolvedTransform!.Matrix[13], 6);Assert.Equal(48, head.ResolvedTransform.Matrix[14], 6);diff --git a/Aetheris.Kernel.Firmament.Tests/Assembly/IncrementalCompilationTests.cs b/Aetheris.Kernel.Firmament.Tests/Assembly/IncrementalCompilationTests.csnew file mode 100644index 00000000..10da4dab--- /dev/null+++ b/Aetheris.Kernel.Firmament.Tests/Assembly/IncrementalCompilationTests.cs@@ -0,0 +1,151 @@+using Aetheris.Kernel.Core.Step242;+using Aetheris.Kernel.Core.Topology;+using Aetheris.Kernel.Firmament.Assembly;++namespace Aetheris.Kernel.Firmament.Tests.Assembly;++public sealed class IncrementalCompilationTests+{+ private const string Recipe = """+ Template<H: Length> Struct Pad {+ Rect2 Outline { Center: [0mm,0mm]; Size: [10mm,10mm] }+ Profile P { Loop Outer { Outline |> TraceLoop } }+ Extrude Body { Profile: P From: 0mm To: H }+ }+ """;+ private static string Source(string height = "2mm", string position = "20mm") => Recipe + $$"""++ Assembly Test {+ <Assembly Test>+ <Part A = Pad<H:{{height}}>> Placement { From: Origin; To: World; } </Part>+ <Part B = Pad<H:{{height}}>> Placement { From: Origin; To: World; TranslateLocal: [{{position}},0mm,0mm]; } </Part>+ </Assembly>+ Anchor: Test;+ }+ """;++ private static AssemblyM1CompilationResult Good(AssemblyM1CompilationResult result)+ {+ Assert.True(result.IsSuccess, string.Join("\n", result.Diagnostics.Select(d => d.Message)));+ return result;+ }++ [Fact]+ public void RepeatedBuildReusesOneDefinitionAndMatchesUncachedExactOutput()+ {+ using var session = new FirmamentCompilationSession();+ var first = Good(session.Compile(Source()));+ var second = Good(session.Compile(Source()));+ var baseline = Good(new AssemblyM1Pipeline().Compile(Source()));+ Assert.Equal(1, first.Reuse!.RebuiltDefinitions);+ Assert.Equal(1, second.Reuse!.ReusedDefinitions);+ Assert.Equal(0, second.Reuse.RebuiltDefinitions);+ Assert.Equal(baseline.Geometry!.Artifact.DeterministicSha256, second.Geometry!.Artifact.DeterministicSha256);+ Assert.Equal(AssemblyIrAp242Exporter.Export(baseline).Value, AssemblyIrAp242Exporter.Export(second).Value);+ Assert.NotSame(first.Geometry!.DefinitionBodies.Values.Single(), second.Geometry.DefinitionBodies.Values.Single());+ }++ [Fact]+ public void PlacementEditReusesGeometryButRevalidatesInterference()+ {+ using var session = new FirmamentCompilationSession();+ Good(session.Compile(Source()));+ var moved = Good(session.Compile(Source(position: "30mm")));+ Assert.Equal(1, moved.Reuse!.ReusedDefinitions);+ var overlapping = session.Compile(Source(position: "00mm"));+ Assert.False(overlapping.IsSuccess);+ Assert.Equal(1, overlapping.Reuse!.ReusedDefinitions);+ Assert.Contains(overlapping.Diagnostics, d => d.Code == "assembly-solid-volume-interference");+ }++ [Fact]+ public void SpecificationAndSharedRecipeEditsInvalidate()+ {+ using var session = new FirmamentCompilationSession();+ Good(session.Compile(Source()));+ var arguments = Good(session.Compile(Source(height: "3mm")));+ Assert.Equal(1, arguments.Reuse!.RebuiltDefinitions);+ var recipe = Good(session.Compile(Source(height: "3mm").Replace("10mm", "12mm")));+ Assert.Equal(1, recipe.Reuse!.RebuiltDefinitions);+ Assert.Equal("definition-inputs-changed", recipe.Reuse.Definitions.Single().Reason);+ }++ [Fact]+ public void ReturnedMutableGeometryAndEvidenceCannotPoisonTheCache()+ {+ using var session = new FirmamentCompilationSession();+ var first = Good(session.Compile(Source()));+ var body = first.Geometry!.DefinitionBodies.Values.Single();+ var before = body.Topology.Vertices.Count();+ body.Topology.AddVertex(new Vertex(new VertexId(999999)));+ first.Geometry.Artifact.Definitions.Single().Metrics.Minimum[0] = 999999;+ var next = Good(session.Compile(Source()));+ Assert.Equal(1, next.Reuse!.ReusedDefinitions);+ Assert.Equal(before, next.Geometry!.DefinitionBodies.Values.Single().Topology.Vertices.Count());+ Assert.NotEqual(999999, next.Geometry.Artifact.Definitions.Single().Metrics.Minimum[0]);+ }++ [Fact]+ public void FailedBuildIsNotCachedAndClearAndDisposeAreExplicit()+ {+ using var session = new FirmamentCompilationSession();+ var bad = Source(height: "-2mm");+ Assert.False(session.Compile(bad).IsSuccess);+ Assert.False(session.Compile(bad).IsSuccess);+ var fixedBuild = Good(session.Compile(Source()));+ Assert.Equal(1, fixedBuild.Reuse!.RebuiltDefinitions);+ session.Clear();+ Assert.Equal(1, Good(session.Compile(Source())).Reuse!.RebuiltDefinitions);+ session.Dispose();+ Assert.Throws<ObjectDisposedException>(() => session.Compile(Source()));+ }++ [Fact]+ public void CapacityEvictsDefinitionsWithoutChangingCorrectness()+ {+ using var session = new FirmamentCompilationSession(1);+ Good(session.Compile(Source()));+ Good(session.Compile(Source(height: "3mm")));+ Assert.Equal(1, Good(session.Compile(Source())).Reuse!.RebuiltDefinitions);+ }++ [Fact]+ public void SnapshotChangesAndMissingDocumentsCannotReuseStaleGeometry()+ {+ using var session = new FirmamentCompilationSession();+ FirmamentProjectSnapshot Project(string recipe) => new("main.firmasm", [+ KeyValuePair.Create("main.firmasm", "Include \"part.firmament\";\n" + Source()[Recipe.Length..]),+ KeyValuePair.Create("part.firmament", recipe)]);+ Good(session.CompileProject(Project(Recipe)));+ Assert.Equal(1, Good(session.CompileProject(Project(Recipe))).Reuse!.ReusedDefinitions);+ Assert.Equal(1, Good(session.CompileProject(Project(Recipe.Replace("10mm", "12mm")))).Reuse!.RebuiltDefinitions);+ var missing = new FirmamentProjectSnapshot("main.firmasm", [KeyValuePair.Create("main.firmasm", "Include \"part.firmament\";\n" + Source()[Recipe.Length..])]);+ var failed = session.CompileProject(missing);+ Assert.False(failed.IsSuccess);+ Assert.Empty(failed.Reuse!.Definitions);+ }++ [Fact]+ public void GuitarFileEditInvalidatesOnlyItsFileBackedDefinition()+ {+ var path = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Canonical/AssemblyInterfaces/GuitarX0/guitar.firmasm");+ var directory = Path.GetDirectoryName(path)!;+ var documents = Directory.GetFiles(directory, "*.firmament").Append(path)+ .Select(p => KeyValuePair.Create(Path.GetFileName(p), File.ReadAllText(p))).ToDictionary(p => p.Key, p => p.Value);+ using var session = new FirmamentCompilationSession();+ FirmamentProjectSnapshot Project() => new("guitar.firmasm", documents);+ var first = Good(session.CompileProject(Project()));+ var repeated = Good(session.CompileProject(Project()));+ Assert.Equal(53, repeated.Reuse!.ReusedDefinitions);+ Assert.Equal(AssemblyUsdExporter.Serialize(first.Ir!, AssemblyDisplayMeshExporter.Export(first)),+ AssemblyUsdExporter.Serialize(repeated.Ir!, AssemblyDisplayMeshExporter.Export(repeated)));+ var neckFile = documents.Keys.Single(k => k == "Neck.firmament");+ documents[neckFile] = documents[neckFile].Replace("-40mm", "-39.8mm");+ var edited = Good(session.CompileProject(Project()));+ Assert.Equal(52, edited.Reuse!.ReusedDefinitions);+ Assert.Equal(1, edited.Reuse.RebuiltDefinitions);+ Assert.Contains(edited.Reuse.Definitions, d => !d.Reused && d.DefinitionIdentity.Contains("Neck.firmament", StringComparison.Ordinal));+ Assert.NotEqual(first.Geometry!.Artifact.Definitions.Single(d => d.DefinitionIdentity.Contains("Neck.firmament", StringComparison.Ordinal)).StepSha256,+ edited.Geometry!.Artifact.Definitions.Single(d => d.DefinitionIdentity.Contains("Neck.firmament", StringComparison.Ordinal)).StepSha256);+ }+}diff --git a/Aetheris.Kernel.Firmament.Tests/FunctionalPickupTests.cs b/Aetheris.Kernel.Firmament.Tests/FunctionalPickupTests.csnew file mode 100644index 00000000..f6d6c1ef--- /dev/null+++ b/Aetheris.Kernel.Firmament.Tests/FunctionalPickupTests.cs@@ -0,0 +1,108 @@+using Aetheris.Kernel.Core.Brep.Verification;+using Aetheris.Kernel.Core.Step242;+using Aetheris.Kernel.Firmament.FirmamentV2;++namespace Aetheris.Kernel.Firmament.Tests;++public sealed class FunctionalPickupTests+{+ private static string Source => File.ReadAllText(FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/Canonical/Feature/pickup-functional.firmament"));++ [Fact]+ public void PickupHasEightNamedBossesPrivateProfilesAndOneExactClosedBody()+ {+ var source = Source;+ var parsed = FirmamentV2Parser.Parse(source.Replace("schema Mechanical", ""));+ Assert.True(parsed.IsSuccess, string.Join("\n", parsed.Diagnostics));+ Assert.Equal(8, parsed.Document!.Bosses!.Count);+ Assert.Equal(3, parsed.Document.FeatureInvocations!.Count);+ Assert.Equal(new[] { "UpperCoil", "LowerCoil", "PoleSeed" }, parsed.Document.FeatureInvocations.Select(i => i.ResultIdentity));+ var pattern = Assert.Single(parsed.Document.StaticAuthoring!.LinearPatterns!);+ Assert.Equal("PoleSeed", pattern.Source);+ Assert.Equal(6, pattern.Count);+ Assert.Equal(10.2, pattern.Spacing);+ Assert.Equal(2, parsed.Document.StaticAuthoring.PlanarAxes!.Count);+ Assert.Contains(parsed.Document.Bosses, b => b.Name == "UpperCoil" && b.On == "BaseTop");+ Assert.Contains(parsed.Document.Bosses, b => b.Name == "LowerCoil" && b.On == "BaseTop");+ Assert.Equal("UpperCoil__Section", parsed.Document.Bosses.Single(b => b.Name == "UpperCoil").Profile);+ Assert.Equal("LowerCoil__Section", parsed.Document.Bosses.Single(b => b.Name == "LowerCoil").Profile);+ var build = FirmamentBuildAndExport.CompileSource(source);+ Assert.True(build.IsSuccess, string.Join("\n", build.Diagnostics));+ var import = Step242Importer.ImportBody(build.Value!.StepText);+ Assert.True(import.IsSuccess, string.Join("\n", import.Diagnostics));+ var mass = BrepMassProperties.Evaluate(import.Value!);+ Assert.True(mass.IsEnclosed, string.Join("\n", mass.Diagnostics));+ Assert.True(mass.IsOrientationConsistent, string.Join("\n", mass.Diagnostics));+ var expected = (88 * 46 - (4 - Math.PI) * 16) * 4+ + 2 * (70 * 17 - (4 - Math.PI) * 9) * 5 + 6 * Math.PI * 2.2 * 2.2;+ Assert.Equal(expected, mass.SignedVolume, 5);+ }++ [Fact]+ public void NestedNamedCallsKeepPrivateConstructionNamesDistinct()+ {+ var source = """+ Model NestedProfiles {+ Units: mm+ Feature Inner() -> Boss {+ Circle2 Outline { Center: [0mm,0mm]; Radius: 2mm }+ Profile Section { Loop Outer { Outline |> TraceLoop } }+ return Boss { On: Top; Profile: Section; Height: 2mm }+ }+ Feature Outer() -> Boss {+ Circle2 Outline { Center: [0mm,0mm]; Radius: 3mm }+ Profile Section { Loop Outer { Outline |> TraceLoop } }+ return Inner()+ }+ Concept Struct Layout On XY { Rect2 Stock { Center: [0mm,0mm]; Size: [20mm,20mm] } }+ Profile BaseProfile Using Layout { Loop Outer { Stock.Bottom |> Stock.Right |> Stock.Top |> Stock.Left |> Close } }+ Struct Product { Compose Body {+ Base Stock { Profile: BaseProfile; From: 0mm; To: 4mm; Role: Stock }+ Feature Pad = Outer()+ } }+ }+ """;+ var build = FirmamentBuildAndExport.CompileSource(source);+ Assert.True(build.IsSuccess, string.Join("\n", build.Diagnostics));+ var diagnostics = new List<string>();+ var expansion = FirmamentV2FeatureExpansion.Expand(source, diagnostics);+ Assert.NotNull(expansion);+ Assert.Empty(diagnostics);+ Assert.Contains("Profile Pad__Section", expansion.Source);+ Assert.Contains("Profile Pad__Call1__Section", expansion.Source);+ Assert.Contains("Boss Pad ", expansion.Source);+ }++ [Theory]+ [InlineData("Source: PoleSeed", "Source: UpperCoil", "firmament-feature-linear-source-profile-not-qualified")]+ [InlineData("Count: 6", "Count: 0", "firmament-feature-linear-count-invalid")]+ [InlineData("Count: 6", "Count: 1025", "firmament-feature-linear-count-invalid")]+ [InlineData("Spacing: Spec.PolePitch", "Spacing: 0mm", "firmament-feature-linear-spacing-invalid")]+ [InlineData("Direction: [1,0]", "Direction: [0,0]", "firmament-feature-linear-axis-invalid")]+ [InlineData("Layout.Longitudinal.Direction", "Layout.Unknown.Direction", "firmament-feature-linear-axis-unresolved")]+ [InlineData("Up: [0,1,0]", "Up: [1,0,0]", "feature-support-plane-not-qualified")]+ [InlineData("Count: 6", "Count: 6; Extra: 1", "firmament-feature-linear-fields-invalid")]+ [InlineData("Normal: [0,0,1]", "Normal: [0,1,0]", "feature-support-plane-not-qualified")]+ [InlineData("Spec.BaseHeight + Spec.CoilHeight", "100mm", "firmament-boss-disconnected-from-host")]+ [InlineData("Point2 LowerCenter", "Point2 WrongCenter", "firmament-boundary2-invalid-dimensions")]+ public void InvalidPickupStopsAtTheOwningSemanticBoundary(string before, string after, string diagnostic)+ {+ var result = FirmamentBuildAndExport.CompileSource(Source.Replace(before, after));+ Assert.False(result.IsSuccess);+ Assert.Contains(result.Diagnostics, d => d.Message.StartsWith(diagnostic, StringComparison.Ordinal));+ }++ [Fact]+ public void WithOverrideChangesPoleSpacingAndExpansionRemainsDeterministic()+ {+ var source = Source.Replace("Humbucker<Spec: StandardPickup>", "Humbucker<Spec: BridgePickupSpec>")+ .Replace("with { PolePitch: 10.2mm }", "with { PolePitch: 10.4mm }");+ var first = FirmamentBuildAndExport.CompileSource(source);+ var second = FirmamentBuildAndExport.CompileSource(source);+ Assert.True(first.IsSuccess, string.Join("\n", first.Diagnostics));+ Assert.True(second.IsSuccess, string.Join("\n", second.Diagnostics));+ Assert.Equal(first.Value!.StepText, second.Value!.StepText);+ var parsed = FirmamentV2Parser.Parse(source.Replace("schema Mechanical", ""));+ Assert.Equal(10.4, Assert.Single(parsed.Document!.StaticAuthoring!.LinearPatterns!).Spacing);+ }+}diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyDatumAuthoring.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyDatumAuthoring.csnew file mode 100644index 00000000..757a9403--- /dev/null+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyDatumAuthoring.cs@@ -0,0 +1,199 @@+using System.Globalization;+using System.Text.RegularExpressions;+using Aetheris.Kernel.Core.Math;+using Aetheris.Semantics;++namespace Aetheris.Kernel.Firmament.Assembly;++internal sealed record AssemblyLayoutDatum(string Identity, string Plane, AssemblyFrameTransformSource Transform);++/// <summary>Bounded datum-directed Fixed seating. No constraint search or synthetic parts.</summary>+internal static class AssemblyDatumAuthoring+{+ internal static IReadOnlyList<AssemblyLayoutDatum> ParseLayouts(string source, string sourceIdentity,+ List<AssemblyDiagnostic> diagnostics, out string declarations)+ {+ var result = new List<AssemblyLayoutDatum>();+ var masked = source.ToCharArray();+ foreach (Match header in Regex.Matches(source, @"\bConcept\s+Struct\s+(?<name>\w+)\s*\{"))+ {+ if (!IsTopLevel(source, header.Index)) continue;+ var body = AssemblyM0Parser.BalancedBody(source, header.Index + header.Length - 1, diagnostics, "Concept layout");+ if (body is null || !Regex.IsMatch(body, @"\bPlane\s+\w+\s*\{")) continue;+ var owner = header.Groups["name"].Value;+ var remaining = body;+ var planes = new Dictionary<string, AssemblyFrameTransformSource>(StringComparer.Ordinal);+ foreach (Match member in Regex.Matches(body, @"\bPlane\s+(?<name>\w+)\s*\{"))+ {+ var fields = AssemblyM0Parser.BalancedBody(body, member.Index + member.Length - 1, diagnostics, "layout plane")!;+ if (fields is null) continue;+ var name = member.Groups["name"].Value;+ var origin = Vector(fields, "Origin", 3, true, diagnostics);+ var normal = Vector(fields, "Normal", 3, false, diagnostics);+ var up = Vector(fields, "Up", 3, false, diagnostics);+ CheckFields(fields, ["Origin", "Normal", "Up"], diagnostics);+ var transform = new AssemblyFrameTransformSource(owner + "_" + name, "World", origin, "Z", 0, normal, up,+ new(sourceIdentity, header.Index + member.Index, member.Length + fields.Length + 1));+ AssemblyFrameAuthoring.Compose(Transform3D.Identity, transform, diagnostics);+ if (!planes.TryAdd(name, transform)) diagnostics.Add(new("assembly-datum-duplicate", $"Duplicate plane '{owner}.{name}'."));+ result.Add(new(owner + "." + name, owner + "." + name, transform));+ remaining = remaining.Replace(member.Value + fields + "}", "", StringComparison.Ordinal);+ }+ foreach (Match member in Regex.Matches(body, @"\bDatumFrame\s+(?<name>\w+)\s*\{"))+ {+ var fields = AssemblyM0Parser.BalancedBody(body, member.Index + member.Length - 1, diagnostics, "layout frame")!;+ if (fields is null) continue;+ var planeName = Field(fields, "On", diagnostics);+ var at = Vector(fields, "At", 2, true, diagnostics);+ var x = Vector(fields, "X", 2, false, diagnostics);+ CheckFields(fields, ["On", "At", "X"], diagnostics);+ if (!planes.TryGetValue(planeName, out var plane))+ { diagnostics.Add(new("assembly-datum-plane-unresolved", $"Frame '{owner}.{member.Groups["name"].Value}' references unknown plane '{planeName}'.")); continue; }+ if (Math.Sqrt(x[0]*x[0] + x[1]*x[1]) < 1e-12)+ diagnostics.Add(new("assembly-datum-invalid-direction", "DatumFrame X must be nonzero."));+ var angle = Math.Atan2(x[1], x[0]) * 180 / Math.PI;+ var basis = AssemblyFrameAuthoring.Compose(Transform3D.Identity, plane, diagnostics);+ var matrix = (Transform3D.CreateRotationZ(angle * Math.PI / 180)+ * Transform3D.CreateTranslation(new(at[0], at[1], 0)) * basis).ToRowMajor();+ var name = member.Groups["name"].Value;+ var frame = new AssemblyFrameTransformSource(owner + "_" + name, "World", [matrix[12], matrix[13], matrix[14]], "Z", 0,+ [matrix[8], matrix[9], matrix[10]], [matrix[4], matrix[5], matrix[6]], plane.SourceSpan);+ result.Add(new(owner + "." + name, owner + "." + planeName, frame));+ remaining = remaining.Replace(member.Value + fields + "}", "", StringComparison.Ordinal);+ }+ if (!string.IsNullOrWhiteSpace(remaining.Replace(";", "")))+ diagnostics.Add(new("assembly-datum-invalid-layout", $"Unsupported members in Concept Struct '{owner}'."));+ Array.Fill(masked, ' ', header.Index, header.Length + body.Length + 1);+ }+ if (result.Select(d => d.Identity).Distinct(StringComparer.Ordinal).Count() != result.Count)+ diagnostics.Add(new("assembly-datum-duplicate", "Concept layout datum identities must be unique."));+ declarations = new string(masked);+ return result;+ }++ internal static AssemblyDatumContract ParseContract(string fields, List<AssemblyDiagnostic> diagnostics)+ {+ var datum = Field(fields, "Datum", diagnostics);+ var members = Regex.Match(fields, @"\bMembers\s*:\s*\[(?<v>[^]]*)\]\s*;?");+ if (Regex.Matches(fields, @"\bMembers\s*:").Count != 1) diagnostics.Add(new("assembly-datum-members-invalid", "Requires exactly one Members field."));+ if (!members.Success) diagnostics.Add(new("assembly-datum-members-missing", "Datum Fixed Interface requires Members."));+ var paths = members.Groups["v"].Value.Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);+ if (paths.Length == 0 || paths.Distinct(StringComparer.Ordinal).Count() != paths.Length || paths.Any(p => !Regex.IsMatch(p, @"^\w+(?:\.\w+)+$")))+ diagnostics.Add(new("assembly-datum-members-invalid", "Members must be a nonempty unique list of semantic port paths."));+ CheckFields(fields, ["Datum", "Members"], diagnostics);+ return new(datum, paths);+ }++ internal static AssemblyMemberSource Bind(string body, AssemblyMemberSource root,+ IReadOnlyList<AssemblyLayoutDatum> layout, IReadOnlyList<InterfaceDefinition> interfaces,+ List<AssemblyDiagnostic> diagnostics, out IReadOnlyList<AssemblyFrameTransformSource> frames)+ {+ var usedFrames = new Dictionary<string, AssemblyFrameTransformSource>(StringComparer.Ordinal);+ var seats = new Dictionary<string, (AssemblyDatumSeat Seat, AssemblyFramePlacementSource Placement)>(StringComparer.Ordinal);+ foreach (Match header in Regex.Matches(body, @"\bMate\s+(?<name>\w+)\s*:\s*(?<type>\w+)\s*\{"))+ {+ var fields = AssemblyM0Parser.BalancedBody(body, header.Index + header.Length - 1, diagnostics, "datum Mate")!;+ if (fields is null) continue;+ var contract = interfaces.FirstOrDefault(i => i.Name == header.Groups["type"].Value)?.DatumContract;+ if (contract is null)+ {+ if (Regex.IsMatch(fields, @"\bMember\s*:")) diagnostics.Add(new("assembly-datum-interface-unresolved", "Member/At Mate requires a datum-directed Fixed Interface."));+ continue;+ }+ var member = Field(fields, "Member", diagnostics);+ var at = Field(fields, "At", diagnostics);+ var orientation = Field(fields, "Orientation", diagnostics);+ var support = Regex.IsMatch(fields, @"\bSupport\s*:\s*true\b");+ if (Regex.Matches(fields, @"\bSupport\s*:").Count > 1) diagnostics.Add(new("assembly-datum-support-invalid", "Support cannot be duplicated."));+ CheckFields(fields, ["Member", "At", "Orientation", "Support"], diagnostics);+ if (Regex.IsMatch(fields, @"\bSupport\s*:") && !Regex.IsMatch(fields, @"\bSupport\s*:\s*(true|false)\b"))+ diagnostics.Add(new("assembly-datum-support-invalid", "Support requires true or false."));+ if (!contract.Members.Contains(member, StringComparer.Ordinal))+ diagnostics.Add(new("assembly-datum-member-outside-contract", $"'{member}' is not a member of '{header.Groups["type"].Value}'."));+ var datum = layout.FirstOrDefault(d => d.Identity == contract.Datum && d.Plane == d.Identity);+ var target = layout.FirstOrDefault(d => d.Identity == at);+ if (datum is null || target is null || target.Identity == target.Plane || target.Plane != contract.Datum)+ { diagnostics.Add(new("assembly-datum-target-invalid", $"'{at}' must be a frame on Concept plane '{contract.Datum}'.")); continue; }+ if (orientation is not ("SameDirection" or "OpposedDirection"))+ diagnostics.Add(new("assembly-datum-orientation-invalid", "Orientation requires SameDirection or OpposedDirection."));+ var parts = member.Split('.');+ if (parts.Length != 3 || parts[0] != root.Name)+ { diagnostics.Add(new("assembly-datum-member-scope", "Datum seating currently admits a direct part's published semantic port in the owning assembly.")); continue; }+ var occurrence = parts[0] + "." + parts[1];+ if (root.Children.FirstOrDefault(c => c.Name == parts[1]) is not { Kind: AssemblyInstanceKind.Part })+ { diagnostics.Add(new("assembly-datum-member-scope", $"'{occurrence}' must be a direct Part occurrence.")); continue; }+ var targetSpec = target.Transform;+ if (orientation == "OpposedDirection")+ {+ var m = AssemblyFrameAuthoring.Compose(Transform3D.Identity, targetSpec, diagnostics).ToRowMajor();+ targetSpec = targetSpec with { Normal = [-m[8], -m[9], -m[10]], Up = [-m[4], -m[5], -m[6]] };+ }+ targetSpec = targetSpec with { Name = targetSpec.Name + "__" + header.Groups["name"].Value };+ usedFrames[targetSpec.Name] = targetSpec;+ var seat = new AssemblyDatumSeat(header.Groups["type"].Value, contract.Datum, parts[2] + ".Frame",+ datum.Transform.Translation.ToArray(), datum.Transform.Normal!.ToArray(), support);+ if (!seats.TryAdd(occurrence, (seat, new(parts[2] + ".Frame", new(header.Groups["name"].Value,+ targetSpec.Name + ".Frame", [0,0,0], "Z", 0)))))+ diagnostics.Add(new("assembly-placement-authority-conflict", $"'{occurrence}' has multiple datum-directed Mates."));+ }+ // Each member of a contract declared in this scope must be realized once.+ foreach (var definition in interfaces.Where(i => i.DatumContract is not null))+ foreach (var member in definition.DatumContract!.Members.Where(p => p.StartsWith(root.Name + ".", StringComparison.Ordinal)))+ if (!seats.Any(p => p.Value.Seat.Interface == definition.Name && p.Key + "." + p.Value.Seat.Port[..^6] == member))+ diagnostics.Add(new("assembly-datum-member-unseated", $"Contract member '{member}' requires one datum Mate."));+ var children = root.Children.Select(child =>+ {+ if (!seats.TryGetValue(root.Name + "." + child.Name, out var seating)) return child;+ if (child.FramePlacement is not null || child.ExplicitTransform is not null)+ diagnostics.Add(new("assembly-placement-authority-conflict", $"'{root.Name}.{child.Name}' has authored Placement and datum Mate."));+ return child with { FramePlacement = seating.Placement, DatumSeat = seating.Seat,+ PlacementAuthority = PlacementAuthority.AuthoredFrame,+ Provenance = [.. child.Provenance ?? [], new("concept-datum-seating", seating.Seat.Datum, seating.Seat.Interface)] };+ }).ToArray();+ frames = usedFrames.Values.ToArray();+ return root with { Children = children };+ }++ private static string Field(string fields, string name, List<AssemblyDiagnostic> diagnostics)+ {+ var matches = Regex.Matches(fields, $@"\b{name}\s*:\s*(?<v>[A-Za-z_]\w*(?:\.\w+)*)\s*;?");+ if (matches.Count != 1) diagnostics.Add(new("assembly-datum-field-invalid", $"Requires exactly one '{name}' field."));+ return matches.Count == 0 ? "" : matches[0].Groups["v"].Value;+ }++ private static bool IsTopLevel(string source, int offset)+ {+ var depth = 0; var quoted = false; var escaped = false;+ for (var i = 0; i < offset; i++)+ {+ var c = source[i];+ if (c == '"' && !escaped) quoted = !quoted;+ if (!quoted) { if (c == '{') depth++; else if (c == '}') depth--; }+ escaped = quoted && c == '\\' && !escaped;+ }+ return depth == 0;+ }++ private static double[] Vector(string fields, string name, int count, bool length, List<AssemblyDiagnostic> diagnostics)+ {+ var matches = Regex.Matches(fields, $@"\b{name}\s*:\s*\[(?<v>[^]]+)\]\s*;?");+ var parts = matches.Count == 1 ? matches[0].Groups["v"].Value.Split(',', StringSplitOptions.TrimEntries) : [];+ var values = new double[count];+ if (parts.Length != count) { diagnostics.Add(new("assembly-datum-vector-invalid", $"'{name}' requires {count} components.")); return values; }+ for (var i = 0; i < count; i++)+ {+ var text = parts[i];+ if (length && text.EndsWith("mm", StringComparison.Ordinal)) text = text[..^2];+ else if (length) diagnostics.Add(new("assembly-datum-unit-invalid", $"'{name}' requires mm lengths."));+ if (!double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out values[i]) || !double.IsFinite(values[i]))+ diagnostics.Add(new("assembly-datum-vector-invalid", $"'{name}' requires finite components."));+ }+ return values;+ }++ private static void CheckFields(string fields, string[] names, List<AssemblyDiagnostic> diagnostics)+ {+ var remaining = Regex.Replace(fields, $@"\b(?:{string.Join('|', names)})\s*:\s*(?:\[[^]]*\]|[A-Za-z_]\w*(?:\.\w+)*)\s*;?", "");+ if (!string.IsNullOrWhiteSpace(remaining.Replace(";", ""))) diagnostics.Add(new("assembly-datum-fields-invalid", $"Unknown or malformed datum fields: {remaining.Trim()}"));+ }+}diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Compiler.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Compiler.csindex ecdb1fcf..d3bee228 100644--- a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Compiler.cs+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Compiler.cs@@ -131,7 +131,7 @@ public sealed class AssemblyM0Compilerdiagnostics.Add(new("assembly-instance-path-collision", "Assembly contains duplicate deterministic instance paths."));return flat.Select(x => new AssemblyInstanceIr(x.id, x.path, x.member.Kind, x.member.DefinitionIdentity, x.parent,flat.Where(c => c.parent == x.id).Select(c => c.id).Order(StringComparer.Ordinal).ToArray(), x.semantic,- x.member.ExplicitTransform, null, [.. x.member.Provenance ?? [], .. PatternProvenance(x.path)], x.member.PlacementAuthority, x.member.IsEncapsulatedDefinition)).ToArray();+ x.member.ExplicitTransform, null, [.. x.member.Provenance ?? [], .. PatternProvenance(x.path)], x.member.PlacementAuthority, x.member.IsEncapsulatedDefinition, x.member.DatumSeat)).ToArray();IEnumerable<SemanticProvenance> PatternProvenance(AssemblyPath path){diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Models.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Models.csindex be1bb14b..20acae96 100644--- a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Models.cs+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Models.cs@@ -44,7 +44,11 @@ public sealed record InterfaceDefinition(bool CompilerOwnedExpansion = false,IReadOnlyList<InterfacePredicateRequirementDefinition>? PredicateRequirements = null,GearInterfaceOptions? GearOptions = null,- FixedSeatingOptions? Seating = null);+ FixedSeatingOptions? Seating = null,+ AssemblyDatumContract? DatumContract = null);++public sealed record AssemblyDatumContract(string Datum, IReadOnlyList<string> Members);+public sealed record AssemblyDatumSeat(string Interface, string Datum, string Port, double[] Origin, double[] Normal, bool Support);public sealed record FixedSeatingOptions(double GapMm, double ClockingDegrees, DatumOrientationRelation Orientation);@@ -61,7 +65,8 @@ public sealed record AssemblyMemberSource(bool IsEncapsulatedDefinition = false,AssemblyDefinitionIr? SolvedAssemblyDefinition = null,SemanticValue? TypedEndpoint = null,- AssemblyFramePlacementSource? FramePlacement = null);+ AssemblyFramePlacementSource? FramePlacement = null,+ AssemblyDatumSeat? DatumSeat = null);public sealed record AssemblyFrameTransformSource(string Name, string From, double[] Translation,string RotationAxis, double RotationDegrees, double[]? Normal = null, double[]? Up = null,@@ -114,7 +119,8 @@ public sealed record AssemblyInstanceIr(SemanticValue SemanticRoot, AssemblyTransform? LocalTransform, AssemblyTransform? ResolvedTransform,IReadOnlyList<SemanticProvenance> Provenance,PlacementAuthority PlacementAuthority = PlacementAuthority.MateDerived,- bool IsEncapsulatedDefinition = false);+ bool IsEncapsulatedDefinition = false,+ AssemblyDatumSeat? DatumSeat = null);public sealed record MateEndpointIr(string Role, AssemblyPath ParticipantPath, string ParticipantSemanticValueId, IReadOnlyList<string> RequiredCapabilities);public sealed record InterfaceRequirementResultIr(string Name, string Expression, string Status);@@ -193,7 +199,9 @@ public sealed record AssemblyGeometryMetricsIr(int Bodies, int Faces, int Edges,public sealed record AssemblyDefinitionArtifactIr(string StableId, string DefinitionIdentity, string SpecializationIdentity, string StepSha256, AssemblyGeometryMetricsIr Metrics, IReadOnlyList<SemanticProvenance> Provenance);public sealed record AssemblyInstanceGeometryIr(string InstanceStableId, string DefinitionArtifactStableId, AssemblyTransform WorldTransform, AssemblyGeometryMetricsIr Metrics);public sealed record AssemblyMateResidualIr(string ConstraintStableId, PlacementConstraintKind Kind, double PositionResidualMm, double AngularResidualRadians, bool Passed, string Evidence);-public sealed record AssemblyGeometryArtifactIr(string Schema, IReadOnlyList<AssemblyDefinitionArtifactIr> Definitions, IReadOnlyList<AssemblyInstanceGeometryIr> Instances, IReadOnlyList<AssemblyMateResidualIr> MateResiduals, string DeterministicSha256);+public sealed record AssemblyDatumSeatEvidence(string InstanceStableId, string Interface, string Datum, double PlaneResidualMm, IReadOnlyList<string> MaterialFaces, bool Support, bool Passed);+public sealed record AssemblyGeometryArtifactIr(string Schema, IReadOnlyList<AssemblyDefinitionArtifactIr> Definitions, IReadOnlyList<AssemblyInstanceGeometryIr> Instances, IReadOnlyList<AssemblyMateResidualIr> MateResiduals, string DeterministicSha256,+ IReadOnlyList<AssemblyDatumSeatEvidence>? DatumSeats = null);public sealed record AssemblyIr(string Schema, string StableId, string Name, string RootInstanceStableId,IReadOnlyList<AssemblyInstanceIr> Instances, IReadOnlyList<InterfaceDefinition> Interfaces,diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Parser.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Parser.csindex 31da0a93..e8984871 100644--- a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Parser.cs+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Parser.cs@@ -114,7 +114,11 @@ public sealed class AssemblyM0Parserdiagnostics.Add(new("assembly-" + diagnostic.Split(':')[0], diagnostic));var concepts = ParseAssemblyConcepts(source, sourceIdentity, diagnostics);var interfaces = ParseInterfaces(source, sourceIdentity, diagnostics);- var declarationChars = source.ToCharArray();+ var layout = AssemblyDatumAuthoring.ParseLayouts(source, sourceIdentity, diagnostics, out var partDeclarations);+ foreach (var contract in interfaces.Where(i => i.DatumContract is not null))+ if (!layout.Any(d => d.Identity == contract.DatumContract!.Datum && d.Plane == d.Identity))+ diagnostics.Add(new("assembly-datum-plane-unresolved", $"Interface '{contract.Name}' requires a declared Concept plane '{contract.DatumContract!.Datum}'."));+ var declarationChars = partDeclarations.ToCharArray();foreach (Match header in Regex.Matches(source, @"\b(?:Template\s*<[^>]+>\s*Assembly|Assembly|Interface(?:\s*<[^>]+>)?)\s+[A-Za-z_]\w*(?:\s*:\s*[A-Za-z_]\w*)?\s*\{")){var block = BalancedBody(source, header.Index + header.Length - 1, diagnostics, "assembly declaration");@@ -130,7 +134,7 @@ public sealed class AssemblyM0Parserreturn ports;}var templateRanges = new List<(int Start, int Length)>();- var assemblyDefinitions = ParseAssemblyDefinitions(source, sourceIdentity, interfaces, concepts, gearAuthorities, diagnostics, templateRanges, Ports);+ var assemblyDefinitions = ParseAssemblyDefinitions(source, sourceIdentity, interfaces, concepts, gearAuthorities, diagnostics, templateRanges, Ports, layout);// Template-produced Assembly bodies are declarations, not exported roots.// Blank them without changing offsets, then locate the single root Assembly.var rootSearch = source.ToCharArray();@@ -150,6 +154,8 @@ public sealed class AssemblyM0Parservar anchorMatch = Regex.Match(RemoveBlocks(body, "Mate", @"Assert\s+ToleranceStackup"), @"\bAnchor\s*:\s*(?<path>[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\s*;", RegexOptions.CultureInvariant);var anchor = anchorMatch.Success ? AssemblyPath.Parse(anchorMatch.Groups["path"].Value) : new AssemblyPath([tree.Name]);var frames = ParseFrameTransforms(body, sourceIdentity, diagnostics);+ tree = AssemblyDatumAuthoring.Bind(body, tree, layout, interfaces, diagnostics, out var datumFrames);+ frames = frames.Concat(datumFrames).ToArray();var result = new AssemblySource(assemblyHeader.Groups["name"].Value, tree, interfaces, mates, anchor, relations, asserts, sourceIdentity, definitionSource, assemblyDefinitions, SourceDependencies: portDependencies, FrameTransforms: frames, Patterns: expandedPatterns.Document?.Patterns);return Done(result);@@ -227,6 +233,14 @@ public sealed class AssemblyM0Parservar body = BalancedBody(source, header.Index + header.Length - 1, diagnostics, "Interface");if (body is null) continue;var name = header.Groups["name"].Value;+ if (Regex.IsMatch(body, @"\bDatum\s*:"))+ {+ if (header.Groups["family"].Value != "Fixed") diagnostics.Add(new("assembly-datum-family-invalid", "Datum contracts require Interface<Fixed>."));+ var contract = AssemblyDatumAuthoring.ParseContract(body, diagnostics);+ if (result.Any(i => i.Name == name)) diagnostics.Add(new("assembly-interface-duplicate-name", $"Interface '{name}' is duplicated."));+ else result.Add(new("interface:" + name, name, [], [], Family: MechanicalInterfaceFamily.Fixed, DatumContract: contract));+ continue;+ }var family = header.Groups["family"].Success ? Enum.Parse<MechanicalInterfaceFamily>(header.Groups["family"].Value) : MechanicalInterfaceFamily.Custom;var roles = Regex.Matches(body, @"\bRole\s+(?<name>[A-Za-z_]\w*)\s+requires\s+(?<caps>[A-Za-z, ]+)\s*;", RegexOptions.CultureInvariant).Select(m => new InterfaceRoleDefinition(m.Groups["name"].Value,@@ -355,13 +369,15 @@ public sealed class AssemblyM0Parserpublic AssemblyDefinitionIr? SolvedAssemblyDefinition { get; set; }public SemanticValue? TypedEndpoint { get; set; }public AssemblyFramePlacementSource? FramePlacement { get; set; }+ public AssemblyDatumSeat? DatumSeat { get; set; }}private static IReadOnlyList<AssemblyDefinitionSource> ParseAssemblyDefinitions(string source, string sourceIdentity,IReadOnlyList<InterfaceDefinition> interfaces, IReadOnlyList<AssemblyConceptDefinition> concepts,IReadOnlyDictionary<string, GearAir> gearAuthorities,List<AssemblyDiagnostic> diagnostics, List<(int Start, int Length)> ranges,- Func<string, IReadOnlyList<SemanticValue>>? publishedPorts = null)+ Func<string, IReadOnlyList<SemanticValue>>? publishedPorts = null,+ IReadOnlyList<AssemblyLayoutDatum>? layout = null){var result = new List<AssemblyDefinitionSource>();foreach (Match template in Regex.Matches(source,@@ -374,6 +390,7 @@ public sealed class AssemblyM0Parserranges.Add((template.Index, close - template.Index));var root = ParseTree(body, sourceIdentity, diagnostics, result, interfaces, new Dictionary<string, AssemblyMemberSource>(StringComparer.Ordinal), gearAuthorities, publishedPorts);if (root is null) continue;+ root = AssemblyDatumAuthoring.Bind(body, root, layout ?? [], interfaces, diagnostics, out var datumFrames);var exposed = ParseAssemblyExposes(body, root, sourceIdentity, diagnostics);root = root with { ExposedSemantics = exposed, IsEncapsulatedDefinition = true };var name = template.Groups["name"].Value;@@ -401,7 +418,7 @@ public sealed class AssemblyM0Parser.. claimedConcept is null ? [] : new[] { new SemanticProvenance("assembly-concept-satisfaction", claimedConcept, name, SemanticSourceSpan.Generated(sourceIdentity)) },.. staticProvenance],anchor, localMates, ParseRelations(body, diagnostics), ParseAsserts(body, sourceIdentity, diagnostics), exposedRelations, claimedConcept,- ParseFrameTransforms(body, sourceIdentity, diagnostics)));+ ParseFrameTransforms(body, sourceIdentity, diagnostics).Concat(datumFrames).ToArray()));}return result;}@@ -716,12 +733,12 @@ public sealed class AssemblyM0Parserif (root is null) diagnostics.Add(new("assembly-tree-missing", "Assembly body requires a nested <Assembly Name> product tree."));AssemblyMemberSource Freeze(MutableNode node) => new(node.Name, node.Kind, node.Definition,node.Children.Select(Freeze).ToArray(), node.Semantics, [], [new("assembly-source", node.Name, node.Definition, SemanticSourceSpan.Generated(sourceIdentity))],- node.ExplicitTransform, node.PlacementAuthority, node.IsEncapsulatedDefinition, node.SolvedAssemblyDefinition, node.TypedEndpoint, node.FramePlacement);+ node.ExplicitTransform, node.PlacementAuthority, node.IsEncapsulatedDefinition, node.SolvedAssemblyDefinition, node.TypedEndpoint, node.FramePlacement, node.DatumSeat);return root is null ? null : Freeze(root);MutableNode ToMutable(AssemblyMemberSource source){- var mutable = new MutableNode(source.Name, source.Kind, source.DefinitionIdentity) { ExplicitTransform = source.ExplicitTransform, PlacementAuthority = source.PlacementAuthority, IsEncapsulatedDefinition = source.IsEncapsulatedDefinition, SolvedAssemblyDefinition = source.SolvedAssemblyDefinition, TypedEndpoint = source.TypedEndpoint, FramePlacement = source.FramePlacement };+ var mutable = new MutableNode(source.Name, source.Kind, source.DefinitionIdentity) { ExplicitTransform = source.ExplicitTransform, PlacementAuthority = source.PlacementAuthority, IsEncapsulatedDefinition = source.IsEncapsulatedDefinition, SolvedAssemblyDefinition = source.SolvedAssemblyDefinition, TypedEndpoint = source.TypedEndpoint, FramePlacement = source.FramePlacement, DatumSeat = source.DatumSeat };mutable.Semantics.AddRange(source.ExposedSemantics);mutable.Children.AddRange(source.Children.Select(ToMutable));return mutable;@@ -826,6 +843,7 @@ public sealed class AssemblyM0Parserforeach (Match header in Regex.Matches(body, @"\bMate\s+(?<name>[A-Za-z_]\w*)\s*:\s*(?<interface>[A-Za-z_]\w*)\s*\{", RegexOptions.CultureInvariant)){var block = BalancedBody(body, header.Index + header.Length - 1, diagnostics, "Mate"); if (block is null) continue;+ if (Regex.IsMatch(block, @"\bMember\s*:")) continue;var roles = Regex.Matches(block, @"\b(?<role>[A-Za-z_]\w*)\s*:\s*(?<path>[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\s*;", RegexOptions.CultureInvariant).Select(m => new MateRoleAssignment(m.Groups["role"].Value, AssemblyPath.Parse(m.Groups["path"].Value))).ToArray();result.Add(new(header.Groups["name"].Value, header.Groups["interface"].Value, roles, SemanticSourceSpan.Generated(sourceIdentity)));diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyM1Execution.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyM1Execution.csindex 6cfb1357..410e2988 100644--- a/Aetheris.Kernel.Firmament/Assembly/AssemblyM1Execution.cs+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyM1Execution.cs@@ -4,6 +4,7 @@ using System.Text;using System.Text.Json;using Aetheris.Kernel.Core.Brep;using Aetheris.Kernel.Core.Brep.Verification;+using Aetheris.Kernel.Core.Brep.Queries;using Aetheris.Kernel.Core.Geometry;using Aetheris.Kernel.Core.Math;using Aetheris.Kernel.Core.Step242;@@ -22,7 +23,8 @@ public sealed record AssemblyM1CompilationResult(AssemblyIr? Ir,AssemblyExecutedGeometry? Geometry,IReadOnlyList<AssemblyDiagnostic> Diagnostics,- AssemblyPerformanceIr? Performance = null)+ AssemblyPerformanceIr? Performance = null,+ AssemblyCompilationReuse? Reuse = null){public bool IsSuccess => Ir is not null && Geometry is not null && Diagnostics.All(diagnostic => diagnostic.Severity != AssemblyDiagnosticSeverity.Error);}@@ -50,7 +52,8 @@ internal sealed record MaterializedAssemblyDefinition(string SpecializationIdentity,BrepBody Body,IReadOnlyList<SemanticValue> Semantics,- AssemblyDefinitionArtifactIr Artifact);+ AssemblyDefinitionArtifactIr Artifact,+ string? CanonicalStep = null);/// <summary>/// M1's definition seam: specialize through the ordinary Firmament compiler, then@@ -133,7 +136,7 @@ internal static class AssemblyDefinitionMaterializervar sectionProvenance = new[] { new SemanticProvenance("section-chain-source", sectionPath, section.Chain!.StableId, SemanticSourceSpan.Generated(sourceIdentity)) };var ports = AssemblyPublishedPorts.Read(sectionSource,section.Chain.StableId,definitionIdentity,sectionPath,diagnostics,section.Chain);return new(definitionIdentity, "section-chain:" + sectionHash[..16], sectionImport.Value, ports,- new(sectionStableId, definitionIdentity, "section-chain:" + sectionHash[..16], sectionHash, Metrics(sectionImport.Value), sectionProvenance));+ new(sectionStableId, definitionIdentity, "section-chain:" + sectionHash[..16], sectionHash, Metrics(sectionImport.Value), sectionProvenance), sectionStep.Value);}var gearDocument = GearAuthoring.ParseDefinitions(definitionSource);var gear = gearDocument.Gears.SingleOrDefault(candidate => string.Equals(candidate.Name, definitionIdentity, StringComparison.Ordinal));@@ -195,7 +198,7 @@ internal static class AssemblyDefinitionMaterializervar externalStableId = "assembly-definition:" + Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(definitionIdentity)))[..16];var externalProvenance = new[] { new SemanticProvenance("imported-step-definition", resolvedPath, externalHash, SemanticSourceSpan.Generated(sourceIdentity)) };return new(definitionIdentity, "external-step:" + externalHash[..16], externalImport.Value, [],- new(externalStableId, definitionIdentity, "external-step:" + externalHash[..16], externalHash, Metrics(externalImport.Value), externalProvenance));+ new(externalStableId, definitionIdentity, "external-step:" + externalHash[..16], externalHash, Metrics(externalImport.Value), externalProvenance), stepText);}if (string.IsNullOrWhiteSpace(definitionSource) || !definitionIdentity.Contains('<', StringComparison.Ordinal)) return null;// Assembly files keep reusable declarations beside relational assembly syntax.@@ -255,7 +258,7 @@ internal static class AssemblyDefinitionMaterializervar hash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(build.Value.StepText)));var stableId = "assembly-definition:" + Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(definitionIdentity)))[..16];var artifact = new AssemblyDefinitionArtifactIr(stableId, definitionIdentity, specialization, hash, Metrics(import.Value), provenance);- return new(definitionIdentity, specialization, import.Value, semantics, artifact);+ return new(definitionIdentity, specialization, import.Value, semantics, artifact, build.Value.StepText);}private static IEnumerable<SemanticValue> WindingSemantics(FirmamentWireFormReport? wire,@@ -330,6 +333,9 @@ internal static class AssemblyDefinitionMaterializerpublic sealed class AssemblyM1Pipeline{+ private readonly AssemblyDefinitionCache? cache;+ public AssemblyM1Pipeline() { }+ internal AssemblyM1Pipeline(AssemblyDefinitionCache cache) => this.cache = cache;public AssemblyM1CompilationResult CompileFile(string path, AssemblyPartMaterializer? domainMaterializer = null){var parsed = new AssemblyM0Parser().ParseFile(path);@@ -358,14 +364,17 @@ public sealed class AssemblyM1Pipelinereturn CompileParsed(parsed, null, project);}- private static AssemblyM1CompilationResult CompileParsed(AssemblyM0Parser.ParseResult parsed, AssemblyPartMaterializer? domainMaterializer, FirmamentProjectSnapshot? project = null)+ private AssemblyM1CompilationResult CompileParsed(AssemblyM0Parser.ParseResult parsed, AssemblyPartMaterializer? domainMaterializer, FirmamentProjectSnapshot? project = null){if (!parsed.IsSuccess || parsed.Source is null) return new(null, null, parsed.Diagnostics);var diagnostics = parsed.Diagnostics.ToList();var materializationWatch = Stopwatch.StartNew();var definitions = parsed.Source.Root.Flatten().Where(member => member.Kind == AssemblyInstanceKind.Part).Select(member => member.DefinitionIdentity).Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal)- .Select(identity => Materialize(identity, parsed.Source.DefinitionSource, parsed.Source.SourceIdentity, diagnostics, domainMaterializer, project))+ .Select(identity => cache is null+ ? Materialize(identity, parsed.Source.DefinitionSource, parsed.Source.SourceIdentity, diagnostics, domainMaterializer, project)+ : cache.Materialize(identity, parsed.Source.DefinitionSource, parsed.Source.SourceIdentity, diagnostics, project,+ () => Materialize(identity, parsed.Source.DefinitionSource, parsed.Source.SourceIdentity, diagnostics, domainMaterializer, project))).Where(definition => definition is not null).Cast<MaterializedAssemblyDefinition>().ToDictionary(definition => definition.DefinitionIdentity, StringComparer.Ordinal);materializationWatch.Stop();var enriched = parsed.Source with { Root = Enrich(parsed.Source.Root, definitions) };@@ -447,11 +456,12 @@ public sealed class AssemblyM1Pipelineforeach (var residual in residuals.Where(item => !item.Passed))diagnostics.Add(new("assembly-mate-geometry-residual", $"Constraint '{residual.ConstraintStableId}' residual position={residual.PositionResidualMm:G6}mm angle={residual.AngularResidualRadians:G6}rad."));ValidateSolidInterference(ir, instances, diagnostics);+ var datumSeats = ValidateDatumSeats(ir, instances, diagnostics);validatedIr = ir with { Schema = "aetheris/assembly-ir/m1", PlacementConstraints = constraints, Diagnostics = diagnostics };var definitionsIr = definitions.Values.Select(definition => definition.Artifact).OrderBy(definition => definition.StableId, StringComparer.Ordinal).ToArray();var canonical = JsonSerializer.Serialize(new { definitions = definitionsIr, instances = instanceArtifacts, residuals });var hash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(canonical)));- var artifact = new AssemblyGeometryArtifactIr("aetheris/assembly-geometry/m1", definitionsIr, instanceArtifacts, residuals, hash);+ var artifact = new AssemblyGeometryArtifactIr("aetheris/assembly-geometry/m1", definitionsIr, instanceArtifacts, residuals, hash, datumSeats);return new(artifact, definitions.ToDictionary(pair => pair.Key, pair => pair.Value.Body, StringComparer.Ordinal), instances);}@@ -471,6 +481,50 @@ public sealed class AssemblyM1Pipeline+ $"contained tetrahedron={result.WitnessTetrahedronVolumeMm3:G6}mm^3). Face/edge contact is allowed, but positive-volume overlap is not."));}}++ private static IReadOnlyList<AssemblyDatumSeatEvidence> ValidateDatumSeats(AssemblyIr ir,+ IReadOnlyDictionary<string, BrepBody> bodies, List<AssemblyDiagnostic> diagnostics)+ {+ var evidence = new List<AssemblyDatumSeatEvidence>();+ var queries = bodies.ToDictionary(p => p.Key, p => new BrepPlanarSeatQuery(p.Value), StringComparer.Ordinal);+ var points = new List<(AssemblyInstanceIr Instance, Point3D Point, Vector3D Normal)>();+ foreach (var instance in ir.Instances.Where(i => i.DatumSeat is not null))+ {+ var seat = instance.DatumSeat!;+ var value = instance.SemanticRoot;+ foreach (var segment in seat.Port.Split('.'))+ {+ if (!value.ExposedMembers.TryGetValue(segment, out var next)) { value = null!; break; }+ value = next;+ }+ if (value is null || !value.TryBinding<ExactDatumFrameBinding>(out var frame) ||+ instance.ResolvedTransform is null || !bodies.TryGetValue(instance.StableId, out var body))+ { diagnostics.Add(new("assembly-datum-port-invalid", $"'{instance.Path}' requires a published seating Frame and material body.")); continue; }+ var world = Transform3D.FromRowMajor(instance.ResolvedTransform.Matrix);+ var point = world.Apply(new Point3D(frame.OriginX, frame.OriginY, frame.OriginZ));+ var parent = ir.Instances.Single(i => i.StableId == instance.ParentStableId);+ var parentWorld = Transform3D.FromRowMajor(parent.ResolvedTransform!.Matrix);+ var origin = parentWorld.Apply(new Point3D(seat.Origin[0], seat.Origin[1], seat.Origin[2]));+ var normal = parentWorld.Apply(new Vector3D(seat.Normal[0], seat.Normal[1], seat.Normal[2]));+ normal.TryNormalize(out normal);+ var residual = Math.Abs((point - origin).Dot(normal));+ var faces = queries[instance.StableId].FindFaces(point, normal);+ var passed = residual <= 1e-7 && faces.Count > 0;+ evidence.Add(new(instance.StableId, seat.Interface, seat.Datum, residual,+ faces.Select(f => f.ToString()).ToArray(), seat.Support, passed));+ if (!passed) diagnostics.Add(new("assembly-datum-material-seat-missing", $"'{instance.Path}' has no admitted planar material face at its seating point on '{seat.Datum}' (residual={residual:G6}mm)."));+ points.Add((instance, point, normal));+ }+ foreach (var support in points.Where(p => p.Instance.DatumSeat!.Support))+ foreach (var seated in points.Where(p => !p.Instance.DatumSeat!.Support && p.Instance.DatumSeat.Datum == support.Instance.DatumSeat!.Datum))+ {+ if (queries[support.Instance.StableId].FindFaces(seated.Point, seated.Normal).Count > 0) continue;+ diagnostics.Add(new("assembly-datum-support-contact-missing", $"'{seated.Instance.Path}' seating point does not contact the planar support of '{support.Instance.Path}'."));+ var index = evidence.FindIndex(e => e.InstanceStableId == seated.Instance.StableId);+ if (index >= 0) evidence[index] = evidence[index] with { Passed = false };+ }+ return evidence;+ }}public static class AssemblyWorldQuerydiff --git a/Aetheris.Kernel.Firmament/Assembly/FirmamentCompilationSession.cs b/Aetheris.Kernel.Firmament/Assembly/FirmamentCompilationSession.csnew file mode 100644index 00000000..323254e5--- /dev/null+++ b/Aetheris.Kernel.Firmament/Assembly/FirmamentCompilationSession.cs@@ -0,0 +1,172 @@+using System.Security.Cryptography;+using System.Text;+using System.Text.RegularExpressions;+using Aetheris.Kernel.Core.Step242;+using Aetheris.Semantics;++namespace Aetheris.Kernel.Firmament.Assembly;++public sealed record AssemblyDefinitionReuse(string DefinitionIdentity, bool Reused, string Reason);+public sealed record AssemblyCompilationReuse(IReadOnlyList<AssemblyDefinitionReuse> Definitions)+{+ public int ReusedDefinitions => Definitions.Count(d => d.Reused);+ public int RebuiltDefinitions => Definitions.Count(d => !d.Reused);+}++/// <summary>Explicit, bounded, in-memory reuse of successful exact part materializations.+/// Parsing, assembly solving and physical validation still run for each build.</summary>+public sealed class FirmamentCompilationSession : IDisposable+{+ private readonly object gate = new();+ private readonly AssemblyDefinitionCache cache;+ private readonly AssemblyM1Pipeline pipeline;+ private bool disposed;++ public FirmamentCompilationSession(int maximumDefinitions = 256)+ {+ if (maximumDefinitions < 1) throw new ArgumentOutOfRangeException(nameof(maximumDefinitions));+ cache = new(maximumDefinitions);+ pipeline = new(cache);+ }++ public AssemblyM1CompilationResult CompileFile(string path) => Run(() => pipeline.CompileFile(path));+ public AssemblyM1CompilationResult Compile(string source, string sourceIdentity = "<memory>") => Run(() => pipeline.Compile(source, sourceIdentity));+ public AssemblyM1CompilationResult CompileProject(FirmamentProjectSnapshot project) => Run(() => pipeline.CompileProject(project));++ public void Clear()+ {+ lock (gate) { ObjectDisposedException.ThrowIf(disposed, this); cache.Clear(); }+ }++ public void Dispose()+ {+ lock (gate) { cache.Clear(); disposed = true; }+ }++ private AssemblyM1CompilationResult Run(Func<AssemblyM1CompilationResult> compile)+ {+ lock (gate)+ {+ ObjectDisposedException.ThrowIf(disposed, this);+ cache.BeginBuild();+ return compile() with { Reuse = new(cache.Evidence.ToArray()) };+ }+ }+}++internal sealed class AssemblyDefinitionCache(int capacity)+{+ // STEP text is the immutable cache payload. A hit reimports a fresh body so+ // public mutable topology/geometry stores can never corrupt a later build.+ private sealed record Entry(string Key, string Step, MaterializedAssemblyDefinition Metadata,+ IReadOnlyList<AssemblyDiagnostic> Diagnostics);+ private readonly Dictionary<string, Entry> entries = new(StringComparer.Ordinal);+ private readonly Queue<string> insertionOrder = new();+ internal List<AssemblyDefinitionReuse> Evidence { get; } = [];+ internal void BeginBuild() => Evidence.Clear();+ internal void Clear() { entries.Clear(); insertionOrder.Clear(); Evidence.Clear(); }++ internal MaterializedAssemblyDefinition? Materialize(string identity, string? declarations, string sourceIdentity,+ List<AssemblyDiagnostic> diagnostics, FirmamentProjectSnapshot? project,+ Func<MaterializedAssemblyDefinition?> build)+ {+ var key = Key(identity, declarations, sourceIdentity, project);+ var reason = key is null ? "unsupported-resource-dependency" : "first-build-or-evicted";+ if (key is not null && entries.TryGetValue(identity, out var entry))+ {+ reason = "definition-inputs-changed";+ if (entry.Key == key)+ {+ var import = Step242Importer.ImportBody(entry.Step);+ if (import.IsSuccess && import.Value is not null)+ {+ diagnostics.AddRange(entry.Diagnostics);+ Evidence.Add(new(identity, true, "unchanged-definition-inputs"));+ return CopyMetadata(entry.Metadata) with { Body = import.Value };+ }+ reason = "cached-step-reimport-failed";+ }+ }+ var diagnosticStart = diagnostics.Count;+ var result = build();+ Evidence.Add(new(identity, false, result is null ? "materialization-failed" : reason));+ if (key is null || result is null || diagnostics.Skip(diagnosticStart).Any(d => d.Severity == AssemblyDiagnosticSeverity.Error))+ return result;+ if (Key(identity, declarations, sourceIdentity, project) != key)+ {+ Evidence[^1] = new(identity, false, "resource-changed-during-build");+ return result;+ }+ // This bounded cache only admits immutable scalar/datum semantic bindings.+ // Domain materializers and geometry-valued ports stay on the uncached path.+ if (!result.Semantics.All(CanCopy) || result.CanonicalStep is not { } step)+ {+ Evidence[^1] = new(identity, false, "producer-or-semantics-not-cacheable");+ return result;+ }+ var metadata = CopyMetadata(result);+ // The private body is never exposed; fresh imports supply returned bodies.+ var privateImport = Step242Importer.ImportBody(step);+ if (!privateImport.IsSuccess || privateImport.Value is null) return result;+ metadata = metadata with { Body = privateImport.Value };+ if (!entries.ContainsKey(identity))+ {+ while (entries.Count >= capacity) entries.Remove(insertionOrder.Dequeue());+ insertionOrder.Enqueue(identity);+ }+ entries[identity] = new(key, step, metadata, diagnostics.Skip(diagnosticStart).ToArray());+ return result;+ }++ private static string? Key(string identity, string? declarations, string sourceIdentity, FirmamentProjectSnapshot? project)+ {+ var file = Regex.Match(identity, "^(?:SectionChainFile|LoftFile|ExternalStep)<\\\"(?<path>[^\\\"]+)\\\">$", RegexOptions.CultureInvariant);+ string inputs;+ if (file.Success)+ {+ var requested = file.Groups["path"].Value;+ if (project is not null)+ {+ if (identity.StartsWith("ExternalStep", StringComparison.Ordinal)) return null;+ try { if (!project.TryResolve(requested, out inputs!)) return null; }+ catch (ArgumentException) { return null; }+ }+ else+ {+ var path = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(Path.GetFullPath(sourceIdentity))!, requested));+ if (!File.Exists(path)) return null;+ inputs = File.ReadAllText(path);+ }+ }+ else+ {+ if (declarations is null || Regex.IsMatch(declarations, @"\bInlineStep\b", RegexOptions.CultureInvariant)) return null;+ // Keep exact text, including offsets, because cached semantic evidence+ // carries source spans. The parser already excludes assembly bodies.+ inputs = declarations;+ }+ return Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(+ "assembly-definition-cache-v1\0" + sourceIdentity + "\0" + identity + "\0" + inputs)));+ }++ private static bool CanCopy(SemanticValue value) => value.Bindings.All(b => b is+ ExactAxisBinding or ExactPlaneBinding or ExactPointBinding or ExactDatumFrameBinding or TolerancedDimensionBinding)+ && value.ExposedMembers.Values.All(CanCopy);++ private static SemanticValue Copy(SemanticValue value) => new(value.StableIdentity, value.Type,+ value.Capabilities.Values, value.Bindings, value.ExposedMembers.Values.Select(Copy), value.Provenance.ToArray(),+ value.AuthoredSourceSpan, value.GeneratedSourceSpan, value.ExposedName);++ private static MaterializedAssemblyDefinition CopyMetadata(MaterializedAssemblyDefinition definition) => definition with+ {+ Semantics = definition.Semantics.Select(Copy).ToArray(),+ Artifact = definition.Artifact with+ {+ Provenance = definition.Artifact.Provenance.ToArray(),+ Metrics = definition.Artifact.Metrics with+ {+ Minimum = definition.Artifact.Metrics.Minimum.ToArray(), Maximum = definition.Artifact.Metrics.Maximum.ToArray()+ }+ }+ };+}diff --git a/Aetheris.Kernel.Firmament/FirmamentBuildAndExport.cs b/Aetheris.Kernel.Firmament/FirmamentBuildAndExport.csindex 3c73e51e..2f4a1084 100644--- a/Aetheris.Kernel.Firmament/FirmamentBuildAndExport.cs+++ b/Aetheris.Kernel.Firmament/FirmamentBuildAndExport.cs@@ -294,21 +294,21 @@ public static class FirmamentBuildAndExportreturn KernelResult<FirmamentStepExportResult>.Failure(staticDiagnostics.Select(diagnostic => new Kernel.Core.Diagnostics.KernelDiagnostic(Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed, Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error, diagnostic, "FirmamentV2.ClosedBoundary2")).ToArray());}- var featureExpansion = FirmamentV2FeatureExpansion.Expand(boundaryExpansion.Source, staticDiagnostics);- if (featureExpansion is null)- {- return KernelResult<FirmamentStepExportResult>.Failure(staticDiagnostics.Select(diagnostic => new Kernel.Core.Diagnostics.KernelDiagnostic(- Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed, Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error, diagnostic, "FirmamentV2.FeatureExpansion")).ToArray());- }var templateBindWatch = System.Diagnostics.Stopwatch.StartNew();- var templateExpansion = FirmamentV2TemplateExpansion.Expand(featureExpansion.Source, staticDiagnostics);+ var templateExpansion = FirmamentV2TemplateExpansion.Expand(boundaryExpansion.Source, staticDiagnostics);templateBindWatch.Stop();if (templateExpansion is null){return KernelResult<FirmamentStepExportResult>.Failure(staticDiagnostics.Select(diagnostic => new Kernel.Core.Diagnostics.KernelDiagnostic(Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed, Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error, diagnostic, "FirmamentV2.TemplateExpansion")).ToArray());}- var specializedBoundaries = ClosedBoundary2Authoring.Expand(templateExpansion.Source, staticDiagnostics);+ var featureExpansion = FirmamentV2FeatureExpansion.Expand(templateExpansion.Source, staticDiagnostics);+ if (featureExpansion is null)+ {+ return KernelResult<FirmamentStepExportResult>.Failure(staticDiagnostics.Select(diagnostic => new Kernel.Core.Diagnostics.KernelDiagnostic(+ Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed, Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error, diagnostic, "FirmamentV2.FeatureExpansion")).ToArray());+ }+ var specializedBoundaries = ClosedBoundary2Authoring.Expand(featureExpansion.Source, staticDiagnostics);if (specializedBoundaries is null)return KernelResult<FirmamentStepExportResult>.Failure(staticDiagnostics.Select(SchemaDiagnostic).ToArray());var staticExpansion = CanonicalStaticAuthoring.Expand(specializedBoundaries.Source, staticDiagnostics);diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/CanonicalStaticAuthoring.cs b/Aetheris.Kernel.Firmament/FirmamentV2/CanonicalStaticAuthoring.csindex a1ebf2c7..02aaf030 100644--- a/Aetheris.Kernel.Firmament/FirmamentV2/CanonicalStaticAuthoring.cs+++ b/Aetheris.Kernel.Firmament/FirmamentV2/CanonicalStaticAuthoring.cs@@ -69,12 +69,15 @@ internal static class CanonicalStaticAuthoringpublic static Result? Expand(string source, List<string> diagnostics){+ var linear = LinearFeatureAuthoring.Expand(source, diagnostics);+ if (linear is null) return null;+ source = linear.Source;var symmetry = SemanticSymmetryAuthoring.Expand(source, diagnostics);if (symmetry is null) return null;source = symmetry.Source;var canonicalRoot = Regex.IsMatch(source, @"^\s*Model\s+[A-Za-z_]\w*\s*\{", RegexOptions.CultureInvariant);var staticDeclaration = Regex.IsMatch(source, @"\b(?:Record|Static|Template\s*(?:<|[A-Za-z_]\w*\s*\()|Pattern\s+\w+\s+Over)\b", RegexOptions.CultureInvariant)- || symmetry.Mirrors.Count > 0 || symmetry.RadialPatterns.Count > 0;+ || symmetry.Mirrors.Count > 0 || symmetry.RadialPatterns.Count > 0 || linear.Patterns.Count > 0 || linear.Axes.Count > 0;if (!staticDeclaration && !(canonicalRoot && Regex.IsMatch(source, @"\b(?:Require\s+[A-Za-z_]\w*\s*(?:=>|\{)|Pmi\s*\{[\s\S]*?\bFrom\s*:)", RegexOptions.CultureInvariant))) return new(source, null);var changes = new List<(int Start, int Length, string Text)>();var names = new HashSet<string>(StringComparer.Ordinal);@@ -139,10 +142,10 @@ internal static class CanonicalStaticAuthoringchanges.Add((header.Index, close - header.Index + 1, string.Empty));}- foreach (Match header in Regex.Matches(source, @"\bStatic\s+(?<name>[A-Za-z_]\w*)\s*:\s*(?<type>[A-Za-z_]\w*)\s*=\s*(?<literal>[A-Za-z_]\w*)\s*\{", RegexOptions.CultureInvariant))+ foreach (Match header in Regex.Matches(source, @"\bStatic\s+(?<name>[A-Za-z_]\w*)\s*:\s*(?<type>[A-Za-z_]\w*)(?:\s*=\s*(?<literal>[A-Za-z_]\w*))?\s*\{", RegexOptions.CultureInvariant)){var open = source.IndexOf('{', header.Index); var close = MatchPair(source, open, '{', '}');- var name = header.Groups["name"].Value; var type = header.Groups["type"].Value; var literalType = header.Groups["literal"].Value;+ var name = header.Groups["name"].Value; var type = header.Groups["type"].Value; var literalType = header.Groups["literal"].Success ? header.Groups["literal"].Value : type;if (close < 0 || !recordByName.TryGetValue(type, out var record)) { diagnostics.Add(Prefix + "record-type-invalid:" + name); continue; }if (!string.Equals(type, literalType, StringComparison.Ordinal)) { diagnostics.Add(Prefix + "record-literal-type-mismatch:" + name); continue; }if (!names.Add(name)) { diagnostics.Add(FirmamentV2Parser.DuplicateName + ":Static:" + name); continue; }@@ -328,7 +331,7 @@ internal static class CanonicalStaticAuthoring.Where(change => !erasures.Any(erase => erase.Start < change.Start && change.Start < erase.Start + erase.Length)).OrderByDescending(change => change.Start))source = source.Remove(change.Start, change.Length).Insert(change.Start, change.Text);- return new(source, new(recordTypes, arrays, templates.Select(t => new FirmamentV2CanonicalTemplateDecl(t.Name, t.Type, t.Parameter, t.Body, t.Span)).ToArray(), patterns, requires, semanticConstraints, projections, staticRecords, tables, sets, symmetry.Mirrors, symmetry.RadialPatterns));+ return new(source, new(recordTypes, arrays, templates.Select(t => new FirmamentV2CanonicalTemplateDecl(t.Name, t.Type, t.Parameter, t.Body, t.Span)).ToArray(), patterns, requires, semanticConstraints, projections, staticRecords, tables, sets, symmetry.Mirrors, symmetry.RadialPatterns, linear.Patterns, linear.Axes));}private static IReadOnlyList<FirmamentV2StaticSetEntry> ParseSetEntries(string source, int start, int end, string setName, string elementType,diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/ClosedBoundary2Authoring.cs b/Aetheris.Kernel.Firmament/FirmamentV2/ClosedBoundary2Authoring.csindex a94a219e..f0581b31 100644--- a/Aetheris.Kernel.Firmament/FirmamentV2/ClosedBoundary2Authoring.cs+++ b/Aetheris.Kernel.Firmament/FirmamentV2/ClosedBoundary2Authoring.cs@@ -32,7 +32,12 @@ internal static class ClosedBoundary2Authoring{// Template bodies have local names and unbound dimensions. Their selected// specializations pass through this lowering after ordinary template binding.- var templates = FirmamentV2TemplateExpansion.DeclarationSpans(source, diagnostics);+ var templates = FirmamentV2TemplateExpansion.DeclarationSpans(source, diagnostics).ToList();+ foreach (Match feature in Regex.Matches(source, @"\bFeature\s+[A-Za-z_]\w*\s*\([^()]*\)\s*->[^{}]+\{"))+ {+ var close = Matching(source, source.IndexOf('{', feature.Index));+ if (close >= 0) templates.Add(new(feature.Index, close - feature.Index + 1));+ }bool InTemplate(int offset) => templates.Any(span => offset >= span.Start && offset < span.Start + span.Length);var shapes = new List<Shape>(); var names = new HashSet<string>(StringComparer.Ordinal);foreach (Match header in Header.Matches(source))@@ -186,7 +191,12 @@ internal static class ClosedBoundary2Authoringinternal static IReadOnlyDictionary<string, LineArcProfileCurve2D> SmoothGuides(string source, List<string> diagnostics){var guides = new Dictionary<string, LineArcProfileCurve2D>();- var templates = FirmamentV2TemplateExpansion.DeclarationSpans(source, diagnostics);+ var templates = FirmamentV2TemplateExpansion.DeclarationSpans(source, diagnostics).ToList();+ foreach (Match feature in Regex.Matches(source, @"\bFeature\s+[A-Za-z_]\w*\s*\([^()]*\)\s*->[^{}]+\{"))+ {+ var close = Matching(source, source.IndexOf('{', feature.Index));+ if (close >= 0) templates.Add(new(feature.Index, close - feature.Index + 1));+ }foreach (Match header in Header.Matches(source)){if (templates.Any(span => header.Index >= span.Start && header.Index < span.Start + span.Length)) continue;diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Ast.cs b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Ast.csindex f3222a90..ae3a45e8 100644--- a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Ast.cs+++ b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Ast.cs@@ -142,7 +142,7 @@ public sealed record FirmamentV2FeatureDefinition(string Name, IReadOnlyList<Firstring ReturnType, FirmamentV2SourceSpan SourceSpan, string Scope, string Evaluation);public sealed record FirmamentV2FeatureInvocation(string Feature, int Ordinal, string ReturnType,IReadOnlyDictionary<string, string> Arguments, FirmamentV2SourceSpan SourceSpan,- string ExpandedSemanticKind, string Status)+ string ExpandedSemanticKind, string Status, string? ResultIdentity = null){public string GeneratedByFeature => Feature;}@@ -276,7 +276,7 @@ public sealed record FirmamentV2BossDecl(string Name, string Host, string On, stpublic sealed record FirmamentV2PocketDecl(string Name, string Host, string On, string Profile, double Depth, double HostThickness, double RemainingFloor, double MinimumFloorThickness, string MinimumFloorPolicySource, string StableId, FirmamentV2SourceSpan SourceSpan);public sealed record FirmamentV2SelectionDecl(string Name, string Target, string Source, string Requirement, FirmamentV2SourceSpan SourceSpan);/// <summary>Normalized, erased-before-materialization evidence for canonical static authoring.</summary>-public sealed record FirmamentV2StaticAuthoringDocument(IReadOnlyList<FirmamentV2RecordTypeDecl> RecordTypes, IReadOnlyList<FirmamentV2StaticArrayDecl> Arrays, IReadOnlyList<FirmamentV2CanonicalTemplateDecl> Templates, IReadOnlyList<FirmamentV2CanonicalPatternDecl> Patterns, IReadOnlyList<FirmamentV2RequireDecl> Requires, IReadOnlyList<FirmamentV2SemanticConstraint>? SemanticConstraints = null, IReadOnlyDictionary<string, FirmamentV2PmiProjection>? PmiProjections = null, IReadOnlyList<FirmamentV2StaticRecordDecl>? StaticRecords = null, IReadOnlyList<FirmamentV2StaticTableDecl>? Tables = null, IReadOnlyList<FirmamentV2StaticSetDecl>? Sets = null, IReadOnlyList<FirmamentV2MirrorDerivation>? Mirrors = null, IReadOnlyList<FirmamentV2RadialPatternDecl>? RadialPatterns = null);+public sealed record FirmamentV2StaticAuthoringDocument(IReadOnlyList<FirmamentV2RecordTypeDecl> RecordTypes, IReadOnlyList<FirmamentV2StaticArrayDecl> Arrays, IReadOnlyList<FirmamentV2CanonicalTemplateDecl> Templates, IReadOnlyList<FirmamentV2CanonicalPatternDecl> Patterns, IReadOnlyList<FirmamentV2RequireDecl> Requires, IReadOnlyList<FirmamentV2SemanticConstraint>? SemanticConstraints = null, IReadOnlyDictionary<string, FirmamentV2PmiProjection>? PmiProjections = null, IReadOnlyList<FirmamentV2StaticRecordDecl>? StaticRecords = null, IReadOnlyList<FirmamentV2StaticTableDecl>? Tables = null, IReadOnlyList<FirmamentV2StaticSetDecl>? Sets = null, IReadOnlyList<FirmamentV2MirrorDerivation>? Mirrors = null, IReadOnlyList<FirmamentV2RadialPatternDecl>? RadialPatterns = null, IReadOnlyList<FirmamentV2LinearPatternDecl>? LinearPatterns = null, IReadOnlyList<FirmamentV2Axis2Decl>? PlanarAxes = null);public sealed record FirmamentV2RecordTypeDecl(string Name, IReadOnlyDictionary<string, string> Fields, FirmamentV2SourceSpan SourceSpan);public sealed record FirmamentV2StaticArrayDecl(string Name, string ElementType, IReadOnlyList<IReadOnlyDictionary<string, string>> Elements, FirmamentV2SourceSpan SourceSpan);/// <summary>A finite immutable source-ordered collection whose entry names are semantic identity.</summary>@@ -321,3 +321,7 @@ public sealed record FirmamentV2ParseResult(public static FirmamentV2ParseResult Success(FirmamentV2Document document, IReadOnlyList<string> diagnostics) => new(true, document, diagnostics, FirmamentV2ParseDisposition.RecognizedValid);public static FirmamentV2ParseResult Failure(IReadOnlyList<string> diagnostics, FirmamentV2ParseDisposition disposition = FirmamentV2ParseDisposition.RecognizedInvalid) => new(false, null, diagnostics, disposition);}++public sealed record FirmamentV2LinearPatternDecl(string Name, string Source, string Direction, int Count, double Spacing, double DirectionX, double DirectionY, IReadOnlyList<string> GeneratedFeatures, FirmamentV2SourceSpan SourceSpan);++public sealed record FirmamentV2Axis2Decl(string Identity, double OriginX, double OriginY, double DirectionX, double DirectionY, FirmamentV2SourceSpan SourceSpan);diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2FeatureExpansion.cs b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2FeatureExpansion.csindex 1e54e3cb..d9c84d57 100644--- a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2FeatureExpansion.cs+++ b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2FeatureExpansion.cs@@ -6,7 +6,7 @@ namespace Aetheris.Kernel.Firmament.FirmamentV2;/// <summary>/// Bounded, pure expansion for Firmament's function-like Feature declarations.-/// Feature bodies are deliberately expression-only: immutable local derivations and one+/// Feature bodies contain immutable local derivations/construction declarations and one/// terminal return. Expansion produces ordinary semantic declarations before Feature AIR./// </summary>internal static class FirmamentV2FeatureExpansion@@ -31,7 +31,7 @@ internal static class FirmamentV2FeatureExpansionprivate sealed record Parameter(string Name, string Type, string? DefaultExpression, FirmamentV2SourceSpan Span);private sealed record Declaration(string Name, ImmutableArray<Parameter> Parameters, string ReturnTypeName,- string ReturnExpression, ImmutableArray<Local> Locals, FirmamentV2SourceSpan Span);+ string ReturnExpression, ImmutableArray<Local> Locals, string Construction, ImmutableArray<string> ConstructionNames, FirmamentV2SourceSpan Span);private sealed record Local(string Name, string Type, string Expression);internal sealed record Result(@@ -59,9 +59,9 @@ internal static class FirmamentV2FeatureExpansionvar invocations = new List<FirmamentV2FeatureInvocation>();var ordinal = 0;string ExpandCall(Declaration declaration, string argumentText, FirmamentV2SourceSpan span,- IReadOnlyList<string> stack, bool patternContext)+ IReadOnlyList<string> stack, bool patternContext, string? resultName = null){- var bound = Bind(declaration, argumentText, span.Start, diagnostics);+ var bound = Bind(declaration, argumentText, span.Start, diagnostics, source);if (bound is null) return string.Empty;var invocationOrdinal = ordinal++;var environment = new Dictionary<string, string>(bound, StringComparer.Ordinal);@@ -81,7 +81,16 @@ internal static class FirmamentV2FeatureExpansionenvironment[local.Name] = NormalizeExpression(expression, local.Type);}+ var construction = Substitute(declaration.Construction, environment);var returned = Substitute(declaration.ReturnExpression, environment).Trim();+ var prefix = resultName is null ? declaration.Name + "__" + invocationOrdinal.ToString(CultureInfo.InvariantCulture)+ : stack.Count == 1 ? resultName : resultName + "__Call" + invocationOrdinal.ToString(CultureInfo.InvariantCulture);+ foreach (var localName in declaration.ConstructionNames)+ {+ var generated = prefix + "__" + localName;+ construction = Regex.Replace(construction, $@"\b{Regex.Escape(localName)}\b(?!\s*:)", generated);+ returned = Regex.Replace(returned, $@"\b{Regex.Escape(localName)}\b(?!\s*:)", generated);+ }var nested = Regex.Match(returned, @"^(?<name>[A-Za-z_]\w*)\s*\((?<args>[\s\S]*)\)$", RegexOptions.CultureInvariant);string expanded;string expandedKind;@@ -98,7 +107,7 @@ internal static class FirmamentV2FeatureExpansionreturn string.Empty;}expanded = ExpandCall(nestedDeclaration, nested.Groups["args"].Value, span,- stack.Append(nestedDeclaration.Name).ToArray(), patternContext);+ stack.Append(nestedDeclaration.Name).ToArray(), patternContext, resultName);expandedKind = nestedDeclaration.ReturnTypeName;}else@@ -124,15 +133,15 @@ internal static class FirmamentV2FeatureExpansiondiagnostics.Add(ReturnType + $":{declaration.Name}:expected-{declaration.ReturnTypeName}:actual-{expandedKind}");return string.Empty;}- var generatedName = patternContext+ var generatedName = resultName ?? (patternContext? PatternItemName(returned, declaration.Name, invocationOrdinal)- : declaration.Name + "__" + invocationOrdinal.ToString(CultureInfo.InvariantCulture);+ : declaration.Name + "__" + invocationOrdinal.ToString(CultureInfo.InvariantCulture));expanded = returned.Insert(constructor.Index + constructor.Length - 1, " " + generatedName + " ");}invocations.Add(new(declaration.Name, invocationOrdinal, declaration.ReturnTypeName,- bound, span, expandedKind, "ExpandedBeforeFeatureAir"));- return expanded;+ bound, span, expandedKind, "ExpandedBeforeFeatureAir", resultName));+ return construction + "\n" + expanded;}var changes = declarations.Select(item => (item.Span.Start, item.Span.Length, Text: string.Empty)).ToList();@@ -148,9 +157,10 @@ internal static class FirmamentV2FeatureExpansionvar open = source.IndexOf('(', site.Call.Index); var close = Matching(source, open, '(', ')');if (close < 0) { diagnostics.Add(ArgumentCount + ":" + site.Declaration.Name); continue; }var span = new FirmamentV2SourceSpan(site.Call.Index, close - site.Call.Index + 1);+ var named = Regex.Match(source[..site.Call.Index], @"\bFeature\s+(?<name>[A-Za-z_]\w*)\s*=\s*$");var patternContext = IsInsideBlock(source, site.Call.Index, "Pattern");- var expansion = ExpandCall(site.Declaration, source[(open + 1)..close], span, [site.Declaration.Name], patternContext);- if (expansion.Length > 0) changes.Add((span.Start, span.Length, expansion));+ var expansion = ExpandCall(site.Declaration, source[(open + 1)..close], span, [site.Declaration.Name], patternContext, named.Success ? named.Groups["name"].Value : null);+ if (expansion.Length > 0) changes.Add((named.Success ? named.Index : span.Start, close - (named.Success ? named.Index : span.Start) + 1, expansion));}if (HasErrors(diagnostics)) return null;foreach (var change in changes.OrderByDescending(item => item.Start))@@ -204,11 +214,24 @@ internal static class FirmamentV2FeatureExpansionlocals.Add(new(local.Groups["name"].Value, local.Groups["type"].Value, local.Groups["expression"].Value.Trim()));consumed.Add((local.Index, local.Length));}+ var constructionNames = ImmutableArray.CreateBuilder<string>();+ var constructions = new List<string>();+ foreach (Match local in Regex.Matches(beforeReturn, @"\b(?:Point2|Circle2|RoundedRect2|Rect2|Profile)\s+(?<name>[A-Za-z_]\w*)\s*\{"))+ {+ var localClose = Matching(beforeReturn, beforeReturn.IndexOf('{', local.Index), '{', '}');+ if (localClose < 0) { diagnostics.Add(UnsupportedBody + ":" + name); continue; }+ var localName = local.Groups["name"].Value;+ if (constructionNames.Contains(localName) || parameters.Any(p => p.Name == localName) || locals.Any(l => l.Name == localName))+ diagnostics.Add(LocalDuplicate + $":{name}:{localName}");+ constructionNames.Add(localName);+ constructions.Add(beforeReturn[local.Index..(localClose + 1)]);+ consumed.Add((local.Index, localClose - local.Index + 1));+ }var residue = beforeReturn;foreach (var item in consumed.OrderByDescending(item => item.Start)) residue = residue.Remove(item.Start, item.Length);if (!string.IsNullOrWhiteSpace(residue)) diagnostics.Add(UnsupportedBody + ":" + name);result.Add(new(name, parameters, NormalizeType(header.Groups["return"].Value),- returnExpression, locals.ToImmutable(), new(header.Index, close - header.Index + 1)));+ returnExpression, locals.ToImmutable(), string.Join("\n", constructions), constructionNames.ToImmutable(), new(header.Index, close - header.Index + 1)));}return result.ToImmutable();}@@ -229,7 +252,7 @@ internal static class FirmamentV2FeatureExpansionreturn result.ToImmutable();}- private static ImmutableDictionary<string, string>? Bind(Declaration declaration, string argumentText, int offset, List<string> diagnostics)+ private static ImmutableDictionary<string, string>? Bind(Declaration declaration, string argumentText, int offset, List<string> diagnostics, string source){var supplied = new Dictionary<string, string>(StringComparer.Ordinal); var position = 0;foreach (var (raw, _) in SplitTopLevel(argumentText))@@ -253,6 +276,7 @@ internal static class FirmamentV2FeatureExpansionforeach (var parameter in declaration.Parameters)if (supplied.TryGetValue(parameter.Name, out var expression)){+ if (parameter.Type == "Point2") expression = ResolvePointArgument(source, expression);if (!TypeMatches(expression, parameter.Type))diagnostics.Add(ArgumentType + $":{declaration.Name}:{parameter.Name}:expected-{parameter.Type}:actual-{DescribeType(expression)}:at-{offset}");else supplied[parameter.Name] = NormalizeExpression(expression, parameter.Type);@@ -260,6 +284,26 @@ internal static class FirmamentV2FeatureExpansionreturn HasErrors(diagnostics) ? null : supplied.ToImmutableDictionary(StringComparer.Ordinal);}+ private static string ResolvePointArgument(string source, string expression)+ {+ var reference = expression.Trim().Split('.');+ if (reference.Length is < 1 or > 2 || reference.Any(r => !Regex.IsMatch(r, @"^[A-Za-z_]\w*$"))) return expression;+ var scope = source;+ if (reference.Length == 2)+ {+ var owner = Regex.Match(source, $@"\bConcept\s+Struct\s+{Regex.Escape(reference[0])}\s+On\s+XY\s*\{{");+ var close = owner.Success ? Matching(source, source.IndexOf('{', owner.Index), '{', '}') : -1;+ if (close < 0) return expression;+ scope = source[owner.Index..(close + 1)];+ }+ var point = Regex.Match(scope, $@"\bPoint2\s+{Regex.Escape(reference[^1])}\s*\{{\s*Position\s*:\s*\[(?<value>[^]]+)\]");+ if (!point.Success) return expression;+ var values = point.Groups["value"].Value.Split(',');+ if (values.Length != 2 || !TryEvaluateScalar(values[0], out var x, out var xu) || xu != "mm"+ || !TryEvaluateScalar(values[1], out var y, out var yu) || yu != "mm") return expression;+ return $"Point2({x.ToString("R", CultureInfo.InvariantCulture)}mm,{y.ToString("R", CultureInfo.InvariantCulture)}mm)";+ }+private static void DetectCycles(IEnumerable<Declaration> declarations, IReadOnlyDictionary<string, Declaration> byName, List<string> diagnostics){foreach (var declaration in declarations)@@ -329,7 +373,7 @@ internal static class FirmamentV2FeatureExpansionreturn expression.Trim();}- private static bool TryEvaluateScalar(string expression, out double value, out string unit)+ internal static bool TryEvaluateScalar(string expression, out double value, out string unit){var parser = new ScalarParser(expression); return parser.TryParse(out value, out unit);}diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Parser.cs b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Parser.csindex d6a4b4f4..71daaab1 100644--- a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Parser.cs+++ b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Parser.cs@@ -332,19 +332,6 @@ public static class FirmamentV2Parservar v2AdmissionCandidate = IsV2AdmissionCandidate(source);conceptCatalog ??= FirmamentV2ForgeConceptRegistry.Catalog;- // Feature is Firmament's bounded function-like abstraction. It is expanded once,- // before Template/static specialization, so every downstream command consumes the- // same concrete semantic declarations and no geometry callback can bypass AIR.- var featureExpansion = FirmamentV2FeatureExpansion.Expand(source, diagnostics);- if (featureExpansion is null)- {- diagnostics.Add("firmament-v2-parse-failed");- return FirmamentV2ParseResult.Failure(- diagnostics.Distinct(StringComparer.Ordinal).Order().ToArray(),- FirmamentV2ParseDisposition.RecognizedInvalid);- }- source = featureExpansion.Source;-// Modern Template specialization owns typed Record binding. Run it while// Record and scalar Static declarations still exist, then let canonical// static authoring erase those compile-time declarations before AIR.@@ -358,6 +345,21 @@ public static class FirmamentV2Parser}source = templateExpansion.Source;+ // Feature is Firmament's bounded function-like abstraction. It is expanded once,+ // after typed Template specialization and before static pattern lowering, so every command consumes the+ // same concrete semantic declarations and no geometry callback can bypass AIR.+ var featureExpansion = FirmamentV2FeatureExpansion.Expand(source, diagnostics);+ if (featureExpansion is null)+ {+ diagnostics.Add("firmament-v2-parse-failed");+ return FirmamentV2ParseResult.Failure(+ diagnostics.Distinct(StringComparer.Ordinal).Order().ToArray(),+ FirmamentV2ParseDisposition.RecognizedInvalid);+ }+ source = featureExpansion.Source;+++var specializedBoundaries = ClosedBoundary2Authoring.Expand(source, diagnostics);if (specializedBoundaries is null){@@ -983,7 +985,7 @@ public static class FirmamentV2Parservar known = new HashSet<string>(StringComparer.Ordinal){- "Box", "Cylinder", "Cone", "Sphere", "Torus", "RoundedBox", "Frustum", "StandardPart", "ExactCoaxialPart", "Point2", "Line2", "Rect2", "Circle2", "Ellipse2Guide", "SmoothRoundedRect2", "Plateau", "Concept", "Struct", "Construction", "Profile", "Span", "Compose", "Boss", "Pocket", "AddOffset", "RemoveOffset", "EdgeFinish",+ "Box", "Cylinder", "Cone", "Sphere", "Torus", "RoundedBox", "Frustum", "StandardPart", "ExactCoaxialPart", "Plane", "Axis2", "Point2", "Line2", "Rect2", "Circle2", "Ellipse2Guide", "SmoothRoundedRect2", "Plateau", "Concept", "Struct", "Construction", "Profile", "Span", "Compose", "Boss", "Pocket", "AddOffset", "RemoveOffset", "EdgeFinish","Record", "Static", "Template", "template", "ProfileDelta", "Selection", "InlineStep", "Recognize", "Replace", "Pmi", "Modify", "Match", "Require", "Assert", "Thread"};var compatibilityOnly = new HashSet<string>(StringComparer.Ordinal)diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2TemplateExpansion.cs b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2TemplateExpansion.csindex 54258156..5ee8bcf6 100644--- a/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2TemplateExpansion.cs+++ b/Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2TemplateExpansion.cs@@ -573,9 +573,9 @@ internal static class FirmamentV2TemplateExpansionIReadOnlyDictionary<string, ImmutableHashSet<string>> enums, IReadOnlyDictionary<string, TemplateStaticTableIr> tables, List<string> diagnostics){var result = new Dictionary<string, TemplateStaticRecordIr>(StringComparer.Ordinal);- foreach (Match header in Regex.Matches(source, @"\bStatic\s+(?<name>[A-Za-z_]\w*)\s*:\s*(?<type>[A-Za-z_]\w*)\s*=\s*(?<literal>[A-Za-z_]\w*)\s*\{", RegexOptions.CultureInvariant))+ foreach (Match header in Regex.Matches(source, @"\bStatic\s+(?<name>[A-Za-z_]\w*)\s*:\s*(?<type>[A-Za-z_]\w*)(?:\s*=\s*(?<literal>[A-Za-z_]\w*))?\s*\{", RegexOptions.CultureInvariant)){- var name = header.Groups["name"].Value; var typeName = header.Groups["type"].Value; var literalType = header.Groups["literal"].Value;+ var name = header.Groups["name"].Value; var typeName = header.Groups["type"].Value; var literalType = header.Groups["literal"].Success ? header.Groups["literal"].Value : typeName;var open = source.IndexOf('{', header.Index); var close = Matching(source, open, '{', '}');if (close < 0 || !recordTypes.TryGetValue(typeName, out var recordType)) continue;if (!string.Equals(typeName, literalType, StringComparison.Ordinal)) { diagnostics.Add(WrongRecordType + $":{name}:expected-{typeName}:actual-{literalType}"); continue; }diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/LinearFeatureAuthoring.cs b/Aetheris.Kernel.Firmament/FirmamentV2/LinearFeatureAuthoring.csnew file mode 100644index 00000000..ec94fca7--- /dev/null+++ b/Aetheris.Kernel.Firmament/FirmamentV2/LinearFeatureAuthoring.cs@@ -0,0 +1,106 @@+using System.Globalization;+using System.Text.RegularExpressions;+using Aetheris.Kernel.Firmament.Materializer;++namespace Aetheris.Kernel.Firmament.FirmamentV2;++/// <summary>Finite translation of circular Boss intent, before AIR or BRep construction.</summary>+internal static class LinearFeatureAuthoring+{+ internal sealed record Result(string Source, IReadOnlyList<FirmamentV2LinearPatternDecl> Patterns, IReadOnlyList<FirmamentV2Axis2Decl> Axes);+ internal static Result? Expand(string source, List<string> diagnostics)+ {+ var reports = new List<FirmamentV2LinearPatternDecl>();+ var axes = new Dictionary<string, FirmamentV2Axis2Decl>(StringComparer.Ordinal);+ foreach (Match axis in Regex.Matches(source, @"\bAxis2\s+(?<name>[A-Za-z_]\w*)\s*\{"))+ {+ var end = Matching(source, source.IndexOf('{', axis.Index));+ var identity = axis.Groups["name"].Value;+ foreach (Match owner in Regex.Matches(source, @"\bConcept\s+Struct\s+(?<name>[A-Za-z_]\w*)\s+On\s+XY\s*\{"))+ if (axis.Index > owner.Index && axis.Index < Matching(source, source.IndexOf('{', owner.Index)))+ identity = owner.Groups["name"].Value + "." + axis.Groups["name"].Value;+ if (end < 0) { Error("axis-malformed", identity); continue; }+ var fields = source[(source.IndexOf('{', axis.Index) + 1)..end];+ var origin = Regex.Match(fields, @"\bOrigin\s*:\s*\[(?<x>[^,]+),(?<y>[^]]+)\]");+ var vector = Regex.Match(fields, @"\bDirection\s*:\s*\[(?<x>[^,]+),(?<y>[^]]+)\]");+ if (!origin.Success || !vector.Success+ || !FirmamentV2FeatureExpansion.TryEvaluateScalar(origin.Groups["x"].Value, out var x, out var xu) || xu != "mm"+ || !FirmamentV2FeatureExpansion.TryEvaluateScalar(origin.Groups["y"].Value, out var y, out var yu) || yu != "mm"+ || !FirmamentV2FeatureExpansion.TryEvaluateScalar(vector.Groups["x"].Value, out var vx, out var vxu) || vxu.Length != 0+ || !FirmamentV2FeatureExpansion.TryEvaluateScalar(vector.Groups["y"].Value, out var vy, out var vyu) || vyu.Length != 0+ || !double.IsFinite(vx * vx + vy * vy) || vx * vx + vy * vy < 1e-24)+ { Error("axis-invalid", identity); continue; }+ var norm = Math.Sqrt(vx * vx + vy * vy);+ if (!axes.TryAdd(identity, new(identity, x, y, vx / norm, vy / norm, new(axis.Index, end - axis.Index + 1)))) Error("axis-duplicate", identity);+ }+ var changes = new List<(int Start, int Length, string Text)>();+ var consumed = new HashSet<string>(StringComparer.Ordinal);+ var patternNames = new HashSet<string>(StringComparer.Ordinal);+ foreach (Match header in Regex.Matches(source, @"\bLinear\s+Pattern\s+(?<name>[A-Za-z_]\w*)\s*\{"))+ {+ var close = Matching(source, source.IndexOf('{', header.Index));+ var name = header.Groups["name"].Value;+ if (close < 0) { Error("malformed", name); continue; }+ var body = source[(source.IndexOf('{', header.Index) + 1)..close];+ if (!patternNames.Add(name)) { Error("duplicate-name", name); continue; }+ if (Regex.IsMatch(body, @"\bPattern\s+")) { Error("nested-unsupported", name); continue; }+ var fields = Regex.Matches(body, @"\b(?<name>[A-Za-z_]\w*)\s*:").Cast<Match>().Select(m => m.Groups["name"].Value).ToArray();+ if (fields.Length != 4 || fields.Distinct(StringComparer.Ordinal).Count() != 4 || fields.Any(f => f is not ("Source" or "Direction" or "Count" or "Spacing")))+ { Error("fields-invalid", name); continue; }+ var seed = Field(body, "Source"); var direction = Field(body, "Direction");+ if (!int.TryParse(Field(body, "Count"), out var count) || count is < 1 or > 1024)+ { Error("count-invalid", name); continue; }+ if (!FirmamentV2FeatureExpansion.TryEvaluateScalar(Field(body, "Spacing"), out var spacing, out var unit) || unit != "mm" || spacing <= 0)+ { Error("spacing-invalid", name); continue; }+ if (direction.EndsWith(".Direction", StringComparison.Ordinal))+ {+ if (!axes.TryGetValue(direction[..^10], out var axis)) { Error("axis-unresolved", name); continue; }+ direction = $"[{F(axis.DirectionX)},{F(axis.DirectionY)}]";+ }+ var components = direction.Trim().Trim('[', ']').Split(',');+ if (components.Length != 2 || !double.TryParse(components[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var dx)+ || !double.TryParse(components[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var dy)+ || !double.IsFinite(dx) || !double.IsFinite(dy) || Math.Sqrt(dx * dx + dy * dy) < 1e-12)+ { Error("direction-invalid", name); continue; }+ var length = Math.Sqrt(dx * dx + dy * dy);+ if (!double.IsFinite(length)) { Error("direction-invalid", name); continue; }+ dx /= length; dy /= length;+ var feature = Regex.Match(source, $@"\bBoss\s+{Regex.Escape(seed)}\s*\{{");+ var featureClose = feature.Success ? Matching(source, source.IndexOf('{', feature.Index)) : -1;+ if (featureClose < 0 || !consumed.Add(seed)) { Error("source-invalid-or-reused", name); continue; }+ var featureBody = source[(source.IndexOf('{', feature.Index) + 1)..featureClose];+ var profileName = Field(featureBody, "Profile");+ var profile = ProfileAuthoringParser.ResolveNamedProfile(source, profileName, out var profileErrors);+ if (profile is null || profile.PlaneFrame != "XY" || profile.Loops.Count != 1+ || profile.Loops[0].Segments.Count != 1 || profile.Loops[0].Segments[0].Geometry is not LineArcFullCircle2D circle)+ { diagnostics.AddRange(profileErrors); Error("source-profile-not-qualified", name); continue; }+ var output = new List<string>(); var identities = new List<string>();+ for (var i = 0; i < count; i++)+ {+ var id = name + "_Instance" + i.ToString(CultureInfo.InvariantCulture);+ if (Regex.IsMatch(source, $@"\b(?:Boss|Profile|Point2|Circle2)\s+{Regex.Escape(id)}\b")) { Error("identity-collision", id); break; }+ var center = id + "__Center"; var guide = id + "__Circle"; var section = id + "__Profile";+ var x = circle.Center.X + i * spacing * dx; var y = circle.Center.Y + i * spacing * dy;+ output.Add($"Point2 {center} {{ Position: [{F(x)}mm,{F(y)}mm] }}\nCircle2 {guide} {{ Center: {center}; Radius: {F(circle.Radius)}mm }}\nProfile {section} {{ Loop Outer {{ {guide} |> TraceLoop }} }}\nBoss {id} {{ "+ + Regex.Replace(featureBody, @"\bProfile\s*:\s*[A-Za-z_]\w*", "Profile: " + section) + " }");+ identities.Add(id);+ }+ changes.Add((feature.Index, featureClose - feature.Index + 1, ""));+ changes.Add((header.Index, close - header.Index + 1, string.Join("\n", output)));+ reports.Add(new(name, seed, Field(body, "Direction"), count, spacing, dx, dy, identities, new(header.Index, close - header.Index + 1)));+ }+ if (diagnostics.Any(d => d.StartsWith("firmament-feature-linear-", StringComparison.Ordinal))) return null;+ foreach (var change in changes.OrderByDescending(c => c.Start)) source = source.Remove(change.Start, change.Length).Insert(change.Start, change.Text);+ return new(source, reports, axes.Values.ToArray());+ void Error(string code, string detail) => diagnostics.Add("firmament-feature-linear-" + code + ":" + detail);+ }+ private static string F(double value) => value.ToString("R", CultureInfo.InvariantCulture);+ private static string Field(string body, string name) => Regex.Match(body, $@"\b{name}\s*:\s*(?<value>[^;\r\n}}]+)").Groups["value"].Value.Trim();+ private static int Matching(string source, int open)+ {+ var depth = 0;+ for (var i = open; i >= 0 && i < source.Length; i++)+ { if (source[i] == '{') depth++; else if (source[i] == '}' && --depth == 0) return i; }+ return -1;+ }+}diff --git a/Aetheris.Kernel.Firmament/FirmamentV2/RevolveAuthoringParser.cs b/Aetheris.Kernel.Firmament/FirmamentV2/RevolveAuthoringParser.csindex 425c5fee..1eab104f 100644--- a/Aetheris.Kernel.Firmament/FirmamentV2/RevolveAuthoringParser.cs+++ b/Aetheris.Kernel.Firmament/FirmamentV2/RevolveAuthoringParser.cs@@ -108,11 +108,11 @@ public static class RevolveAuthoringParser// resolved before the profile binder, just as they are for actual materialization.var boundaries = ClosedBoundary2Authoring.Expand(source, diagnostics);if (boundaries is null) return null;- var features = FirmamentV2FeatureExpansion.Expand(boundaries.Source, diagnostics);- if (features is null) return null;- var templates = FirmamentV2TemplateExpansion.Expand(features.Source, diagnostics);+ var templates = FirmamentV2TemplateExpansion.Expand(boundaries.Source, diagnostics);if (templates is null) return null;- var specializedBoundaries = ClosedBoundary2Authoring.Expand(templates.Source, diagnostics);+ var features = FirmamentV2FeatureExpansion.Expand(templates.Source, diagnostics);+ if (features is null) return null;+ var specializedBoundaries = ClosedBoundary2Authoring.Expand(features.Source, diagnostics);if (specializedBoundaries is null) return null;var staticAuthoring = CanonicalStaticAuthoring.Expand(specializedBoundaries.Source, diagnostics);return staticAuthoring?.Source;diff --git a/Aetheris.Kernel.Firmament/Materializer/PrismaticProfileComposition.cs b/Aetheris.Kernel.Firmament/Materializer/PrismaticProfileComposition.csindex e0c829b3..1df096be 100644--- a/Aetheris.Kernel.Firmament/Materializer/PrismaticProfileComposition.cs+++ b/Aetheris.Kernel.Firmament/Materializer/PrismaticProfileComposition.cs@@ -347,11 +347,14 @@ public static class PrismaticProfileCompositionParserif (!profiles.TryGetValue(profileName, out var bossProfile)) { diagnostics.Add($"firmament-boss-invalid-profile:{name}:profile={profileName}"); continue; }if (!double.IsFinite(height) || height <= 0d) { diagnostics.Add($"firmament-boss-height-must-be-positive:{name}:height={height:R}mm"); continue; }surfaceSpans.TryGetValue(face, out var supportSpan);- if (supportSpan is null && !IsTopSelector(face)) { diagnostics.Add($"firmament-boss-invalid-target:{name}:On={face}:supported=Top-or-<feature>.Top-or-Span<Plane>"); continue; }+ var authoredPlane = Regex.Match(source, $@"\bPlane\s+{Regex.Escape(face)}\s*\{{\s*Origin\s*:\s*\[(?<origin>[^]]+)\]\s*;?\s*Normal\s*:\s*\[(?<normal>[^]]+)\](?:\s*;?\s*Up\s*:\s*\[(?<up>[^]]+)\])?", RegexOptions.CultureInvariant);+ if (supportSpan is null && !IsTopSelector(face) && !authoredPlane.Success) { diagnostics.Add($"firmament-boss-invalid-target:{name}:On={face}:supported=Top-or-<feature>.Top-or-Span<Plane>"); continue; }if (supportSpan is not null && !IsProfileFootprintInsideSpan(supportSpan, bossProfile, profiles)){ diagnostics.Add($"firmament-feature-footprint-outside-span:{name}:{face}:profile={profileName}"); continue; }var candidates = supportSpan is null- ? ResolveTopSupports(face, stock, operations, bossProfile, profiles)+ ? authoredPlane.Success+ ? ResolvePlaneTopSupports(authoredPlane, name, operations, bossProfile, profiles, diagnostics)+ : ResolveTopSupports(face, stock, operations, bossProfile, profiles): ResolveSpanTopSupports(supportSpan, operations, bossProfile, profiles);if (candidates.Count == 0) { diagnostics.Add(face.EndsWith(".Top", StringComparison.Ordinal)? $"feature-support-not-found:{name}:{face}:host={compose.Groups["n"].Value}:profile={profileName}"@@ -815,6 +818,27 @@ public static class PrismaticProfileCompositionParserreturn IsPocketFootprintInsideStock(support, footprint, available);}+ // Bounded +Z prismatic support: a plane names an axial level, never an+ // arbitrary topology face or permission to add disconnected material.+ private static IReadOnlyList<PrismaticProfileOperation> ResolvePlaneTopSupports(Match plane, string feature,+ IReadOnlyList<PrismaticProfileOperation> operations, ResolvedProfile2D footprint,+ IReadOnlyDictionary<string, ResolvedProfile2D> profiles, List<string> diagnostics)+ {+ var origin = plane.Groups["origin"].Value.Split(',');+ var normal = plane.Groups["normal"].Value.Split(',');+ var up = plane.Groups["up"].Success ? plane.Groups["up"].Value.Split(',').Select(v => v.Trim()).ToArray() : new[] { "0", "1", "0" };+ if (!up.SequenceEqual(new[] { "0", "1", "0" }) || origin.Length != 3 || normal.Length != 3+ || !FirmamentV2FeatureExpansion.TryEvaluateScalar(origin[0], out var x, out var xu) || xu != "mm" || Math.Abs(x) > 1e-9+ || !FirmamentV2FeatureExpansion.TryEvaluateScalar(origin[1], out var y, out var yu) || yu != "mm" || Math.Abs(y) > 1e-9+ || !FirmamentV2FeatureExpansion.TryEvaluateScalar(origin[2], out var z, out var zu) || zu != "mm"+ || !double.TryParse(normal[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var nx) || nx != 0+ || !double.TryParse(normal[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var ny) || ny != 0+ || !double.TryParse(normal[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var nz) || nz != 1)+ { diagnostics.Add($"feature-support-plane-not-qualified:{feature}:qualified=origin-[0,0,z]-normal-+Z"); return []; }+ return operations.Where(o => o.Intent != PrismaticProfileIntent.Remove && Math.Abs(o.To - z) < 1e-9+ && profiles.TryGetValue(o.ProfileReference, out var profile) && HasConnectedBossSupport(o, footprint, profiles)).ToArray();+ }+private static IReadOnlyList<PrismaticProfileOperation> ResolveTopSupports(string selector,PrismaticProfileOperation stock,diff --git a/Aetheris.Web.Runtime/Program.cs b/Aetheris.Web.Runtime/Program.csindex 40886981..59361e8c 100644--- a/Aetheris.Web.Runtime/Program.cs+++ b/Aetheris.Web.Runtime/Program.cs@@ -92,6 +92,7 @@ public static partial class Programvar session = new WebModelSession(id, request.Source, request.SourceName ?? "model.firmament");var result = session.Rebuild();if (result.Success) Sessions[id] = session;+ else session.Dispose();return result;}@@ -201,12 +202,13 @@ public static partial class Programprivate static object DisposeSession(WebRequest request){- if (request.SessionId is not null) Sessions.Remove(request.SessionId);+ if (request.SessionId is not null && Sessions.Remove(request.SessionId, out var session)) session.Dispose();return new { disposed = true };}private static object DisposeRuntime(){+ foreach (var session in Sessions.Values) session.Dispose();Sessions.Clear();return new { disposed = true };}@@ -226,10 +228,13 @@ public static partial class Programpublic string Code { get; } = code;}- private sealed class WebModelSession(string id, string source, string sourceName)+ private sealed class WebModelSession(string id, string source, string sourceName) : IDisposable{private string _source = source;private string _sourceName = sourceName;+ private readonly FirmamentCompilationSession _compilationSession = new();+ private AssemblyCompilationReuse? _lastReuse;+ public void Dispose() => _compilationSession.Dispose();private IReadOnlyList<WebProperty> _properties = [];private IReadOnlyList<FirmamentConstructProjection> _projections = [];private readonly Dictionary<string, WebPropertyValue> _overrides = new(StringComparer.Ordinal);@@ -308,6 +313,7 @@ public static partial class Programvar sourceProperties = ParameterInspector.Inspect(Id, _sourceName, _source);inspectPhase.Dispose();var effective = ApplyOverrides(_source, sourceProperties, _overrides);+ _lastReuse = null;var nextProperties = sourceProperties;foreach (var (propertyId, value) in _overrides){@@ -333,7 +339,7 @@ public static partial class Program};var perf = BuildPerfTrace.Snapshot();var timings = new { compileMilliseconds = compiled.CompileMilliseconds, meshMilliseconds = compiled.MeshMilliseconds,- totalBeforeSnapshotMilliseconds = totalWatch.Elapsed.TotalMilliseconds,+ totalBeforeSnapshotMilliseconds = totalWatch.Elapsed.TotalMilliseconds, reuse = _lastReuse,profile = new { phases = perf.Phases.Select(sample => new { sample.Name, sample.InclusiveMilliseconds,sample.ExclusiveMilliseconds, sample.AllocatedBytes }).ToArray(), counts = perf.Counts,gc0 = perf.Gc0, gc1 = perf.Gc1, gc2 = perf.Gc2 } };@@ -421,7 +427,8 @@ public static partial class Programprivate WebBuildResult CompileAssembly(string effective, List<WebProperty> properties){var watch = System.Diagnostics.Stopwatch.StartNew();- var compilation = new AssemblyM1Pipeline().Compile(effective, _sourceName);+ var compilation = _compilationSession.Compile(effective, _sourceName);+ _lastReuse = compilation.Reuse;var compileMs = watch.Elapsed.TotalMilliseconds;if (!compilation.IsSuccess || compilation.Ir is null || compilation.Geometry is null)return WebBuildResult.Failed(compilation.Diagnostics.Select(d => new WebDiagnostic(d.Severity == AssemblyDiagnosticSeverity.Error ? "error" : "warning", d.Code, d.Message, SourceRef(_sourceName, 0, effective.Length))).ToArray(), compileMs);diff --git a/demos/GuitarSurfacingX0/Program.cs b/demos/GuitarSurfacingX0/Program.csindex 3f14634d..3d41c403 100644--- a/demos/GuitarSurfacingX0/Program.cs+++ b/demos/GuitarSurfacingX0/Program.cs@@ -5,11 +5,14 @@ using Aetheris.Kernel.Firmament.Assembly;var source = args.Length > 0 ? args[0] : "fixtures/Canonical/AssemblyInterfaces/GuitarX0/guitar.firmasm";var output = args.Length > 1 ? args[1] : "artifacts/local/guitar-x0/timings.json";var runs = new List<object>();-for (var i = 0; i < 2; i++)+using var session = new FirmamentCompilationSession();+string? baselineUsd = null;+for (var i = 0; i < 3; i++){+ if (i == 2) session.CompileFile(source); // Populate outside the measured cached run.var total = Stopwatch.StartNew();var clock = Stopwatch.StartNew();- var compiled = new AssemblyM1Pipeline().CompileFile(source);+ var compiled = i < 2 ? new AssemblyM1Pipeline().CompileFile(source) : session.CompileFile(source);var compileMilliseconds = clock.Elapsed.TotalMilliseconds;if (!compiled.IsSuccess) throw new InvalidOperationException(string.Join("\n", compiled.Diagnostics.Select(d => d.Message)));clock.Restart();@@ -17,9 +20,13 @@ for (var i = 0; i < 2; i++)var displayMilliseconds = clock.Elapsed.TotalMilliseconds;clock.Restart();var usd = AssemblyUsdExporter.Serialize(compiled.Ir!, mesh);+ baselineUsd ??= usd;+ if (usd != baselineUsd) throw new InvalidOperationException("Incremental guitar output differs from the uncached USD baseline.");runs.Add(new{- lane = i == 0 ? "cold-first-compile-in-fresh-process" : "warm-recompile-in-same-process",+ lane = i == 0 ? "cold-first-compile-in-fresh-process" : i == 1 ? "warm-recompile-in-same-process" : "incremental-session-recompile",+ reuse = compiled.Reuse,+ matchesUncachedUsd = usd == baselineUsd,compileMilliseconds, displayMilliseconds,serializationMilliseconds = clock.Elapsed.TotalMilliseconds,totalMilliseconds = total.Elapsed.TotalMilliseconds,@@ -30,6 +37,6 @@ for (var i = 0; i < 2; i++)});}Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(output))!);-var json = JsonSerializer.Serialize(new { source, methodology = "Cold includes first-use JIT and library initialization; warm recompiles the same source without a persistent model cache. Neither includes dotnet build or process startup.", runs }, new JsonSerializerOptions { WriteIndented = true });+var json = JsonSerializer.Serialize(new { source, methodology = "Cold includes first-use JIT/library initialization. Warm is uncached; incremental uses a populated in-memory session and still reimports fresh exact bodies. Process startup and dotnet build are excluded.", runs }, new JsonSerializerOptions { WriteIndented = true });File.WriteAllText(output, json + "\n");Console.WriteLine(json);diff --git a/docs/public/demos/guitar-subassemblies.md b/docs/public/demos/guitar-subassemblies.mdindex 0cdd4d27..0307c198 100644--- a/docs/public/demos/guitar-subassemblies.md+++ b/docs/public/demos/guitar-subassemblies.md@@ -1,5 +1,10 @@# Guitar as a multi-file assembly+The body crown, pickups and bridge now use [Concept-directed Fixed seating](../firmament/datum-seating.md)+against the shared `hardware-layout.firmament` deck. The bridge's former 4mm gap is removed.++The pickup construction has since been consolidated into [one functional part](../firmament/functional-pickup.md), placed twice. The qualification table below records the earlier organization-only snapshot; current counts are 91 visible parts and 53 geometry definitions.+The preferred entry is [guitar.firmasm](../../../fixtures/Canonical/AssemblyInterfaces/GuitarX0/guitar.firmasm).It contains only Include declarations and five top-level subassembly occurrences.The old guitar-x0.firmament entry is a small compatibility composition root.@@ -13,7 +18,8 @@ guitar.firmasm│ ├─ Neck.firmament exact six-section neck and published ports│ └─ tuners-assembly.firmament keyed tuner posts, washers and buttons├─ electronics-assembly.firmament knobs, selector and decorative covers-│ └─ pickups-assembly.firmament keyed seats, coils and poles+│ └─ pickups-assembly.firmament two complete pickup occurrences+│ └─ pickup.firmament housing, coil functions and pole feature pattern├─ bridge-assembly.firmament bridge, stop tailpiece and keyed saddles└─ strings-assembly.firmament WireForm template and six formed routes```diff --git a/docs/public/demos/guitar-surfacing-x0.md b/docs/public/demos/guitar-surfacing-x0.mdindex 0f089cad..f41bd351 100644--- a/docs/public/demos/guitar-surfacing-x0.md+++ b/docs/public/demos/guitar-surfacing-x0.md@@ -1,10 +1,13 @@# Single-cut carved electric guitar+The current source also qualifies [Concept-directed Fixed seating](../firmament/datum-seating.md):+the planar body crown, pickups and bridge conform to one authored 53mm hardware deck.+**Verdict: accepted for GUITAR-SURFACING-X0.** This is good enough as a presentation/dunk witness: a coherent surfaced guitar built from code, exact STEP export, a clean compiled USD display path and slide-ready Cycles images. The result demonstrates Aetheris's pipeline; the comparison does not claim a measured speed ratio against Zoo.GUITAR-SURFACING-X0 is an original single-cut guitar presentation witness inspired by the Les Paul family. The supplied photographs guided proportions and finish; no photograph, logo, downloaded guitar model, or external product mesh is bundled. Aetheris constructs every guitar part. Blender imports the actual OpenUSD export and adds downstream appearance, studio lighting, floor, and camera.-The [authored assembly](../../../fixtures/Canonical/AssemblyInterfaces/GuitarX0/guitar.firmasm) has a cubic single-cut outline, mahogany back, cream edge band, a five-section carved maple top with a 13 mm rise, a six-section D-profile G1 neck, tapered fretboard, tilted headstock, 22 frets, inlays, two pickups, bridge, stop tailpiece, four controls, selector, tuner placeholders, and six continuous formed strings. See [the multi-file subassembly layout](guitar-subassemblies.md) for the current source organization.+The [authored assembly](../../../fixtures/Canonical/AssemblyInterfaces/GuitarX0/guitar.firmasm) has a cubic single-cut outline, mahogany back, cream edge band, a five-section carved maple top with a 13 mm rise, a six-section D-profile G1 neck, tapered fretboard, tilted headstock, 22 frets, inlays, two pickups, bridge, stop tailpiece, four controls, selector, tuner placeholders, and six continuous formed strings. See [the multi-file subassembly layout](guitar-subassemblies.md) and [functional pickup construction](../firmament/functional-pickup.md) for the current source. Pickup consolidation changes current counts to 91 visible parts and 53 definitions; performance and render evidence below describe the earlier witness snapshots.## Reproducediff --git a/docs/public/firmament/assemblies.md b/docs/public/firmament/assemblies.mdindex 5638f7c0..b81c382c 100644--- a/docs/public/firmament/assemblies.md+++ b/docs/public/firmament/assemblies.md@@ -1,5 +1,11 @@# Typed interfaces and reusable subassemblies+For layout-first placement against authored Concept planes, see+[Concept-directed Fixed seating](datum-seating.md).++For reusing unchanged exact parts across builds, see+[incremental compilation sessions](incremental-compilation.md).+For readable placement, named FrameTransform composition, definition-owned ports,keyed occurrence patterns and Fixed Gap/Clocking seating, see the[assembly authoring foundation](assembly-authoring-foundation.md).diff --git a/docs/public/firmament/datum-seating.md b/docs/public/firmament/datum-seating.mdnew file mode 100644index 00000000..52539610--- /dev/null+++ b/docs/public/firmament/datum-seating.md@@ -0,0 +1,105 @@+# Concept-directed Fixed seating++Author the layout first, declare which published seating ports conform to its+plane, then realize each member at a complete frame on that plane. The product+tree remains containment; datum geometry is semantic design authority, not a+synthetic Part. No simultaneous constraint search is introduced.++```firmament+Concept Struct Layout {+ Plane Deck { Origin: [0mm,0mm,53mm]; Normal: [0,0,1]; Up: [0,1,0] }+ DatumFrame BridgeSeat { On: Deck; At: [0mm,-35mm]; X: [1,0] }+}+Interface<Fixed> DeckSeat {+ Datum: Layout.Deck+ Members: [Hardware.Bridge.BottomSeat]+}+Assembly Hardware {+ <Assembly Hardware><Part Bridge = Panel<L:82mm,W:12mm,H:10mm,R:5mm>></Part></Assembly>+ Anchor: Hardware;+ Mate BridgeOnDeck: DeckSeat {+ Member: Hardware.Bridge.BottomSeat+ At: Layout.BridgeSeat+ Orientation: SameDirection+ }+}+```++`BottomSeat` is definition-owned and publishes a `Frame`. The Interface names the+common Concept plane; the Mate names one member and its complete target frame.+The compiler validates membership and derives a placement through the existing+frame-authoring path. The occurrence cannot also declare a Placement or another+datum Mate. Inspection retains the datum contract, per-occurrence DatumSeat,+placement constraints and material-seat evidence.++The initial syntax admits top-level Concept Struct layouts with finite literal+Plane Origin/Normal/Up and DatumFrame On/At/X fields. Origins and At coordinates+require mm; basis vectors are dimensionless. At is a two-component coordinate+within the plane; X is a nonzero two-component direction. Orientation is+SameDirection or OpposedDirection. A bare plane is insufficient as an At target.+Each member must be realized once. Members are direct part ports within their+owning assembly; direct traversal through private subassembly children is not+admitted. Concept structures inside part definitions remain part-owned.++Reusable subassemblies can share the same layout declaration, with scoped seating+contracts for their own parts. Frames are interpreted in the owning assembly's+coordinates, following the existing local-definition model. The guitar's owning+subassemblies have identity placement, so their shared deck is also one world+plane. Arbitrary datum targeting across independently moved subassemblies and+parameterized layout expressions are not qualified by this first implementation.++## Material evidence++The seating frame is checked against the transformed material body: an admitted+planar face must contain the seating point on the Concept plane. This rejects a+frame declared in empty space. `Support: true` marks a material support member;+other seats using the same named datum are also checked against its planar face+at their seating points in world coordinates.++Plane coincidence is analytic. Straight-edged face inclusion uses the kernel's+planar domain classifier. Curved trim inclusion uses existing bounded boundary+tessellation, so that inclusion check is approximate and retains the material+face identity. Bounding-box inclusion never proves seating. This is point-contact+evidence, not a manufacturing claim of full-footprint support, machining tolerance+or screw engagement. Existing mate residual and solid-interference checks remain.++## Guitar migration++[`hardware-layout.firmament`](../../../fixtures/Canonical/AssemblyInterfaces/GuitarX0/hardware-layout.firmament)+owns the single 53mm HardwareDeck and the body, pickup and bridge target frames.+Body, pickup and bridge subassemblies reference that plane through scoped Fixed+contracts. Their seating ports are published by the part definitions.++The bridge previously began at 57mm, leaving a 4mm gap above the 53mm deck. It now+begins at 53mm and its simplified panel is 10mm tall, preserving its 63mm top and+the existing saddles/string layout. The carved body's final two sections broaden+the flat crown to provide the intended hardware support while retaining the+carved perimeter. All four material seats pass, including hardware contact with+the body support. No geometry is supplied by the renderer.++Regression coverage includes common-datum motion with cached part reuse, complete+frame requirements, membership, orientation/basis checks, competing placement+authorities, false material ports, support misses, and the guitar's bridge bounds.++## Qualification and artifacts++The Release solution build, fast core lane (1,004 tests), and full serial solution+lane (4,061 tests) passed. Fresh CLI inspection reports all four material seats+passing with zero plane residual. Moving only the Concept deck in the regression+reuses the two part geometry definitions and recomputes their assembly placement.++AP242 export and CLI reimport succeeded with 126 occurrences excluding the root.+Export reports 60 definitions; reimport reports 53 geometry definitions and seven+subassemblies.+USD export and Blender Cycles rendering also succeeded. The refreshed hero and+close side image were visually inspected; the side image shows bridge contact+with the body. This change did not repeat browser camera-interaction qualification.++Generated evidence is under ignored `artifacts/local/guitar-datum-seating/`:+`inspection.json`, `guitar.step`, `step-export.json`, `step-reimport.json`,+`guitar.usda`, `guitar-studio.blend`, `hero.png`, and `deck-side.png`.+Build/test logs are `artifacts/local/pickup-features/datum-closeout-{build,fast,full}.log`.+The fresh inspection measured 8.879 seconds of definition materialization and+0.978 seconds of geometry execution/validation; this is a single uncached run,+not an incremental benchmark. The 1,800 by 2,200 hero took 206.7 seconds at+64 Cycles samples on this host.diff --git a/docs/public/firmament/functional-pickup.md b/docs/public/firmament/functional-pickup.mdnew file mode 100644index 00000000..f556b1ba--- /dev/null+++ b/docs/public/firmament/functional-pickup.md@@ -0,0 +1,132 @@+# Functional pickup construction++A pickup is one reusable exact part whose housing, coils and poles are features.+The guitar places two occurrences of its definition; poles are not assembly+occurrences. The authored recipe is [pickup.firmament](../../../fixtures/Canonical/AssemblyInterfaces/GuitarX0/pickup.firmament).+The [standalone witness](../../../fixtures/Canonical/Feature/pickup-functional.firmament)+uses the same recipe without assembly port publication.++```firmament+Feature Pole(Center: Point2, Support: Plane) -> Boss {+ Circle2 Outline { Center: Center; Radius: 2.2mm }+ Profile Section { Loop Outer { Outline |> TraceLoop } }+ return Boss { On: Support; Profile: Section; Height: 1mm }+}++// Inside the pickup's Compose Body, after its housing and two coil features:+Feature PoleSeed = Pole(Center: Layout.FirstPole, Support: CoilTop)+Linear Pattern Poles {+ Source: PoleSeed+ Direction: Layout.Longitudinal.Direction+ Count: 6+ Spacing: Spec.PolePitch+}+```++Feature evaluation is pure semantic construction. Private local guides/profiles+receive invocation-qualified names, e.g. `UpperCoil__Section`. Named calls retain+`ResultIdentity` in Feature invocation evidence. Local declarations admit the+bounded Point2/Rect2/RoundedRect2/Circle2/Profile subset; arbitrary geometry,+mutation, runtime loops and recursion remain unsupported.++`Axis2` is a non-materialized planar datum with a Length-valued two-component+Origin and a finite nonzero dimensionless Direction. Direction is normalized;+inspection records the qualified owner, origin, direction and source span.+The pickup declares longitudinal and transverse axes under its XY Layout.++Linear Pattern is qualified for a circular-profile Boss in XY. It translates+semantic profile/feature intent before AIR, using one checked source and an+explicit direction. Count is 1..1024, includes the seed as instance zero, and+Spacing is a positive Length. Generated identities are `Poles_Instance0` through+`Poles_Instance5`. The seed is consumed rather than materialized a seventh time.+Inspection retains source, direction reference, normalized vector, spacing,+count and generated feature identities. Other profile families, Hole/Pocket+linear repetition, arbitrary 3D transforms and nested patterns are not qualified+by this milestone; rejected circular-Boss inputs have specific diagnostics.++Named Plane supports are bounded to origins `[0mm,0mm,z]`, normal `[0,0,1]` and optional Up `[0,1,0]`, in+an ordinary +Z prismatic Compose. A plane selects an actual connected material+support at its declared level; it does not permit detached material. Unsupported+planes, absent supports and ambiguous supports fail closed. Both coil features+use BaseTop; poles use CoilTop. No feature relies on mutable current-Top selection.++Templates specialize checked Record values before functional Features bind their+arguments. `Static Name: RecordType { ... }` is now a shorthand for the ordinary+`Static Name: RecordType = RecordType { ... }`. Immutable `with` derives a variant:++```firmament+Static BridgePickupSpec = StandardPickup with { PolePitch: 10.4mm }+```++The actual guitar currently places the same StandardPickup specialization twice,+so both occurrences share one geometry definition. Changing one occurrence to+`Humbucker<Spec: BridgePickupSpec>` selects a separate variant. Definition cache+identity remains the existing authored application identity; this milestone does+not add equality-based interning of differently named record aliases.++## Geometry and appearance++The pickup uses the existing exact prismatic section-stack compiler/emitter:+rounded housing, two rounded coil bosses, six circular pole bosses. There are+no imported mesh substitutes or pickup coordinate calculations in Python.+Published Mount frames let the assembly own only the two mounting placements.++The body is deliberately fused for the presentation witness. It does not claim+physical coil insulation, separate fasteners, magnets or manufacturing joinery.+The STEP assembly contains NeckPickup and BridgePickup, each with one body.+The guitar now has 91 visible parts and 53 shared geometry definitions, down from+107 and 55. Four assembly occurrence patterns remain for saddles/tuner hardware.++USD preview assigns one dark pickup material. Blender/Cycles restores cream,+black and nickel regions through default-recipe axial face-height bands, solely+as downstream appearance. That recipe-specific coloration is not authored+feature material assignment and does not change vertices or topology. The+renderer checks the imported geometry hash before and after shading. General+feature-owned appearance assignment remains a separate improvement.++## Reproduce++```powershell+python scripts/create-guitar-x0.py+dotnet Aetheris.CLI/bin/Release/net10.0/aetheris.dll build fixtures/Canonical/Feature/pickup-functional.firmament --out artifacts/local/pickup-features/pickup.step --json+dotnet Aetheris.CLI/bin/Release/net10.0/aetheris.dll asm inspect fixtures/Canonical/AssemblyInterfaces/GuitarX0/guitar.firmasm --json --profile+./scripts/qualify-guitar-x0.ps1 -OutDir artifacts/local/pickup-features/guitar+```++The generator preserves the authored pickup recipe and derives the standalone+witness from it. It emits only the two pickup occurrence placements.++## Qualification results++The Release solution build, fast core lane (1,004 tests), and full serial solution+lane (4,042 tests) passed. Regression coverage checks private construction hygiene,+named invocation evidence, immutable specification overrides, deterministic STEP,+exact fused volume, support selection, and rejected pattern/support inputs.+CLI inspection exposes both typed axes, the six-member linear pattern, and named+Feature results.++The standalone pickup STEP reimports as one closed, consistently oriented body.+The guitar STEP reimport contains 91 bodies sharing 53 definitions; NeckPickup and+BridgePickup reference one definition, with no coil/seat/pole category groups.+Pickup display tessellation has 7,436 triangles, no unmatched edges and no+nonpositive normal triangles.++Measured guitar compilation was 10.091 seconds cold and 4.389 seconds warm;+display preparation was 0.593 and 0.426 seconds respectively. Cold includes+first-use JIT/library initialization; warm recompiles without a persistent model+cache. Process startup and dotnet build are excluded. Camera interaction was not+remeasured in this change.++The updated 1800-by-2200 Cycles hero was visually inspected. Rendering took+43.659 seconds on an RTX 3070 at 64 samples. Both fused pickups received the+documented appearance bands; product topology hashes were unchanged by shading.+This preserves the presentation witness while correcting its part ownership.++Generated evidence is under ignored `artifacts/local/pickup-features/`:++- `pickup.step`, `part-inspection.json`: standalone exact part and typed evidence.+- `guitar/guitar.step`, `guitar/guitar.usda`, `guitar/guitar-studio.blend`: exports and scene.+- `guitar/hero.png`: refreshed hero image.+- `guitar/step-analysis.json`, `guitar/mesh-check.json`, `guitar/timings.json`,+ `guitar/render.json`: hierarchy, mesh, timing and shading evidence.+- `solution-build.log`, `fast.log`, `closeout-full.log`: build and test validation logs.diff --git a/docs/public/firmament/incremental-compilation.md b/docs/public/firmament/incremental-compilation.mdnew file mode 100644index 00000000..81842ddb--- /dev/null+++ b/docs/public/firmament/incremental-compilation.md@@ -0,0 +1,92 @@+# Incremental assembly compilation++Keep a `FirmamentCompilationSession` alive across builds to reuse successful exact+part materializations. This is a bounded in-memory cache, with no new Firmament+syntax, disk cache, background process or dependency graph solver.++```csharp+using var session = new FirmamentCompilationSession(maximumDefinitions: 256);+var first = session.CompileProject(project);+var next = session.CompileProject(editedProject);+Console.WriteLine(next.Reuse?.ReusedDefinitions);+Console.WriteLine(next.Reuse?.RebuiltDefinitions);+```++`CompileFile(path)` and `Compile(source, sourceIdentity)` are also available.+Reuse evidence lists every requested distinct definition, whether it was reused,+and its reason. `Clear()` drops cached definitions; disposal releases the cache.+Calls within a session are serialized. Capacity uses deterministic insertion-order+eviction, retaining one latest entry per authored definition identity.++## What is reused++Ordinary template parts reuse the exact producer STEP payload, scalar/datum+semantic evidence and definition metadata. SectionChainFile, LoftFile and external+STEP definitions use their own source contents as inputs. Each hit reimports a+fresh BRep body from the original payload, avoiding geometry construction while+isolating the cache from public mutable topology and geometry stores. Metadata+arrays and semantic provenance are copied at the cache boundary.++Parsing, port binding, assembly solving, placement, mate residual checks and solid+interference checks still run. Display tessellation and export also run normally.+Moving a part can therefore reuse geometry while still reporting a new overlap.+Camera rotation continues to be a display operation, separate from compilation.++## Conservative invalidation++Keys include source identity, authored specialization identity and exact input+contents. Ordinary parts use the parser's entire non-assembly declaration catalog.+A shared feature, specification, declaration or relevant source-offset change+therefore invalidates ordinary parts conservatively. File-backed geometry uses its+own contents and does not depend on unrelated declaration changes. Assembly edits+reuse ordinary parts when the parser's declaration catalog is unchanged; edits+that alter blanked spans before/between declarations can invalidate them too.+Exact text is retained to protect source-span provenance rather than guessing+semantic equivalence from formatting.++Invalid inputs still go through current parsing and validation. Failed part+materializations are not stored. InlineStep resource dependencies, domain-specific+materializer delegates, geometry-valued semantic ports and non-STEP-backed producer+branches are outside this first cache qualification and use the uncached route.+There is no cross-process reuse; ordinary one-shot CLI commands retain their+existing behavior.++Web Runtime model sessions now retain this cache for assembly rebuilds and expose+reuse evidence under snapshot `timings.reuse`. Standalone Web Runtime part builds+continue through their existing uncached path. The .NET session API is also the+multi-document snapshot entry point; this does not add a multi-file browser editor.++## Guitar benchmark++```powershell+dotnet run --project demos/GuitarSurfacingX0 -c Release -- fixtures/Canonical/AssemblyInterfaces/GuitarX0/guitar.firmasm artifacts/local/incremental-guitar/timings.json+```++The harness measures cold and warm uncached compilation, then a populated-session+compile. Cache population is outside the measured incremental run. Every run+must produce byte-identical USD to the uncached baseline. Display preparation is+measured separately; process startup and dotnet build are excluded.++On the guitar snapshot before Concept-directed material seating was added,+measured compilation was 9.885 seconds+cold, 4.137 seconds warm uncached, and 0.244 seconds with the populated session+(about 17 times faster than warm uncached). All 53 definitions were reused; none+were rebuilt. Every run produced identical USD. Display preparation remained+separate: 0.568, 0.404 and 0.292 seconds respectively.++The guitar snapshot regression changes the neck's section geometry and proves+one definition rebuilt while 52 were reused, with a changed neck STEP hash.+Other regressions cover exact export parity, placement-only edits, fresh overlap+validation, specification/shared-recipe changes, failed inputs, missing documents,+caller mutation, bounded eviction and explicit Clear/Dispose.++Qualification passed the Release solution build (including Web Runtime), all+eight focused incremental tests, the fast core lane (1,004 tests), and the full+serial solution lane (4,050 tests). Fresh CLI assembly inspection also succeeded.+Web Runtime wiring is build-qualified here; this run did not perform a browser+interaction qualification.++Recorded evidence is under ignored `artifacts/local/pickup-features/`:+`incremental-final-timings.json`, `incremental-final-focused.log`,+`incremental-final-build.log`, `incremental-final-fast.log` and+`incremental-final-full.log`.diff --git a/docs/public/firmament/syntax.md b/docs/public/firmament/syntax.mdindex 74fcb4e1..0bb27ac1 100644--- a/docs/public/firmament/syntax.md+++ b/docs/public/firmament/syntax.md@@ -65,7 +65,7 @@ Modify Plate {}```-Parameters are strongly typed and calls may use positional or named arguments. Defaults are optional. A body contains immutable typed `let` derivations followed by one terminal `return`. A Feature may return `Hole<Shaft>`, `Hole<Counterbore>`, `Hole<Countersink>`, `Boss`, `Pocket`, or `EdgeFinish`, and may call another Feature with the same return type. Direct and indirect recursion are rejected. Feature names occupy the callable namespace, separate from typed construction declarations such as `Profile`.+Parameters are strongly typed and calls may use positional or named arguments. Defaults are optional. A body contains immutable typed `let` derivations and optional private `Point2`, `Rect2`, `RoundedRect2`, `Circle2`, and `Profile` construction declarations followed by one terminal `return`. Local construction names are qualified separately for each invocation. Product Templates specialize before Feature argument binding; Feature results then lower before patterns and Feature AIR. A Feature may return `Hole<Shaft>`, `Hole<Counterbore>`, `Hole<Countersink>`, `Boss`, `Pocket`, or `EdgeFinish`, and may call another Feature with the same return type. Direct and indirect recursion are rejected. Feature names occupy the callable namespace, separate from typed construction declarations such as `Profile`. Named results use `Feature Name = Function(...)`; the name becomes the returned feature identity and appears in invocation inspection. See [functional pickup construction](functional-pickup.md) for a qualified part example.Firmament intentionally does not provide general runtime control flow. `if`/`else`, conditional expressions, `match` inside Feature, mutable variables, exceptions, and `for`/`while` loops are rejected. A Firmament program describes one deterministic engineering construction, not a runtime family of topologically unrelated outputs.diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/CarvedMaple.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/CarvedMaple.firmamentindex 8815e136..1f38b911 100644--- a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/CarvedMaple.firmament+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/CarvedMaple.firmament@@ -287,60 +287,60 @@ Model CarvedMaple {Segment Edge17 { Trace: P2C17; From: P2P17; To: P2P0 }} }Construction Plane F3 { Trace: Frames.S3 }- Point2 P3P0 { Position: [0mm,-149.8mm] }- Point2 P3A0 { Position: [24.533333mm,-149.8mm] }- Point2 P3B0 { Position: [-24.533333mm,-149.8mm] }- Point2 P3P1 { Position: [73.6mm,-133.8mm] }- Point2 P3A1 { Position: [91.52mm,-122.6mm] }- Point2 P3B1 { Position: [55.68mm,-145mm] }- Point2 P3P2 { Position: [107.52mm,-82.6mm] }- Point2 P3A2 { Position: [111.04mm,-65.533333mm] }- Point2 P3B2 { Position: [104mm,-99.666667mm] }- Point2 P3P3 { Position: [94.72mm,-31.4mm] }- Point2 P3A3 { Position: [88mm,-16.146667mm] }- Point2 P3B3 { Position: [101.44mm,-46.653333mm] }- Point2 P3P4 { Position: [67.2mm,8.92mm] }- Point2 P3A4 { Position: [64mm,22.786667mm] }- Point2 P3B4 { Position: [70.4mm,-4.946667mm] }- Point2 P3P5 { Position: [75.52mm,51.8mm] }- Point2 P3A5 { Position: [77.546667mm,63.746667mm] }- Point2 P3B5 { Position: [73.493333mm,39.853333mm] }- Point2 P3P6 { Position: [79.36mm,80.6mm] }- Point2 P3A6 { Position: [78.826667mm,87.533333mm] }- Point2 P3B6 { Position: [79.893333mm,73.666667mm] }- Point2 P3P7 { Position: [72.32mm,93.4mm] }- Point2 P3A7 { Position: [68.8mm,93.613333mm] }- Point2 P3B7 { Position: [75.84mm,93.186667mm] }- Point2 P3P8 { Position: [58.24mm,81.88mm] }- Point2 P3A8 { Position: [51.306667mm,79.426667mm] }- Point2 P3B8 { Position: [65.173333mm,84.333333mm] }- Point2 P3P9 { Position: [30.72mm,78.68mm] }- Point2 P3A9 { Position: [24mm,85.293333mm] }- Point2 P3B9 { Position: [37.44mm,72.066667mm] }- Point2 P3P10 { Position: [17.92mm,121.56mm] }- Point2 P3A10 { Position: [8.32mm,128.813333mm] }- Point2 P3B10 { Position: [27.52mm,114.306667mm] }- Point2 P3P11 { Position: [-26.88mm,122.2mm] }- Point2 P3A11 { Position: [-41.706667mm,119mm] }- Point2 P3B11 { Position: [-12.053333mm,125.4mm] }- Point2 P3P12 { Position: [-71.04mm,102.36mm] }- Point2 P3A12 { Position: [-79.253333mm,92.76mm] }- Point2 P3B12 { Position: [-62.826667mm,111.96mm] }- Point2 P3P13 { Position: [-76.16mm,64.6mm] }- Point2 P3A13 { Position: [-74.453333mm,50.306667mm] }- Point2 P3B13 { Position: [-77.866667mm,78.893333mm] }- Point2 P3P14 { Position: [-60.8mm,16.6mm] }- Point2 P3A14 { Position: [-62.72mm,0.92mm] }- Point2 P3B14 { Position: [-58.88mm,32.28mm] }- Point2 P3P15 { Position: [-87.68mm,-29.48mm] }- Point2 P3A15 { Position: [-95.466667mm,-46.013333mm] }- Point2 P3B15 { Position: [-79.893333mm,-12.946667mm] }- Point2 P3P16 { Position: [-107.52mm,-82.6mm] }- Point2 P3A16 { Position: [-105.173333mm,-99.986667mm] }- Point2 P3B16 { Position: [-109.866667mm,-65.213333mm] }- Point2 P3P17 { Position: [-73.6mm,-133.8mm] }- Point2 P3A17 { Position: [-55.68mm,-145mm] }- Point2 P3B17 { Position: [-91.52mm,-122.6mm] }+ Point2 P3P0 { Position: [0mm,-173.2mm] }+ Point2 P3A0 { Position: [29.133333mm,-173.2mm] }+ Point2 P3B0 { Position: [-29.133333mm,-173.2mm] }+ Point2 P3P1 { Position: [87.4mm,-154.2mm] }+ Point2 P3A1 { Position: [108.68mm,-140.9mm] }+ Point2 P3B1 { Position: [66.12mm,-167.5mm] }+ Point2 P3P2 { Position: [127.68mm,-93.4mm] }+ Point2 P3A2 { Position: [131.86mm,-73.133333mm] }+ Point2 P3B2 { Position: [123.5mm,-113.666667mm] }+ Point2 P3P3 { Position: [112.48mm,-32.6mm] }+ Point2 P3A3 { Position: [104.5mm,-14.486667mm] }+ Point2 P3B3 { Position: [120.46mm,-50.713333mm] }+ Point2 P3P4 { Position: [79.8mm,15.28mm] }+ Point2 P3A4 { Position: [76mm,31.746667mm] }+ Point2 P3B4 { Position: [83.6mm,-1.186667mm] }+ Point2 P3P5 { Position: [89.68mm,66.2mm] }+ Point2 P3A5 { Position: [92.086667mm,80.386667mm] }+ Point2 P3B5 { Position: [87.273333mm,52.013333mm] }+ Point2 P3P6 { Position: [94.24mm,100.4mm] }+ Point2 P3A6 { Position: [93.606667mm,108.633333mm] }+ Point2 P3B6 { Position: [94.873333mm,92.166667mm] }+ Point2 P3P7 { Position: [85.88mm,115.6mm] }+ Point2 P3A7 { Position: [81.7mm,115.853333mm] }+ Point2 P3B7 { Position: [90.06mm,115.346667mm] }+ Point2 P3P8 { Position: [69.16mm,101.92mm] }+ Point2 P3A8 { Position: [60.926667mm,99.006667mm] }+ Point2 P3B8 { Position: [77.393333mm,104.833333mm] }+ Point2 P3P9 { Position: [36.48mm,98.12mm] }+ Point2 P3A9 { Position: [28.5mm,105.973333mm] }+ Point2 P3B9 { Position: [44.46mm,90.266667mm] }+ Point2 P3P10 { Position: [21.28mm,149.04mm] }+ Point2 P3A10 { Position: [9.88mm,157.653333mm] }+ Point2 P3B10 { Position: [32.68mm,140.426667mm] }+ Point2 P3P11 { Position: [-31.92mm,149.8mm] }+ Point2 P3A11 { Position: [-49.526667mm,146mm] }+ Point2 P3B11 { Position: [-14.313333mm,153.6mm] }+ Point2 P3P12 { Position: [-84.36mm,126.24mm] }+ Point2 P3A12 { Position: [-94.113333mm,114.84mm] }+ Point2 P3B12 { Position: [-74.606667mm,137.64mm] }+ Point2 P3P13 { Position: [-90.44mm,81.4mm] }+ Point2 P3A13 { Position: [-88.413333mm,64.426667mm] }+ Point2 P3B13 { Position: [-92.466667mm,98.373333mm] }+ Point2 P3P14 { Position: [-72.2mm,24.4mm] }+ Point2 P3A14 { Position: [-74.48mm,5.78mm] }+ Point2 P3B14 { Position: [-69.92mm,43.02mm] }+ Point2 P3P15 { Position: [-104.12mm,-30.32mm] }+ Point2 P3A15 { Position: [-113.366667mm,-49.953333mm] }+ Point2 P3B15 { Position: [-94.873333mm,-10.686667mm] }+ Point2 P3P16 { Position: [-127.68mm,-93.4mm] }+ Point2 P3A16 { Position: [-124.893333mm,-114.046667mm] }+ Point2 P3B16 { Position: [-130.466667mm,-72.753333mm] }+ Point2 P3P17 { Position: [-87.4mm,-154.2mm] }+ Point2 P3A17 { Position: [-66.12mm,-167.5mm] }+ Point2 P3B17 { Position: [-108.68mm,-140.9mm] }CubicBezier2 P3C0 { From: P3P0; Control1: P3A0; Control2: P3B1; To: P3P1 }CubicBezier2 P3C1 { From: P3P1; Control1: P3A1; Control2: P3B2; To: P3P2 }CubicBezier2 P3C2 { From: P3P2; Control1: P3A2; Control2: P3B3; To: P3P3 }@@ -380,60 +380,60 @@ Model CarvedMaple {Segment Edge17 { Trace: P3C17; From: P3P17; To: P3P0 }} }Construction Plane F4 { Trace: Frames.S4 }- Point2 P4P0 { Position: [0mm,-99.1mm] }- Point2 P4A0 { Position: [14.566667mm,-99.1mm] }- Point2 P4B0 { Position: [-14.566667mm,-99.1mm] }- Point2 P4P1 { Position: [43.7mm,-89.6mm] }- Point2 P4A1 { Position: [54.34mm,-82.95mm] }- Point2 P4B1 { Position: [33.06mm,-96.25mm] }- Point2 P4P2 { Position: [63.84mm,-59.2mm] }- Point2 P4A2 { Position: [65.93mm,-49.066667mm] }- Point2 P4B2 { Position: [61.75mm,-69.333333mm] }- Point2 P4P3 { Position: [56.24mm,-28.8mm] }- Point2 P4A3 { Position: [52.25mm,-19.743333mm] }- Point2 P4B3 { Position: [60.23mm,-37.856667mm] }- Point2 P4P4 { Position: [39.9mm,-4.86mm] }- Point2 P4A4 { Position: [38mm,3.373333mm] }- Point2 P4B4 { Position: [41.8mm,-13.093333mm] }- Point2 P4P5 { Position: [44.84mm,20.6mm] }- Point2 P4A5 { Position: [46.043333mm,27.693333mm] }- Point2 P4B5 { Position: [43.636667mm,13.506667mm] }- Point2 P4P6 { Position: [47.12mm,37.7mm] }- Point2 P4A6 { Position: [46.803333mm,41.816667mm] }- Point2 P4B6 { Position: [47.436667mm,33.583333mm] }- Point2 P4P7 { Position: [42.94mm,45.3mm] }- Point2 P4A7 { Position: [40.85mm,45.426667mm] }- Point2 P4B7 { Position: [45.03mm,45.173333mm] }- Point2 P4P8 { Position: [34.58mm,38.46mm] }- Point2 P4A8 { Position: [30.463333mm,37.003333mm] }- Point2 P4B8 { Position: [38.696667mm,39.916667mm] }- Point2 P4P9 { Position: [18.24mm,36.56mm] }- Point2 P4A9 { Position: [14.25mm,40.486667mm] }- Point2 P4B9 { Position: [22.23mm,32.633333mm] }- Point2 P4P10 { Position: [10.64mm,62.02mm] }- Point2 P4A10 { Position: [4.94mm,66.326667mm] }- Point2 P4B10 { Position: [16.34mm,57.713333mm] }- Point2 P4P11 { Position: [-15.96mm,62.4mm] }- Point2 P4A11 { Position: [-24.763333mm,60.5mm] }- Point2 P4B11 { Position: [-7.156667mm,64.3mm] }- Point2 P4P12 { Position: [-42.18mm,50.62mm] }- Point2 P4A12 { Position: [-47.056667mm,44.92mm] }- Point2 P4B12 { Position: [-37.303333mm,56.32mm] }- Point2 P4P13 { Position: [-45.22mm,28.2mm] }- Point2 P4A13 { Position: [-44.206667mm,19.713333mm] }- Point2 P4B13 { Position: [-46.233333mm,36.686667mm] }- Point2 P4P14 { Position: [-36.1mm,-0.3mm] }- Point2 P4A14 { Position: [-37.24mm,-9.61mm] }- Point2 P4B14 { Position: [-34.96mm,9.01mm] }- Point2 P4P15 { Position: [-52.06mm,-27.66mm] }- Point2 P4A15 { Position: [-56.683333mm,-37.476667mm] }- Point2 P4B15 { Position: [-47.436667mm,-17.843333mm] }- Point2 P4P16 { Position: [-63.84mm,-59.2mm] }- Point2 P4A16 { Position: [-62.446667mm,-69.523333mm] }- Point2 P4B16 { Position: [-65.233333mm,-48.876667mm] }- Point2 P4P17 { Position: [-43.7mm,-89.6mm] }- Point2 P4A17 { Position: [-33.06mm,-96.25mm] }- Point2 P4B17 { Position: [-54.34mm,-82.95mm] }+ Point2 P4P0 { Position: [0mm,-165.4mm] }+ Point2 P4A0 { Position: [27.6mm,-165.4mm] }+ Point2 P4B0 { Position: [-27.6mm,-165.4mm] }+ Point2 P4P1 { Position: [82.8mm,-147.4mm] }+ Point2 P4A1 { Position: [102.96mm,-134.8mm] }+ Point2 P4B1 { Position: [62.64mm,-160mm] }+ Point2 P4P2 { Position: [120.96mm,-89.8mm] }+ Point2 P4A2 { Position: [124.92mm,-70.6mm] }+ Point2 P4B2 { Position: [117mm,-109mm] }+ Point2 P4P3 { Position: [106.56mm,-32.2mm] }+ Point2 P4A3 { Position: [99mm,-15.04mm] }+ Point2 P4B3 { Position: [114.12mm,-49.36mm] }+ Point2 P4P4 { Position: [75.6mm,13.16mm] }+ Point2 P4A4 { Position: [72mm,28.76mm] }+ Point2 P4B4 { Position: [79.2mm,-2.44mm] }+ Point2 P4P5 { Position: [84.96mm,61.4mm] }+ Point2 P4A5 { Position: [87.24mm,74.84mm] }+ Point2 P4B5 { Position: [82.68mm,47.96mm] }+ Point2 P4P6 { Position: [89.28mm,93.8mm] }+ Point2 P4A6 { Position: [88.68mm,101.6mm] }+ Point2 P4B6 { Position: [89.88mm,86mm] }+ Point2 P4P7 { Position: [81.36mm,108.2mm] }+ Point2 P4A7 { Position: [77.4mm,108.44mm] }+ Point2 P4B7 { Position: [85.32mm,107.96mm] }+ Point2 P4P8 { Position: [65.52mm,95.24mm] }+ Point2 P4A8 { Position: [57.72mm,92.48mm] }+ Point2 P4B8 { Position: [73.32mm,98mm] }+ Point2 P4P9 { Position: [34.56mm,91.64mm] }+ Point2 P4A9 { Position: [27mm,99.08mm] }+ Point2 P4B9 { Position: [42.12mm,84.2mm] }+ Point2 P4P10 { Position: [20.16mm,139.88mm] }+ Point2 P4A10 { Position: [9.36mm,148.04mm] }+ Point2 P4B10 { Position: [30.96mm,131.72mm] }+ Point2 P4P11 { Position: [-30.24mm,140.6mm] }+ Point2 P4A11 { Position: [-46.92mm,137mm] }+ Point2 P4B11 { Position: [-13.56mm,144.2mm] }+ Point2 P4P12 { Position: [-79.92mm,118.28mm] }+ Point2 P4A12 { Position: [-89.16mm,107.48mm] }+ Point2 P4B12 { Position: [-70.68mm,129.08mm] }+ Point2 P4P13 { Position: [-85.68mm,75.8mm] }+ Point2 P4A13 { Position: [-83.76mm,59.72mm] }+ Point2 P4B13 { Position: [-87.6mm,91.88mm] }+ Point2 P4P14 { Position: [-68.4mm,21.8mm] }+ Point2 P4A14 { Position: [-70.56mm,4.16mm] }+ Point2 P4B14 { Position: [-66.24mm,39.44mm] }+ Point2 P4P15 { Position: [-98.64mm,-30.04mm] }+ Point2 P4A15 { Position: [-107.4mm,-48.64mm] }+ Point2 P4B15 { Position: [-89.88mm,-11.44mm] }+ Point2 P4P16 { Position: [-120.96mm,-89.8mm] }+ Point2 P4A16 { Position: [-118.32mm,-109.36mm] }+ Point2 P4B16 { Position: [-123.6mm,-70.24mm] }+ Point2 P4P17 { Position: [-82.8mm,-147.4mm] }+ Point2 P4A17 { Position: [-62.64mm,-160mm] }+ Point2 P4B17 { Position: [-102.96mm,-134.8mm] }CubicBezier2 P4C0 { From: P4P0; Control1: P4A0; Control2: P4B1; To: P4P1 }CubicBezier2 P4C1 { From: P4P1; Control1: P4A1; Control2: P4B2; To: P4P2 }CubicBezier2 P4C2 { From: P4P2; Control1: P4A2; Control2: P4B3; To: P4P3 }@@ -491,4 +491,5 @@ Model CarvedMaple {Start: CapEnd: Cap}+ Expose { Semantic TopSeat { DatumFrame Frame = [0mm,0mm,53mm] x [1,0,0] y [0,1,0] z [0,0,1]; } }}diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/body-assembly.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/body-assembly.firmamentindex fbe57030..207e6a8e 100644--- a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/body-assembly.firmament+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/body-assembly.firmament@@ -1,3 +1,4 @@+Include "hardware-layout.firmament";Subassembly GuitarBody {<Assembly GuitarBody>@@ -8,9 +9,11 @@ Subassembly GuitarBody {Placement { From: Origin; To: World; TranslateLocal: [0mm,0mm,0mm]; }</Part><Part CarvedMaple = SectionChainFile<"CarvedMaple.firmament">>- Placement { From: Origin; To: World; TranslateLocal: [0mm,0mm,0mm]; }</Part></Assembly>+ Interface<Fixed> BodyDeckSeat { Datum: GuitarLayout.HardwareDeck; Members: [GuitarBody.CarvedMaple.TopSeat] }+ Mate BodyOnDeck: BodyDeckSeat { Member: GuitarBody.CarvedMaple.TopSeat; At: GuitarLayout.BodySeat; Orientation: SameDirection; Support: true; }+Anchor: GuitarBody;}diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/bridge-assembly.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/bridge-assembly.firmamentindex ee0beed4..5f5b6af1 100644--- a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/bridge-assembly.firmament+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/bridge-assembly.firmament@@ -1,3 +1,4 @@+Include "hardware-layout.firmament";Static SaddlesSites: Set<HardwareSite> {Saddle0 => HardwareSite { X: -25.5mm; Y: -35mm; Z: 63mm }Saddle1 => HardwareSite { X: -15.3mm; Y: -35mm; Z: 63mm }@@ -8,8 +9,7 @@ Static SaddlesSites: Set<HardwareSite> {}Subassembly GuitarBridge {<Assembly GuitarBridge>- <Part Bridge = Panel<L:82mm,W:12mm,H:6mm,R:5mm>>- Placement { From: Origin; To: World; TranslateLocal: [0mm,-35mm,57mm]; }+ <Part Bridge = Panel<L:82mm,W:12mm,H:10mm,R:5mm>></Part><Part Tailpiece = Panel<L:88mm,W:15mm,H:7mm,R:6mm>>Placement { From: Origin; To: World; TranslateLocal: [0mm,-75mm,53mm]; }@@ -21,5 +21,8 @@ Subassembly GuitarBridge {}</Assembly>+ Interface<Fixed> BridgeDeckSeat { Datum: GuitarLayout.HardwareDeck; Members: [GuitarBridge.Bridge.BottomSeat] }+ Mate BridgeOnDeck: BridgeDeckSeat { Member: GuitarBridge.Bridge.BottomSeat; At: GuitarLayout.BridgeSeat; Orientation: SameDirection; }+Anchor: GuitarBridge;}diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/hardware-definitions.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/hardware-definitions.firmamentindex b545cae2..60f3acb4 100644--- a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/hardware-definitions.firmament+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/hardware-definitions.firmament@@ -1,4 +1,5 @@Template<L: Length, W: Length, H: Length, R: Length> Struct Panel {+ Expose { Semantic BottomSeat { DatumFrame Frame = [0mm,0mm,0mm] x [1,0,0] y [0,1,0] z [0,0,1]; } }RoundedRect2 Outline { Center: [0mm,0mm] Size: [L,W] Radius: R }Profile P { Loop Outer { Outline |> TraceLoop } }Extrude Body { Profile: P From: 0mm To: H }diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/hardware-layout.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/hardware-layout.firmamentnew file mode 100644index 00000000..e7388ddb--- /dev/null+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/hardware-layout.firmament@@ -0,0 +1,7 @@+Concept Struct GuitarLayout {+ Plane HardwareDeck { Origin: [0mm,0mm,53mm]; Normal: [0,0,1]; Up: [0,1,0] }+ DatumFrame BodySeat { On: HardwareDeck; At: [0mm,0mm]; X: [1,0] }+ DatumFrame NeckPickupSeat { On: HardwareDeck; At: [0mm,98mm]; X: [1,0] }+ DatumFrame BridgePickupSeat { On: HardwareDeck; At: [0mm,0mm]; X: [1,0] }+ DatumFrame BridgeSeat { On: HardwareDeck; At: [0mm,-35mm]; X: [1,0] }+}diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/pickup.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/pickup.firmamentnew file mode 100644index 00000000..0b16608c--- /dev/null+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/pickup.firmament@@ -0,0 +1,50 @@+// One exact pickup part; all construction coordinates are local to its Mount.+Record PickupSpec {+ Width: Length; Depth: Length; BaseHeight: Length+ CoilWidth: Length; CoilDepth: Length; CoilHeight: Length+ CoilOffset: Length; PolePitch: Length+}+Static StandardPickup: PickupSpec {+ Width: 88mm; Depth: 46mm; BaseHeight: 4mm+ CoilWidth: 70mm; CoilDepth: 17mm; CoilHeight: 5mm+ CoilOffset: 10mm; PolePitch: 10.2mm+}+Static BridgePickupSpec = StandardPickup with { PolePitch: 10.2mm }++Feature Coil(Center: Point2, Width: Length, Depth: Length, Height: Length, Support: Plane) -> Boss {+ RoundedRect2 Outline { Center: Center; Size: [Width,Depth]; Radius: 3mm }+ Profile Section { Loop Outer { Outline |> TraceLoop } }+ return Boss { On: Support; Profile: Section; Height: Height }+}+Feature Pole(Center: Point2, Support: Plane) -> Boss {+ Circle2 Outline { Center: Center; Radius: 2.2mm }+ Profile Section { Loop Outer { Outline |> TraceLoop } }+ return Boss { On: Support; Profile: Section; Height: 1mm }+}++Template<Spec: PickupSpec> Struct Humbucker {+ Concept Struct Layout On XY {+ Point2 UpperCenter { Position: [0mm,Spec.CoilOffset] }+ Point2 LowerCenter { Position: [0mm,-Spec.CoilOffset] }+ Axis2 Longitudinal { Origin: [0mm,0mm]; Direction: [1,0] }+ Axis2 Transverse { Origin: [0mm,0mm]; Direction: [0,1] }+ Point2 FirstPole { Position: [-2.5 * Spec.PolePitch,Spec.CoilOffset] }+ RoundedRect2 BaseOutline { Center: [0mm,0mm]; Size: [Spec.Width,Spec.Depth]; Radius: 4mm }+ }+ Profile BaseProfile Using Layout { Loop Outer { BaseOutline |> TraceLoop } }+ Plane BaseTop { Origin: [0mm,0mm,Spec.BaseHeight]; Normal: [0,0,1]; Up: [0,1,0] }+ Plane CoilTop { Origin: [0mm,0mm,Spec.BaseHeight + Spec.CoilHeight]; Normal: [0,0,1]; Up: [0,1,0] }+ Compose Body {+ Base Housing { Profile: BaseProfile; From: 0mm; To: Spec.BaseHeight; Role: Stock }+ Feature UpperCoil = Coil(Center: Layout.UpperCenter, Width: Spec.CoilWidth, Depth: Spec.CoilDepth, Height: Spec.CoilHeight, Support: BaseTop)+ Feature LowerCoil = Coil(Center: Layout.LowerCenter, Width: Spec.CoilWidth, Depth: Spec.CoilDepth, Height: Spec.CoilHeight, Support: BaseTop)+ Feature PoleSeed = Pole(Center: Layout.FirstPole, Support: CoilTop)+ Linear Pattern Poles {+ Source: PoleSeed+ Direction: Layout.Longitudinal.Direction+ Count: 6+ Spacing: Spec.PolePitch+ }+ }+ Expose { Semantic Mount { DatumFrame Frame = [0mm,0mm,0mm] x [1,0,0] y [0,1,0] z [0,0,1]; } }+}diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/pickups-assembly.firmament b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/pickups-assembly.firmamentindex 1061e535..38cca0e6 100644--- a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/pickups-assembly.firmament+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/pickups-assembly.firmament@@ -1,45 +1,15 @@-Static PickupSeatsSites: Set<HardwareSite> {- NeckPickupCream => HardwareSite { X: 0mm; Y: 98mm; Z: 53mm }- BridgePickupCream => HardwareSite { X: 0mm; Y: 0mm; Z: 53mm }-}-Static PickupCoilsSites: Set<HardwareSite> {- NeckPickupCoil0 => HardwareSite { X: 0mm; Y: 88mm; Z: 57mm }- NeckPickupCoil1 => HardwareSite { X: 0mm; Y: 108mm; Z: 57mm }- BridgePickupCoil0 => HardwareSite { X: 0mm; Y: -10mm; Z: 57mm }- BridgePickupCoil1 => HardwareSite { X: 0mm; Y: 10mm; Z: 57mm }-}-Static PickupPolesSites: Set<HardwareSite> {- NeckPickupPole0 => HardwareSite { X: -25.5mm; Y: 108mm; Z: 62mm }- NeckPickupPole1 => HardwareSite { X: -15.3mm; Y: 108mm; Z: 62mm }- NeckPickupPole2 => HardwareSite { X: -5.1mm; Y: 108mm; Z: 62mm }- NeckPickupPole3 => HardwareSite { X: 5.1mm; Y: 108mm; Z: 62mm }- NeckPickupPole4 => HardwareSite { X: 15.3mm; Y: 108mm; Z: 62mm }- NeckPickupPole5 => HardwareSite { X: 25.5mm; Y: 108mm; Z: 62mm }- BridgePickupPole0 => HardwareSite { X: -25.5mm; Y: 10mm; Z: 62mm }- BridgePickupPole1 => HardwareSite { X: -15.3mm; Y: 10mm; Z: 62mm }- BridgePickupPole2 => HardwareSite { X: -5.1mm; Y: 10mm; Z: 62mm }- BridgePickupPole3 => HardwareSite { X: 5.1mm; Y: 10mm; Z: 62mm }- BridgePickupPole4 => HardwareSite { X: 15.3mm; Y: 10mm; Z: 62mm }- BridgePickupPole5 => HardwareSite { X: 25.5mm; Y: 10mm; Z: 62mm }-}+Include "pickup.firmament";+Include "hardware-layout.firmament";+Subassembly GuitarPickups {<Assembly GuitarPickups>- Pattern PickupSeats Over PickupSeatsSites {- site => <Part PickupCream = Surround<L:88mm,W:46mm,H:4mm>>- Placement { From: Origin; To: World; TranslateLocal: [site.X,site.Y,site.Z]; }- </Part>- }- Pattern PickupCoils Over PickupCoilsSites {- site => <Part PickupCoil = Panel<L:70mm,W:17mm,H:5mm,R:3mm>>- Placement { From: Origin; To: World; TranslateLocal: [site.X,site.Y,site.Z]; }- </Part>- }- Pattern PickupPoles Over PickupPolesSites {- site => <Part PickupPole = Drum<R:2.2mm,H:1mm>>- Placement { From: Origin; To: World; TranslateLocal: [site.X,site.Y,site.Z]; }- </Part>- }+ <Part NeckPickup = Humbucker<Spec: StandardPickup>></Part>+ <Part BridgePickup = Humbucker<Spec: StandardPickup>></Part></Assembly>+ Interface<Fixed> PickupsDeckSeat { Datum: GuitarLayout.HardwareDeck; Members: [GuitarPickups.NeckPickup.Mount,GuitarPickups.BridgePickup.Mount] }+ Mate NeckPickupOnDeck: PickupsDeckSeat { Member: GuitarPickups.NeckPickup.Mount; At: GuitarLayout.NeckPickupSeat; Orientation: SameDirection; }+ Mate BridgePickupOnDeck: PickupsDeckSeat { Member: GuitarPickups.BridgePickup.Mount; At: GuitarLayout.BridgePickupSeat; Orientation: SameDirection; }+Anchor: GuitarPickups;}diff --git a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/preview-materials.json b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/preview-materials.jsonindex 775e0dc7..dbc10781 100644--- a/fixtures/Canonical/AssemblyInterfaces/GuitarX0/preview-materials.json+++ b/fixtures/Canonical/AssemblyInterfaces/GuitarX0/preview-materials.json@@ -55,19 +55,12 @@"metallic": 0,"roughness": 0.4},- "Panel<L:70mm,W:17mm,H:5mm,R:3mm>": {- "red": 0.009,- "green": 0.007,- "blue": 0.006,- "metallic": 0,- "roughness": 0.4- },- "Surround<L:88mm,W:46mm,H:4mm>": {- "red": 0.72,- "green": 0.59,- "blue": 0.36,- "metallic": 0,- "roughness": 0.4+ "Humbucker<Spec: StandardPickup>": {+ "red": 0.025,+ "green": 0.025,+ "blue": 0.025,+ "metallic": 0.15,+ "roughness": 0.3},"Drum<R:9mm,H:9mm>": {"red": 0.38,diff --git a/fixtures/Canonical/Feature/pickup-functional.firmament b/fixtures/Canonical/Feature/pickup-functional.firmamentnew file mode 100644index 00000000..2932c35d--- /dev/null+++ b/fixtures/Canonical/Feature/pickup-functional.firmament@@ -0,0 +1,55 @@+schema Mechanical+Model PickupFunctional {+ Units: mm+// One exact pickup part; all construction coordinates are local to its Mount.+Record PickupSpec {+ Width: Length; Depth: Length; BaseHeight: Length+ CoilWidth: Length; CoilDepth: Length; CoilHeight: Length+ CoilOffset: Length; PolePitch: Length+}+Static StandardPickup: PickupSpec {+ Width: 88mm; Depth: 46mm; BaseHeight: 4mm+ CoilWidth: 70mm; CoilDepth: 17mm; CoilHeight: 5mm+ CoilOffset: 10mm; PolePitch: 10.2mm+}+Static BridgePickupSpec = StandardPickup with { PolePitch: 10.2mm }++Feature Coil(Center: Point2, Width: Length, Depth: Length, Height: Length, Support: Plane) -> Boss {+ RoundedRect2 Outline { Center: Center; Size: [Width,Depth]; Radius: 3mm }+ Profile Section { Loop Outer { Outline |> TraceLoop } }+ return Boss { On: Support; Profile: Section; Height: Height }+}+Feature Pole(Center: Point2, Support: Plane) -> Boss {+ Circle2 Outline { Center: Center; Radius: 2.2mm }+ Profile Section { Loop Outer { Outline |> TraceLoop } }+ return Boss { On: Support; Profile: Section; Height: 1mm }+}++Template<Spec: PickupSpec> Struct Humbucker {+ Concept Struct Layout On XY {+ Point2 UpperCenter { Position: [0mm,Spec.CoilOffset] }+ Point2 LowerCenter { Position: [0mm,-Spec.CoilOffset] }+ Axis2 Longitudinal { Origin: [0mm,0mm]; Direction: [1,0] }+ Axis2 Transverse { Origin: [0mm,0mm]; Direction: [0,1] }+ Point2 FirstPole { Position: [-2.5 * Spec.PolePitch,Spec.CoilOffset] }+ RoundedRect2 BaseOutline { Center: [0mm,0mm]; Size: [Spec.Width,Spec.Depth]; Radius: 4mm }+ }+ Profile BaseProfile Using Layout { Loop Outer { BaseOutline |> TraceLoop } }+ Plane BaseTop { Origin: [0mm,0mm,Spec.BaseHeight]; Normal: [0,0,1]; Up: [0,1,0] }+ Plane CoilTop { Origin: [0mm,0mm,Spec.BaseHeight + Spec.CoilHeight]; Normal: [0,0,1]; Up: [0,1,0] }+ Compose Body {+ Base Housing { Profile: BaseProfile; From: 0mm; To: Spec.BaseHeight; Role: Stock }+ Feature UpperCoil = Coil(Center: Layout.UpperCenter, Width: Spec.CoilWidth, Depth: Spec.CoilDepth, Height: Spec.CoilHeight, Support: BaseTop)+ Feature LowerCoil = Coil(Center: Layout.LowerCenter, Width: Spec.CoilWidth, Depth: Spec.CoilDepth, Height: Spec.CoilHeight, Support: BaseTop)+ Feature PoleSeed = Pole(Center: Layout.FirstPole, Support: CoilTop)+ Linear Pattern Poles {+ Source: PoleSeed+ Direction: Layout.Longitudinal.Direction+ Count: 6+ Spacing: Spec.PolePitch+ }+ }+}++ Struct Product = Humbucker<Spec: StandardPickup>+}diff --git a/scripts/check-guitar-x0.py b/scripts/check-guitar-x0.pyindex a971a026..bb2cd8f9 100644--- a/scripts/check-guitar-x0.py+++ b/scripts/check-guitar-x0.py@@ -8,7 +8,7 @@ root=Path(sys.argv[1] if len(sys.argv)>1 else 'artifacts/local/guitar-x0')document=json.loads((root/'display.json').read_text())results=[]for definition in document['mesh']['definitions']:- if 'File<' not in definition['identity'] and not definition['identity'].startswith('GuitarString<'):+ if 'File<' not in definition['identity'] and not definition['identity'].startswith(('GuitarString<','Humbucker<')):continueraw=definition['positions']points=[tuple(round(v,6) for v in raw[i:i+3]) for i in range(0,len(raw),3)]diff --git a/scripts/create-guitar-x0.py b/scripts/create-guitar-x0.pyindex ed4a62dd..97324aa7 100644--- a/scripts/create-guitar-x0.py+++ b/scripts/create-guitar-x0.py@@ -50,12 +50,15 @@ def body_chain(name, stations, continuity):rows.append(f' SectionChain {name} {{ Continuity: {continuity}')for i in range(len(stations)):rows.append(f' Section S{i} {{ Frame: F{i}\n Profile: P{i}\n Seam: Edge0 }}')- rows.extend([' Start: Cap', ' End: Cap', ' }','}'])+ rows.extend([' Start: Cap', ' End: Cap', ' }'])+ if name == 'CarvedMaple':+ rows.append(' Expose { Semantic TopSeat { DatumFrame Frame = [0mm,0mm,53mm] x [1,0,0] y [0,1,0] z [0,0,1]; } }')+ rows.append('}')(ROOT/f'{name}.firmament').write_text('\n'.join(rows)+'\n')body_chain('MahoganyBack',[(0,1),(38,1)],'G0')body_chain('IvoryBinding',[(38,1),(40,1)],'G0')-body_chain('CarvedMaple',[(40,.992),(43,.955),(48,.84),(52,.64),(53,.38)],'G1')+body_chain('CarvedMaple',[(40,.992),(43,.955),(48,.84),(52,.76),(53,.72)],'G1')# A closed D-section neck: flat fretboard seat, elliptical back, shaped heel and# a shallow nut transition that actually meets the tilted headstock base.@@ -108,6 +111,7 @@ Template<D: Length, Lead: Length, Tail: Length, Deflection: Angle> Struct Guitar}}Template<L: Length, W: Length, H: Length, R: Length> Struct Panel {+ Expose { Semantic BottomSeat { DatumFrame Frame = [0mm,0mm,0mm] x [1,0,0] y [0,1,0] z [0,0,1]; } }RoundedRect2 Outline { Center: [0mm,0mm] Size: [L,W] Radius: R }Profile P { Loop Outer { Outline |> TraceLoop } }Extrude Body { Profile: P From: 0mm To: H }@@ -205,13 +209,7 @@ parts.append('''<Part Headstock = Head<H:14mm>><Part HeadVeneer = Head<H:1mm>></Part>''')part('Nut','Panel<L:44mm,W:4mm,H:3mm,R:1mm>',y=658,z=62)-for name,y in [('NeckPickup',98),('BridgePickup',0)]:- part(name+'Cream','Surround<L:88mm,W:46mm,H:4mm>',y=y,z=53)- for j,dy in enumerate([-10,10]):- part(name+f'Coil{j}','Panel<L:70mm,W:17mm,H:5mm,R:3mm>',y=y+dy,z=57)- for i in range(6):- part(name+f'Pole{i}','Drum<R:2.2mm,H:1mm>',x=(i-2.5)*10.2,y=y+10,z=62)-part('Bridge','Panel<L:82mm,W:12mm,H:6mm,R:5mm>',y=-35,z=57)+part('Bridge','Panel<L:82mm,W:12mm,H:10mm,R:5mm>',y=-35,z=53)part('Tailpiece','Panel<L:88mm,W:15mm,H:7mm,R:6mm>',y=-75,z=53)for i in range(6):x=(i-2.5)*10.2@@ -246,9 +244,6 @@ for side in [-1,1]:# Records; the compiler owns expansion, identities, and definition sharing.catalog=[]for family,matcher in [- ('PickupSeats',r'(?:Neck|Bridge)PickupCream'),- ('PickupCoils',r'(?:Neck|Bridge)PickupCoil[01]'),- ('PickupPoles',r'(?:Neck|Bridge)PickupPole[0-5]'),('Saddles',r'Saddle[0-5]'),('TunerPosts',r'TunerPost[02][0-2]'),('TunerWashers',r'TunerWasher[02][0-2]'),@@ -264,7 +259,7 @@ for family,matcher in [catalog.append(f'Static {family}Sites: Set<HardwareSite> {{\n'+ '\n'.join(f' {m[1]} => HardwareSite {{ X: {m[3]}; Y: {m[4]}; Z: {m[5]} }}' for _,m in selected)+'\n}')for declaration,_ in selected: parts.remove(declaration)- leaf='PickupCream' if family=='PickupSeats' else family.removesuffix('s')+ leaf=family.removesuffix('s')parts.append(f'''Pattern {family} Over {family}Sites {{site => <Part {leaf} = {next(iter(definitions))}>Placement {{ From: Origin; To: World; TranslateLocal: [site.X,site.Y,site.Z]; }}@@ -301,7 +296,20 @@ def rows_for(prefixes):string_end=templates.index('Template<L: Length')string_template=templates[:string_end](ROOT/'hardware-definitions.firmament').write_text(templates[string_end:]+'\nRecord HardwareSite { X: Length; Y: Length; Z: Length }\n')-write_module('body-assembly.firmament','GuitarBody',groups['Body'])+# Concept layout is authored once and shared by each owning subassembly.+(ROOT/'hardware-layout.firmament').write_text('''Concept Struct GuitarLayout {+ Plane HardwareDeck { Origin: [0mm,0mm,53mm]; Normal: [0,0,1]; Up: [0,1,0] }+ DatumFrame BodySeat { On: HardwareDeck; At: [0mm,0mm]; X: [1,0] }+ DatumFrame NeckPickupSeat { On: HardwareDeck; At: [0mm,98mm]; X: [1,0] }+ DatumFrame BridgePickupSeat { On: HardwareDeck; At: [0mm,0mm]; X: [1,0] }+ DatumFrame BridgeSeat { On: HardwareDeck; At: [0mm,-35mm]; X: [1,0] }+}+''')+groups['Body']=[re.sub(r'\s*Placement\s*\{[^}]*\}', '', p) if '<Part CarvedMaple ' in p else p for p in groups['Body']]+write_module('body-assembly.firmament','GuitarBody',groups['Body'],includes=('hardware-layout.firmament',),relations='''+ Interface<Fixed> BodyDeckSeat { Datum: GuitarLayout.HardwareDeck; Members: [GuitarBody.CarvedMaple.TopSeat] }+ Mate BodyOnDeck: BodyDeckSeat { Member: GuitarBody.CarvedMaple.TopSeat; At: GuitarLayout.BodySeat; Orientation: SameDirection; Support: true; }+''')write_module('tuners-assembly.firmament','GuitarTuners',groups['Tuners'],rows_for(('Tuner',)))neck_relations=''' FrameTransform NutWorld { From: GuitarNeck.Neck.NutMount.Frame; Normal: [0,1,0]; Up: [0,0,1]; TranslateLocal: [0mm,-7mm,0mm]; }FrameTransform HeadTilt { From: NutWorld.Frame; RotateLocal: { Axis: X; Angle: -13deg } }@@ -309,10 +317,25 @@ neck_relations=''' FrameTransform NutWorld { From: GuitarNeck.Neck.NutMount.Framwrite_module('neck-assembly.firmament','GuitarNeck',groups['Neck']+[occurrence('Tuners','GuitarTuners')],includes=('tuners-assembly.firmament',),relations=neck_relations,exposes='DatumFrame NutMount = Neck.NutMount.Frame; DatumFrame HeelMount = Neck.HeelMount.Frame; DatumFrame HeadFront = Headstock.Front.Frame;')-write_module('pickups-assembly.firmament','GuitarPickups',groups['Pickups'],rows_for(('Pickup',)))+# Pickup construction is authored in Firmament, not generated pole/coil coordinates.+write_module('pickups-assembly.firmament','GuitarPickups',[+ '<Part NeckPickup = Humbucker<Spec: StandardPickup>></Part>',+ '<Part BridgePickup = Humbucker<Spec: StandardPickup>></Part>'],+ includes=('pickup.firmament','hardware-layout.firmament'), relations="""+ Interface<Fixed> PickupsDeckSeat { Datum: GuitarLayout.HardwareDeck; Members: [GuitarPickups.NeckPickup.Mount,GuitarPickups.BridgePickup.Mount] }+ Mate NeckPickupOnDeck: PickupsDeckSeat { Member: GuitarPickups.NeckPickup.Mount; At: GuitarLayout.NeckPickupSeat; Orientation: SameDirection; }+ Mate BridgePickupOnDeck: PickupsDeckSeat { Member: GuitarPickups.BridgePickup.Mount; At: GuitarLayout.BridgePickupSeat; Orientation: SameDirection; }+""")+pickup_source=(ROOT/'pickup.firmament').read_text()+pickup_source=re.sub(r' Expose \{ Semantic Mount \{[^\n]+\n','',pickup_source)+(ROOT.parents[1]/'Feature'/'pickup-functional.firmament').write_text('schema Mechanical\nModel PickupFunctional {\n Units: mm\n'+pickup_source+'\n Struct Product = Humbucker<Spec: StandardPickup>\n}\n')write_module('electronics-assembly.firmament','GuitarElectronics',groups['Electronics']+[occurrence('Pickups','GuitarPickups')],includes=('pickups-assembly.firmament',))-write_module('bridge-assembly.firmament','GuitarBridge',groups['Bridge'],rows_for(('Saddles',)))+groups['Bridge']=[re.sub(r'\s*Placement\s*\{[^}]*\}', '', p) if '<Part Bridge ' in p else p for p in groups['Bridge']]+write_module('bridge-assembly.firmament','GuitarBridge',groups['Bridge'],rows_for(('Saddles',)),includes=('hardware-layout.firmament',),relations='''+ Interface<Fixed> BridgeDeckSeat { Datum: GuitarLayout.HardwareDeck; Members: [GuitarBridge.Bridge.BottomSeat] }+ Mate BridgeOnDeck: BridgeDeckSeat { Member: GuitarBridge.Bridge.BottomSeat; At: GuitarLayout.BridgeSeat; Orientation: SameDirection; }+''')write_module('strings-assembly.firmament','GuitarStrings',groups['Strings'],rows=(string_template,))assembly='''// GUITAR-SURFACING-X0: composition root. Geometry and local layout live in modules.Include "hardware-definitions.firmament";@@ -340,10 +363,9 @@ looks={'Board<H:2mm>':(.055,.017,.008,0,.4),'Head<H:1mm>':(.008,.008,.008,0,.4),'Head<H:14mm>':(.15,.025,.012,0,.4),- 'Panel<L:70mm,W:17mm,H:5mm,R:3mm>':(.009,.007,.006,0,.4),- 'Surround<L:88mm,W:46mm,H:4mm>':(.72,.59,.36,0,.4),+ 'Humbucker<Spec: StandardPickup>':(.025,.025,.025,.15,.3),'Drum<R:9mm,H:9mm>':(.38,.13,.013,.2,.3),'Panel<L:25mm,W:12mm,H:0.3mm,R:1mm>':(.74,.73,.62,.1,.3),}(ROOT/'preview-materials.json').write_text(json.dumps({k:dict(zip(['red','green','blue','metallic','roughness'],v)) for k,v in looks.items()},indent=2)+'\n')-print(f'Authored guitar with seven keyed hardware patterns in {ROOT}; inspect via Aetheris.CLI for expanded occurrence counts.')+print(f'Authored guitar with four keyed hardware patterns and two feature-built pickups in {ROOT}; inspect via Aetheris.CLI for expanded occurrence counts.')diff --git a/scripts/render-guitar-x0.py b/scripts/render-guitar-x0.pyindex 5b4eabe6..097ed27f 100644--- a/scripts/render-guitar-x0.py+++ b/scripts/render-guitar-x0.py@@ -9,6 +9,7 @@ import hashlibimport jsonimport mathimport sys+import reimport timefrom pathlib import Pathfrom mathutils import Vector, Matrix@@ -16,6 +17,7 @@ from mathutils import Vector, Matrixargs=sys.argv[sys.argv.index('--')+1:]source,root=map(lambda p:Path(p).resolve(),args[:2])preview='--preview' in args+selected_view=next((arg.split('=',1)[1] for arg in args if arg.startswith('--view=')),None)root.mkdir(parents=True,exist_ok=True)bpy.ops.wm.read_factory_settings(use_empty=True)started=time.perf_counter()@@ -24,7 +26,7 @@ bpy.ops.wm.usd_import(filepath=str(source),support_scene_instancing=False,load_seconds=time.perf_counter()-startedscene=bpy.context.sceneproducts=[o for o in scene.objects if o.type=='MESH']-assert len(products)==107, len(products)+assert len(products) in (91,107), len(products)def material(name,color,metal=0,rough=.25,coat=.35):m=bpy.data.materials.new(name);m.use_nodes=True@@ -86,6 +88,7 @@ def signature():return h.hexdigest()original_signature=signature()+pickup_shaded=0for obj in products:name=obj.parent.name if obj.parent else obj.nameif 'CarvedMaple' in name:@@ -99,6 +102,17 @@ for obj in products:for start in range(0,len(pts),256):distances=np.sqrt(((pts[start:start+256,None,:2]-edge[None,:,:])**2).sum(axis=2)).min(axis=1)for i,d in enumerate(distances,start):attr.data[i].value=min(1,float(d)/.065)+ elif re.search(r'(?:^|_)(?:NeckPickup|BridgePickup)(?:_\d+)?$',name.split('.')[0]):+ # Appearance only: exact feature-built pickup geometry is imported intact.+ # Default witness axial levels are base 0..4, coils 4..9, poles 9..10 mm.+ obj.data.materials.clear()+ for look in (cream,black,chrome):obj.data.materials.append(look)+ zs=[v.co.z for v in obj.data.vertices];low,high=min(zs),max(zs)+ for poly in obj.data.polygons:+ level=(sum(obj.data.vertices[i].co.z for i in poly.vertices)/len(poly.vertices)-low)/(high-low)+ poly.material_index=2 if level>.900001 else 1 if level>.400001 else 0+ pickup_shaded+=1+ continueelif any(s in name for s in ['MahoganyBack','Headstock','Neck_']):m=woodelif 'Rosewood' in name:m=roseelif 'HeadVeneer' in name:m=ebony@@ -111,6 +125,7 @@ for obj in products:obj.data.materials.clear();obj.data.materials.append(m)assert signature()==original_signature, 'Shading must not alter imported product topology'+assert len(products)!=91 or pickup_shaded==2, f'Expected two feature-built pickup appearance assignments; found {pickup_shaded}'floor=material('Studio charcoal',(.014,.018,.024),.12,.32,0)bpy.ops.mesh.primitive_plane_add(size=200,location=(0,.3,-.004))@@ -152,10 +167,14 @@ scene.render.image_settings.file_format='PNG';scene.render.film_transparent=Falsscene.render.resolution_percentage=100views=[('hero',(.73,-.18,1.6),(0,.30,.04),1.23,1800,2200),+ ('deck-side',(.65,.015,.060),(0,.015,.053),.27,1800,1800),('carve-detail',(.45,-.48,.62),(0,-.005,.047),.60,2200,1600),('shaded-isometric',(.9,-.5,1.05),(0,.30,.04),1.28,1800,2200),('neck-side',(.65,.48,.045),(0,.48,.045),.66,1600,2200),('neck-back',(.25,.49,-.7),(0,.49,.035),.70,1600,2200)]+if selected_view:+ views=[v for v in views if v[0]==selected_view]+ assert views, f'Unknown view: {selected_view}'renders=[]print('GUITAR_SCENE_READY',scene.cycles.device, 'samples',scene.cycles.samples,flush=True)for name,location,target,scale,w,h in sorted(views,key=lambda v:not v[0].startswith('neck-')):@@ -182,5 +201,5 @@ bpy.ops.wm.save_as_mainfile(filepath=str(root/'guitar-studio.blend'))usdSha256=hashlib.sha256(source.read_bytes()).hexdigest(),devices=[device.name for device in prefs.devices if device.use],productMeshObjects=len(products),productTopologyHash=original_signature,- productTopologyUnchanged=signature()==original_signature,renders=renders),indent=2)+'\n')+ productTopologyUnchanged=signature()==original_signature,pickupAppearance='Default feature axial height bands; shading only',pickupObjectsStyled=pickup_shaded,renders=renders),indent=2)+'\n')print('GUITAR_RENDER_COMPLETE',json.dumps(renders))