Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add template assembly geometry inspection and fit relations

Yuechen Lie716c334479e
diff --git a/Aetheris.CLI.Tests/AssemblyM0CliTests.cs b/Aetheris.CLI.Tests/AssemblyM0CliTests.cs
index 2030e6b4..918dd81c 100644
--- a/Aetheris.CLI.Tests/AssemblyM0CliTests.cs
+++ b/Aetheris.CLI.Tests/AssemblyM0CliTests.cs
@@ -35,6 +35,24 @@ public sealed class AssemblyM0CliTests
Assert.Contains(json.RootElement.GetProperty("diagnostics").EnumerateArray(), x => x.GetProperty("code").GetString() == "assembly-tolerance-assertion-failure");
}
+ [Fact]
+ public void AsmInspect_TemplateAssembly_EmitsExecutableGeometryResidualsAndDefinitionReuseSeam()
+ {
+ var root = FindRepoRoot();
+ var path = Path.Combine(root, "fixtures", "AssemblyM1", "template-block-pair.firmament");
+ var stdout = new StringWriter(); var stderr = new StringWriter();
+ var exit = Aetheris.CLI.CliRunner.Run(["asm", "inspect", path, "--json"], stdout, stderr);
+ Assert.Equal(0, exit);
+ using var json = JsonDocument.Parse(stdout.ToString());
+ Assert.Equal("aetheris/assembly-ir/m1", json.RootElement.GetProperty("assemblyIr").GetProperty("schema").GetString());
+ var geometry = json.RootElement.GetProperty("geometryArtifact");
+ Assert.Equal("aetheris/assembly-geometry/m1", geometry.GetProperty("schema").GetString());
+ Assert.Equal(2, geometry.GetProperty("definitions").GetArrayLength());
+ Assert.Equal(2, geometry.GetProperty("instances").GetArrayLength());
+ Assert.All(geometry.GetProperty("mateResiduals").EnumerateArray(), residual => Assert.True(residual.GetProperty("passed").GetBoolean()));
+ Assert.Empty(stderr.ToString());
+ }
+
private static string FindRepoRoot()
{
var directory = new DirectoryInfo(AppContext.BaseDirectory);
diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.cs
index b9d40e4a..25f4f0ac 100644
--- a/Aetheris.CLI/CliRunner.cs
+++ b/Aetheris.CLI/CliRunner.cs
@@ -2,6 +2,7 @@ using System.Security.Cryptography;
using System.Diagnostics;
using System.Text.Json;
using System.Text.Json.Serialization;
+using System.Text.RegularExpressions;
using Aetheris.Forge.Abstractions.FirmamentInterop;
using Aetheris.Kernel.Core.Brep.Verification;
using Aetheris.Kernel.Core.Brep.Tessellation;
@@ -2555,8 +2556,32 @@ public static class CliRunner
else { stderr.WriteLine(AsmInspectUsage); return 1; }
}
if (!File.Exists(path)) { stderr.WriteLine($"Assembly source '{path}' was not found."); return 1; }
- var result = new AssemblyM0Pipeline().CompileFile(path);
- var reportJson = JsonSerializer.Serialize(new { success = result.IsSuccess, assemblyIr = result.Ir, diagnostics = result.Diagnostics, performance = profile ? result.Performance : null }, JsonOptions);
+ var sourceText = File.ReadAllText(path);
+ var usesTemplateInstances = Regex.IsMatch(sourceText, @"<Part\s+[A-Za-z_]\w*\s*=\s*[A-Za-z_]\w*\s*<", RegexOptions.CultureInvariant);
+ AssemblyIr? assemblyIr;
+ AssemblyGeometryArtifactIr? geometryArtifact;
+ IReadOnlyList<AssemblyDiagnostic> assemblyDiagnostics;
+ AssemblyPerformanceIr? assemblyPerformance;
+ bool success;
+ if (usesTemplateInstances)
+ {
+ var m1 = new AssemblyM1Pipeline().CompileFile(path);
+ assemblyIr = m1.Ir;
+ geometryArtifact = m1.Geometry?.Artifact;
+ assemblyDiagnostics = m1.Diagnostics;
+ assemblyPerformance = m1.Performance;
+ success = m1.IsSuccess;
+ }
+ else
+ {
+ var m0 = new AssemblyM0Pipeline().CompileFile(path);
+ assemblyIr = m0.Ir;
+ geometryArtifact = null;
+ assemblyDiagnostics = m0.Diagnostics;
+ assemblyPerformance = m0.Performance;
+ success = m0.IsSuccess;
+ }
+ var reportJson = JsonSerializer.Serialize(new { success, assemblyIr, geometryArtifact, diagnostics = assemblyDiagnostics, performance = profile ? assemblyPerformance : null }, JsonOptions);
if (outputPath is not null)
{
var fullOutputPath = Path.GetFullPath(outputPath);
@@ -2567,7 +2592,7 @@ public static class CliRunner
{
stdout.WriteLine(reportJson);
}
- else if (result.Ir is { } ir)
+ else if (assemblyIr is { } ir)
{
stdout.WriteLine($"Assembly: {ir.Name} ({ir.Schema})");
stdout.WriteLine("Product tree:");
@@ -2576,17 +2601,26 @@ public static class CliRunner
stdout.WriteLine("Mates:");
foreach (var mate in ir.Mates)
stdout.WriteLine($"- {mate.Name}: {mate.InterfaceStableId} ({string.Join(", ", mate.Roles.Select(x => x.Role + "=" + x.ParticipantPath))})");
+ if (geometryArtifact is not null)
+ {
+ stdout.WriteLine($"Executable geometry: {geometryArtifact.Instances.Count} instances, {geometryArtifact.Definitions.Count} definitions, sha256={geometryArtifact.DeterministicSha256}");
+ foreach (var residual in geometryArtifact.MateResiduals)
+ stdout.WriteLine($"- residual {residual.ConstraintStableId}: position={residual.PositionResidualMm:G6}mm angle={residual.AngularResidualRadians:G6}rad {(residual.Passed ? "passed" : "failed")}");
+ stdout.WriteLine("BOM:");
+ foreach (var group in ir.Instances.Where(x => x.Kind == AssemblyInstanceKind.Part).GroupBy(x => x.DefinitionIdentity, StringComparer.Ordinal).OrderBy(x => x.Key, StringComparer.Ordinal))
+ stdout.WriteLine($"- {group.Key}: quantity={group.Count()} instances=[{string.Join(",", group.Select(x => x.Path))}]");
+ }
stdout.WriteLine("Tolerance stackups:");
foreach (var stack in ir.ToleranceStackups)
stdout.WriteLine($"- {stack.Name}: nominal={stack.Nominal:G6} {stack.Unit}, worst=[{stack.WorstCaseMinimum:G6},{stack.WorstCaseMaximum:G6}], {stack.Status}, contributors={stack.Contributions.Count}");
- foreach (var diagnostic in result.Diagnostics)
+ foreach (var diagnostic in assemblyDiagnostics)
(diagnostic.Severity == AssemblyDiagnosticSeverity.Error ? stderr : stdout).WriteLine($"{diagnostic.Severity}: {diagnostic.Code}: {diagnostic.Message}");
}
else
{
- foreach (var diagnostic in result.Diagnostics) stderr.WriteLine($"{diagnostic.Code}: {diagnostic.Message}");
+ foreach (var diagnostic in assemblyDiagnostics) stderr.WriteLine($"{diagnostic.Code}: {diagnostic.Message}");
}
- return result.IsSuccess ? 0 : 1;
+ return success ? 0 : 1;
}
private static int RunAsmExec(string[] args, TextWriter stdout, TextWriter stderr)
diff --git a/Aetheris.Kernel.Core/Math/Transform3D.cs b/Aetheris.Kernel.Core/Math/Transform3D.cs
index 51926284..33fcaa54 100644
--- a/Aetheris.Kernel.Core/Math/Transform3D.cs
+++ b/Aetheris.Kernel.Core/Math/Transform3D.cs
@@ -24,6 +24,16 @@ public readonly struct Transform3D
public static Transform3D Identity { get; } = new([1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]);
+ public static Transform3D FromRowMajor(IReadOnlyList<double> matrix)
+ {
+ ArgumentNullException.ThrowIfNull(matrix);
+ if (matrix.Count != 16 || matrix.Any(value => !double.IsFinite(value)))
+ throw new ArgumentException("A finite 4x4 row-major matrix is required.", nameof(matrix));
+ var transform = new Transform3D(matrix.ToArray());
+ if (!transform.IsRigid()) throw new ArgumentException("Assembly instance transforms must be rigid.", nameof(matrix));
+ return transform;
+ }
+
public static Transform3D CreateTranslation(Vector3D t) =>
new([1,0,0,0, 0,1,0,0, 0,0,1,0, t.X,t.Y,t.Z,1]);
diff --git a/Aetheris.Kernel.Firmament.Tests/Assembly/AssemblyM1Tests.cs b/Aetheris.Kernel.Firmament.Tests/Assembly/AssemblyM1Tests.cs
new file mode 100644
index 00000000..787980dd
--- /dev/null
+++ b/Aetheris.Kernel.Firmament.Tests/Assembly/AssemblyM1Tests.cs
@@ -0,0 +1,41 @@
+using Aetheris.Kernel.Firmament.Assembly;
+using Aetheris.Semantics;
+
+namespace Aetheris.Kernel.Firmament.Tests.Assembly;
+
+public sealed class AssemblyM1Tests
+{
+ [Fact]
+ public void TemplateRecordParts_ExecuteAsReusedExactWorldGeometryWithResidualValidation()
+ {
+ var path = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/AssemblyM1/template-block-pair.firmament");
+ var first = new AssemblyM1Pipeline().CompileFile(path);
+ var second = new AssemblyM1Pipeline().CompileFile(path);
+
+ Assert.True(first.IsSuccess, string.Join(Environment.NewLine, first.Diagnostics.Select(diagnostic => $"{diagnostic.Code}: {diagnostic.Message}")));
+ Assert.Equal("aetheris/assembly-ir/m1", first.Ir!.Schema);
+ Assert.Equal(2, first.Geometry!.Artifact.Definitions.Count);
+ Assert.Equal(2, first.Geometry.Artifact.Instances.Count);
+ Assert.All(first.Geometry.Artifact.Definitions, definition => Assert.Contains(definition.Provenance, item => item.Stage == "static-record"));
+ Assert.All(first.Geometry.Artifact.MateResiduals, residual => Assert.True(residual.Passed));
+ Assert.All(first.Ir.PlacementConstraints, constraint => Assert.Equal("geometry-validated", constraint.Status));
+ Assert.Equal(first.Geometry.Artifact.DeterministicSha256, second.Geometry!.Artifact.DeterministicSha256);
+
+ var moving = first.Ir.Instances.Single(instance => instance.Path.ToString() == "TemplateBlockPair.Moving");
+ var axis = moving.SemanticRoot.ExposedMembers["Interface"].ExposedMembers["Axis"];
+ var world = Assert.IsType<ExactAxisBinding>(AssemblyWorldQuery.Resolve(first.Ir, axis.StableIdentity));
+ Assert.Equal(0, world.OriginX, 8);
+ Assert.Equal(0, world.OriginY, 8);
+ Assert.Equal(2.5, world.OriginZ, 8); // local box center 7.5mm, Mate-derived seating transform -5mm
+
+ var automatic = Assert.Single(first.Ir.DimensionalRelations, relation => relation.Provenance == "Interface:SeatedAxis.Fit");
+ Assert.Equal(-5, automatic.Nominal, 8);
+ Assert.Equal("mate:TemplateBlockPair:Seat", automatic.MateStableId);
+ Assert.Equal("interface:SeatedAxis", automatic.InterfaceStableId);
+ Assert.Contains(automatic.SourceProvenance!, item => item.Stage == "static-record" && item.Identity == "MovingSpec");
+ Assert.Contains(automatic.SourceProvenance!, item => item.Stage == "template-specialization");
+ var stackup = Assert.Single(first.Ir.ToleranceStackups);
+ Assert.True(stackup.Passed);
+ Assert.Contains(Assert.Single(stackup.Contributions).SourceProvenance!, item => item.Stage == "static-record" && item.Identity == "FixedSpec");
+ }
+}
diff --git a/Aetheris.Kernel.Firmament.Tests/FirmamentV2LanguageManifestTests.cs b/Aetheris.Kernel.Firmament.Tests/FirmamentV2LanguageManifestTests.cs
new file mode 100644
index 00000000..d15af803
--- /dev/null
+++ b/Aetheris.Kernel.Firmament.Tests/FirmamentV2LanguageManifestTests.cs
@@ -0,0 +1,24 @@
+using System.Text.Json;
+
+namespace Aetheris.Kernel.Firmament.Tests;
+
+public sealed class FirmamentV2LanguageManifestTests
+{
+ [Fact]
+ public void CanonicalLanguageManifest_IsValidClassifiedAndDocumentationTargetsExist()
+ {
+ var root = FirmamentCorpusHarness.RepoRoot();
+ var path = Path.Combine(root, "docs", "firmament-v2", "language-features.json");
+ using var document = JsonDocument.Parse(File.ReadAllText(path));
+ var features = document.RootElement.GetProperty("features").EnumerateArray().ToArray();
+ Assert.True(features.Length >= 30);
+ var admitted = new HashSet<string>(StringComparer.Ordinal)
+ {
+ "Supported", "Experimental", "Internal-only", "Legacy", "Deprecated", "Parser-only / dead", "Future / incomplete"
+ };
+ Assert.All(features, feature => Assert.Contains(feature.GetProperty("status").GetString()!, admitted));
+ Assert.Equal(features.Length, features.Select(feature => feature.GetProperty("name").GetString()).Distinct(StringComparer.Ordinal).Count());
+ Assert.True(File.Exists(Path.Combine(root, "docs", "firmament-v2", "language-reference.md")));
+ Assert.True(File.Exists(Path.Combine(root, "docs", "firmament-v2", "quickstart.md")));
+ }
+}
diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Compiler.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Compiler.cs
index db86f9c5..e46c4824 100644
--- a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Compiler.cs
+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Compiler.cs
@@ -44,7 +44,9 @@ public sealed class AssemblyM0Compiler
placementWatch.Stop();
var graphWatch = Stopwatch.StartNew();
- var relations = BindDimensionalRelations(source, instances, diagnostics);
+ var relations = BindDimensionalRelations(source, instances, diagnostics)
+ .Concat(LowerInterfaceDimensionalRelations(mates, interfaces, instances, diagnostics))
+ .OrderBy(relation => relation.StableId, StringComparer.Ordinal).ToArray();
graphWatch.Stop();
var toleranceWatch = Stopwatch.StartNew();
@@ -333,6 +335,46 @@ public sealed class AssemblyM0Compiler
return result;
}
+ private static IReadOnlyList<DimensionalRelationIr> LowerInterfaceDimensionalRelations(
+ IReadOnlyList<MateIr> mates,
+ IReadOnlyDictionary<string, InterfaceDefinition> interfaces,
+ IReadOnlyList<AssemblyInstanceIr> instances,
+ List<AssemblyDiagnostic> diagnostics)
+ {
+ var values = Flatten(instances.Select(instance => instance.SemanticRoot)).ToDictionary(value => value.StableIdentity, StringComparer.Ordinal);
+ var result = new List<DimensionalRelationIr>();
+ foreach (var mate in mates.OrderBy(item => item.StableId, StringComparer.Ordinal))
+ {
+ var definition = interfaces.Values.Single(item => item.StableId == mate.InterfaceStableId);
+ if (definition.Fit is not { } fit) continue;
+ var shaft = mate.Roles.FirstOrDefault(role => role.Role == fit.ShaftRole);
+ var bore = mate.Roles.FirstOrDefault(role => role.Role == fit.BoreRole);
+ if (shaft is null || bore is null) continue;
+ var shaftId = ResolveRelativeSemantic(shaft.ParticipantSemanticValueId, fit.ShaftDimension, instances);
+ var boreId = ResolveRelativeSemantic(bore.ParticipantSemanticValueId, fit.BoreDimension, instances);
+ if (shaftId is null || boreId is null
+ || !values[shaftId].TryBinding<TolerancedDimensionBinding>(out var shaftDimension)
+ || !values[boreId].TryBinding<TolerancedDimensionBinding>(out var boreDimension)
+ || !string.Equals(shaftDimension.Unit, boreDimension.Unit, StringComparison.Ordinal)) continue;
+ result.Add(new(
+ $"dimension-relation:{mate.StableId}:fit-clearance",
+ shaftId,
+ boreId,
+ boreDimension.Nominal - shaftDimension.Nominal,
+ boreDimension.LowerTolerance - shaftDimension.UpperTolerance,
+ boreDimension.UpperTolerance - shaftDimension.LowerTolerance,
+ shaftDimension.Unit,
+ 1,
+ OwnerPath(shaftId, instances),
+ $"Interface:{definition.Name}.Fit",
+ mate.StableId,
+ definition.StableId,
+ values[shaftId].Provenance.Concat(values[boreId].Provenance)
+ .DistinctBy(item => (item.Stage, item.Identity, item.Evidence)).ToArray()));
+ }
+ return result;
+ }
+
private static IReadOnlyList<ToleranceStackupResultIr> AnalyzeStackups(AssemblySource source,
IReadOnlyList<DimensionalRelationIr> relations, IReadOnlyList<AssemblyInstanceIr> instances,
List<AssemblyDiagnostic> diagnostics)
@@ -349,7 +391,7 @@ public sealed class AssemblyM0Compiler
step.sign * step.edge.Nominal,
step.sign > 0 ? step.edge.LowerTolerance : -step.edge.UpperTolerance,
step.sign > 0 ? step.edge.UpperTolerance : -step.edge.LowerTolerance,
- step.edge.Unit, step.edge.OriginInstancePath, step.edge.Provenance, step.edge.MateStableId, step.edge.InterfaceStableId)).ToArray();
+ step.edge.Unit, step.edge.OriginInstancePath, step.edge.Provenance, step.edge.MateStableId, step.edge.InterfaceStableId, step.edge.SourceProvenance)).ToArray();
if (contributions.Any(x => x.Unit != assertion.Unit))
{ diagnostics.Add(new("assembly-tolerance-unit-mismatch", $"Assert ToleranceStackup '{assertion.Name}' mixes units.")); continue; }
var nominal = contributions.Sum(x => x.Nominal);
diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Models.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Models.cs
index a33f6c5e..dfc49d27 100644
--- a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Models.cs
+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Models.cs
@@ -41,7 +41,8 @@ public sealed record AssemblySource(
IReadOnlyList<MateSource> Mates, AssemblyPath Anchor,
IReadOnlyList<DimensionalRelationSource> DimensionalRelations,
IReadOnlyList<ToleranceStackupAssertSource> StackupAsserts,
- string SourceIdentity);
+ string SourceIdentity,
+ string? DefinitionSource = null);
public sealed record AssemblyTransform(double[] Matrix)
{
@@ -65,11 +66,13 @@ public sealed record PlacementResultIr(string InstanceStableId, PlacementStatus
public sealed record DimensionalRelationIr(
string StableId, string FromSemanticValueId, string ToSemanticValueId,
double Nominal, double LowerTolerance, double UpperTolerance, string Unit,
- int Sign, string OriginInstancePath, string Provenance, string? MateStableId = null, string? InterfaceStableId = null);
+ int Sign, string OriginInstancePath, string Provenance, string? MateStableId = null, string? InterfaceStableId = null,
+ IReadOnlyList<SemanticProvenance>? SourceProvenance = null);
public sealed record StackupContributionIr(
string RelationStableId, int Sign, double Nominal, double LowerTolerance, double UpperTolerance,
- string Unit, string OriginInstancePath, string Provenance, string? MateStableId, string? InterfaceStableId);
+ string Unit, string OriginInstancePath, string Provenance, string? MateStableId, string? InterfaceStableId,
+ IReadOnlyList<SemanticProvenance>? SourceProvenance = null);
public sealed record ToleranceStackupResultIr(
string Name, string StartSemanticValueId, string EndSemanticValueId,
double Nominal, double WorstCaseMinimum, double WorstCaseMaximum,
@@ -78,7 +81,12 @@ public sealed record ToleranceStackupResultIr(
public sealed record InterfaceFitResultIr(
string MateStableId, double NominalClearance, double WorstCaseMinimum, double WorstCaseMaximum, string Unit, bool Compatible);
-public sealed record AssemblyPerformanceIr(double ParseMilliseconds, double BindMilliseconds, double MateValidationMilliseconds, double PlacementMilliseconds, double DimensionalGraphMilliseconds, double ToleranceAnalysisMilliseconds);
+public sealed record AssemblyPerformanceIr(double ParseMilliseconds, double BindMilliseconds, double MateValidationMilliseconds, double PlacementMilliseconds, double DimensionalGraphMilliseconds, double ToleranceAnalysisMilliseconds, double DefinitionMaterializationMilliseconds = 0, double GeometryExecutionMilliseconds = 0);
+public sealed record AssemblyGeometryMetricsIr(int Bodies, int Faces, int Edges, int Vertices, double[] Minimum, double[] Maximum);
+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 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.cs
index 23de47d8..dd418988 100644
--- a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Parser.cs
+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Parser.cs
@@ -31,7 +31,13 @@ public sealed class AssemblyM0Parser
var asserts = ParseAsserts(body, sourceIdentity, diagnostics);
var 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 result = new AssemblySource(assemblyHeader.Groups["name"].Value, tree, interfaces, mates, anchor, relations, asserts, sourceIdentity);
+ var definitionBoundary = new[]
+ {
+ Regex.Match(source, @"^[ \t]*Interface\s+[A-Za-z_]\w*\s*\{", RegexOptions.CultureInvariant | RegexOptions.Multiline),
+ Regex.Match(source, @"^[ \t]*Assembly\s+[A-Za-z_]\w*\s*\{", RegexOptions.CultureInvariant | RegexOptions.Multiline)
+ }.Where(match => match.Success).Select(match => match.Index).DefaultIfEmpty(0).Min();
+ var definitionSource = definitionBoundary > 0 ? source[..definitionBoundary].Trim() : null;
+ var result = new AssemblySource(assemblyHeader.Groups["name"].Value, tree, interfaces, mates, anchor, relations, asserts, sourceIdentity, definitionSource);
return Done(result);
ParseResult Done(AssemblySource? value) { watch.Stop(); return new(value, diagnostics, watch.Elapsed.TotalMilliseconds); }
@@ -74,7 +80,9 @@ public sealed class AssemblyM0Parser
private static AssemblyMemberSource? ParseTree(string body, string sourceIdentity, List<AssemblyDiagnostic> diagnostics)
{
- var tagPattern = new Regex(@"<(?<close>/)?(?<kind>Assembly|Part)\s*(?<rest>[^>]*)>", RegexOptions.CultureInvariant);
+ // One bounded generic argument list is admitted in a Part definition. The
+ // inner '>' belongs to the Firmament Template application, not the XML-like tag.
+ var tagPattern = new Regex(@"<(?<close>/)?(?<kind>Assembly|Part)\s*(?<rest>[^<>]*(?:<[^<>]*>[^<>]*)?)>", RegexOptions.CultureInvariant);
var matches = tagPattern.Matches(body).Cast<Match>().ToArray();
MutableNode? root = null;
var stack = new Stack<(MutableNode node, int bodyStart)>();
@@ -87,7 +95,7 @@ public sealed class AssemblyM0Parser
var rest = tag.Groups["rest"].Value.Trim();
var nodeMatch = kind == "Assembly"
? Regex.Match(rest, @"^(?<name>[A-Za-z_]\w*)$")
- : Regex.Match(rest, @"^(?<name>[A-Za-z_]\w*)\s*=\s*(?<definition>[A-Za-z_]\w*)$");
+ : Regex.Match(rest, @"^(?<name>[A-Za-z_]\w*)\s*=\s*(?<definition>[A-Za-z_]\w*(?:\s*<[^>]+>)?)$");
if (!nodeMatch.Success) { diagnostics.Add(new("assembly-tree-invalid-tag", $"Invalid <{kind}> tree tag '{tag.Value}'.")); continue; }
var node = new MutableNode(nodeMatch.Groups["name"].Value, kind == "Assembly" ? AssemblyInstanceKind.Assembly : AssemblyInstanceKind.Part,
kind == "Assembly" ? nodeMatch.Groups["name"].Value : nodeMatch.Groups["definition"].Value);
diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyM1Execution.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyM1Execution.cs
new file mode 100644
index 00000000..30ef705d
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyM1Execution.cs
@@ -0,0 +1,296 @@
+using System.Security.Cryptography;
+using System.Diagnostics;
+using System.Text;
+using System.Text.Json;
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Core.Math;
+using Aetheris.Kernel.Core.Step242;
+using Aetheris.Kernel.Firmament.FirmamentV2;
+using Aetheris.Semantics;
+
+namespace Aetheris.Kernel.Firmament.Assembly;
+
+public sealed record AssemblyExecutedGeometry(
+ AssemblyGeometryArtifactIr Artifact,
+ IReadOnlyDictionary<string, BrepBody> DefinitionBodies,
+ IReadOnlyDictionary<string, BrepBody> InstanceBodies);
+
+public sealed record AssemblyM1CompilationResult(
+ AssemblyIr? Ir,
+ AssemblyExecutedGeometry? Geometry,
+ IReadOnlyList<AssemblyDiagnostic> Diagnostics,
+ AssemblyPerformanceIr? Performance = null)
+{
+ public bool IsSuccess => Ir is not null && Geometry is not null && Diagnostics.All(diagnostic => diagnostic.Severity != AssemblyDiagnosticSeverity.Error);
+}
+
+internal sealed record MaterializedAssemblyDefinition(
+ string DefinitionIdentity,
+ string SpecializationIdentity,
+ BrepBody Body,
+ IReadOnlyList<SemanticValue> Semantics,
+ AssemblyDefinitionArtifactIr Artifact);
+
+/// <summary>
+/// M1's definition seam: specialize through the ordinary Firmament compiler, then
+/// reimport its canonical AP242 exact body. Assembly has no second part generator.
+/// </summary>
+internal static class AssemblyDefinitionMaterializer
+{
+ public static MaterializedAssemblyDefinition? TryMaterialize(string definitionIdentity, string? definitionSource, string sourceIdentity, List<AssemblyDiagnostic> diagnostics)
+ {
+ if (string.IsNullOrWhiteSpace(definitionSource) || !definitionIdentity.Contains('<', StringComparison.Ordinal)) return null;
+ // Assembly files keep reusable declarations beside relational assembly syntax.
+ // Wrap that declaration catalog in the ordinary V2 Model root for the exact
+ // same compiler/build path used by standalone Firmament parts.
+ var module = "Model __AssemblyDefinition {" + Environment.NewLine
+ + "Units: mm" + Environment.NewLine
+ + definitionSource + Environment.NewLine
+ + $"Struct __AssemblyPart = {definitionIdentity}" + Environment.NewLine
+ + "}" + Environment.NewLine;
+ var build = FirmamentBuildAndExport.CompileSource(module, Path.GetDirectoryName(Path.GetFullPath(sourceIdentity)));
+ if (!build.IsSuccess || build.Value is null)
+ {
+ foreach (var diagnostic in build.Diagnostics)
+ diagnostics.Add(new("assembly-definition-materialization-failed", $"Definition '{definitionIdentity}' failed ordinary Firmament materialization: {diagnostic.Message}"));
+ return null;
+ }
+ var import = Step242Importer.ImportBody(build.Value.StepText);
+ if (!import.IsSuccess || import.Value is null)
+ {
+ foreach (var diagnostic in import.Diagnostics)
+ diagnostics.Add(new("assembly-definition-reimport-failed", $"Definition '{definitionIdentity}' AP242 reimport failed: {diagnostic.Message}"));
+ return null;
+ }
+ var specialization = build.Value.ConceptIr?.TemplateInstantiations?.LastOrDefault()?.SpecializationIdentity
+ ?? "ordinary:" + definitionIdentity;
+ var provenance = new List<SemanticProvenance>
+ {
+ new("Firmament-definition", definitionIdentity, "ordinary Firmament build and canonical AP242 reimport", SemanticSourceSpan.Generated(sourceIdentity)),
+ new("template-specialization", specialization, definitionIdentity, SemanticSourceSpan.Generated(sourceIdentity))
+ };
+ if (build.Value.ConceptIr?.TemplateInstantiations?.LastOrDefault()?.RecordArguments is { Count: > 0 } records)
+ provenance.AddRange(records.OrderBy(pair => pair.Key, StringComparer.Ordinal).Select(pair =>
+ new SemanticProvenance("static-record", pair.Value.StaticValue, $"{pair.Key}:{pair.Value.RecordType};{pair.Value.Provenance}", SemanticSourceSpan.Generated(sourceIdentity))));
+ var semantics = build.Value.ConceptIr is null ? Array.Empty<SemanticValue>() : SemanticValues(build.Value.ConceptIr, provenance, sourceIdentity);
+ var 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);
+ }
+
+ private static IReadOnlyList<SemanticValue> SemanticValues(ConceptIrDocument ir, IReadOnlyList<SemanticProvenance> provenance, string sourceIdentity)
+ {
+ var members = ir.MaterializedStruct.ExposedMembers
+ .Where(member => member.Value is ConceptIrAxisValue or ConceptIrPlaneValue or ConceptIrPoint3Value or ConceptIrLengthValue)
+ .OrderBy(member => member.Name, StringComparer.Ordinal)
+ .Select(member => FromMember(member, provenance, sourceIdentity)).ToArray();
+ if (members.Length == 0) return [];
+ return [new SemanticValue(
+ "template-semantic:" + ir.MaterializedStruct.Name,
+ new("Semantic"),
+ members.SelectMany(member => member.Capabilities.Values).DistinctBy(capability => capability.GetType()),
+ exposedMembers: members,
+ provenance: provenance,
+ authoredSourceSpan: SemanticSourceSpan.Generated(sourceIdentity),
+ exposedName: "Interface")];
+ }
+
+ private static SemanticValue FromMember(ConceptIrSemanticMember member, IReadOnlyList<SemanticProvenance> provenance, string sourceIdentity)
+ {
+ var span = new SemanticSourceSpan(sourceIdentity, member.SourceSpan.Start, member.SourceSpan.Length);
+ return member.Value switch
+ {
+ ConceptIrAxisValue axis => new(member.StableId, new("Axis"), [new AxisCapability()],
+ [new ExactAxisBinding(axis.Origin.X, axis.Origin.Y, axis.Origin.Z, axis.Direction.X, axis.Direction.Y, axis.Direction.Z, member.StableId)],
+ provenance: provenance, authoredSourceSpan: span, exposedName: member.Name),
+ ConceptIrPlaneValue plane => new(member.StableId, new("Plane"), [new PlaneCapability()],
+ [new ExactPlaneBinding(plane.Origin.X, plane.Origin.Y, plane.Origin.Z, plane.Normal.X, plane.Normal.Y, plane.Normal.Z, member.StableId)],
+ provenance: provenance, authoredSourceSpan: span, exposedName: member.Name),
+ ConceptIrPoint3Value point => new(member.StableId, new("Point"), [new PointCapability()],
+ [new ExactPointBinding(point.Point.X, point.Point.Y, point.Point.Z, member.StableId)],
+ provenance: provenance, authoredSourceSpan: span, exposedName: member.Name),
+ ConceptIrLengthValue length => new(member.StableId, new("Length"), [new DimensionalCapability()],
+ [new TolerancedDimensionBinding(length.Value, 0, 0, length.Unit, member.StableId)],
+ provenance: provenance, authoredSourceSpan: span, exposedName: member.Name),
+ _ => throw new InvalidOperationException($"Unsupported assembly semantic member '{member.Name}'.")
+ };
+ }
+
+ internal static AssemblyGeometryMetricsIr Metrics(BrepBody body)
+ {
+ var points = body.Topology.Vertices.Select(vertex => body.TryGetVertexPoint(vertex.Id, out var point) ? point : (Point3D?)null).Where(point => point.HasValue).Select(point => point!.Value).ToArray();
+ var minimum = points.Length == 0 ? [0d, 0d, 0d] : new[] { points.Min(point => point.X), points.Min(point => point.Y), points.Min(point => point.Z) };
+ var maximum = points.Length == 0 ? [0d, 0d, 0d] : new[] { points.Max(point => point.X), points.Max(point => point.Y), points.Max(point => point.Z) };
+ return new(body.Topology.Bodies.Count(), body.Topology.Faces.Count(), body.Topology.Edges.Count(), body.Topology.Vertices.Count(), minimum, maximum);
+ }
+}
+
+public sealed class AssemblyM1Pipeline
+{
+ public AssemblyM1CompilationResult CompileFile(string path)
+ {
+ var parsed = new AssemblyM0Parser().ParseFile(path);
+ 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 => AssemblyDefinitionMaterializer.TryMaterialize(identity, parsed.Source.DefinitionSource, parsed.Source.SourceIdentity, diagnostics))
+ .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) };
+ var compiled = new AssemblyM0Compiler().Compile(enriched, parsed.ElapsedMilliseconds);
+ diagnostics.AddRange(compiled.Diagnostics);
+ if (compiled.Ir is null) return new(null, null, diagnostics, compiled.Performance);
+ var geometryWatch = Stopwatch.StartNew();
+ var geometry = Execute(compiled.Ir, definitions, diagnostics, out var validatedIr);
+ geometryWatch.Stop();
+ var performance = compiled.Performance is null ? null : compiled.Performance with
+ {
+ DefinitionMaterializationMilliseconds = materializationWatch.Elapsed.TotalMilliseconds,
+ GeometryExecutionMilliseconds = geometryWatch.Elapsed.TotalMilliseconds
+ };
+ return new(validatedIr, geometry, diagnostics, performance);
+ }
+
+ private static AssemblyMemberSource Enrich(AssemblyMemberSource member, IReadOnlyDictionary<string, MaterializedAssemblyDefinition> definitions)
+ {
+ var generated = definitions.TryGetValue(member.DefinitionIdentity, out var definition) ? definition.Semantics : [];
+ var provenance = definitions.TryGetValue(member.DefinitionIdentity, out definition)
+ ? [.. member.Provenance ?? [], .. definition.Artifact.Provenance]
+ : member.Provenance;
+ return member with
+ {
+ Children = member.Children.Select(child => Enrich(child, definitions)).ToArray(),
+ ExposedSemantics = [.. member.ExposedSemantics, .. generated],
+ Provenance = provenance
+ };
+ }
+
+ private static AssemblyExecutedGeometry? Execute(AssemblyIr ir, IReadOnlyDictionary<string, MaterializedAssemblyDefinition> definitions, List<AssemblyDiagnostic> diagnostics, out AssemblyIr validatedIr)
+ {
+ var instances = new Dictionary<string, BrepBody>(StringComparer.Ordinal);
+ var instanceArtifacts = new List<AssemblyInstanceGeometryIr>();
+ foreach (var instance in ir.Instances.Where(item => item.Kind == AssemblyInstanceKind.Part).OrderBy(item => item.StableId, StringComparer.Ordinal))
+ {
+ if (!definitions.TryGetValue(instance.DefinitionIdentity, out var definition)) continue;
+ if (instance.ResolvedTransform is null)
+ {
+ diagnostics.Add(new("assembly-geometry-unresolved-transform", $"Part instance '{instance.Path}' has geometry but no resolved transform."));
+ continue;
+ }
+ var transform = Transform3D.FromRowMajor(instance.ResolvedTransform.Matrix);
+ var body = FirmasmAssemblyExecutor.TransformBody(definition.Body, transform);
+ instances[instance.StableId] = body;
+ instanceArtifacts.Add(new(instance.StableId, definition.Artifact.StableId, instance.ResolvedTransform, AssemblyDefinitionMaterializer.Metrics(body)));
+ }
+ if (definitions.Count == 0 || instanceArtifacts.Count == 0)
+ {
+ validatedIr = ir;
+ diagnostics.Add(new("assembly-geometry-no-materialized-definitions", "No Template-specialized part definitions were available for executable Assembly geometry."));
+ return null;
+ }
+ var residuals = AssemblyWorldQuery.ValidateResiduals(ir, instances.Keys.ToHashSet(StringComparer.Ordinal));
+ var byConstraint = residuals.ToDictionary(residual => residual.ConstraintStableId, StringComparer.Ordinal);
+ var constraints = ir.PlacementConstraints.Select(constraint => byConstraint.TryGetValue(constraint.StableId, out var residual)
+ ? constraint with { Residual = Math.Max(residual.PositionResidualMm, residual.AngularResidualRadians), Status = residual.Passed ? "geometry-validated" : "geometry-residual-failed" }
+ : constraint).ToArray();
+ foreach (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."));
+ 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);
+ return new(artifact, definitions.ToDictionary(pair => pair.Key, pair => pair.Value.Body, StringComparer.Ordinal), instances);
+ }
+}
+
+public static class AssemblyWorldQuery
+{
+ public static SemanticBinding Resolve(AssemblyIr ir, string semanticValueId)
+ {
+ var instance = ir.Instances.FirstOrDefault(candidate => Flatten(candidate.SemanticRoot).Any(value => value.StableIdentity == semanticValueId))
+ ?? throw new KeyNotFoundException($"Semantic value '{semanticValueId}' has no owning assembly instance.");
+ if (instance.ResolvedTransform is null) throw new InvalidOperationException($"Instance '{instance.Path}' has no resolved world transform.");
+ var value = Flatten(instance.SemanticRoot).Single(candidate => candidate.StableIdentity == semanticValueId);
+ var transform = Transform3D.FromRowMajor(instance.ResolvedTransform.Matrix);
+ if (value.TryBinding<ExactAxisBinding>(out var axis))
+ {
+ var origin = transform.Apply(new Point3D(axis.OriginX, axis.OriginY, axis.OriginZ));
+ var direction = transform.Apply(new Vector3D(axis.DirectionX, axis.DirectionY, axis.DirectionZ));
+ return new ExactAxisBinding(origin.X, origin.Y, origin.Z, direction.X, direction.Y, direction.Z, axis.AxisStableId + ":world:" + instance.StableId);
+ }
+ if (value.TryBinding<ExactPlaneBinding>(out var plane))
+ {
+ var origin = transform.Apply(new Point3D(plane.OriginX, plane.OriginY, plane.OriginZ));
+ var normal = transform.Apply(new Vector3D(plane.NormalX, plane.NormalY, plane.NormalZ));
+ return new ExactPlaneBinding(origin.X, origin.Y, origin.Z, normal.X, normal.Y, normal.Z, plane.PlaneStableId + ":world:" + instance.StableId);
+ }
+ if (value.TryBinding<ExactPointBinding>(out var point))
+ {
+ var world = transform.Apply(new Point3D(point.X, point.Y, point.Z));
+ return new ExactPointBinding(world.X, world.Y, world.Z, point.PointStableId + ":world:" + instance.StableId);
+ }
+ if (value.TryBinding<ExactBrepBodyBinding>(out var body))
+ return new ExactBrepBodyBinding(FirmasmAssemblyExecutor.TransformBody(body.Body, transform), body.BodyStableId + ":world:" + instance.StableId);
+ throw new InvalidOperationException($"Semantic value '{semanticValueId}' has no world-queryable exact binding.");
+ }
+
+ public static IReadOnlyList<AssemblyMateResidualIr> ValidateResiduals(AssemblyIr ir, IReadOnlySet<string> materializedInstanceIds, double positionToleranceMm = 1e-8, double angularToleranceRadians = 1e-8)
+ {
+ var result = new List<AssemblyMateResidualIr>();
+ foreach (var constraint in ir.PlacementConstraints.OrderBy(item => item.StableId, StringComparer.Ordinal))
+ {
+ var owners = ir.Instances.Where(instance => Flatten(instance.SemanticRoot).Any(value => value.StableIdentity == constraint.FirstSemanticValueId || value.StableIdentity == constraint.SecondSemanticValueId)).ToArray();
+ if (owners.Length != 2 || owners.Any(owner => !materializedInstanceIds.Contains(owner.StableId))) continue;
+ var first = Resolve(ir, constraint.FirstSemanticValueId);
+ var second = Resolve(ir, constraint.SecondSemanticValueId);
+ var (position, angle) = Residual(constraint.Kind, first, second, constraint.OffsetMm);
+ result.Add(new(constraint.StableId, constraint.Kind, position, angle, position <= positionToleranceMm && angle <= angularToleranceRadians, "world exact semantic binding over materialized BRep instance"));
+ }
+ return result;
+ }
+
+ private static (double Position, double Angle) Residual(PlacementConstraintKind kind, SemanticBinding first, SemanticBinding second, double offset)
+ {
+ if (first is ExactAxisBinding a && second is ExactAxisBinding b)
+ {
+ var ad = Unit(new(a.DirectionX, a.DirectionY, a.DirectionZ)); var bd = Unit(new(b.DirectionX, b.DirectionY, b.DirectionZ));
+ var delta = new Vector3D(a.OriginX - b.OriginX, a.OriginY - b.OriginY, a.OriginZ - b.OriginZ);
+ var cross = Cross(delta, bd);
+ return (cross.Length, double.Acos(Math.Clamp(Math.Abs(ad.Dot(bd)), -1, 1)));
+ }
+ if (first is ExactPlaneBinding p && second is ExactPlaneBinding q)
+ {
+ var pn = Unit(new(p.NormalX, p.NormalY, p.NormalZ)); var qn = Unit(new(q.NormalX, q.NormalY, q.NormalZ));
+ var delta = new Vector3D(p.OriginX - q.OriginX, p.OriginY - q.OriginY, p.OriginZ - q.OriginZ);
+ return (Math.Abs(delta.Dot(qn) - offset), double.Acos(Math.Clamp(Math.Abs(pn.Dot(qn)), -1, 1)));
+ }
+ if (first is ExactPointBinding x && second is ExactPointBinding y)
+ {
+ var delta = new Vector3D(x.X - y.X, x.Y - y.Y, x.Z - y.Z);
+ return (Math.Abs(delta.Length - offset), 0);
+ }
+ return (double.PositiveInfinity, double.PositiveInfinity);
+ }
+
+ private static Vector3D Unit(Vector3D value) => value / value.Length;
+ private static Vector3D Cross(Vector3D a, Vector3D b) => new(a.Y * b.Z - a.Z * b.Y, a.Z * b.X - a.X * b.Z, a.X * b.Y - a.Y * b.X);
+ private static IEnumerable<SemanticValue> Flatten(SemanticValue root)
+ {
+ yield return root;
+ foreach (var child in root.ExposedMembers.Values.SelectMany(Flatten)) yield return child;
+ }
+}
+
+internal static class AssemblyMemberSourceExtensions
+{
+ public static IEnumerable<AssemblyMemberSource> Flatten(this AssemblyMemberSource root)
+ {
+ yield return root;
+ foreach (var child in root.Children.SelectMany(Flatten)) yield return child;
+ }
+}
diff --git a/Aetheris.Kernel.Firmament/Assembly/FirmasmAssemblyExecutor.cs b/Aetheris.Kernel.Firmament/Assembly/FirmasmAssemblyExecutor.cs
index 80bad05c..6c3e57e2 100644
--- a/Aetheris.Kernel.Firmament/Assembly/FirmasmAssemblyExecutor.cs
+++ b/Aetheris.Kernel.Firmament/Assembly/FirmasmAssemblyExecutor.cs
@@ -92,7 +92,7 @@ public sealed class FirmasmAssemblyExecutor
return world;
}
- private static BrepBody TransformBody(BrepBody sourceBody, Transform3D transform)
+ internal static BrepBody TransformBody(BrepBody sourceBody, Transform3D transform)
{
var transformedGeometry = new BrepGeometryStore();
foreach (var (curveId, curve) in sourceBody.Geometry.Curves)
diff --git a/docs/assembly/architecture.md b/docs/assembly/architecture.md
index 43a52ddb..ef87fd8e 100644
--- a/docs/assembly/architecture.md
+++ b/docs/assembly/architecture.md
@@ -6,7 +6,7 @@ A part instance and a subassembly instance are distinct occurrences of a definit
An `Interface` is a relational Concept. A normal Concept describes one semantic object; an Interface declares named Roles, structural capability requirements, relational requirements, and optional explicitly admitted rigid freedoms. A `Mate` instantiates one Interface by assigning actual `SemanticValue` participants to every Role. No origin-specific branch exists: native, Template/Table-derived, Forge-produced, and recognized values are admissible when their capabilities and exact bindings prove the contract.
-The compiler lowers source syntax before downstream work into `AssemblyIr` (`aetheris/assembly-ir/m0`): explicit tree nodes, Interface definitions, a Mate graph, typed placement constraints, placement results and residual/status data, dimensional relations, stackup results, provenance, diagnostics, and phase timings. Nominal geometry remains nominal; tolerance is symbolic engineering intent.
+The compiler lowers source syntax before downstream work into `AssemblyIr` (`aetheris/assembly-ir/m0`, or `aetheris/assembly-ir/m1` after geometry execution): explicit tree nodes, Interface definitions, a Mate graph, typed placement constraints, placement results and residual/status data, dimensional relations, stackup results, provenance, diagnostics, and phase timings. Nominal geometry remains nominal; tolerance is symbolic engineering intent. M1 specializes ordinary Firmament Templates, materializes each distinct definition once, applies Mate-derived transforms per instance, and records an `aetheris/assembly-geometry/m1` instance artifact without Boolean-flattening the product.
## Placement convention
diff --git a/docs/assembly/artifacts/m1/ap242-audit.md b/docs/assembly/artifacts/m1/ap242-audit.md
new file mode 100644
index 00000000..6a5a7652
--- /dev/null
+++ b/docs/assembly/artifacts/m1/ap242-audit.md
@@ -0,0 +1,10 @@
+# AP242 assembly audit
+
+Evidence: `Aetheris.Kernel.Core/Step242/Step242Exporter.cs`, `Step242Importer.cs`, and `Aetheris.Kernel.Firmament/Assembly/FirmasmAssemblyRoundtripExporter.cs`.
+
+The current exporter supports a single exact `BrepBody`. It emits one PRODUCT, PRODUCT_DEFINITION_FORMATION, PRODUCT_DEFINITION, PRODUCT_DEFINITION_SHAPE, shape representation, and SHAPE_DEFINITION_REPRESENTATION. It does not emit `NEXT_ASSEMBLY_USAGE_OCCURRENCE`, `PRODUCT_DEFINITION_RELATIONSHIP`, `MAPPED_ITEM`, `ITEM_DEFINED_TRANSFORMATION`, `REPRESENTATION_RELATIONSHIP_WITH_TRANSFORMATION`, or `CONTEXT_DEPENDENT_SHAPE_REPRESENTATION`.
+
+The legacy roundtrip exporter writes one transformed STEP file per instance plus a JSON package. This proves transformed geometry but is not native AP242 product structure and does not reuse definition geometry.
+
+The importer returns one `BrepBody`; it does not expose product hierarchy or occurrence transforms. Consequently a native M1 AP242 assembly writer would need a bounded product-structure schema/writer first, followed by a structural parser/import result distinct from `ImportBody`. Boolean flattening would be incorrect. This is the exact remaining blocker; M1 does not paper over it with a fused body.
+
diff --git a/docs/assembly/artifacts/m1/determinism.md b/docs/assembly/artifacts/m1/determinism.md
new file mode 100644
index 00000000..508da155
--- /dev/null
+++ b/docs/assembly/artifacts/m1/determinism.md
@@ -0,0 +1,8 @@
+# M1 determinism evidence
+
+Two independent `AssemblyM1Pipeline` compilations of `template-block-pair.firmament` produce the same definition specialization identities, transforms, residuals, topology metrics, and `AssemblyGeometryArtifactIr.DeterministicSha256`.
+
+Canonical recorded artifact hash: `28CDA0D2A40F2CA2C41E3A99CCAB6543B43764412B679A25D9050B2B659F949E`.
+
+The generated inspection artifact is `executable-assembly.json`; performance timings are deliberately excluded from the deterministic payload.
+
diff --git a/docs/assembly/artifacts/m1/executable-assembly.json b/docs/assembly/artifacts/m1/executable-assembly.json
new file mode 100644
index 00000000..d6c655c5
--- /dev/null
+++ b/docs/assembly/artifacts/m1/executable-assembly.json
@@ -0,0 +1,1533 @@
+{
+ "success": true,
+ "assemblyIr": {
+ "schema": "aetheris/assembly-ir/m1",
+ "stableId": "assembly:TemplateBlockPair",
+ "name": "TemplateBlockPair",
+ "rootInstanceStableId": "assembly-instance:TemplateBlockPair",
+ "instances": [
+ {
+ "stableId": "assembly-instance:TemplateBlockPair",
+ "path": {
+ "segments": [
+ "TemplateBlockPair"
+ ]
+ },
+ "kind": "Assembly",
+ "definitionIdentity": "TemplateBlockPair",
+ "parentStableId": null,
+ "childrenStableIds": [
+ "assembly-instance:TemplateBlockPair.Fixed",
+ "assembly-instance:TemplateBlockPair.Moving"
+ ],
+ "semanticRoot": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair",
+ "type": {
+ "name": "Assembly",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": []
+ },
+ "bindings": [],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair",
+ "evidence": "TemplateBlockPair",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": null,
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": null
+ },
+ "localTransform": null,
+ "resolvedTransform": null,
+ "provenance": [
+ {
+ "stage": "assembly-source",
+ "identity": "TemplateBlockPair",
+ "evidence": "TemplateBlockPair",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ },
+ {
+ "stableId": "assembly-instance:TemplateBlockPair.Fixed",
+ "path": {
+ "segments": [
+ "TemplateBlockPair",
+ "Fixed"
+ ]
+ },
+ "kind": "Part",
+ "definitionIdentity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "parentStableId": "assembly-instance:TemplateBlockPair",
+ "childrenStableIds": [],
+ "semanticRoot": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Fixed",
+ "type": {
+ "name": "Part",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": []
+ },
+ "bindings": [],
+ "exposedMembers": {
+ "Interface": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Fixed:Interface",
+ "type": {
+ "name": "Semantic",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "AxisCapable"
+ },
+ {
+ "name": "DimensionalCapable"
+ },
+ {
+ "name": "PlaneCapable"
+ }
+ ]
+ },
+ "bindings": [],
+ "exposedMembers": {
+ "Axis": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Axis",
+ "type": {
+ "name": "Axis",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "AxisCapable"
+ }
+ ]
+ },
+ "bindings": [
+ {
+ "kind": "ExactAxis",
+ "stableBindingIdentity": "materialized:__AssemblyPart.exposed:Axis"
+ }
+ ],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "materialized:__AssemblyPart.exposed:Axis",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 607,
+ "length": 25
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Axis"
+ },
+ "Height": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Height",
+ "type": {
+ "name": "Length",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "DimensionalCapable"
+ }
+ ]
+ },
+ "bindings": [
+ {
+ "kind": "TolerancedDimension",
+ "stableBindingIdentity": "materialized:__AssemblyPart.exposed:Height"
+ }
+ ],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "materialized:__AssemblyPart.exposed:Height",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 659,
+ "length": 34
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Height"
+ },
+ "Seat": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Seat",
+ "type": {
+ "name": "Plane",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "PlaneCapable"
+ }
+ ]
+ },
+ "bindings": [
+ {
+ "kind": "ExactPlane",
+ "stableBindingIdentity": "materialized:__AssemblyPart.exposed:Seat"
+ }
+ ],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "materialized:__AssemblyPart.exposed:Seat",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 633,
+ "length": 25
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Seat"
+ }
+ },
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "template-semantic:__AssemblyPart",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Interface"
+ }
+ },
+ "provenance": [
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": null,
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": null
+ },
+ "localTransform": null,
+ "resolvedTransform": {
+ "matrix": [
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "provenance": [
+ {
+ "stage": "assembly-source",
+ "identity": "Fixed",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ },
+ {
+ "stableId": "assembly-instance:TemplateBlockPair.Moving",
+ "path": {
+ "segments": [
+ "TemplateBlockPair",
+ "Moving"
+ ]
+ },
+ "kind": "Part",
+ "definitionIdentity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "parentStableId": "assembly-instance:TemplateBlockPair",
+ "childrenStableIds": [],
+ "semanticRoot": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Moving",
+ "type": {
+ "name": "Part",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": []
+ },
+ "bindings": [],
+ "exposedMembers": {
+ "Interface": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Moving:Interface",
+ "type": {
+ "name": "Semantic",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "AxisCapable"
+ },
+ {
+ "name": "DimensionalCapable"
+ },
+ {
+ "name": "PlaneCapable"
+ }
+ ]
+ },
+ "bindings": [],
+ "exposedMembers": {
+ "Axis": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Moving:Interface.Axis",
+ "type": {
+ "name": "Axis",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "AxisCapable"
+ }
+ ]
+ },
+ "bindings": [
+ {
+ "kind": "ExactAxis",
+ "stableBindingIdentity": "materialized:__AssemblyPart.exposed:Axis"
+ }
+ ],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "materialized:__AssemblyPart.exposed:Axis",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 607,
+ "length": 25
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Axis"
+ },
+ "Height": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Moving:Interface.Height",
+ "type": {
+ "name": "Length",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "DimensionalCapable"
+ }
+ ]
+ },
+ "bindings": [
+ {
+ "kind": "TolerancedDimension",
+ "stableBindingIdentity": "materialized:__AssemblyPart.exposed:Height"
+ }
+ ],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "materialized:__AssemblyPart.exposed:Height",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 659,
+ "length": 34
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Height"
+ },
+ "Seat": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Moving:Interface.Seat",
+ "type": {
+ "name": "Plane",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "PlaneCapable"
+ }
+ ]
+ },
+ "bindings": [
+ {
+ "kind": "ExactPlane",
+ "stableBindingIdentity": "materialized:__AssemblyPart.exposed:Seat"
+ }
+ ],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "materialized:__AssemblyPart.exposed:Seat",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 633,
+ "length": 25
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Seat"
+ }
+ },
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "template-semantic:__AssemblyPart",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Interface"
+ }
+ },
+ "provenance": [
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": null,
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": null
+ },
+ "localTransform": null,
+ "resolvedTransform": {
+ "matrix": [
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ -5,
+ 1
+ ]
+ },
+ "provenance": [
+ {
+ "stage": "assembly-source",
+ "identity": "Moving",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ }
+ ],
+ "interfaces": [
+ {
+ "stableId": "interface:SeatedAxis",
+ "name": "SeatedAxis",
+ "roles": [
+ {
+ "name": "Fixed",
+ "requiredCapabilities": [
+ "AxisCapable",
+ "PlaneCapable",
+ "DimensionalCapable"
+ ],
+ "minimum": 1,
+ "maximum": 1
+ },
+ {
+ "name": "Moving",
+ "requiredCapabilities": [
+ "AxisCapable",
+ "PlaneCapable",
+ "DimensionalCapable"
+ ],
+ "minimum": 1,
+ "maximum": 1
+ }
+ ],
+ "requirements": [
+ {
+ "kind": "AxisCoincident",
+ "firstRole": "Moving",
+ "firstMember": "Axis",
+ "secondRole": "Fixed",
+ "secondMember": "Axis",
+ "offsetMm": 0
+ },
+ {
+ "kind": "PlaneCoincident",
+ "firstRole": "Moving",
+ "firstMember": "Seat",
+ "secondRole": "Fixed",
+ "secondMember": "Seat",
+ "offsetMm": 0
+ }
+ ],
+ "fit": {
+ "shaftRole": "Moving",
+ "shaftDimension": "Height",
+ "boreRole": "Fixed",
+ "boreDimension": "Height"
+ },
+ "admittedFreeMotions": [
+ "rotation:about-axis"
+ ],
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "mates": [
+ {
+ "stableId": "mate:TemplateBlockPair:Seat",
+ "name": "Seat",
+ "interfaceStableId": "interface:SeatedAxis",
+ "roles": [
+ {
+ "role": "Fixed",
+ "participantPath": {
+ "segments": [
+ "TemplateBlockPair",
+ "Fixed",
+ "Interface"
+ ]
+ },
+ "participantSemanticValueId": "assembly-semantic:TemplateBlockPair.Fixed:Interface",
+ "requiredCapabilities": [
+ "AxisCapable",
+ "PlaneCapable",
+ "DimensionalCapable"
+ ]
+ },
+ {
+ "role": "Moving",
+ "participantPath": {
+ "segments": [
+ "TemplateBlockPair",
+ "Moving",
+ "Interface"
+ ]
+ },
+ "participantSemanticValueId": "assembly-semantic:TemplateBlockPair.Moving:Interface",
+ "requiredCapabilities": [
+ "AxisCapable",
+ "PlaneCapable",
+ "DimensionalCapable"
+ ]
+ }
+ ],
+ "constraintIds": [
+ "constraint:mate:TemplateBlockPair:Seat:00",
+ "constraint:mate:TemplateBlockPair:Seat:01"
+ ],
+ "validationStatus": "valid"
+ }
+ ],
+ "placementConstraints": [
+ {
+ "stableId": "constraint:mate:TemplateBlockPair:Seat:00",
+ "kind": "AxisCoincident",
+ "mateStableId": "mate:TemplateBlockPair:Seat",
+ "firstSemanticValueId": "assembly-semantic:TemplateBlockPair.Moving:Interface.Axis",
+ "secondSemanticValueId": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Axis",
+ "offsetMm": 0,
+ "residual": 0,
+ "status": "geometry-validated"
+ },
+ {
+ "stableId": "constraint:mate:TemplateBlockPair:Seat:01",
+ "kind": "PlaneCoincident",
+ "mateStableId": "mate:TemplateBlockPair:Seat",
+ "firstSemanticValueId": "assembly-semantic:TemplateBlockPair.Moving:Interface.Seat",
+ "secondSemanticValueId": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Seat",
+ "offsetMm": 0,
+ "residual": 0,
+ "status": "geometry-validated"
+ }
+ ],
+ "placements": [
+ {
+ "instanceStableId": "assembly-instance:TemplateBlockPair",
+ "status": "Unresolved",
+ "transform": null,
+ "freeTranslations": [
+ "X",
+ "Y",
+ "Z"
+ ],
+ "freeRotations": [
+ "X",
+ "Y",
+ "Z"
+ ],
+ "constraintIds": []
+ },
+ {
+ "instanceStableId": "assembly-instance:TemplateBlockPair.Fixed",
+ "status": "Anchored",
+ "transform": {
+ "matrix": [
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "freeTranslations": [],
+ "freeRotations": [],
+ "constraintIds": []
+ },
+ {
+ "instanceStableId": "assembly-instance:TemplateBlockPair.Moving",
+ "status": "Resolved",
+ "transform": {
+ "matrix": [
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ -5,
+ 1
+ ]
+ },
+ "freeTranslations": [],
+ "freeRotations": [],
+ "constraintIds": [
+ "constraint:mate:TemplateBlockPair:Seat:00",
+ "constraint:mate:TemplateBlockPair:Seat:01"
+ ]
+ }
+ ],
+ "dimensionalRelations": [
+ {
+ "stableId": "dimension-relation:mate:TemplateBlockPair:Seat:fit-clearance",
+ "fromSemanticValueId": "assembly-semantic:TemplateBlockPair.Moving:Interface.Height",
+ "toSemanticValueId": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Height",
+ "nominal": -5,
+ "lowerTolerance": 0,
+ "upperTolerance": 0,
+ "unit": "mm",
+ "sign": 1,
+ "originInstancePath": "TemplateBlockPair.Moving",
+ "provenance": "Interface:SeatedAxis.Fit",
+ "mateStableId": "mate:TemplateBlockPair:Seat",
+ "interfaceStableId": "interface:SeatedAxis",
+ "sourceProvenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "materialized:__AssemblyPart.exposed:Height",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "materialized:__AssemblyPart.exposed:Height",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ }
+ ],
+ "toleranceStackups": [
+ {
+ "name": "TemplateFitTransition",
+ "startSemanticValueId": "assembly-semantic:TemplateBlockPair.Moving:Interface.Height",
+ "endSemanticValueId": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Height",
+ "nominal": -5,
+ "worstCaseMinimum": -5,
+ "worstCaseMaximum": -5,
+ "requiredMinimum": -5,
+ "unit": "mm",
+ "passed": true,
+ "status": "passed",
+ "contributions": [
+ {
+ "relationStableId": "dimension-relation:mate:TemplateBlockPair:Seat:fit-clearance",
+ "sign": 1,
+ "nominal": -5,
+ "lowerTolerance": 0,
+ "upperTolerance": 0,
+ "unit": "mm",
+ "originInstancePath": "TemplateBlockPair.Moving",
+ "provenance": "Interface:SeatedAxis.Fit",
+ "mateStableId": "mate:TemplateBlockPair:Seat",
+ "interfaceStableId": "interface:SeatedAxis",
+ "sourceProvenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "materialized:__AssemblyPart.exposed:Height",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "materialized:__AssemblyPart.exposed:Height",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "fitResults": [
+ {
+ "mateStableId": "mate:TemplateBlockPair:Seat",
+ "nominalClearance": -5,
+ "worstCaseMinimum": -5,
+ "worstCaseMaximum": -5,
+ "unit": "mm",
+ "compatible": false
+ }
+ ],
+ "diagnostics": [
+ {
+ "code": "assembly-interface-incompatible-dimensions",
+ "message": "Mate \u0027Seat\u0027 fit ranges from -5 to -5 mm (nominal -5).",
+ "severity": "Warning"
+ }
+ ]
+ },
+ "geometryArtifact": {
+ "schema": "aetheris/assembly-geometry/m1",
+ "definitions": [
+ {
+ "stableId": "assembly-definition:ACEEA9A33404DBC3",
+ "definitionIdentity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "specializationIdentity": "template:88509cacec6ff417",
+ "stepSha256": "5E6D828E9E9D8310848A9984EA1A9B5225A0D77ACB88B36414443D2B06FF9F30",
+ "metrics": {
+ "bodies": 1,
+ "faces": 10,
+ "edges": 20,
+ "vertices": 12,
+ "minimum": [
+ -6,
+ -6,
+ -0
+ ],
+ "maximum": [
+ 6,
+ 6,
+ 15
+ ]
+ },
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ },
+ {
+ "stableId": "assembly-definition:BDBDA1A577822F80",
+ "definitionIdentity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "specializationIdentity": "template:0a30ccff1bd91583",
+ "stepSha256": "7787F88FCB60744618A9785B2D972875128C23660656E785A8095A35EA03A99A",
+ "metrics": {
+ "bodies": 1,
+ "faces": 10,
+ "edges": 20,
+ "vertices": 12,
+ "minimum": [
+ -10,
+ -10,
+ -0
+ ],
+ "maximum": [
+ 10,
+ 10,
+ 10
+ ]
+ },
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ }
+ ],
+ "instances": [
+ {
+ "instanceStableId": "assembly-instance:TemplateBlockPair.Fixed",
+ "definitionArtifactStableId": "assembly-definition:BDBDA1A577822F80",
+ "worldTransform": {
+ "matrix": [
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "metrics": {
+ "bodies": 1,
+ "faces": 10,
+ "edges": 20,
+ "vertices": 12,
+ "minimum": [
+ -10,
+ -10,
+ 0
+ ],
+ "maximum": [
+ 10,
+ 10,
+ 10
+ ]
+ }
+ },
+ {
+ "instanceStableId": "assembly-instance:TemplateBlockPair.Moving",
+ "definitionArtifactStableId": "assembly-definition:ACEEA9A33404DBC3",
+ "worldTransform": {
+ "matrix": [
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ -5,
+ 1
+ ]
+ },
+ "metrics": {
+ "bodies": 1,
+ "faces": 10,
+ "edges": 20,
+ "vertices": 12,
+ "minimum": [
+ -6,
+ -6,
+ -5
+ ],
+ "maximum": [
+ 6,
+ 6,
+ 10
+ ]
+ }
+ }
+ ],
+ "mateResiduals": [
+ {
+ "constraintStableId": "constraint:mate:TemplateBlockPair:Seat:00",
+ "kind": "AxisCoincident",
+ "positionResidualMm": 0,
+ "angularResidualRadians": 0,
+ "passed": true,
+ "evidence": "world exact semantic binding over materialized BRep instance"
+ },
+ {
+ "constraintStableId": "constraint:mate:TemplateBlockPair:Seat:01",
+ "kind": "PlaneCoincident",
+ "positionResidualMm": 0,
+ "angularResidualRadians": 0,
+ "passed": true,
+ "evidence": "world exact semantic binding over materialized BRep instance"
+ }
+ ],
+ "deterministicSha256": "28CDA0D2A40F2CA2C41E3A99CCAB6543B43764412B679A25D9050B2B659F949E"
+ },
+ "diagnostics": [
+ {
+ "code": "assembly-interface-incompatible-dimensions",
+ "message": "Mate \u0027Seat\u0027 fit ranges from -5 to -5 mm (nominal -5).",
+ "severity": "Warning"
+ }
+ ],
+ "performance": null
+}
diff --git a/docs/assembly/artifacts/m1/performance.json b/docs/assembly/artifacts/m1/performance.json
new file mode 100644
index 00000000..b06a03a5
--- /dev/null
+++ b/docs/assembly/artifacts/m1/performance.json
@@ -0,0 +1,1542 @@
+{
+ "success": true,
+ "assemblyIr": {
+ "schema": "aetheris/assembly-ir/m1",
+ "stableId": "assembly:TemplateBlockPair",
+ "name": "TemplateBlockPair",
+ "rootInstanceStableId": "assembly-instance:TemplateBlockPair",
+ "instances": [
+ {
+ "stableId": "assembly-instance:TemplateBlockPair",
+ "path": {
+ "segments": [
+ "TemplateBlockPair"
+ ]
+ },
+ "kind": "Assembly",
+ "definitionIdentity": "TemplateBlockPair",
+ "parentStableId": null,
+ "childrenStableIds": [
+ "assembly-instance:TemplateBlockPair.Fixed",
+ "assembly-instance:TemplateBlockPair.Moving"
+ ],
+ "semanticRoot": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair",
+ "type": {
+ "name": "Assembly",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": []
+ },
+ "bindings": [],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair",
+ "evidence": "TemplateBlockPair",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": null,
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": null
+ },
+ "localTransform": null,
+ "resolvedTransform": null,
+ "provenance": [
+ {
+ "stage": "assembly-source",
+ "identity": "TemplateBlockPair",
+ "evidence": "TemplateBlockPair",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ },
+ {
+ "stableId": "assembly-instance:TemplateBlockPair.Fixed",
+ "path": {
+ "segments": [
+ "TemplateBlockPair",
+ "Fixed"
+ ]
+ },
+ "kind": "Part",
+ "definitionIdentity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "parentStableId": "assembly-instance:TemplateBlockPair",
+ "childrenStableIds": [],
+ "semanticRoot": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Fixed",
+ "type": {
+ "name": "Part",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": []
+ },
+ "bindings": [],
+ "exposedMembers": {
+ "Interface": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Fixed:Interface",
+ "type": {
+ "name": "Semantic",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "AxisCapable"
+ },
+ {
+ "name": "DimensionalCapable"
+ },
+ {
+ "name": "PlaneCapable"
+ }
+ ]
+ },
+ "bindings": [],
+ "exposedMembers": {
+ "Axis": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Axis",
+ "type": {
+ "name": "Axis",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "AxisCapable"
+ }
+ ]
+ },
+ "bindings": [
+ {
+ "kind": "ExactAxis",
+ "stableBindingIdentity": "materialized:__AssemblyPart.exposed:Axis"
+ }
+ ],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "materialized:__AssemblyPart.exposed:Axis",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 607,
+ "length": 25
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Axis"
+ },
+ "Height": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Height",
+ "type": {
+ "name": "Length",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "DimensionalCapable"
+ }
+ ]
+ },
+ "bindings": [
+ {
+ "kind": "TolerancedDimension",
+ "stableBindingIdentity": "materialized:__AssemblyPart.exposed:Height"
+ }
+ ],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "materialized:__AssemblyPart.exposed:Height",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 659,
+ "length": 34
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Height"
+ },
+ "Seat": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Seat",
+ "type": {
+ "name": "Plane",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "PlaneCapable"
+ }
+ ]
+ },
+ "bindings": [
+ {
+ "kind": "ExactPlane",
+ "stableBindingIdentity": "materialized:__AssemblyPart.exposed:Seat"
+ }
+ ],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "materialized:__AssemblyPart.exposed:Seat",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 633,
+ "length": 25
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Seat"
+ }
+ },
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "template-semantic:__AssemblyPart",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Interface"
+ }
+ },
+ "provenance": [
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": null,
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": null
+ },
+ "localTransform": null,
+ "resolvedTransform": {
+ "matrix": [
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "provenance": [
+ {
+ "stage": "assembly-source",
+ "identity": "Fixed",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ },
+ {
+ "stableId": "assembly-instance:TemplateBlockPair.Moving",
+ "path": {
+ "segments": [
+ "TemplateBlockPair",
+ "Moving"
+ ]
+ },
+ "kind": "Part",
+ "definitionIdentity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "parentStableId": "assembly-instance:TemplateBlockPair",
+ "childrenStableIds": [],
+ "semanticRoot": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Moving",
+ "type": {
+ "name": "Part",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": []
+ },
+ "bindings": [],
+ "exposedMembers": {
+ "Interface": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Moving:Interface",
+ "type": {
+ "name": "Semantic",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "AxisCapable"
+ },
+ {
+ "name": "DimensionalCapable"
+ },
+ {
+ "name": "PlaneCapable"
+ }
+ ]
+ },
+ "bindings": [],
+ "exposedMembers": {
+ "Axis": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Moving:Interface.Axis",
+ "type": {
+ "name": "Axis",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "AxisCapable"
+ }
+ ]
+ },
+ "bindings": [
+ {
+ "kind": "ExactAxis",
+ "stableBindingIdentity": "materialized:__AssemblyPart.exposed:Axis"
+ }
+ ],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "materialized:__AssemblyPart.exposed:Axis",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 607,
+ "length": 25
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Axis"
+ },
+ "Height": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Moving:Interface.Height",
+ "type": {
+ "name": "Length",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "DimensionalCapable"
+ }
+ ]
+ },
+ "bindings": [
+ {
+ "kind": "TolerancedDimension",
+ "stableBindingIdentity": "materialized:__AssemblyPart.exposed:Height"
+ }
+ ],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "materialized:__AssemblyPart.exposed:Height",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 659,
+ "length": 34
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Height"
+ },
+ "Seat": {
+ "stableIdentity": "assembly-semantic:TemplateBlockPair.Moving:Interface.Seat",
+ "type": {
+ "name": "Plane",
+ "isCollection": false
+ },
+ "capabilities": {
+ "values": [
+ {
+ "name": "PlaneCapable"
+ }
+ ]
+ },
+ "bindings": [
+ {
+ "kind": "ExactPlane",
+ "stableBindingIdentity": "materialized:__AssemblyPart.exposed:Seat"
+ }
+ ],
+ "exposedMembers": {},
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "materialized:__AssemblyPart.exposed:Seat",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 633,
+ "length": 25
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Seat"
+ }
+ },
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "template-semantic:__AssemblyPart",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": "Interface"
+ }
+ },
+ "provenance": [
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "authoredSourceSpan": null,
+ "generatedSourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ },
+ "exposedName": null
+ },
+ "localTransform": null,
+ "resolvedTransform": {
+ "matrix": [
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ -5,
+ 1
+ ]
+ },
+ "provenance": [
+ {
+ "stage": "assembly-source",
+ "identity": "Moving",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ }
+ ],
+ "interfaces": [
+ {
+ "stableId": "interface:SeatedAxis",
+ "name": "SeatedAxis",
+ "roles": [
+ {
+ "name": "Fixed",
+ "requiredCapabilities": [
+ "AxisCapable",
+ "PlaneCapable",
+ "DimensionalCapable"
+ ],
+ "minimum": 1,
+ "maximum": 1
+ },
+ {
+ "name": "Moving",
+ "requiredCapabilities": [
+ "AxisCapable",
+ "PlaneCapable",
+ "DimensionalCapable"
+ ],
+ "minimum": 1,
+ "maximum": 1
+ }
+ ],
+ "requirements": [
+ {
+ "kind": "AxisCoincident",
+ "firstRole": "Moving",
+ "firstMember": "Axis",
+ "secondRole": "Fixed",
+ "secondMember": "Axis",
+ "offsetMm": 0
+ },
+ {
+ "kind": "PlaneCoincident",
+ "firstRole": "Moving",
+ "firstMember": "Seat",
+ "secondRole": "Fixed",
+ "secondMember": "Seat",
+ "offsetMm": 0
+ }
+ ],
+ "fit": {
+ "shaftRole": "Moving",
+ "shaftDimension": "Height",
+ "boreRole": "Fixed",
+ "boreDimension": "Height"
+ },
+ "admittedFreeMotions": [
+ "rotation:about-axis"
+ ],
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ],
+ "mates": [
+ {
+ "stableId": "mate:TemplateBlockPair:Seat",
+ "name": "Seat",
+ "interfaceStableId": "interface:SeatedAxis",
+ "roles": [
+ {
+ "role": "Fixed",
+ "participantPath": {
+ "segments": [
+ "TemplateBlockPair",
+ "Fixed",
+ "Interface"
+ ]
+ },
+ "participantSemanticValueId": "assembly-semantic:TemplateBlockPair.Fixed:Interface",
+ "requiredCapabilities": [
+ "AxisCapable",
+ "PlaneCapable",
+ "DimensionalCapable"
+ ]
+ },
+ {
+ "role": "Moving",
+ "participantPath": {
+ "segments": [
+ "TemplateBlockPair",
+ "Moving",
+ "Interface"
+ ]
+ },
+ "participantSemanticValueId": "assembly-semantic:TemplateBlockPair.Moving:Interface",
+ "requiredCapabilities": [
+ "AxisCapable",
+ "PlaneCapable",
+ "DimensionalCapable"
+ ]
+ }
+ ],
+ "constraintIds": [
+ "constraint:mate:TemplateBlockPair:Seat:00",
+ "constraint:mate:TemplateBlockPair:Seat:01"
+ ],
+ "validationStatus": "valid"
+ }
+ ],
+ "placementConstraints": [
+ {
+ "stableId": "constraint:mate:TemplateBlockPair:Seat:00",
+ "kind": "AxisCoincident",
+ "mateStableId": "mate:TemplateBlockPair:Seat",
+ "firstSemanticValueId": "assembly-semantic:TemplateBlockPair.Moving:Interface.Axis",
+ "secondSemanticValueId": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Axis",
+ "offsetMm": 0,
+ "residual": 0,
+ "status": "geometry-validated"
+ },
+ {
+ "stableId": "constraint:mate:TemplateBlockPair:Seat:01",
+ "kind": "PlaneCoincident",
+ "mateStableId": "mate:TemplateBlockPair:Seat",
+ "firstSemanticValueId": "assembly-semantic:TemplateBlockPair.Moving:Interface.Seat",
+ "secondSemanticValueId": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Seat",
+ "offsetMm": 0,
+ "residual": 0,
+ "status": "geometry-validated"
+ }
+ ],
+ "placements": [
+ {
+ "instanceStableId": "assembly-instance:TemplateBlockPair",
+ "status": "Unresolved",
+ "transform": null,
+ "freeTranslations": [
+ "X",
+ "Y",
+ "Z"
+ ],
+ "freeRotations": [
+ "X",
+ "Y",
+ "Z"
+ ],
+ "constraintIds": []
+ },
+ {
+ "instanceStableId": "assembly-instance:TemplateBlockPair.Fixed",
+ "status": "Anchored",
+ "transform": {
+ "matrix": [
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "freeTranslations": [],
+ "freeRotations": [],
+ "constraintIds": []
+ },
+ {
+ "instanceStableId": "assembly-instance:TemplateBlockPair.Moving",
+ "status": "Resolved",
+ "transform": {
+ "matrix": [
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ -5,
+ 1
+ ]
+ },
+ "freeTranslations": [],
+ "freeRotations": [],
+ "constraintIds": [
+ "constraint:mate:TemplateBlockPair:Seat:00",
+ "constraint:mate:TemplateBlockPair:Seat:01"
+ ]
+ }
+ ],
+ "dimensionalRelations": [
+ {
+ "stableId": "dimension-relation:mate:TemplateBlockPair:Seat:fit-clearance",
+ "fromSemanticValueId": "assembly-semantic:TemplateBlockPair.Moving:Interface.Height",
+ "toSemanticValueId": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Height",
+ "nominal": -5,
+ "lowerTolerance": 0,
+ "upperTolerance": 0,
+ "unit": "mm",
+ "sign": 1,
+ "originInstancePath": "TemplateBlockPair.Moving",
+ "provenance": "Interface:SeatedAxis.Fit",
+ "mateStableId": "mate:TemplateBlockPair:Seat",
+ "interfaceStableId": "interface:SeatedAxis",
+ "sourceProvenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "materialized:__AssemblyPart.exposed:Height",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "materialized:__AssemblyPart.exposed:Height",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ }
+ ],
+ "toleranceStackups": [
+ {
+ "name": "TemplateFitTransition",
+ "startSemanticValueId": "assembly-semantic:TemplateBlockPair.Moving:Interface.Height",
+ "endSemanticValueId": "assembly-semantic:TemplateBlockPair.Fixed:Interface.Height",
+ "nominal": -5,
+ "worstCaseMinimum": -5,
+ "worstCaseMaximum": -5,
+ "requiredMinimum": -5,
+ "unit": "mm",
+ "passed": true,
+ "status": "passed",
+ "contributions": [
+ {
+ "relationStableId": "dimension-relation:mate:TemplateBlockPair:Seat:fit-clearance",
+ "sign": 1,
+ "nominal": -5,
+ "lowerTolerance": 0,
+ "upperTolerance": 0,
+ "unit": "mm",
+ "originInstancePath": "TemplateBlockPair.Moving",
+ "provenance": "Interface:SeatedAxis.Fit",
+ "mateStableId": "mate:TemplateBlockPair:Seat",
+ "interfaceStableId": "interface:SeatedAxis",
+ "sourceProvenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Moving",
+ "evidence": "materialized:__AssemblyPart.exposed:Height",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "assembly-instance",
+ "identity": "TemplateBlockPair.Fixed",
+ "evidence": "materialized:__AssemblyPart.exposed:Height",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ }
+ ]
+ }
+ ],
+ "fitResults": [
+ {
+ "mateStableId": "mate:TemplateBlockPair:Seat",
+ "nominalClearance": -5,
+ "worstCaseMinimum": -5,
+ "worstCaseMaximum": -5,
+ "unit": "mm",
+ "compatible": false
+ }
+ ],
+ "diagnostics": [
+ {
+ "code": "assembly-interface-incompatible-dimensions",
+ "message": "Mate \u0027Seat\u0027 fit ranges from -5 to -5 mm (nominal -5).",
+ "severity": "Warning"
+ }
+ ]
+ },
+ "geometryArtifact": {
+ "schema": "aetheris/assembly-geometry/m1",
+ "definitions": [
+ {
+ "stableId": "assembly-definition:ACEEA9A33404DBC3",
+ "definitionIdentity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "specializationIdentity": "template:88509cacec6ff417",
+ "stepSha256": "5E6D828E9E9D8310848A9984EA1A9B5225A0D77ACB88B36414443D2B06FF9F30",
+ "metrics": {
+ "bodies": 1,
+ "faces": 10,
+ "edges": 20,
+ "vertices": 12,
+ "minimum": [
+ -6,
+ -6,
+ -0
+ ],
+ "maximum": [
+ 6,
+ 6,
+ 15
+ ]
+ },
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:88509cacec6ff417",
+ "evidence": "AssemblyBlock\u003CSpec: MovingSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "MovingSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ },
+ {
+ "stableId": "assembly-definition:BDBDA1A577822F80",
+ "definitionIdentity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "specializationIdentity": "template:0a30ccff1bd91583",
+ "stepSha256": "7787F88FCB60744618A9785B2D972875128C23660656E785A8095A35EA03A99A",
+ "metrics": {
+ "bodies": 1,
+ "faces": 10,
+ "edges": 20,
+ "vertices": 12,
+ "minimum": [
+ -10,
+ -10,
+ -0
+ ],
+ "maximum": [
+ 10,
+ 10,
+ 10
+ ]
+ },
+ "provenance": [
+ {
+ "stage": "Firmament-definition",
+ "identity": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "evidence": "ordinary Firmament build and canonical AP242 reimport",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "template-specialization",
+ "identity": "template:0a30ccff1bd91583",
+ "evidence": "AssemblyBlock\u003CSpec: FixedSpec\u003E",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ },
+ {
+ "stage": "static-record",
+ "identity": "FixedSpec",
+ "evidence": "Spec:BlockSpec;StaticRecord",
+ "sourceSpan": {
+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM1\\template-block-pair.firmament",
+ "start": 0,
+ "length": 0
+ }
+ }
+ ]
+ }
+ ],
+ "instances": [
+ {
+ "instanceStableId": "assembly-instance:TemplateBlockPair.Fixed",
+ "definitionArtifactStableId": "assembly-definition:BDBDA1A577822F80",
+ "worldTransform": {
+ "matrix": [
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1
+ ]
+ },
+ "metrics": {
+ "bodies": 1,
+ "faces": 10,
+ "edges": 20,
+ "vertices": 12,
+ "minimum": [
+ -10,
+ -10,
+ 0
+ ],
+ "maximum": [
+ 10,
+ 10,
+ 10
+ ]
+ }
+ },
+ {
+ "instanceStableId": "assembly-instance:TemplateBlockPair.Moving",
+ "definitionArtifactStableId": "assembly-definition:ACEEA9A33404DBC3",
+ "worldTransform": {
+ "matrix": [
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ 0,
+ 1,
+ 0,
+ 0,
+ 0,
+ -5,
+ 1
+ ]
+ },
+ "metrics": {
+ "bodies": 1,
+ "faces": 10,
+ "edges": 20,
+ "vertices": 12,
+ "minimum": [
+ -6,
+ -6,
+ -5
+ ],
+ "maximum": [
+ 6,
+ 6,
+ 10
+ ]
+ }
+ }
+ ],
+ "mateResiduals": [
+ {
+ "constraintStableId": "constraint:mate:TemplateBlockPair:Seat:00",
+ "kind": "AxisCoincident",
+ "positionResidualMm": 0,
+ "angularResidualRadians": 0,
+ "passed": true,
+ "evidence": "world exact semantic binding over materialized BRep instance"
+ },
+ {
+ "constraintStableId": "constraint:mate:TemplateBlockPair:Seat:01",
+ "kind": "PlaneCoincident",
+ "positionResidualMm": 0,
+ "angularResidualRadians": 0,
+ "passed": true,
+ "evidence": "world exact semantic binding over materialized BRep instance"
+ }
+ ],
+ "deterministicSha256": "28CDA0D2A40F2CA2C41E3A99CCAB6543B43764412B679A25D9050B2B659F949E"
+ },
+ "diagnostics": [
+ {
+ "code": "assembly-interface-incompatible-dimensions",
+ "message": "Mate \u0027Seat\u0027 fit ranges from -5 to -5 mm (nominal -5).",
+ "severity": "Warning"
+ }
+ ],
+ "performance": {
+ "parseMilliseconds": 17.7035,
+ "bindMilliseconds": 5.7029,
+ "mateValidationMilliseconds": 2.4483,
+ "placementMilliseconds": 9.5809,
+ "dimensionalGraphMilliseconds": 3.2976,
+ "toleranceAnalysisMilliseconds": 4.1076,
+ "definitionMaterializationMilliseconds": 273.9934,
+ "geometryExecutionMilliseconds": 41.7308
+ }
+}
diff --git a/docs/assembly/artifacts/m1/tolerance-chain.md b/docs/assembly/artifacts/m1/tolerance-chain.md
new file mode 100644
index 00000000..042a2677
--- /dev/null
+++ b/docs/assembly/artifacts/m1/tolerance-chain.md
@@ -0,0 +1,14 @@
+# Template/Record/Mate tolerance transition evidence
+
+`TemplateFitTransition` in `fixtures/AssemblyM1/template-block-pair.firmament` crosses the dimensional edge generated automatically by `SeatedAxis.Fit`.
+
+- from: `TemplateBlockPair.Moving.Interface.Height` (`MovingSpec`, Template specialization `template:88509cacec6ff417`)
+- to: `TemplateBlockPair.Fixed.Interface.Height` (`FixedSpec`, Template specialization `template:0a30ccff1bd91583`)
+- Mate: `mate:TemplateBlockPair:Seat`
+- Interface: `interface:SeatedAxis`
+- nominal/worst case: `-5mm`
+- requirement: `Clearance >= -5mm`
+- result: passed
+
+The `DimensionalRelationIr.SourceProvenance` and resulting `StackupContributionIr.SourceProvenance` retain both `static-record` and `template-specialization` entries. M0's separate six-edge bearing stack still proves asymmetric tolerances and a 3+ part chain.
+
diff --git a/docs/assembly/assembly-m1.md b/docs/assembly/assembly-m1.md
new file mode 100644
index 00000000..1d3c6c8e
--- /dev/null
+++ b/docs/assembly/assembly-m1.md
@@ -0,0 +1,52 @@
+# Assembly M1: executable semantic product geometry
+
+Assembly M1 keeps M0's product tree, independent Mate graph, typed Interfaces, and symbolic tolerance graph. It adds a definition/materialization seam and a deterministic transformed-instance artifact; transforms remain compiler results, never authoring inputs.
+
+## Canonical path
+
+```text
+Static Record
+ -> ordinary Firmament Template specialization
+ -> ordinary Firmament exact BRep/AP242 build
+ -> Part definition artifact (once per specialization)
+ -> Assembly instance + Mate-derived rigid transform
+ -> transformed exact instance BRep
+ -> world-coordinate semantic bindings
+ -> post-materialization Mate residual validation
+```
+
+The canonical proof is `fixtures/AssemblyM1/template-block-pair.firmament`. A Part tag may apply an existing Firmament Template:
+
+```firmament
+<Part Fixed = AssemblyBlock<Spec: FixedSpec>></Part>
+```
+
+The specialization is compiled by `FirmamentBuildAndExport.CompileSource`; Assembly does not own a parallel geometry generator. The canonical AP242 part result is reimported to the exact BRep path. Definition identity, specialization identity, Static Record provenance, instance identity, and transform are retained separately.
+
+## Runtime and inspection
+
+`AssemblyM1Pipeline` returns AssemblyIR plus an in-memory collection of source definition bodies and transformed instance bodies. The serializable `AssemblyGeometryArtifactIr` contains definition hashes, topology/bounds metrics, instance-to-definition mappings, world transforms, residuals, and a deterministic hash.
+
+```powershell
+dotnet run --project Aetheris.CLI -- asm inspect fixtures/AssemblyM1/template-block-pair.firmament --json
+```
+
+Human-readable inspection includes the product tree, Mates, residuals, a minimal derived BOM, and stackups. JSON distinguishes definition artifacts from instance artifacts.
+
+## World semantics and residual authority
+
+`AssemblyWorldQuery.Resolve` composes an instance's definition-local `ExactAxisBinding`, `ExactPlaneBinding`, `ExactPointBinding`, or exact body with the resolved rigid transform, using double precision. It does not clone authored definitions.
+
+After both participant bodies exist, every admitted Axis/Plane/Point placement constraint is reevaluated in world coordinates. Position and angular residuals are recorded independently of the solver's abstract success. The M1 canonical fixture produces zero residual for its coincident axis and seating plane.
+
+## Dimensional consequences
+
+An Interface `Fit` now lowers a typed clearance transition into AssemblyIR with Mate and Interface identities. Its source provenance includes the endpoint Template specialization and Static Record rows, and that evidence is copied into stackup contributions. The canonical M1 assertion proves the automatic transition from `MovingSpec` to `FixedSpec`; explicit `Relation` remains the bounded way to author other signed dimensional transitions. M0 tolerance paths remain unchanged and green.
+
+## Current boundary
+
+- Template-generated Parts are supported. Template-authored Assembly/subassembly definitions are designed for by definition identity and the retained tree, but are not parsed/materialized in M1.
+- Exact instance BReps are executable and inspectable. Cadmata has not yet gained an Assembly display endpoint.
+- Native AP242 product structure is not emitted. The current exporter creates one PRODUCT/PRODUCT_DEFINITION and one shape representation per body and has no NAUO, mapped-item, or representation-relationship-with-transformation writer. See `docs/assembly/artifacts/m1/ap242-audit.md`.
+- `.firmasm` remains a deprecated transform-first compatibility lane. Its executor/export package is preserved; raw transforms have no Interface meaning. Automated source migration is not implemented.
+- InlineStep/Recognize semantic regions remain exact BRep regions, but current recognizers do not produce AxisCapable, PlaneCapable, or DimensionalCapable values, so they cannot yet satisfy these Assembly Roles.
diff --git a/docs/firmament-v2/artifacts/language-audit-m1/binder-lowering-test-matrix.md b/docs/firmament-v2/artifacts/language-audit-m1/binder-lowering-test-matrix.md
new file mode 100644
index 00000000..2eff3096
--- /dev/null
+++ b/docs/firmament-v2/artifacts/language-audit-m1/binder-lowering-test-matrix.md
@@ -0,0 +1,14 @@
+# Binder, lowering, and test matrix
+
+| Family | Binding/type result | Lowering/consumer | Principal tests | Status |
+|---|---|---|---|---|
+| Values/Records/Tables/Templates | typed static graph + Concept IR source maps | erased before feature AIR | StaticLogic, StaticTablesWithM1, TemplateExpansion, TemplatePattern | Supported |
+| Concepts/Expose/Concept Path | structural conformance + stable semantic members | SemanticValue/Profile/feature AIR | ConceptExpansion, CanonicalAdvancedGrammar | Supported |
+| Primitives/Profile/Compose | feature/constructive AIR | exact BRep + AP242 | PrimitiveLowering/Execution, BuildAndExport | Supported by route |
+| Modify feature families | typed bounded declarations | specialized materializers | Hole, Pattern, EdgeFinish suites | Experimental as a family; tested routes supported |
+| InlineStep/Recognize/Replace | exact imported bindings and bounded regions | Modify/PMI/analysis | InlineStep tests | Supported bounded workflow |
+| PMI | typed bound records | datum/diameter AP242 subset | PMI tests | Experimental overall |
+| FEA Analysis | typed material/region/load/result declarations | AnalysisIR/solver adapters | Aetheris.FEA.Tests | Supported bounded language |
+| Interface/Mate/Assembly | capability binding + placement/dimensional graph | AssemblyIR M0/M1 | AssemblyM0Tests, AssemblyM1Tests | Supported; Template Part Experimental |
+| Assert Volume/Stackup | typed compile-time evidence | build/assembly failure gate | VolumeAssertion, AssemblyM0 | Supported |
+
diff --git a/docs/firmament-v2/artifacts/language-audit-m1/canonical-fixtures.md b/docs/firmament-v2/artifacts/language-audit-m1/canonical-fixtures.md
new file mode 100644
index 00000000..a1880e25
--- /dev/null
+++ b/docs/firmament-v2/artifacts/language-audit-m1/canonical-fixtures.md
@@ -0,0 +1,11 @@
+# Canonical fixture references
+
+- `fixtures/FirmamentV2/Canonical/valid/table-template-concept-path-compose.firmament`: Table/Record/with/Template/Concept Path/Profile/Compose.
+- `fixtures/FirmamentV2/Canonical/valid/inline-step-recognize-replace.firmament`: imported exact workflow.
+- `fixtures/FirmamentV2/Canonical/valid/record-array-pattern-holes.firmament`: Record/static Pattern/Hole.
+- `fixtures/FirmamentV2/Canonical/valid/pmi-projected-hole-diameter-asymmetric-tolerance.firmament`: PMI/tolerance.
+- `fixtures/AssemblyM0/bearing-module.firmament`: Assembly semantics, Interface/Mate, explicit relations, passing stackup.
+- `fixtures/AssemblyM0/bearing-module-failing.firmament`: failing stackup diagnostic.
+- `fixtures/AssemblyM1/template-block-pair.firmament`: Record-driven Template Part materialization, world semantics, geometry residuals, automatic Fit relation.
+- FEA fixtures are exercised by `Aetheris.FEA.Tests` through `FirmamentAnalysisCompiler`.
+
diff --git a/docs/firmament-v2/artifacts/language-audit-m1/dead-legacy-syntax-inventory.md b/docs/firmament-v2/artifacts/language-audit-m1/dead-legacy-syntax-inventory.md
new file mode 100644
index 00000000..484277f7
--- /dev/null
+++ b/docs/firmament-v2/artifacts/language-audit-m1/dead-legacy-syntax-inventory.md
@@ -0,0 +1,12 @@
+# Dead, legacy, and incomplete syntax inventory
+
+- `.firmasm`: Deprecated transform-first JSON/YAML compatibility input; deprecation diagnostic is mandatory.
+- Firmament V1 TOON-style `op`/`expect` fixtures: Legacy regression language, not V2 canonical style.
+- `FirmamentV2TemplateDecl` manufacturing-process AST: Internal/legacy representation used by bounded DFM routes; not canonical generic Template syntax.
+- lowercase/alternate PMI record spellings: compatibility aliases; canonical docs use the named V2 records.
+- Template-authored Assembly/subassembly application: Future/incomplete; no parser/binder/materializer path.
+- native AP242 assembly occurrences and reimport: Future/incomplete; no exporter entities or structural importer result.
+- general equation Relations, recognizer-generated axis/plane/dimension semantics, arbitrary kinematics/contact: Future/incomplete.
+
+No branch met the safe-removal bar of parsed + unbound + untested + unused: broad regex paths overlap current compatibility fixtures. Classification is safer than deletion in M1.
+
diff --git a/docs/firmament-v2/artifacts/language-audit-m1/deterministic-manifest-hash.md b/docs/firmament-v2/artifacts/language-audit-m1/deterministic-manifest-hash.md
new file mode 100644
index 00000000..cb3ab7a4
--- /dev/null
+++ b/docs/firmament-v2/artifacts/language-audit-m1/deterministic-manifest-hash.md
@@ -0,0 +1,7 @@
+# Deterministic language audit hashes
+
+- `language-features.json` SHA-256: `D7836BAE63487BCA11CB2D443643EECEC35087E1E9517E43E47AE49CD682F065`
+- `language-reference.md` SHA-256: `5511C80F7725E49617C1F67B1961550CDD2B391AEC86077E3117751B863C3106`
+
+The manifest is serialized as checked-in canonical JSON and validated by `FirmamentV2LanguageManifestTests`.
+
diff --git a/docs/firmament-v2/artifacts/language-audit-m1/docs-coverage-matrix.md b/docs/firmament-v2/artifacts/language-audit-m1/docs-coverage-matrix.md
new file mode 100644
index 00000000..65f25afa
--- /dev/null
+++ b/docs/firmament-v2/artifacts/language-audit-m1/docs-coverage-matrix.md
@@ -0,0 +1,18 @@
+# Documentation coverage matrix
+
+Before M1, language facts were distributed across milestone/design pages and the public overview omitted active Assembly datum/relationship syntax. After M1:
+
+| Public construct group | Canonical coverage |
+|---|---|
+| Model/Units/values/let/tol | language reference + quickstart |
+| Record/Table/with/Template/Match/Pattern/Require | language reference + canonical fixture links |
+| Concept/Semantic/SemanticValue | language reference with exact distinctions |
+| Point/Axis/Plane/Dimension | language reference with local/world semantics |
+| Geometry/Profile/Compose/Modify/Selection | language reference with bounded-route caveat |
+| InlineStep/Recognize/Replace | language reference with capability limits |
+| FEA | language reference bounded language section |
+| Interface/Role/Lower/Fit/Allow/Assembly/Mate/Anchor/Relation | language reference + Assembly M0/M1 docs |
+| Assert Volume/ToleranceStackup | language reference + test/fixture evidence |
+
+The standalone public website source is outside this repository and was not mutated under the repository-locality rule.
+
diff --git a/docs/firmament-v2/artifacts/language-audit-m1/lexer-token-inventory.md b/docs/firmament-v2/artifacts/language-audit-m1/lexer-token-inventory.md
new file mode 100644
index 00000000..cf24f923
--- /dev/null
+++ b/docs/firmament-v2/artifacts/language-audit-m1/lexer-token-inventory.md
@@ -0,0 +1,12 @@
+# Lexer/token inventory
+
+Firmament V2 has no standalone lexer/token enum. `FirmamentV2Parser` and its cooperating binders use anchored regular-expression productions. The user-facing spelling inventory is therefore:
+
+- roots/declarations: `Model`, `Units`, `Concept`, `Struct`, `Concept Struct`, `Enum`, `Record`, `Static`, `Table`, `Key`, `let`, `Template`, `Require`, `Match`, `Pattern`;
+- semantic/construction: `Expose`, `Concept Path`, `Start`, `Heading`, `Line`, `Arc`, `Close`, `Profile`, `Compose`, `Selection`, `Modify`, `Hole`, `Slot`, `Pattern`, `EdgeFinish`, `InlineStep`, `Recognize`, `Replace`, `PMI`, `Analysis`;
+- assembly: `Semantic`, `Point`, `Axis`, `Plane`, `Dimension`, `Interface`, `Role`, `requires`, `Lower`, `Fit`, `inside`, `Allow`, `Assembly`, `Part`, `Anchor`, `Mate`, `Relation`, `Assert`, `ToleranceStackup`, `Between`, `Clearance`;
+- operators/punctuation: `{ } [ ] ( ) < > : ; , . = -> => + - * / == != < <= > >=`, member access `.`, comments `//`;
+- literal/unit words: `mm`, `deg`, `true`, `false`, `tol`, `PlusMinus`.
+
+Parser consumers are mapped in `language-features.json`. `satisfies` is consumed by Template type parameters; lowercase `requires` only by Role declarations. Keywords found only in legacy V1 parser/fixture lanes are not included as V2-supported tokens.
+
diff --git a/docs/firmament-v2/artifacts/language-audit-m1/parser-production-inventory.md b/docs/firmament-v2/artifacts/language-audit-m1/parser-production-inventory.md
new file mode 100644
index 00000000..eb84f71a
--- /dev/null
+++ b/docs/firmament-v2/artifacts/language-audit-m1/parser-production-inventory.md
@@ -0,0 +1,14 @@
+# Parser production inventory
+
+| Production family | Owning parser | Result |
+|---|---|---|
+| Model/Units/primitives/Modify/InlineStep/Recognize/Replace/PMI/let | `FirmamentV2Parser` | `FirmamentV2Document` AST/bound records |
+| Concept/Concept Struct/Struct/Expose | `ConceptIrResolver` | `ConceptIrDocument` |
+| Record/Static/Table/with/Require/Pattern | `CanonicalStaticAuthoring` | static authoring document + erased source |
+| Template/Match/defaults/satisfies | `FirmamentV2TemplateExpansion` | specialization/source-map evidence + erased source |
+| Concept Path/Profile/Compose/Selection | `ProfileAuthoringParser` plus V2 parser | validated profile/construction declarations |
+| Assembly/Interface/Semantic datum/Relation/Assert stackup | `AssemblyM0Parser` | `AssemblySource` |
+| Analysis/material/constraints/loads/results | `FirmamentAnalysisCompiler` | `AnalysisIR` |
+
+Active AST nodes are those reachable from these results and a consumer. Historical `FirmamentV2TemplateDecl` manufacturing-process records coexist with canonical Template expansion; they are internal legacy representation, not a second public Template grammar.
+
diff --git a/docs/firmament-v2/language-audit-m1.md b/docs/firmament-v2/language-audit-m1.md
new file mode 100644
index 00000000..7c6bc385
--- /dev/null
+++ b/docs/firmament-v2/language-audit-m1.md
@@ -0,0 +1,29 @@
+# Firmament V2 language audit — Assembly M1
+
+## Method
+
+Evidence priority was parser/regex productions, binder/Concept IR/static expansion, regression tests, canonical fixtures, production consumers, then old docs. `Aetheris.Kernel.Firmament/FirmamentV2/FirmamentV2Parser.cs` is a hand-written bounded parser with cooperating parsers (`ConceptIr`, `CanonicalStaticAuthoring`, `FirmamentV2TemplateExpansion`, `ProfileAuthoringParser`) rather than a generated token stream. Therefore the token inventory records source spellings and parser consumers, not a nonexistent token enum.
+
+Assembly relational syntax is currently owned by `AssemblyM0Parser`. This is now documented explicitly; pretending `FirmamentV2Parser` alone defined every supported construct was the largest documentation contradiction.
+
+## Findings
+
+- `satisfies` and `requires` are not synonyms. `satisfies` is Template type-parameter structural conformance; lowercase `requires` is an Assembly Role capability list; `Require` is a compile-time predicate/constraint.
+- `Semantic` is an Assembly semantic member group normalized to SemanticValue, not a general synonym for Concept/Struct.
+- Point/Axis/Plane/Dimension assembly syntax creates exact typed bindings in definition-local millimetres. M1 establishes the world-binding seam without cloning definitions.
+- `Lower` is a finite Interface-to-placement lowering declaration. `Fit` is interval clearance plus a typed dimensional transition. `Allow` admits named residual rigid freedoms.
+- `Relation` is a bounded dimensional graph edge, not general symbolic algebra.
+- Parser breadth is substantially larger than uniformly productionized lowering. Route-specific Hole/Slot/EdgeFinish/PMI/lattice forms are Experimental unless a bounded supported route is identified.
+- Old `.firmasm` and V1 fixture/expect syntax are Legacy/Deprecated and do not define V2.
+
+No parser branches were deleted in this pass: several apparently historical representations share regex paths with active compatibility fixtures, and removal without a generated grammar/token test would be risky. They are classified rather than blessed.
+
+## Deliverables
+
+- Canonical reference: `docs/firmament-v2/language-reference.md`
+- Beginner path: `docs/firmament-v2/quickstart.md`
+- Machine-readable status: `docs/firmament-v2/language-features.json`
+- Evidence matrices: `docs/firmament-v2/artifacts/language-audit-m1/`
+
+Public website source is not contained in the Aetheris repository. The repository documentation is reconciled here; changing the separate website repository would violate this task's repository-locality instruction. That external publication remains a concrete integration task, not an undocumented omission.
+
diff --git a/docs/firmament-v2/language-features.json b/docs/firmament-v2/language-features.json
new file mode 100644
index 00000000..36a47b3f
--- /dev/null
+++ b/docs/firmament-v2/language-features.json
@@ -0,0 +1,39 @@
+{
+ "schema": "aetheris/firmament-v2-language-features/m1",
+ "authorityOrder": ["parser", "binder", "tests", "fixtures", "consumers", "docs"],
+ "features": [
+ {"name":"Model and Units","keywords":["Model","Units"],"status":"Supported","produces":"FirmamentV2Document","consumers":["FirmamentBuildAndExport"],"docs":"language-reference.md#models-values-and-tolerances","evidence":["FirmamentV2Parser.cs","FirmamentV2ParserTests.cs"]},
+ {"name":"let and typed expressions","keywords":["let"],"status":"Supported","produces":"FirmamentV2BoundLet","consumers":["static binder","PMI","templates"],"docs":"language-reference.md#models-values-and-tolerances","evidence":["FirmamentV2Ast.cs","FirmamentV2StaticLogicTests.cs"]},
+ {"name":"tol","keywords":["tol","PlusMinus"],"status":"Supported","produces":"nominal interval","consumers":["PMI","AssemblyIR","stackup"],"docs":"language-reference.md#models-values-and-tolerances","evidence":["FirmamentV2Ast.cs","AssemblyM0Tests.cs"]},
+ {"name":"Record Static Table with","keywords":["Record","Static","Table","Key","with"],"status":"Supported","produces":"compile-time records/rows","consumers":["Template expansion"],"docs":"language-reference.md#records-static-tables-and-with","evidence":["CanonicalStaticAuthoring.cs","FirmamentV2StaticTablesWithM1Tests.cs"]},
+ {"name":"Concept","keywords":["Concept"],"status":"Supported","produces":"structural contract","consumers":["ConceptIrResolver","Template constraints"],"docs":"language-reference.md#concepts-structs-and-semantic-exposure","evidence":["ConceptIr.cs","FirmamentV2ConceptExpansionTests.cs"]},
+ {"name":"Struct and Concept Struct","keywords":["Struct","Concept Struct"],"status":"Supported","produces":"ConceptIr struct/materialized struct","consumers":["feature AIR","SemanticValue"],"docs":"language-reference.md#concepts-structs-and-semantic-exposure","evidence":["ConceptIr.cs","FirmamentV2TemplateExpansionTests.cs"]},
+ {"name":"Expose","keywords":["Expose"],"status":"Supported","produces":"public semantic members","consumers":["SemanticReference","Assembly M1"],"docs":"language-reference.md#concepts-structs-and-semantic-exposure","evidence":["ConceptIr.cs","AssemblyM1Tests.cs"]},
+ {"name":"Point Axis Plane","keywords":["Point","Axis","Plane"],"status":"Supported","produces":"exact datum SemanticValues","consumers":["placement","Assembly world query"],"docs":"language-reference.md#point-axis-plane-and-dimension","evidence":["AssemblyM0Parser.cs","SemanticModel.cs","AssemblyM1Tests.cs"]},
+ {"name":"Dimension","keywords":["Dimension"],"status":"Supported","produces":"DimensionalCapable interval","consumers":["Fit","tolerance graph"],"docs":"language-reference.md#point-axis-plane-and-dimension","evidence":["AssemblyM0Parser.cs","AssemblyM0Tests.cs"]},
+ {"name":"Concept Path","keywords":["Concept Path","Start","Heading","Line","Arc","Close"],"status":"Supported","produces":"validated path semantic","consumers":["Profile","Compose"],"docs":"language-reference.md#profiles-concept-path-compose-and-modify","evidence":["ConceptPathAst.cs","FirmamentV2CanonicalAdvancedGrammarTests.cs"]},
+ {"name":"Profile and Compose","keywords":["Profile","Compose"],"status":"Supported","produces":"ResolvedProfile2D/constructive body","consumers":["AIR materializers"],"docs":"language-reference.md#profiles-concept-path-compose-and-modify","evidence":["ProfileAuthoringParser.cs","FirmamentV2BuildLowering.cs"]},
+ {"name":"Modify Hole Slot Pattern EdgeFinish","keywords":["Modify","Hole","Slot","Pattern","EdgeFinish"],"status":"Experimental","produces":"bounded feature AIR","consumers":["route-specific BRep materializers"],"docs":"language-reference.md#profiles-concept-path-compose-and-modify","evidence":["FirmamentV2Parser.cs","fixtures/FirmamentV2/Canonical"]},
+ {"name":"Selection","keywords":["Selection","Target","Source","Require"],"status":"Supported","produces":"typed selection","consumers":["Modify"],"docs":"language-reference.md#profiles-concept-path-compose-and-modify","evidence":["FirmamentV2Ast.cs","FirmamentV2CanonicalGrammarTests.cs"]},
+ {"name":"Template","keywords":["Template"],"status":"Supported","produces":"deterministic specialization","consumers":["Concept IR","Assembly M1"],"docs":"language-reference.md#templates-match-pattern-and-require","evidence":["FirmamentV2TemplateExpansion.cs","FirmamentV2TemplateExpansionTests.cs"]},
+ {"name":"Match Pattern Require","keywords":["Match","Pattern","Require"],"status":"Supported","produces":"compile-time selection/expansion/gate","consumers":["Template expansion"],"docs":"language-reference.md#templates-match-pattern-and-require","evidence":["CanonicalStaticAuthoring.cs","FirmamentV2TemplatePatternTests.cs"]},
+ {"name":"satisfies","keywords":["satisfies"],"status":"Supported","produces":"Template type conformance constraint","consumers":["Template binder"],"docs":"language-reference.md#concepts-structs-and-semantic-exposure","evidence":["FirmamentV2TemplateExpansion.cs"]},
+ {"name":"SemanticValue","keywords":[],"status":"Supported","produces":"capability/binding/provenance graph","consumers":["Profile","Modify","FEA","Assembly"],"docs":"language-reference.md#semanticreference-and-semanticvalue","evidence":["SemanticModel.cs","FirmamentSemanticValues.cs"]},
+ {"name":"InlineStep Recognize Replace","keywords":["InlineStep","Recognize","Replace"],"status":"Supported","produces":"bounded exact imported semantic regions","consumers":["Modify","PMI","FEA"],"docs":"language-reference.md#inlinestep-recognize-and-replace","evidence":["FirmamentV2Parser.cs","FirmamentV2InlineStepTests.cs"]},
+ {"name":"PMI","keywords":["PMI","Datum","HoleDiameter","Distance","Flatness","Parallel","Perpendicular","Coplanar"],"status":"Experimental","produces":"bound PMI records","consumers":["AP242 datum/diameter export"],"docs":"language-reference.md#inlinestep-recognize-and-replace","evidence":["FirmamentV2Parser.cs","FirmamentPmiTests.cs"]},
+ {"name":"Forge concepts","keywords":[],"status":"Experimental","produces":"typed extension values/SemanticValues","consumers":["ForgeHost","Assembly"],"docs":"language-reference.md#forge","evidence":["FirmamentV2ForgeRuntime.cs","AssemblyM0Tests.cs"]},
+ {"name":"FEA Analysis","keywords":["Analysis","material","fixed","traction","force","pressure","results"],"status":"Supported","produces":"AnalysisIR","consumers":["FEA solver adapters"],"docs":"language-reference.md#fea-analysis-language","evidence":["FirmamentAnalysisCompiler.cs","Aetheris.FEA.Tests"]},
+ {"name":"Semantic group","keywords":["Semantic"],"status":"Supported","produces":"instance-scoped SemanticValue namespace","consumers":["Assembly Roles"],"docs":"language-reference.md#concepts-structs-and-semantic-exposure","evidence":["AssemblyM0Parser.cs","bearing-module.firmament"]},
+ {"name":"Interface Role","keywords":["Interface","Role","requires"],"status":"Supported","produces":"relational role contract","consumers":["Mate binder"],"docs":"language-reference.md#interfaces-mates-and-assemblies","evidence":["AssemblyM0Parser.cs","AssemblyM0Tests.cs"]},
+ {"name":"Lower Fit Allow","keywords":["Lower","Fit","Allow"],"status":"Supported","produces":"placement/dimensional consequences and admitted freedoms","consumers":["placement solver","tolerance graph"],"docs":"language-reference.md#interfaces-mates-and-assemblies","evidence":["AssemblyM0Compiler.cs","AssemblyM1Tests.cs"]},
+ {"name":"Assembly Part Anchor Mate","keywords":["Assembly","Part","Anchor","Mate"],"status":"Supported","produces":"AssemblyIR product tree and Mate graph","consumers":["Assembly M0/M1 pipelines","CLI"],"docs":"language-reference.md#interfaces-mates-and-assemblies","evidence":["AssemblyM0Parser.cs","AssemblyM0Tests.cs"]},
+ {"name":"Template Part application","keywords":["Part","Template"],"status":"Experimental","produces":"materialized reusable definition and occurrence","consumers":["AssemblyM1Pipeline"],"docs":"language-reference.md#interfaces-mates-and-assemblies","evidence":["AssemblyM1Execution.cs","AssemblyM1Tests.cs"]},
+ {"name":"Relation","keywords":["Relation"],"status":"Supported","produces":"bounded dimensional graph edge","consumers":["ToleranceStackup"],"docs":"language-reference.md#interfaces-mates-and-assemblies","evidence":["AssemblyM0Compiler.cs","bearing-module.firmament"]},
+ {"name":"Assert Volume","keywords":["Assert","Volume"],"status":"Supported","produces":"authoritative volume result","consumers":["Firmament build gate"],"docs":"language-reference.md#assertions","evidence":["FirmamentV2VolumeAssertions.cs","FirmamentV2VolumeAssertionTests.cs"]},
+ {"name":"Assert ToleranceStackup","keywords":["Assert","ToleranceStackup"],"status":"Supported","produces":"worst-case stackup result","consumers":["Assembly compile gate"],"docs":"language-reference.md#assertions","evidence":["AssemblyM0Compiler.cs","AssemblyM0Tests.cs"]},
+ {"name":"Lattice Fill","keywords":["Fill","Lattice"],"status":"Experimental","produces":"bounded lattice plan/BRep","consumers":["specialized materializers"],"docs":"language-reference.md#status-appendix","evidence":["FirmamentV2DfmEnforcement.cs","FirmamentV2StandaloneCubicLatticeTests.cs"]},
+ {"name":"legacy firmasm","keywords":[],"status":"Deprecated","produces":"transform-first compatibility assembly","consumers":["FirmasmAssemblyExecutor"],"docs":"../assembly/assembly-m1.md#current-boundary","evidence":["FirmasmManifestLoader.cs","FirmasmAssemblyExecutorTests.cs"]},
+ {"name":"Template subassembly","keywords":["Template","Assembly"],"status":"Future / incomplete","produces":"none","consumers":[],"docs":"../assembly/assembly-m1.md#current-boundary","evidence":[]},
+ {"name":"native AP242 assembly structure","keywords":[],"status":"Future / incomplete","produces":"none","consumers":[],"docs":"../assembly/artifacts/m1/ap242-audit.md","evidence":["Step242Exporter.cs"]}
+ ]
+}
diff --git a/docs/firmament-v2/language-reference.md b/docs/firmament-v2/language-reference.md
new file mode 100644
index 00000000..7275a751
--- /dev/null
+++ b/docs/firmament-v2/language-reference.md
@@ -0,0 +1,159 @@
+# Firmament V2 language reference
+
+This is the canonical implementation-grounded reference for Firmament V2 as of Assembly M1. Parser acceptance alone is not support: each feature below is classified by binding, lowering, tests, and a real consumer. Older milestone documents are historical evidence when they disagree with this page.
+
+## Language model
+
+Firmament is a deterministic, statically evaluated CAD authoring language. Source declarations bind names, units, immutable values, semantic contracts, selections, and construction intent. Compile-time Records, Tables, `with`, Templates, Match, Pattern, and `Require` are erased before feature AIR. Exact geometry lowers through bounded AIR/materializers to BRep and STEP AP242. Tolerance is symbolic engineering intent and does not perturb nominal geometry.
+
+There are two current frontend lanes:
+
+1. the canonical `Model { Units: mm ... }` V2 parser/binder; and
+2. the supported Assembly relational parser for `Interface` plus `Assembly` source. M1 lets its Part tags apply declarations from the adjacent canonical V2 definition catalog.
+
+This split is implementation structure, not two languages. `.firmasm` is a Legacy compatibility format and is not Firmament V2 architecture.
+
+## Lexical structure
+
+Identifiers start with a letter or underscore and continue with letters, digits, or underscore. Keywords are case-sensitive in canonical syntax. `//` starts a line comment. Blocks use braces. Lists use brackets and comma separators. Member/path access uses `.`. Named fields use `:`. Template application uses `<...>`. `=>` belongs to Match arms, Template `Require`, and selected canonical projections—not general lambda syntax.
+
+Numeric literals are invariant-culture decimal/scientific numbers. Implemented engineering suffixes include `mm` and `deg`; canonical Models declare `Units: mm`. Primitive compile-time types are `Int`, `Float`, `Length`, `Angle`, `String`, and `Bool`; Concept IR additionally carries Point/Vector/Axis/Plane/Box/Region/PointSet values.
+
+## Models, values, and tolerances
+
+```firmament
+Model Example {
+ Units: mm
+ let Width: Length = 40mm tol PlusMinus(0.05mm)
+}
+```
+
+`Model` is the ordinary compilation root. `Units` establishes the document length unit. `let` declares an immutable compile-time scalar or record field; dependency evaluation is ordered by an acyclic expression graph. Arithmetic is typed. It is not runtime or mutable state.
+
+`tol` attaches an interval to a nominal Length/Angle value. The implemented canonical forms are bilateral `PlusMinus(value)` and asymmetric `PlusMinus(plus, minus)`; assembly-local `Dimension` and `Relation` also accept `tol 0.02mm` and `tol +0.03mm -0.02mm`. Internally all become nominal, lower, upper, and unit. Arithmetic that would silently lose tolerance is diagnosed. Canonical docs prefer `PlusMinus(...)` in Models and the explicit `+... -...` assembly spelling where asymmetric.
+
+An ordinary `let Length` is a compile-time scalar. An Assembly `Dimension` is a named engineering semantic that carries `DimensionalCapable`, an exact `TolerancedDimensionBinding`, provenance, and participation in fits/stackups.
+
+## Records, Static Tables, and `with`
+
+```firmament
+Record BlockSpec { Width: Length Height: Length Depth: Length }
+Static Table Blocks: BlockSpec Key: Width {
+ Width: [20mm, 40mm]
+ Height: [10mm, 15mm]
+ Depth: [20mm, 40mm]
+}
+Static Base = Blocks[20mm]
+Static Tall = Base with { Height: 15mm }
+```
+
+`Record` defines a structural compile-time product type. `Static Name: Type = Type { ... }` creates an immutable value. `Static Table` is a finite columnar compile-time collection with equal column lengths and an optional typed key. Indexing selects a row. `with` derives a new immutable record while rechecking fields and types. Record, row, derivation, and Template argument provenance survive Template expansion and now survive into Assembly definition artifacts.
+
+## Concepts, Structs, and semantic exposure
+
+`Concept` defines a structural contract for one value/type. `Struct Name: Concept { ... }` and `Concept Struct` bind members and validate structural conformance. A materialized Struct may contain primitives/features and an `Expose` block. Exposed members form its public semantic surface and carry stable IDs into Concept IR.
+
+`satisfies` has one implemented meaning: a Template type parameter must structurally conform to a Concept (`type T satisfies C`). `requires` is not its synonym. Lowercase `requires` belongs to Assembly Role capability requirements. Capitalized `Require` is a compile-time predicate/constraint declaration. These spellings are intentionally distinct and are not interchangeable.
+
+Assembly `Semantic Name { ... }` is a first-class exposed semantic member group on a Part definition/instance. It creates a named `SemanticValue` namespace with structural capabilities aggregated from its members. It is not a `Struct`, a runtime object, or a Concept declaration. M1 Template parts obtain the same normalized seam from their ordinary `Expose` block, currently under the generated `Interface` group.
+
+## Point, Axis, Plane, and Dimension
+
+Assembly-local exact datum syntax is:
+
+```firmament
+Semantic Joint {
+ Point Origin = [0,0,0];
+ Axis Axis = [0,0,0] -> [0,0,1];
+ Plane Seat = [0,0,10] normal [0,0,1];
+ Dimension Diameter = 20mm tol +0.01mm -0.008mm;
+}
+```
+
+- `Point` is a definition-local millimetre coordinate and produces PointCapable + ExactPoint.
+- `Axis` stores a definition-local origin and direction. M0/M1 accept the point-to-direction form above; the direction is normalized by placement/query consumers. It produces AxisCapable + ExactAxis.
+- `Plane` stores a definition-local origin and oriented normal and produces PlaneCapable + ExactPlane. Coincidence currently treats opposite normals as angularly coincident; material-side semantics are not inferred.
+- `Dimension` stores a named nominal scalar interval and produces DimensionalCapable. An optional direction string exists in the semantic binding but Assembly syntax does not author it yet.
+
+Canonical Concept IR also produces exact Point3/Axis/Plane/Length values from expressions such as `Bounds.Center.Axis(+Z)` and `Bounds.Face(+Z)`. M1 converts Template-exposed values into the same Assembly capability/binding seam and composes them with the instance transform for world queries.
+
+## Profiles, Concept Path, Compose, and Modify
+
+`Concept Path` is a compile-time ordered planar construction (`Start`, `Heading`, named `Line`/`Arc`, `Close`). Validation establishes continuity, positive lengths, winding, and a stable provenance identity. `Profile Name From Path` converts an admitted closed path to exact `ResolvedProfile2D` semantics.
+
+`Compose` builds a named bounded constructive body from ordered operations such as profile stock/extrusion. `Modify Target` applies admitted feature families to an already-bound body. Supported families include semantic Hole variants (Shaft, Counterbore, Countersink with ThroughAll/Depth policies), bounded Slot/profile operations, Pattern, and EdgeFinish routes. Support is intentionally route-specific; diagnostics reject unsupported surface/termination/topology combinations rather than claiming a general CAD operation.
+
+`Selection` names a typed, validated set from an exposed/profile/body source and a bounded `Require` such as closed-loop selection. It is semantic selection—not backend topology-ID scripting.
+
+## Templates, Match, Pattern, and Require
+
+```firmament
+Template < Spec: BlockSpec, type T satisfies PrismaticBody >
+Struct Block: BlockConcept {
+ Require Positive => Spec.Width > 0mm
+ // compile-time Match and materialized declarations
+}
+Struct Part = Block < Spec: Standard, T: Box >
+```
+
+Templates accept typed value/Record parameters, type parameters constrained with `satisfies`, and typed defaults. Binding diagnoses missing/unknown/mismatched arguments, default cycles, failed `Require`, and recursive specialization. `Match` is finite compile-time selection over admitted enum/static values. `Pattern` expands a bounded static source into deterministic generated declarations. Specialization occurs before feature AIR and records arguments, defaults, selected Match arms, Record/Table provenance, source spans, and a deterministic specialization identity.
+
+`Require Name => BoolExpression` gates Template/static expansion. Canonical semantic `Require` records may also validate an expected engineering value and project limited PMI. Assembly `Assert ToleranceStackup` uses a `Require: Clearance >= ...` field but is a distinct assertion grammar.
+
+## SemanticReference and SemanticValue
+
+Concept paths and exposed names resolve to `SemanticReference` (value + resolved path + consumer span). The normalized `SemanticValue` carries a stable identity, structural capabilities, exact bindings, exposed children, authored/generated spans, and ordered provenance.
+
+Supported producers are native Firmament concepts/profiles, Template expansion, bounded InlineStep/Recognize, and Forge extensions. Consumers include Profiles/Compose, Selection/Modify, FEA regions, and Assembly Roles. Capability checks are origin-independent. Exact-capability claims require an exact binding.
+
+## InlineStep, Recognize, and Replace
+
+`InlineStep` imports only canonical, exact AP242 accepted by the current importer. `Recognize` attaches bounded region semantics to verified imported face IDs with evidence/confidence; it does not recover arbitrary design history. Recognized values currently expose boundary/selectable/exact/analysis/modify capabilities. `Replace` supports a bounded recognized through-hole rematerialization workflow with verification. Because recognizers do not currently emit AxisCapable/PlaneCapable/DimensionalCapable, recognized regions cannot yet fill those Assembly Roles.
+
+## Forge
+
+Forge concepts are registered typed capabilities with field descriptors. A Forge producer can return validated SemanticValues. Assembly and other consumers dispatch by capability and exact binding, not by Forge/native origin. General arbitrary source-level capability call syntax remains Experimental; the supported public seam is the Forge host/SDK integration and registered concept application tested in the repository.
+
+## FEA analysis language
+
+`Analysis Name { ... }` is parsed by the FEA compiler. The supported bounded declaration includes a source model/InlineStep resource, one isotropic material (elastic modulus and Poisson ratio), fixed-displacement regions, traction vectors, resultant-force vectors, pressure scalars, and requested fields from Displacement, Strain, Stress, and ReactionForce. Regions must resolve through exact semantic bindings. This is compile/lower support to AnalysisIR and solver input, not Assembly FEA.
+
+## Interfaces, Mates, and Assemblies
+
+`Concept` is unary structural semantics; `Interface` is an independent relational contract over named Roles.
+
+```firmament
+Interface SeatedAxis {
+ Role Fixed requires AxisCapable, PlaneCapable;
+ Role Moving requires AxisCapable, PlaneCapable;
+ Lower AxisCoincident Moving.Axis Fixed.Axis;
+ Lower PlaneCoincident Moving.Seat Fixed.Seat;
+ Allow rotation:about-axis;
+}
+```
+
+`Role ... requires ...` states the required capabilities of another semantic participant. `Lower` declares a bounded relational consequence: AxisCoincident, AxisAligned, PlaneCoincident, PointCoincident, or OffsetAlongAxis. It is not a user-defined compiler pass. `Fit A.Diameter inside B.Diameter` evaluates a typed clearance interval and now contributes a typed Mate/Interface dimensional transition. It does not implement ISO fit classes. `Allow` admits a remaining solver freedom (`rotation:about-axis` or `translation:along-axis`); it is neither tolerance relaxation nor multiplicity.
+
+An `Assembly` body contains one XML-like product tree, an `Anchor`, independent `Mate` declarations, optional explicit `Relation`s, and stackup assertions. Part definitions are named after `=`; M1 also admits one Template application, for example `<Part P = Block<Spec: Standard>></Part>`. `Anchor` selects the instance datum whose owning Part receives identity placement. A final transform is a lowered result from Anchor + Mates.
+
+`Relation Name: A -> B = nominal tol ... from "provenance";` is a bounded directed dimensional edge, not an unrestricted equation graph. `Assert ToleranceStackup` finds one deterministic path, sums signed worst-case intervals, retains every contribution, and emits a typed compile failure if its clearance minimum is not met.
+
+## Assertions
+
+- `Assert Volume`: canonical Model assertion evaluated after exact STEP reimport/mass properties; authoritative routes fail the build on mismatch.
+- `Assert ToleranceStackup`: Assembly compile-time worst-case interval assertion with full relation provenance.
+- Historical V1 `expect` validation forms belong to the legacy frontend and are not canonical V2 assertions.
+
+## Status appendix
+
+| Status | Constructs |
+|---|---|
+| Supported | Model, Units, primitive literals/types, let, Record, Static Record/Table/array, indexing, with, Concept, Concept Struct, Struct, Expose, Concept Path, Profile, Compose, bounded Modify/Hole/Pattern/EdgeFinish/Selection, Template, Match, Require, InlineStep, bounded Recognize/Replace, PMI datum/diameter binding, Analysis declarations, SemanticValue, Interface/Role/Lower/Fit/Allow, Assembly/Part/Anchor/Mate/Relation/Dimension/tol, Assert Volume, Assert ToleranceStackup |
+| Experimental | standalone/fill lattice routes, broader PMI controls/export, general Forge source invocation, some Slot/EdgeFinish/Boolean/placement routes, M1 Template Part syntax while the central grammar remains split |
+| Internal-only | AIR/CIR/BRep plans, topology IDs, semantic source maps, Template expansion artifacts, Judgment/route machinery |
+| Legacy/Deprecated | Firmament V1 TOON-style fixture syntax, `.firmasm`, transform-first assembly execution, legacy lowercase/alternate PMI spellings accepted for compatibility |
+| Parser-only / dead | no syntax is promoted solely from an AST type; historical AST `FirmamentV2TemplateDecl` manufacturing-template representation and broad parser regex branches without binder/lowering evidence remain internal/legacy, not public Template syntax |
+| Future/incomplete | Template-authored subassemblies, native AP242 product structure/import, recognizer-produced datum/dimension capabilities, unrestricted symbolic relations, general kinematics/contact/assembly FEA |
+
+The machine-readable status and source evidence are in `language-features.json` and `artifacts/language-audit-m1/`.
+
diff --git a/docs/firmament-v2/quickstart.md b/docs/firmament-v2/quickstart.md
new file mode 100644
index 00000000..45ca9b2a
--- /dev/null
+++ b/docs/firmament-v2/quickstart.md
@@ -0,0 +1,147 @@
+# Firmament V2 quickstart
+
+Firmament is Aetheris's statically evaluated, typed compiler metaprogramming language for engineering intent. The examples below use canonical source and real CLI commands. They are not a second tutorial-only dialect.
+
+## 1. Compile one exact part
+
+```firmament
+Model Plate {
+ Units: mm
+ Box Body { Size: [40mm, 20mm, 8mm] }
+}
+```
+
+Save the source as `plate.firmament`, then validate and build deterministic STEP AP242:
+
+```powershell
+aetheris validate plate.firmament
+aetheris build plate.firmament --output artifacts/plate.step --json
+```
+
+`Model` is the ordinary root and `Units: mm` establishes the document length unit. Exact BRep/STEP is the geometry result; the compiler also retains semantic and source evidence.
+
+## 2. Name engineering semantics
+
+Concepts and `Expose` publish stable semantic members instead of asking downstream tools to rediscover anonymous topology. Canonical Concept IR expressions include `Bounds.Center.Axis(+Z)` and `Bounds.Face(+Z)`. Assembly-local semantics use explicit datums:
+
+```firmament
+Semantic Joint {
+ Point Origin = [0,0,0];
+ Axis Axis = [0,0,0] -> [0,0,1];
+ Plane Seat = [0,0,10] normal [0,0,1];
+ Dimension Diameter = 20mm tol +0.01mm -0.008mm;
+}
+```
+
+Point, Axis, Plane, and Dimension carry capabilities plus exact bindings. Part occurrences compose those local bindings with their instance transforms.
+
+## 3. Move parameters into typed values and Records
+
+`let` is immutable compile-time data. `tol` is a symbolic interval; it never randomly perturbs nominal geometry.
+
+```firmament
+Record BlockSpec {
+ Width: Length
+ Depth: Length
+ Height: Length
+}
+
+Static Standard: BlockSpec = BlockSpec {
+ Width: 20mm
+ Depth: 20mm
+ Height: 10mm
+}
+
+Static Tall = Standard with { Height: 15mm }
+```
+
+`with` creates a new value and rechecks the field names and types. The derivation remains in specialization provenance.
+
+## 4. Put finite standards data in a Static Table
+
+```firmament
+Static Table Blocks: BlockSpec Key: Width {
+ Width: [20mm, 40mm]
+ Depth: [20mm, 40mm]
+ Height: [10mm, 15mm]
+}
+
+Static Small = Blocks[20mm]
+```
+
+Columns must have the same length and keyed lookup is typed. The complete Table/Template/Profile example is `fixtures/FirmamentV2/Canonical/valid/table-template-concept-path-compose.firmament`.
+
+## 5. Specialize a Template
+
+```firmament
+Template < Spec: BlockSpec >
+Struct AssemblyBlock: AssemblyBlockConcept {
+ Require Positive => Spec.Width > 0mm && Spec.Depth > 0mm && Spec.Height > 0mm
+ Concept Struct Design: AssemblyBlockConcept {
+ Bounds: Box3 { Size: [Spec.Width, Spec.Depth, Spec.Height] }
+ Axis: Bounds.Center.Axis(+Z)
+ Seat: Bounds.Face(+Z)
+ Height: Spec.Height
+ }
+ Box Body { Bounds: Design.Bounds }
+ Expose {
+ Bounds: Design.Bounds
+ Axis: Design.Axis
+ Seat: Design.Seat
+ Height: Design.Height
+ }
+}
+```
+
+Template binding checks fields, types, defaults, `Require`, and recursion before feature AIR. The compiler records arguments, defaults, Match arms, source spans, and Record/Table provenance.
+
+## 6. Build a Profile and Compose it
+
+Use `Concept Path` for named ordered planar motion, convert a valid closed Path to a Profile, then use the ordinary Compose/Modify lanes. The canonical complete source is `fixtures/FirmamentV2/Canonical/valid/table-template-concept-path-compose.firmament`.
+
+This separation is useful: Path captures construction intent, Profile is admitted exact planar geometry, Compose builds a body, and Modify applies a supported semantic feature route.
+
+## 7. Bring in existing STEP
+
+The complete `fixtures/FirmamentV2/Canonical/valid/inline-step-recognize-replace.firmament` workflow performs:
+
+```text
+InlineStep -> Recognize -> SemanticValue -> bounded Replace
+```
+
+Recognition binds verified imported face IDs to named semantic regions with evidence. It does not promise arbitrary feature-history recovery. A recognized value can enter Selection, PMI, Modify, or FEA only when its capabilities and exact binding meet that consumer's contract.
+
+## 8. Add a linear-elastic Analysis
+
+`docs/fea/artifacts/m5/plate-with-hole.firmament` is the canonical native plate-with-hole benchmark. Its `Analysis` declares one isotropic material, semantic fixed/load regions, and requested results.
+
+```powershell
+aetheris fea docs/fea/artifacts/m5/plate-with-hole.firmament --out-dir artifacts/plate-fea --json
+```
+
+The command writes AnalysisIR, native displacement/stress results, diagnostics/metrics, and an Abaqus `.inp` verification deck. No commercial Abaqus execution is claimed; running Abaqus requires the user's installation.
+
+## 9. Assemble Template-produced parts
+
+`fixtures/AssemblyM1/template-block-pair.firmament` turns two Static Records into Template-produced Part definitions, instantiates them in one product tree, and relates their exposed semantics through an Interface and Mate.
+
+```powershell
+aetheris asm inspect fixtures/AssemblyM1/template-block-pair.firmament --json
+```
+
+The report distinguishes reusable definitions from occurrences and includes transforms, world bounds, Mate residuals, dimensional transitions, and Template/Record provenance.
+
+## 10. Assert a worst-case tolerance path
+
+`fixtures/AssemblyM0/bearing-module.firmament` combines Shaft/Bore and seated-axis Interfaces with explicit dimensional Relations:
+
+```firmament
+Assert ToleranceStackup AxialReach {
+ Between: [BearingModule.FixedSupport.Housing.Datum, BearingModule.Rotor.Shaft.Shoulder];
+ Require: Clearance >= 44.90mm;
+}
+```
+
+The compiler finds one deterministic path, propagates signed nominal/lower/upper intervals, retains every contribution and provenance string, and fails compilation when the minimum clearance is not met. `bearing-module-failing.firmament` is the intentional negative proof.
+
+Continue with the [definitive language reference](language-reference.md) for exact syntax/status, then use `language-features.json` as the machine-readable feature contract.
diff --git a/docs/preview2/evidence/docsite-m2/build-test-results.md b/docs/preview2/evidence/docsite-m2/build-test-results.md
new file mode 100644
index 00000000..c6586425
--- /dev/null
+++ b/docs/preview2/evidence/docsite-m2/build-test-results.md
@@ -0,0 +1,45 @@
+# P2-DOCSITE-M2 build, test, and rendered QA results
+
+Validated 2026-08-09 on Windows with .NET SDK 10.0.203, TSPack 0.1.8, Vite 6.4.3, and MachinaLayout.JS 0.7.0.
+
+## Aetheris
+
+- `dotnet restore Aetheris.slnx`: passed.
+- `dotnet build Aetheris.slnx -f net10.0 --no-restore /m:1`: passed, 0 warnings, 0 errors.
+- `Aetheris.Kernel.Firmament.Tests`: 1,077 passed.
+- `Aetheris.Semantics.Tests`: 9 passed.
+- `Aetheris.Forge.Sdk.Tests`: 8 passed.
+- `Aetheris.FEA.Tests`: 12 passed.
+- `Aetheris.CLI.Tests`: 355 passed.
+- Total targeted tests: 1,461 passed, 0 failed, 0 skipped.
+
+The exact CLI built all five public geometry sources: bare box, Table/Template/Concept Path, HexBolt, profile bracket, and InlineStep recognize/replace. SurfaceMeshIR OBJ export passed and produced a connected, outward-oriented, watertight mesh. Both public assembly showcases passed `asm inspect`. The plate-with-hole native solve and Abaqus deck export passed. The negative stackup exited 1 with the expected typed diagnostic.
+
+## Public site
+
+- `tspack --version`: 0.1.8.
+- `tspack sync`: passed.
+- `tspack run docs-sync`: passed; 33 language features, 17 platform features, 11 source fixtures, and 2 real visuals.
+- `tspack check`: passed. TSPack reported its standing security notice that 17 acknowledged dependency lifecycle scripts remain blocked; no lifecycle script ran.
+- `tspack check --format`: passed.
+- `tspack run typecheck`: passed.
+- `tspack run test`: 3 passed.
+- `tspack run lint`: passed.
+- `tspack run build`: passed.
+- `tspack run docs-check`: passed; 43 static routes, 10 aliases, 50 feature rows, and 11 canonical fixtures.
+- direct `npm run build`: passed.
+- Production assets: CSS 13.33 kB (3.86 kB gzip); JS 351.56 kB (106.29 kB gzip).
+
+## Rendered QA
+
+In-app Chromium inspection covered the landing page, definitive language reference, assembly guide, tolerance guide, plate-with-hole showcase, Forge host guide, and feature explorer at the default 1280 px viewport. The same shell/reference/explorer/Forge pages were checked at 390×844.
+
+- Required headings, navigation groups, source links, tables, and code blocks rendered.
+- Feature query/status controls updated the MachinaLayout-backed table.
+- No browser console warnings or errors.
+- No document-level horizontal overflow at desktop or mobile widths.
+- Code and tables remain contained and horizontally scrollable.
+- Mobile Contents control exposes the otherwise hidden sidebar.
+- Skip navigation, focus-visible styling, semantic landmarks, labels, and alt text are present.
+
+One defect was found and fixed during QA: C# code blocks did not inherit the Firmament block overflow rule and widened the Forge page. The general code-card rule now contains all languages.
diff --git a/docs/preview2/evidence/docsite-m2/canonical-showcases.md b/docs/preview2/evidence/docsite-m2/canonical-showcases.md
new file mode 100644
index 00000000..dad24d4d
--- /dev/null
+++ b/docs/preview2/evidence/docsite-m2/canonical-showcases.md
@@ -0,0 +1,16 @@
+# Canonical public showcase fixtures
+
+| Showcase | Canonical source | Real validation path | Result |
+|---|---|---|---|
+| First exact part | `fixtures/FirmamentV2/Canonical/valid/bare-box.firmament` | `aetheris build` | passed; authoritative volume assertion passed |
+| Table/Template/Profile | `fixtures/FirmamentV2/Canonical/valid/table-template-concept-path-compose.firmament` | `aetheris build` | passed |
+| HexBolt standards family | `testdata/firmament/examples/hexbolt_template_m2.firmament` | `aetheris build` + `aetheris mesh --format obj --debug-ir` | passed; watertight SurfaceMeshIR output |
+| Profile bracket | `fixtures/FirmamentV2/Canonical/valid/profile-compose-l-bracket-counterbore-pmi.firmament` | `aetheris build` | passed; datum and diameter PMI evidence found |
+| Imported STEP | `fixtures/FirmamentV2/Canonical/valid/inline-step-recognize-replace.firmament` | `aetheris build` | passed; one region recognized/replaced and hybrid STEP verified |
+| Bearing module | `fixtures/AssemblyM0/bearing-module.firmament` | `aetheris asm inspect` | passed; 44.92–45.10 mm path against 44.90 mm minimum |
+| Failing stackup | `fixtures/AssemblyM0/bearing-module-failing.firmament` | `aetheris asm inspect` | expected exit 1; `assembly-tolerance-assertion-failure` |
+| Template block pair | `fixtures/AssemblyM1/template-block-pair.firmament` | `aetheris asm inspect` | passed; definitions/occurrences/placements and source provenance emitted |
+| Plate with hole | `docs/fea/artifacts/m5/plate-with-hole.firmament` | `aetheris fea` | passed; native results and Abaqus deck emitted |
+| Forge host/extension | `tools/Aetheris.Forge.M1Evidence/Program.cs` + `Aetheris.Forge.SampleExtension/SecretGeometryExtension.cs` | Forge SDK test suite | 8/8 passed |
+
+The public site synchronization script reads these sources directly; it does not maintain independent copied snippets.
diff --git a/docs/preview2/evidence/docsite-m2/claim-map.csv b/docs/preview2/evidence/docsite-m2/claim-map.csv
new file mode 100644
index 00000000..6beb4e60
--- /dev/null
+++ b/docs/preview2/evidence/docsite-m2/claim-map.csv
@@ -0,0 +1,13 @@
+public_claim,source_evidence,public_route
+Firmament is statically evaluated compiler metaprogramming,docs/firmament-v2/language-reference.md,/aetheris/firmament/philosophy
+tolerance does not perturb nominal geometry,docs/firmament-v2/language-reference.md,/aetheris/firmament/values-tolerances
+SemanticValue is origin-independent,docs/semantic/architecture.md + Aetheris.Semantics.Tests,/aetheris/firmament/semantics
+recognition is bounded and not arbitrary history recovery,language reference + InlineStep tests,/aetheris/firmament/inline-step
+Forge host performs typed Template invocation,docs/forge/invocation-sdk.md + Aetheris.Forge.Sdk.Tests,/aetheris/forge/host-sdk
+Forge extension can return exact BRep CIR and semantic members,Aetheris.Forge.SampleExtension + Forge SDK tests,/aetheris/forge/extension-sdk
+SurfaceMeshIR precedes OBJ/STL triangulation,Preview 2 mesh evidence + current CLI run,/aetheris/geometry/surface-mesh-ir
+BRep and CIR dual-lower from shared intent,docs/preview2/feature-manifest.json,/aetheris/analysis/continuum
+FEA supports bounded linear isotropic elasticity,docs/fea/firmament-analysis.md + Aetheris.FEA.Tests,/aetheris/analysis/fea
+Assembly structure is a tree and Mate topology a graph,docs/assembly/architecture.md + Assembly tests,/aetheris/assemblies/interfaces-mates
+stackup is deterministic signed interval propagation,docs/assembly/tolerance-stackup.md + bearing fixtures,/aetheris/assemblies/tolerance-stackup
+no top-level Forge CLI exists,Aetheris.CLI --help and `aetheris forge --help` failure,/aetheris/cli
diff --git a/docs/preview2/evidence/docsite-m2/consistency-report.md b/docs/preview2/evidence/docsite-m2/consistency-report.md
new file mode 100644
index 00000000..3fd940b8
--- /dev/null
+++ b/docs/preview2/evidence/docsite-m2/consistency-report.md
@@ -0,0 +1,14 @@
+# Cross-repository consistency report
+
+| Area | Public statement | Verified source | Result |
+|---|---|---|---|
+| Firmament status | 33 feature rows with Supported/Experimental/Legacy/Future boundaries | `language-features.json` + manifest test | synchronized by hash |
+| FEA | bounded linear isotropic elasticity; native/imported admitted domains; fixed/traction/force/pressure; Abaqus deck only | FEA docs, 12 tests, current CLI solve | consistent |
+| Assembly | Interface Roles, Lower/Fit/Allow, product tree, Mate graph, transforms, dimensional graph, worst-case assertion | Assembly source/tests and both `asm inspect` fixtures | consistent |
+| Forge | typed Template host; explicitly registered bounded extensions; exact/CIR/semantic output | Forge docs, sample extension, 8 SDK tests | consistent |
+| SurfaceMeshIR | structured polygons/quads before target triangulation; OBJ/STL; bounded support families | feature manifest and current HexBolt CLI mesh | consistent |
+| Continuum | BRep boundary/topology authority and CIR occupancy dual-lowering; SDF is a backend | Preview 2 feature manifest + Continuum docs | consistent |
+| Imported STEP | exact bounded import/recognition; no arbitrary history recovery | language reference + InlineStep build evidence | consistent |
+| CLI | `build`, `inspect`, `mesh`, `fea`, and `asm inspect` flags | real command help + executed commands | consistent |
+
+Two drift hazards were removed: the public site no longer consumes `preview1-capabilities.json`, and generated public prose/examples now reference a checked-in Preview 2 snapshot with source hashes. Current docsite validation measurements live in `measured-results.json`; they intentionally supersede older milestone result numbers for the public showcase.
diff --git a/docs/preview2/evidence/docsite-m2/public-doc-coverage.csv b/docs/preview2/evidence/docsite-m2/public-doc-coverage.csv
new file mode 100644
index 00000000..37f41b15
--- /dev/null
+++ b/docs/preview2/evidence/docsite-m2/public-doc-coverage.csv
@@ -0,0 +1,19 @@
+topic,before,after,public_route,authority
+Firmament language reference,partial,definitive,/aetheris/reference/language,docs/firmament-v2/language-reference.md
+progressive quickstart,partial,complete,/aetheris/getting-started,docs/firmament-v2/quickstart.md
+language philosophy,absent,complete,/aetheris/firmament/philosophy,language reference + Forge architecture
+let and tol,partial,complete,/aetheris/firmament/values-tolerances,language reference
+Record Table with Template,partial,complete,/aetheris/firmament/records-tables-templates,language reference + canonical fixtures
+SemanticValue,absent,complete,/aetheris/firmament/semantics,docs/semantic/architecture.md
+Point Axis Plane Dimension,absent,complete,/aetheris/firmament/datums-dimensions,language reference + assembly tests
+InlineStep Recognize Replace,partial,complete,/aetheris/firmament/inline-step,canonical fixture + semantic evidence
+Forge host SDK,absent,complete,/aetheris/forge/host-sdk,docs/forge/invocation-sdk.md + evidence program
+Forge extension SDK,absent,complete,/aetheris/forge/extension-sdk,sample extension + extension-sdk.md
+SurfaceMeshIR,absent,complete,/aetheris/geometry/surface-mesh-ir,Preview 2 evidence + CLI
+Continuum,absent,complete,/aetheris/analysis/continuum,Continuum M4/M4C docs + manifest
+linear elasticity FEA,absent,complete,/aetheris/analysis/fea,FEA docs/tests/current artifacts
+Interfaces Roles Mates,absent,complete,/aetheris/assemblies/interfaces-mates,assembly docs/tests
+tolerance stackup,absent,complete,/aetheris/assemblies/tolerance-stackup,assembly fixture/tests
+feature status,Preview 1 freeze,generated Preview 2 explorer,/aetheris/reference/features,language-features.json + feature-manifest.json
+LLM guidance,Preview 1 syntax context,Preview 2 tool-author workflow,/aetheris/for-llms,public reference + CLI diagnostics
+CLI,stale/partial,current help-verified commands,/aetheris/cli,Aetheris.CLI --help outputs
diff --git a/docs/preview2/evidence/docsite-m2/public-site-audit.md b/docs/preview2/evidence/docsite-m2/public-site-audit.md
new file mode 100644
index 00000000..8edc1101
--- /dev/null
+++ b/docs/preview2/evidence/docsite-m2/public-site-audit.md
@@ -0,0 +1,31 @@
+# P2-DOCSITE-M2 public-site audit
+
+Audit performed before the Preview 2 rewrite on 2026-08-09.
+
+## Existing architecture
+
+- React 19/Vite SPA with TSPack-managed dependencies and static HTML copies for each Aetheris route.
+- 21 Aetheris routes in one hand-authored `content.ts`; custom CSS grid shell, sidebar, rail, mobile drawer, code renderer, and keyword search.
+- One synchronization script copied the Preview 1 capability freeze and verified linked fixture paths.
+- No MachinaLayout.JS dependency, no site test target, and no lint target in the TSPack manifest.
+
+## Content and navigation findings
+
+- Global and manual branding said Preview 1.
+- Navigation covered exact CAD authoring well but did not expose Assembly, FEA, Forge, Continuum, or SurfaceMeshIR as first-class systems.
+- SemanticValue, Point/Axis/Plane/Dimension, tolerance propagation, Template-produced assemblies, and the tree-versus-Mate-graph model were absent or scattered.
+- The language reference was a short manually duplicated summary rather than the authoritative Firmament V2 reference.
+- Status UI read `preview1-capabilities.json`; it could not represent the current language audit plus Preview 2 platform manifest.
+- Existing STEP content covered bounded recognition but did not connect imported/native/Forge values through the common semantic contract.
+- CLI examples predated current `asm inspect`, `fea`, and SurfaceMeshIR flags.
+
+## Implementation and layout findings
+
+- Useful foundations: stable routes, readable engineering visual language, responsive table wrappers, source attribution, and static route generation.
+- Friction: one large content module, manual discriminated-union rendering, no copy button, limited deep-link/reference rendering, and a fixed three-column shell whose rail disappears at tablet width.
+- Mobile had a drawer and horizontal code/table overflow, but focus visibility, skip navigation, dialog semantics, long feature matrices, and code toolbar behavior needed work.
+- There was no site-local test coverage for routes, headings, feature status, aliases, or synchronized fixture content.
+
+## Disposition
+
+The rewrite preserved the SPA, stable routes, typography, colors, and restrained square-edged engineering identity. It replaced the stale data boundary and navigation model instead of redesigning the entire site.
diff --git a/docs/preview2/evidence/docsite-m2/route-inventory.md b/docs/preview2/evidence/docsite-m2/route-inventory.md
new file mode 100644
index 00000000..d71f1990
--- /dev/null
+++ b/docs/preview2/evidence/docsite-m2/route-inventory.md
@@ -0,0 +1,14 @@
+# Public route inventory
+
+The Preview 2 site publishes 33 canonical pages in eight navigation groups:
+
+- Start: overview, getting started, Why Aetheris.
+- Firmament V2: philosophy, language tour, values/tolerances, Records/Tables/Templates, semantics, datums/dimensions, Profiles/Compose, InlineStep, language reference, feature status.
+- Forge: host SDK, extension SDK, capability lifecycle.
+- Geometry: exact BRep, SurfaceMeshIR.
+- Analysis: Continuum, FEA.
+- Assemblies: Interfaces/Mates, tolerance stackup.
+- Examples: bearing module, Template block pair, plate with hole, imported STEP.
+- Tools & reference: CLI, cookbook, LLM/tool authors, architecture, VS Code, diagnostics, compatibility.
+
+Ten Preview 1 paths remain aliases, including Concept Path, static authoring, mechanical feature pages, existing STEP, verification, and support status. Vite emits static HTML for all 43 stable routes.
diff --git a/fixtures/AssemblyM1/template-block-pair.firmament b/fixtures/AssemblyM1/template-block-pair.firmament
new file mode 100644
index 00000000..824d0ae0
--- /dev/null
+++ b/fixtures/AssemblyM1/template-block-pair.firmament
@@ -0,0 +1,70 @@
+// Canonical M1 proof: Static Record -> Template specialization -> ordinary part -> Assembly instance.
+Concept AssemblyBlockConcept {
+ Bounds: Box3
+ Axis: Axis
+ Seat: Plane
+ Height: Length
+}
+
+Record BlockSpec {
+ Width: Length
+ Depth: Length
+ Height: Length
+}
+
+Static FixedSpec: BlockSpec = BlockSpec { Width: 20mm Depth: 20mm Height: 10mm }
+Static MovingSpec: BlockSpec = BlockSpec { Width: 12mm Depth: 12mm Height: 15mm }
+
+Template < Spec: BlockSpec >
+Struct AssemblyBlock: AssemblyBlockConcept {
+ Require Positive => Spec.Width > 0mm && Spec.Depth > 0mm && Spec.Height > 0mm
+ Concept Struct Design: AssemblyBlockConcept {
+ Bounds: Box3 { Size: [Spec.Width, Spec.Depth, Spec.Height] }
+ Axis: Bounds.Center.Axis(+Z)
+ Seat: Bounds.Face(+Z)
+ Height: Spec.Height
+ }
+ Box Body { Bounds: Design.Bounds }
+ Modify Body {
+ EdgeFinish ProofBreak {
+ Face: Design.Seat
+ Target: Boundary
+ Kind: Chamfer
+ Distance: 1mm
+ }
+ }
+ Expose {
+ Bounds: Design.Bounds
+ Axis: Design.Axis
+ Seat: Design.Seat
+ Height: Design.Height
+ }
+}
+
+Interface SeatedAxis {
+ Role Fixed requires AxisCapable, PlaneCapable, DimensionalCapable;
+ Role Moving requires AxisCapable, PlaneCapable, DimensionalCapable;
+ Lower AxisCoincident Moving.Axis Fixed.Axis;
+ Lower PlaneCoincident Moving.Seat Fixed.Seat;
+ Fit Moving.Height inside Fixed.Height;
+ Allow rotation:about-axis;
+}
+
+Assembly TemplateBlockPair {
+ <Assembly TemplateBlockPair>
+ <Part Fixed = AssemblyBlock<Spec: FixedSpec>></Part>
+ <Part Moving = AssemblyBlock<Spec: MovingSpec>></Part>
+ </Assembly>
+
+ Anchor: TemplateBlockPair.Fixed.Interface;
+
+ Mate Seat: SeatedAxis {
+ Fixed: TemplateBlockPair.Fixed.Interface;
+ Moving: TemplateBlockPair.Moving.Interface;
+ }
+
+ Assert ToleranceStackup TemplateFitTransition {
+ Between: [TemplateBlockPair.Moving.Interface.Height, TemplateBlockPair.Fixed.Interface.Height];
+ Require: Clearance >= -5mm;
+ }
+}