Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add typed assembly inspection and deprecate legacy firmasm
Yuechen Li35a5ee3fca56
diff --git a/Aetheris.CLI.Tests/AssemblyM0CliTests.cs b/Aetheris.CLI.Tests/AssemblyM0CliTests.csnew file mode 100644index 00000000..2030e6b4--- /dev/null+++ b/Aetheris.CLI.Tests/AssemblyM0CliTests.cs@@ -0,0 +1,45 @@+using System.Text.Json;++namespace Aetheris.CLI.Tests;++public sealed class AssemblyM0CliTests+{+ [Fact]+ public void AsmInspect_EmitsMachineReadableAssemblyIr()+ {+ var root = FindRepoRoot();+ var path = Path.Combine(root, "fixtures", "AssemblyM0", "bearing-module.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.True(json.RootElement.GetProperty("success").GetBoolean());+ var ir = json.RootElement.GetProperty("assemblyIr");+ Assert.Equal("aetheris/assembly-ir/m0", ir.GetProperty("schema").GetString());+ Assert.Equal(2, ir.GetProperty("mates").GetArrayLength());+ Assert.Equal("passed", ir.GetProperty("toleranceStackups")[0].GetProperty("status").GetString());+ Assert.Empty(stderr.ToString());+ }++ [Fact]+ public void AsmInspect_FailingAssertReturnsFailureJsonWithChain()+ {+ var root = FindRepoRoot();+ var path = Path.Combine(root, "fixtures", "AssemblyM0", "bearing-module-failing.firmament");+ var stdout = new StringWriter(); var stderr = new StringWriter();+ var exit = Aetheris.CLI.CliRunner.Run(["asm", "inspect", path, "--json"], stdout, stderr);+ Assert.Equal(1, exit);+ using var json = JsonDocument.Parse(stdout.ToString());+ Assert.False(json.RootElement.GetProperty("success").GetBoolean());+ Assert.Equal(5, json.RootElement.GetProperty("assemblyIr").GetProperty("toleranceStackups")[0].GetProperty("contributions").GetArrayLength());+ Assert.Contains(json.RootElement.GetProperty("diagnostics").EnumerateArray(), x => x.GetProperty("code").GetString() == "assembly-tolerance-assertion-failure");+ }++ private static string FindRepoRoot()+ {+ var directory = new DirectoryInfo(AppContext.BaseDirectory);+ while (directory is not null)+ { if (File.Exists(Path.Combine(directory.FullName, "Aetheris.slnx"))) return directory.FullName; directory = directory.Parent; }+ throw new InvalidOperationException("Unable to locate repository root.");+ }+}diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.csindex c60091bc..b9d40e4a 100644--- a/Aetheris.CLI/CliRunner.cs+++ b/Aetheris.CLI/CliRunner.cs@@ -140,6 +140,7 @@ public static class CliRunnerprivate const string CanonUsage = "Usage: aetheris canon <file.step> --out <canonical.step> [--mode deterministic|production] [--json]";private const string AsmExecUsage = "Usage: aetheris asm exec <file.firmasm> [--json]";private const string AsmExportUsage = "Usage: aetheris asm export <file.firmasm> --out <directory> [--json]";+ private const string AsmInspectUsage = "Usage: aetheris asm inspect <assembly.firmament> [--json] [--profile] [--out <report.json>]";private const string ExperimentalUsage = "Usage: aetheris experimental <airchamfer-cube|airchamfer-corpus|prismatic-corpus|prismatic-map|loop-chamfer-corpus> [options]";private const string ExperimentalAirChamferCubeUsage = "Usage: aetheris experimental airchamfer-cube --out <path> [--json]";private const string ExperimentalAirChamferCorpusUsage = "Usage: aetheris experimental airchamfer-corpus --out-dir <dir> [--json]";@@ -2518,6 +2519,11 @@ public static class CliRunnerreturn RunAsmExec(args.Skip(1).ToArray(), stdout, stderr);}+ if (string.Equals(args[0], "inspect", StringComparison.Ordinal))+ {+ return RunAsmInspect(args.Skip(1).ToArray(), stdout, stderr);+ }+if (string.Equals(args[0], "export", StringComparison.Ordinal)){return RunAsmExport(args.Skip(1).ToArray(), stdout, stderr);@@ -2526,9 +2532,63 @@ public static class CliRunnerstderr.WriteLine($"Unknown asm subcommand '{args[0]}'.");stderr.WriteLine(AsmExecUsage);stderr.WriteLine(AsmExportUsage);+ stderr.WriteLine(AsmInspectUsage);return 1;}+ private static int RunAsmInspect(string[] args, TextWriter stdout, TextWriter stderr)+ {+ if (args.Length == 0 || IsHelpFlag(args[0]))+ {+ (args.Length == 0 ? stderr : stdout).WriteLine(AsmInspectUsage);+ return args.Length == 0 ? 1 : 0;+ }+ var path = args[0];+ var json = false;+ var profile = false;+ string? outputPath = null;+ for (var i = 1; i < args.Length; i++)+ {+ if (args[i] == "--json") json = true;+ else if (args[i] == "--profile") profile = true;+ else if (args[i] == "--out" && i + 1 < args.Length) outputPath = args[++i];+ 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);+ if (outputPath is not null)+ {+ var fullOutputPath = Path.GetFullPath(outputPath);+ Directory.CreateDirectory(Path.GetDirectoryName(fullOutputPath)!);+ File.WriteAllText(fullOutputPath, reportJson + Environment.NewLine);+ }+ if (json)+ {+ stdout.WriteLine(reportJson);+ }+ else if (result.Ir is { } ir)+ {+ stdout.WriteLine($"Assembly: {ir.Name} ({ir.Schema})");+ stdout.WriteLine("Product tree:");+ foreach (var instance in ir.Instances.OrderBy(x => x.Path.Segments.Count).ThenBy(x => x.Path.ToString(), StringComparer.Ordinal))+ stdout.WriteLine($"{new string(' ', (instance.Path.Segments.Count - 1) * 2)}- {instance.Path.Segments[^1]} [{instance.Kind}] = {instance.DefinitionIdentity}");+ 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))})");+ 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)+ (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}");+ }+ return result.IsSuccess ? 0 : 1;+ }+private static int RunAsmExec(string[] args, TextWriter stdout, TextWriter stderr){if (args.Length == 0)@@ -2607,14 +2667,17 @@ public static class CliRunnerpartCount = execute.Value.LoadedAssembly.LoadedParts.Count,instanceCount = execute.Value.Instances.Count,bodyCount = execute.Value.ComposedBody.Topology.Bodies.Count(),- shellCount = execute.Value.ComposedBody.Topology.Shells.Count(),- boundingBox = analysis.Summary.BoundingBox,- analysis+ shellCount = execute.Value.ComposedBody.Topology.Shells.Count(),+ boundingBox = analysis.Summary.BoundingBox,+ analysis,+ diagnostics = execute.Diagnostics.Select(d => new { d.Source, d.Message, severity = d.Severity.ToString() })}, JsonOptions));return 0;}stdout.WriteLine($"ASM execution succeeded: {execute.Value.LoadedAssembly.Manifest.Assembly.Name}");+ foreach (var diagnostic in execute.Diagnostics)+ stderr.WriteLine($"- [{diagnostic.Severity}] {diagnostic.Source}: {diagnostic.Message}");stdout.WriteLine($"Parts: {execute.Value.LoadedAssembly.LoadedParts.Count}");stdout.WriteLine($"Instances: {execute.Value.Instances.Count}");stdout.WriteLine($"Bodies: {execute.Value.ComposedBody.Topology.Bodies.Count()}");@@ -3599,10 +3662,11 @@ public static class CliRunnerprivate static void WriteAsmHelp(TextWriter stdout){- stdout.WriteLine("Execute flattened .firmasm assemblies as rigidly placed body instances, or export STEP interop packages.");+ stdout.WriteLine("Inspect typed Firmament assemblies, or use the deprecated flat .firmasm compatibility runtime/export lane.");stdout.WriteLine();stdout.WriteLine(AsmExecUsage);stdout.WriteLine($" or: {AsmExportUsage[7..]}");+ stdout.WriteLine($" or: {AsmInspectUsage[7..]}");stdout.WriteLine();stdout.WriteLine("Options:");stdout.WriteLine(" --out <path> Required for 'asm export'; output directory for package artifacts.");@@ -3612,6 +3676,7 @@ public static class CliRunnerstdout.WriteLine("Example:");stdout.WriteLine(" aetheris asm exec testdata/firmasm/examples/occt-as1/as1-assembly.firmasm --json");stdout.WriteLine(" aetheris asm export testdata/firmasm/examples/occt-nut-bolt/nut-bolt-assembly.firmasm --out tmp/nutbolt-export --json");+ stdout.WriteLine(" aetheris asm inspect fixtures/AssemblyM0/bearing-module.firmament --json");}private static string FormatBox(Aetheris.Kernel.Core.Math.BoundingBox3D? box) =>diff --git a/Aetheris.Kernel.Firmament.Tests/Assembly/AssemblyM0Tests.cs b/Aetheris.Kernel.Firmament.Tests/Assembly/AssemblyM0Tests.csnew file mode 100644index 00000000..197abb3d--- /dev/null+++ b/Aetheris.Kernel.Firmament.Tests/Assembly/AssemblyM0Tests.cs@@ -0,0 +1,206 @@+using System.Text.Json;+using Aetheris.Kernel.Firmament.Assembly;+using Aetheris.Semantics;++namespace Aetheris.Kernel.Firmament.Tests.Assembly;++public sealed class AssemblyM0Tests+{+ [Fact]+ public void BearingModule_CompilesTreeMatesPlacementFitAndAutomaticStackup()+ {+ var path = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/AssemblyM0/bearing-module.firmament");+ var result = new AssemblyM0Pipeline().CompileFile(path);++ Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(x => $"{x.Code}: {x.Message}")));+ var ir = Assert.IsType<AssemblyIr>(result.Ir);+ Assert.Equal("aetheris/assembly-ir/m0", ir.Schema);+ Assert.Equal(7, ir.Instances.Count);+ Assert.Equal(2, ir.Interfaces.Count);+ Assert.Equal(2, ir.Mates.Count);+ Assert.Equal(3, ir.PlacementConstraints.Count);+ Assert.Contains(ir.Placements, x => x.Status == PlacementStatus.Anchored);+ Assert.Contains(ir.Placements, x => x.Status == PlacementStatus.Resolved && x.Transform is not null);+ var shaftPlacement = ir.Placements.Single(x => x.InstanceStableId.EndsWith(":BearingModule.Rotor.Shaft", StringComparison.Ordinal));+ var bearingPlacement = ir.Placements.Single(x => x.InstanceStableId.EndsWith(":BearingModule.FixedSupport.Bearing", StringComparison.Ordinal));+ Assert.Equal(-15, shaftPlacement.Transform!.Matrix[14], 8);+ Assert.Equal(-15, bearingPlacement.Transform!.Matrix[14], 8);++ var fit = Assert.Single(ir.FitResults);+ Assert.Equal(0.02, fit.NominalClearance, 8);+ Assert.Equal(0.002, fit.WorstCaseMinimum, 8);+ Assert.Equal(0.03, fit.WorstCaseMaximum, 8);++ var stack = Assert.Single(ir.ToleranceStackups);+ Assert.True(stack.Passed);+ Assert.Equal(6, stack.Contributions.Count);+ Assert.Equal(45, stack.Nominal, 8);+ Assert.Equal(44.92, stack.WorstCaseMinimum, 8);+ Assert.Equal(45.10, stack.WorstCaseMaximum, 8);+ Assert.Contains(stack.Contributions, x => x.Provenance == "BearingTable.6204.Width");+ Assert.Contains(stack.Contributions, x => x.Provenance == "SpacerTemplate.Width");+ }++ [Fact]+ public void RepeatedCompilation_IsDeterministicExceptPerformanceTelemetry()+ {+ var path = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/AssemblyM0/bearing-module.firmament");+ var pipeline = new AssemblyM0Pipeline();+ var first = pipeline.CompileFile(path).Ir!;+ var second = pipeline.CompileFile(path).Ir!;+ var options = new JsonSerializerOptions { WriteIndented = true };+ Assert.Equal(JsonSerializer.Serialize(first, options), JsonSerializer.Serialize(second, options));+ Assert.Equal(first.Instances.Select(x => x.StableId), second.Instances.Select(x => x.StableId));+ Assert.Equal(first.Mates.Select(x => x.StableId), second.Mates.Select(x => x.StableId));+ }++ [Fact]+ public void SameDefinitionInstances_HaveDistinctInstanceScopedSemanticIdentities()+ {+ const string source = """+ Assembly Pair {+ <Assembly Pair>+ <Part Left = Bolt> Semantic Shank { Axis Axis = [0,0,0] -> [0,0,1]; } </Part>+ <Part Right = Bolt> Semantic Shank { Axis Axis = [0,0,0] -> [0,0,1]; } </Part>+ </Assembly>+ Anchor: Pair.Left.Shank;+ }+ """;+ var result = new AssemblyM0Compiler().Compile(new AssemblyM0Parser().Parse(source).Source!);+ var left = result.Ir!.Instances.Single(x => x.Path.ToString() == "Pair.Left");+ var right = result.Ir.Instances.Single(x => x.Path.ToString() == "Pair.Right");+ Assert.Equal(left.DefinitionIdentity, right.DefinitionIdentity);+ Assert.NotEqual(left.SemanticRoot.ExposedMembers["Shank"].StableIdentity, right.SemanticRoot.ExposedMembers["Shank"].StableIdentity);+ }++ [Fact]+ public void InterfaceParser_AdmitsNRoleRelationalIr()+ {+ const string source = """+ Interface ThreePlate {+ Role PlateA requires PlaneCapable;+ Role PlateB requires PlaneCapable;+ Role Fastener requires AxisCapable;+ Lower PlaneCoincident PlateA.Seat PlateB.Seat;+ }+ Assembly Three { <Assembly Three><Part P = Plate> Semantic S { Point P = [0,0,0]; } </Part></Assembly> Anchor: Three.P.S; }+ """;+ var parsed = new AssemblyM0Parser().Parse(source);+ Assert.True(parsed.IsSuccess, string.Join(Environment.NewLine, parsed.Diagnostics.Select(x => x.Message)));+ Assert.Equal(3, Assert.Single(parsed.Source!.Interfaces).Roles.Count);+ }++ [Fact]+ public void MissingRoleAndCapabilityMismatch_AreTypedDiagnostics()+ {+ const string source = """+ Interface PinHole { Role Pin requires AxisCapable; Role Hole requires AxisCapable; }+ Assembly Bad {+ <Assembly Bad><Part Thing = Block> Semantic Datum { Point Point = [0,0,0]; } </Part></Assembly>+ Anchor: Bad.Thing.Datum;+ Mate Broken: PinHole { Pin: Bad.Thing.Datum; }+ }+ """;+ var parsed = new AssemblyM0Parser().Parse(source);+ var result = new AssemblyM0Compiler().Compile(parsed.Source!);+ Assert.Contains(result.Diagnostics, x => x.Code == AssemblyM0Compiler.MissingRole);+ Assert.Contains(result.Diagnostics, x => x.Code == AssemblyM0Compiler.CapabilityMismatch);+ }++ [Fact]+ public void FailingStackup_ReportsTypedFailureAndPreservesFullChain()+ {+ var path = FirmamentCorpusHarness.ResolveFixtureFullPath("fixtures/AssemblyM0/bearing-module-failing.firmament");+ var result = new AssemblyM0Pipeline().CompileFile(path);+ Assert.False(result.IsSuccess);+ Assert.Contains(result.Diagnostics, x => x.Code == AssemblyM0Compiler.ToleranceAssertionFailure);+ var stack = Assert.Single(result.Ir!.ToleranceStackups);+ Assert.False(stack.Passed);+ Assert.Equal(5, stack.Contributions.Count);+ Assert.Equal(44.92, stack.WorstCaseMinimum, 8);+ }++ [Fact]+ public void AxisOnlyInterfaceWithoutAdmittedFreedom_IsUnderconstrained()+ {+ const string source = """+ Interface AxisOnly {+ Role A requires AxisCapable;+ Role B requires AxisCapable;+ Lower AxisCoincident A.Axis B.Axis;+ }+ Assembly Free {+ <Assembly Free>+ <Part A = Pin> Semantic Joint { Axis Axis = [0,0,0] -> [0,0,1]; } </Part>+ <Part B = Hole> Semantic Joint { Axis Axis = [1,0,0] -> [0,0,1]; } </Part>+ </Assembly>+ Anchor: Free.A.Joint;+ Mate M: AxisOnly { A: Free.A.Joint; B: Free.B.Joint; }+ }+ """;+ var result = new AssemblyM0Compiler().Compile(new AssemblyM0Parser().Parse(source).Source!);+ Assert.Contains(result.Diagnostics, x => x.Code == AssemblyM0Compiler.Underconstrained);+ var placement = result.Ir!.Placements.Single(x => x.InstanceStableId.EndsWith(":Free.B", StringComparison.Ordinal));+ Assert.Equal(["along-axis"], placement.FreeTranslations);+ Assert.Equal(["about-axis"], placement.FreeRotations);+ }++ [Fact]+ public void ConflictingMates_AreOverconstrainedWithTypedDiagnostic()+ {+ const string source = """+ Interface AxisJoin {+ Role Moving requires AxisCapable;+ Role Fixed requires AxisCapable;+ Lower AxisCoincident Moving.AxisA Fixed.AxisA;+ Lower AxisCoincident Moving.AxisB Fixed.AxisB;+ Allow translation:along-axis;+ Allow rotation:about-axis;+ }+ Assembly Conflict {+ <Assembly Conflict>+ <Part Moving = Pin> Semantic Joint { Axis AxisA = [0,0,0] -> [0,0,1]; Axis AxisB = [0,0,0] -> [0,0,1]; } </Part>+ <Part Fixed = Block> Semantic Joint { Axis AxisA = [0,0,0] -> [0,0,1]; Axis AxisB = [10,0,0] -> [0,0,1]; } </Part>+ </Assembly>+ Anchor: Conflict.Fixed.Joint;+ Mate Broken: AxisJoin { Moving: Conflict.Moving.Joint; Fixed: Conflict.Fixed.Joint; }+ }+ """;+ var result = new AssemblyM0Compiler().Compile(new AssemblyM0Parser().Parse(source).Source!);+ Assert.Contains(result.Diagnostics, x => x.Code == AssemblyM0Compiler.Overconstrained);+ Assert.Contains(result.Ir!.Placements, x => x.Status == PlacementStatus.Overconstrained);+ }++ [Fact]+ public void ForgeProducedSemanticValue_ParticipatesWithoutOriginSpecificMateLogic()+ {+ static SemanticValue Axis(string id, string origin) => new(id, new("Concept"), [new AxisCapability()],+ [new ExactAxisBinding(0, 0, 0, 0, 0, 1, id + ":axis")],+ [new SemanticValue(id + ":Axis", new("Axis"), [new AxisCapability()], [new ExactAxisBinding(0, 0, 0, 0, 0, 1, id + ":axis")], exposedName: "Axis")],+ [new(origin, id, "producer-provenance")], exposedName: "Joint");+ var root = new AssemblyMemberSource("ForgeAssembly", AssemblyInstanceKind.Assembly, "ForgeAssembly",+ [new("Native", AssemblyInstanceKind.Part, "NativePart", [], [Axis("native:joint", "Firmament")]),+ new("Extension", AssemblyInstanceKind.Part, "ForgePart", [], [Axis("forge:joint", "Forge")])], []);+ var iface = new InterfaceDefinition("interface:AxisPair", "AxisPair",+ [new("A", ["AxisCapable"]), new("B", ["AxisCapable"])],+ [new(PlacementConstraintKind.AxisCoincident, "A", "Axis", "B", "Axis")],+ AdmittedFreeMotions: ["translation:along-axis", "rotation:about-axis"]);+ var source = new AssemblySource("ForgeAssembly", root, [iface],+ [new("ForgeMate", "AxisPair", [new("A", AssemblyPath.Parse("ForgeAssembly.Native.Joint")), new("B", AssemblyPath.Parse("ForgeAssembly.Extension.Joint"))])],+ AssemblyPath.Parse("ForgeAssembly.Native.Joint"), [], [], "forge-test");+ var result = new AssemblyM0Compiler().Compile(source);+ Assert.True(result.IsSuccess, string.Join(Environment.NewLine, result.Diagnostics.Select(x => x.Message)));+ Assert.Equal("valid", Assert.Single(result.Ir!.Mates).ValidationStatus);+ Assert.Contains(result.Ir.Instances.Single(x => x.Path.ToString() == "ForgeAssembly.Extension").SemanticRoot.ExposedMembers["Joint"].Provenance,+ x => x.Stage == "Forge");+ }++ [Fact]+ public void LegacyFirmasm_LoadsWithDeprecationDiagnostic()+ {+ var path = FirmamentCorpusHarness.ResolveFixtureFullPath("testdata/firmasm/examples/occt-nut-bolt/nut-bolt-assembly.firmasm");+ var result = new FirmasmManifestLoader().LoadFromFile(path);+ Assert.True(result.IsSuccess);+ Assert.Contains(result.Diagnostics, x => x.Message.StartsWith("legacy-firmasm-deprecation:", StringComparison.Ordinal));+ }+}diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Compiler.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Compiler.csnew file mode 100644index 00000000..db86f9c5--- /dev/null+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Compiler.cs@@ -0,0 +1,417 @@+using System.Diagnostics;+using System.Numerics;+using Aetheris.Semantics;++namespace Aetheris.Kernel.Firmament.Assembly;++public sealed class AssemblyM0Compiler+{+ public const string MissingRole = "assembly-mate-missing-role";+ public const string DuplicateRole = "assembly-mate-duplicate-role";+ public const string CapabilityMismatch = "assembly-role-capability-mismatch";+ public const string InvalidParticipant = "assembly-mate-invalid-participant";+ public const string OutsideScope = "assembly-participant-outside-scope";+ public const string IncompatibleDimensions = "assembly-interface-incompatible-dimensions";+ public const string Underconstrained = "assembly-placement-underconstrained";+ public const string Overconstrained = "assembly-placement-overconstrained";+ public const string UnresolvedTransform = "assembly-placement-unresolved";+ public const string TolerancePathMissing = "assembly-tolerance-path-missing";+ public const string TolerancePathAmbiguous = "assembly-tolerance-path-ambiguous";+ public const string ToleranceAssertionFailure = "assembly-tolerance-assertion-failure";++ public AssemblyCompilationResult Compile(AssemblySource source, double parseMilliseconds = 0)+ {+ var total = Stopwatch.StartNew();+ var diagnostics = new List<AssemblyDiagnostic>();+ var bindWatch = Stopwatch.StartNew();+ var instances = BindInstances(source, diagnostics);+ bindWatch.Stop();+ var byPath = instances.ToDictionary(x => x.Path.ToString(), StringComparer.Ordinal);+ var interfaces = source.Interfaces.ToDictionary(x => x.Name, StringComparer.Ordinal);++ var mateWatch = Stopwatch.StartNew();+ var mates = BindMates(source, interfaces, byPath, diagnostics);+ mateWatch.Stop();++ var placementWatch = Stopwatch.StartNew();+ var constraints = LowerConstraints(mates, interfaces, instances, diagnostics);+ mates = mates.Select(m => m with { ConstraintIds = constraints.Where(c => c.MateStableId == m.StableId).Select(c => c.StableId).ToArray() }).ToArray();+ var placements = ResolvePlacements(source, instances, mates, interfaces, constraints, diagnostics);+ instances = instances.Select(instance => instance with+ {+ ResolvedTransform = placements.First(x => x.InstanceStableId == instance.StableId).Transform+ }).ToArray();+ placementWatch.Stop();++ var graphWatch = Stopwatch.StartNew();+ var relations = BindDimensionalRelations(source, instances, diagnostics);+ graphWatch.Stop();++ var toleranceWatch = Stopwatch.StartNew();+ var fits = AnalyzeFits(mates, interfaces, instances, diagnostics);+ var stackups = AnalyzeStackups(source, relations, instances, diagnostics);+ toleranceWatch.Stop();+ total.Stop();++ var perf = new AssemblyPerformanceIr(parseMilliseconds, bindWatch.Elapsed.TotalMilliseconds,+ mateWatch.Elapsed.TotalMilliseconds, placementWatch.Elapsed.TotalMilliseconds,+ graphWatch.Elapsed.TotalMilliseconds, toleranceWatch.Elapsed.TotalMilliseconds);+ var ir = new AssemblyIr("aetheris/assembly-ir/m0", $"assembly:{source.Name}", source.Name,+ instances.Single(x => x.ParentStableId is null).StableId, instances, source.Interfaces, mates,+ constraints, placements, relations, stackups, fits, diagnostics);+ return new(ir, diagnostics, perf);+ }++ private static IReadOnlyList<AssemblyInstanceIr> BindInstances(AssemblySource source, List<AssemblyDiagnostic> diagnostics)+ {+ var pending = new List<(AssemblyMemberSource member, AssemblyPath path, string? parent)>();+ pending.Add((source.Root, new AssemblyPath([source.Root.Name]), null));+ var flat = new List<(AssemblyMemberSource member, AssemblyPath path, string? parent, string id, SemanticValue semantic)>();+ while (pending.Count > 0)+ {+ var item = pending[0]; pending.RemoveAt(0);+ var id = "assembly-instance:" + item.path;+ var semantic = InstanceScope(item.member, item.path, source.SourceIdentity);+ flat.Add((item.member, item.path, item.parent, id, semantic));+ foreach (var child in item.member.Children)+ pending.Add((child, item.path.Append(child.Name), id));+ }+ if (flat.Select(x => x.path.ToString()).Distinct(StringComparer.Ordinal).Count() != flat.Count)+ diagnostics.Add(new("assembly-instance-path-collision", "Assembly contains duplicate deterministic instance paths."));+ return flat.Select(x => new AssemblyInstanceIr(x.id, x.path, x.member.Kind, x.member.DefinitionIdentity, x.parent,+ flat.Where(c => c.parent == x.id).Select(c => c.id).Order(StringComparer.Ordinal).ToArray(), x.semantic,+ null, null, x.member.Provenance ?? [])).ToArray();+ }++ private static SemanticValue InstanceScope(AssemblyMemberSource member, AssemblyPath path, string sourceIdentity)+ {+ SemanticValue Clone(SemanticValue value, string semanticPath, string? exposedName) => new(+ $"assembly-semantic:{path}:{semanticPath}", value.Type, value.Capabilities.Values, value.Bindings,+ value.ExposedMembers.OrderBy(x => x.Key, StringComparer.Ordinal).Select(x => Clone(x.Value, semanticPath + "." + x.Key, x.Key)),+ [.. value.Provenance, new("assembly-instance", path.ToString(), value.StableIdentity, SemanticSourceSpan.Generated(sourceIdentity))],+ value.AuthoredSourceSpan, SemanticSourceSpan.Generated(sourceIdentity), exposedName);+ return new SemanticValue($"assembly-semantic:{path}", new(member.Kind.ToString()),+ exposedMembers: member.ExposedSemantics.OrderBy(x => x.ExposedName, StringComparer.Ordinal).Select(x => Clone(x, x.ExposedName ?? x.StableIdentity, x.ExposedName)),+ provenance: [new("assembly-instance", path.ToString(), member.DefinitionIdentity, SemanticSourceSpan.Generated(sourceIdentity))],+ generatedSourceSpan: SemanticSourceSpan.Generated(sourceIdentity));+ }++ private static IReadOnlyList<MateIr> BindMates(AssemblySource source, IReadOnlyDictionary<string, InterfaceDefinition> interfaces,+ IReadOnlyDictionary<string, AssemblyInstanceIr> byPath, List<AssemblyDiagnostic> diagnostics)+ {+ var result = new List<MateIr>();+ foreach (var mate in source.Mates.OrderBy(x => x.Name, StringComparer.Ordinal))+ {+ if (!interfaces.TryGetValue(mate.InterfaceName, out var definition))+ { diagnostics.Add(new("assembly-interface-unknown", $"Mate '{mate.Name}' references unknown Interface '{mate.InterfaceName}'.")); continue; }+ var duplicate = mate.Roles.GroupBy(x => x.Role, StringComparer.Ordinal).FirstOrDefault(x => x.Count() > 1);+ if (duplicate is not null) diagnostics.Add(new(DuplicateRole, $"Mate '{mate.Name}' assigns Role '{duplicate.Key}' more than once."));+ var endpoints = new List<MateEndpointIr>();+ foreach (var role in definition.Roles)+ {+ var assignment = mate.Roles.FirstOrDefault(x => x.Role == role.Name);+ if (assignment is null) { diagnostics.Add(new(MissingRole, $"Mate '{mate.Name}' is missing required Role '{role.Name}'.")); continue; }+ if (!TryResolve(assignment.Participant, byPath.Values, out var reference))+ { diagnostics.Add(new(OutsideScope, $"Mate '{mate.Name}' Role '{role.Name}' participant '{assignment.Participant}' is not reachable in the Assembly tree.")); continue; }+ var missing = role.RequiredCapabilities.Where(c => !HasCapability(reference!.Value, c)).ToArray();+ if (missing.Length > 0)+ diagnostics.Add(new(CapabilityMismatch, $"Mate '{mate.Name}' Role '{role.Name}' participant '{assignment.Participant}' lacks: {string.Join(", ", missing)}."));+ endpoints.Add(new(role.Name, assignment.Participant, reference!.Value.StableIdentity, role.RequiredCapabilities));+ }+ result.Add(new($"mate:{source.Name}:{mate.Name}", mate.Name, definition.StableId, endpoints, [],+ endpoints.Count == definition.Roles.Count ? "valid" : "invalid"));+ }+ return result;+ }++ private static bool HasCapability(SemanticValue value, string capability) =>+ value.Capabilities.Values.Any(x => string.Equals(x.Name, capability, StringComparison.Ordinal));++ private static IReadOnlyList<PlacementConstraintIr> LowerConstraints(IReadOnlyList<MateIr> mates,+ IReadOnlyDictionary<string, InterfaceDefinition> interfaces, IReadOnlyList<AssemblyInstanceIr> instances,+ List<AssemblyDiagnostic> diagnostics)+ {+ var result = new List<PlacementConstraintIr>();+ foreach (var mate in mates)+ {+ var definition = interfaces.Values.Single(x => x.StableId == mate.InterfaceStableId);+ foreach (var (requirement, index) in definition.Requirements.Select((x, i) => (x, i)))+ {+ var first = mate.Roles.FirstOrDefault(x => x.Role == requirement.FirstRole);+ var second = mate.Roles.FirstOrDefault(x => x.Role == requirement.SecondRole);+ if (first is null || second is null) continue;+ var firstId = ResolveRelativeSemantic(first.ParticipantSemanticValueId, requirement.FirstMember, instances);+ var secondId = ResolveRelativeSemantic(second.ParticipantSemanticValueId, requirement.SecondMember, instances);+ if (firstId is null || secondId is null)+ { diagnostics.Add(new(InvalidParticipant, $"Interface '{definition.Name}' requirement '{requirement.Kind}' cannot resolve exposed members '{requirement.FirstMember}'/'{requirement.SecondMember}'.")); continue; }+ result.Add(new($"constraint:{mate.StableId}:{index:D2}", requirement.Kind, mate.StableId, firstId, secondId, requirement.OffsetMm, 0, "admitted"));+ }+ }+ return result;+ }++ private static string? ResolveRelativeSemantic(string rootId, string member, IReadOnlyList<AssemblyInstanceIr> instances)+ {+ var root = Flatten(instances.Select(x => x.SemanticRoot)).FirstOrDefault(x => x.StableIdentity == rootId);+ if (root is null) return null;+ if (string.IsNullOrWhiteSpace(member) || member == ".") return root.StableIdentity;+ var current = root;+ foreach (var segment in member.Split('.', StringSplitOptions.RemoveEmptyEntries))+ if (!current.ExposedMembers.TryGetValue(segment, out current!)) return null;+ return current.StableIdentity;+ }++ private static IReadOnlyList<PlacementResultIr> ResolvePlacements(AssemblySource source, IReadOnlyList<AssemblyInstanceIr> instances,+ IReadOnlyList<MateIr> mates, IReadOnlyDictionary<string, InterfaceDefinition> interfaces,+ IReadOnlyList<PlacementConstraintIr> constraints, List<AssemblyDiagnostic> diagnostics)+ {+ var anchor = instances.Where(x => source.Anchor.ToString().StartsWith(x.Path + ".", StringComparison.Ordinal) || source.Anchor.ToString() == x.Path.ToString())+ .OrderByDescending(x => x.Path.Segments.Count).FirstOrDefault();+ if (anchor is null) diagnostics.Add(new("assembly-anchor-invalid", $"Anchor '{source.Anchor}' is outside the Assembly tree."));+ var known = new Dictionary<string, AssemblyTransform>(StringComparer.Ordinal);+ var overconstrained = new HashSet<string>(StringComparer.Ordinal);+ if (anchor is not null) known[anchor.StableId] = AssemblyTransform.Identity;+ var progress = true;+ while (progress)+ {+ progress = false;+ foreach (var mate in mates.OrderBy(x => x.StableId, StringComparer.Ordinal))+ {+ var mateConstraints = constraints.Where(x => x.MateStableId == mate.StableId).ToArray();+ var owners = mateConstraints.SelectMany(x => new[] { OwnerInstance(x.FirstSemanticValueId, instances), OwnerInstance(x.SecondSemanticValueId, instances) })+ .Where(x => x is not null).DistinctBy(x => x!.StableId).Cast<AssemblyInstanceIr>().ToArray();+ if (owners.Length != 2 || mateConstraints.Length == 0) continue;+ var firstKnown = known.ContainsKey(owners[0].StableId); var secondKnown = known.ContainsKey(owners[1].StableId);+ if (firstKnown == secondKnown)+ {+ if (!firstKnown) continue;+ foreach (var moving in owners)+ {+ var target = owners.Single(x => x.StableId != moving.StableId);+ var oriented = Orient(mateConstraints, moving, instances);+ var candidate = CandidateTransform(oriented, instances, known[target.StableId]);+ if (TransformDistance(candidate, known[moving.StableId]) > 1e-7 && overconstrained.Add(moving.StableId))+ diagnostics.Add(new(Overconstrained, $"Instance '{moving.Path}' receives a conflicting placement from Mate '{mate.Name}'; transform residual exceeds 1e-7."));+ }+ continue;+ }+ var movingInstance = firstKnown ? owners[1] : owners[0];+ var targetInstance = firstKnown ? owners[0] : owners[1];+ var orientedConstraints = Orient(mateConstraints, movingInstance, instances);+ var axisCandidates = orientedConstraints.Where(x => x.Kind == PlacementConstraintKind.AxisCoincident)+ .Select(x => CandidateTransform([x], instances, known[targetInstance.StableId])).ToArray();+ if (axisCandidates.Length > 1 && axisCandidates.Skip(1).Any(x => TransformDistance(axisCandidates[0], x) > 1e-7))+ {+ overconstrained.Add(movingInstance.StableId);+ diagnostics.Add(new(Overconstrained, $"Instance '{movingInstance.Path}' receives incompatible constraints from Mate '{mate.Name}'; transform residual exceeds 1e-7."));+ continue;+ }+ known[movingInstance.StableId] = CandidateTransform(orientedConstraints, instances, known[targetInstance.StableId]);+ progress = true;+ }+ }++ var results = new List<PlacementResultIr>();+ foreach (var instance in instances)+ {+ if (anchor is not null && instance.StableId == anchor.StableId)+ { results.Add(new(instance.StableId, PlacementStatus.Anchored, AssemblyTransform.Identity, [], [], [])); continue; }+ var participantIds = Flatten([instance.SemanticRoot]).Select(x => x.StableIdentity).ToHashSet(StringComparer.Ordinal);+ var relevant = constraints.Where(x => participantIds.Contains(x.FirstSemanticValueId) || participantIds.Contains(x.SecondSemanticValueId)).ToArray();+ if (overconstrained.Contains(instance.StableId))+ { results.Add(new(instance.StableId, PlacementStatus.Overconstrained, null, [], [], relevant.Select(x => x.StableId).ToArray())); continue; }+ if (relevant.Length == 0 || !known.TryGetValue(instance.StableId, out var transform))+ { results.Add(new(instance.StableId, PlacementStatus.Unresolved, null, ["X", "Y", "Z"], ["X", "Y", "Z"], relevant.Select(x => x.StableId).ToArray())); continue; }+ var hasAxis = relevant.Any(x => x.Kind is PlacementConstraintKind.AxisCoincident or PlacementConstraintKind.AxisAligned);+ var hasPlane = relevant.Any(x => x.Kind == PlacementConstraintKind.PlaneCoincident);+ var hasPoint = relevant.Any(x => x.Kind == PlacementConstraintKind.PointCoincident);+ var freeT = hasAxis ? (hasPlane || hasPoint ? Array.Empty<string>() : ["along-axis"]) : (hasPoint ? Array.Empty<string>() : ["X", "Y", "Z"]);+ string[] freeR = hasAxis ? ["about-axis"] : ["X", "Y", "Z"];+ var involvedInterfaces = mates.Where(m => relevant.Any(c => c.MateStableId == m.StableId)).Select(m => interfaces.Values.Single(x => x.StableId == m.InterfaceStableId)).ToArray();+ string[] admitted = involvedInterfaces.Length == 0 ? [] : (involvedInterfaces.Select(x => x.AdmittedFreeMotions ?? []).Aggregate((IEnumerable<string>?)null,+ (common, next) => common is null ? next : common.Intersect(next, StringComparer.Ordinal)) ?? []).ToArray();+ var unadmittedT = freeT.Where(x => !admitted.Contains("translation:" + x, StringComparer.Ordinal)).ToArray();+ var unadmittedR = freeR.Where(x => !admitted.Contains("rotation:" + x, StringComparer.Ordinal)).ToArray();+ var status = unadmittedT.Length == 0 && unadmittedR.Length == 0 ? PlacementStatus.Resolved : PlacementStatus.Underconstrained;+ if (status == PlacementStatus.Underconstrained)+ diagnostics.Add(new(Underconstrained, $"Instance '{instance.Path}' retains translations [{string.Join(",", unadmittedT)}] and rotations [{string.Join(",", unadmittedR)}].", AssemblyDiagnosticSeverity.Warning));+ results.Add(new(instance.StableId, status, transform, unadmittedT, unadmittedR, relevant.Select(x => x.StableId).ToArray()));+ }+ return results;+ }++ private static PlacementConstraintIr[] Orient(IEnumerable<PlacementConstraintIr> constraints, AssemblyInstanceIr moving, IReadOnlyList<AssemblyInstanceIr> instances) =>+ constraints.Select(x => OwnerInstance(x.FirstSemanticValueId, instances)?.StableId == moving.StableId+ ? x : x with { FirstSemanticValueId = x.SecondSemanticValueId, SecondSemanticValueId = x.FirstSemanticValueId }).ToArray();++ private static AssemblyInstanceIr? OwnerInstance(string semanticId, IReadOnlyList<AssemblyInstanceIr> instances) =>+ instances.Where(x => semanticId == x.SemanticRoot.StableIdentity || semanticId.StartsWith(x.SemanticRoot.StableIdentity + ":", StringComparison.Ordinal))+ .OrderByDescending(x => x.Path.Segments.Count).FirstOrDefault();++ private static double TransformDistance(AssemblyTransform a, AssemblyTransform b)+ {+ return Math.Sqrt(Enumerable.Range(0, 16).Sum(i => Math.Pow(a.Matrix[i] - b.Matrix[i], 2)));+ }++ private static AssemblyTransform CandidateTransform(IReadOnlyList<PlacementConstraintIr> constraints, IReadOnlyList<AssemblyInstanceIr> instances, AssemblyTransform? targetWorld = null)+ {+ var values = Flatten(instances.Select(x => x.SemanticRoot)).ToDictionary(x => x.StableIdentity, StringComparer.Ordinal);+ var axis = constraints.FirstOrDefault(x => x.Kind == PlacementConstraintKind.AxisCoincident);+ if (axis is null || !values[axis.FirstSemanticValueId].TryBinding<ExactAxisBinding>(out var a) || !values[axis.SecondSemanticValueId].TryBinding<ExactAxisBinding>(out var b))+ return targetWorld ?? AssemblyTransform.Identity;+ var from = Vector3.Normalize(new((float)a.DirectionX, (float)a.DirectionY, (float)a.DirectionZ));+ var to = Vector3.Normalize(new((float)b.DirectionX, (float)b.DirectionY, (float)b.DirectionZ));+ var dot = Math.Clamp(Vector3.Dot(from, to), -1, 1);+ var cross = Vector3.Cross(from, to);+ Matrix4x4 rotation;+ if (cross.LengthSquared() < 1e-12f) rotation = dot >= 0 ? Matrix4x4.Identity : Matrix4x4.CreateFromAxisAngle(Vector3.UnitX, MathF.PI);+ else rotation = Matrix4x4.CreateFromAxisAngle(Vector3.Normalize(cross), MathF.Acos(dot));+ var origin = Vector3.Transform(new((float)a.OriginX, (float)a.OriginY, (float)a.OriginZ), rotation);+ var target = new Vector3((float)b.OriginX, (float)b.OriginY, (float)b.OriginZ);+ rotation.Translation = target - origin;+ var plane = constraints.FirstOrDefault(x => x.Kind == PlacementConstraintKind.PlaneCoincident);+ if (plane is not null && values[plane.FirstSemanticValueId].TryBinding<ExactPlaneBinding>(out var sourcePlane)+ && values[plane.SecondSemanticValueId].TryBinding<ExactPlaneBinding>(out var targetPlane))+ {+ var sourcePlaneWorld = Vector3.Transform(new((float)sourcePlane.OriginX, (float)sourcePlane.OriginY, (float)sourcePlane.OriginZ), rotation);+ var targetPlanePoint = new Vector3((float)targetPlane.OriginX, (float)targetPlane.OriginY, (float)targetPlane.OriginZ);+ var targetAxis = Vector3.Normalize(to);+ rotation.Translation += targetAxis * Vector3.Dot(targetPlanePoint - sourcePlaneWorld, targetAxis);+ }+ if (targetWorld is not null) rotation *= ToMatrix(targetWorld);+ return new([rotation.M11, rotation.M12, rotation.M13, rotation.M14, rotation.M21, rotation.M22, rotation.M23, rotation.M24,+ rotation.M31, rotation.M32, rotation.M33, rotation.M34, rotation.M41, rotation.M42, rotation.M43, rotation.M44]);+ }++ private static Matrix4x4 ToMatrix(AssemblyTransform transform) => new(+ (float)transform.Matrix[0], (float)transform.Matrix[1], (float)transform.Matrix[2], (float)transform.Matrix[3],+ (float)transform.Matrix[4], (float)transform.Matrix[5], (float)transform.Matrix[6], (float)transform.Matrix[7],+ (float)transform.Matrix[8], (float)transform.Matrix[9], (float)transform.Matrix[10], (float)transform.Matrix[11],+ (float)transform.Matrix[12], (float)transform.Matrix[13], (float)transform.Matrix[14], (float)transform.Matrix[15]);++ private static IReadOnlyList<DimensionalRelationIr> BindDimensionalRelations(AssemblySource source,+ IReadOnlyList<AssemblyInstanceIr> instances, List<AssemblyDiagnostic> diagnostics)+ {+ var result = new List<DimensionalRelationIr>();+ foreach (var relation in source.DimensionalRelations)+ {+ if (!TryResolve(relation.From, instances, out var from) || !TryResolve(relation.To, instances, out var to))+ { diagnostics.Add(new(TolerancePathMissing, $"Dimensional relation '{relation.Name}' references an endpoint outside the Assembly tree.")); continue; }+ var origin = OwnerPath(from!.Value.StableIdentity, instances);+ var mateId = relation.Provenance.StartsWith("Mate:", StringComparison.Ordinal) ? "mate-reference:" + relation.Provenance[5..] : null;+ result.Add(new($"dimension-relation:{source.Name}:{relation.Name}", from.Value.StableIdentity, to!.Value.StableIdentity,+ relation.Nominal, relation.LowerTolerance, relation.UpperTolerance, relation.Unit, 1, origin, relation.Provenance, mateId));+ }+ return result;+ }++ private static IReadOnlyList<InterfaceFitResultIr> AnalyzeFits(IReadOnlyList<MateIr> mates,+ IReadOnlyDictionary<string, InterfaceDefinition> interfaces, IReadOnlyList<AssemblyInstanceIr> instances,+ List<AssemblyDiagnostic> diagnostics)+ {+ var values = Flatten(instances.Select(x => x.SemanticRoot)).ToDictionary(x => x.StableIdentity, StringComparer.Ordinal);+ var result = new List<InterfaceFitResultIr>();+ foreach (var mate in mates)+ {+ var definition = interfaces.Values.Single(x => x.StableId == mate.InterfaceStableId);+ if (definition.Fit is not { } fit) continue;+ var shaft = mate.Roles.FirstOrDefault(x => x.Role == fit.ShaftRole);+ var bore = mate.Roles.FirstOrDefault(x => x.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 sd) || !values[boreId].TryBinding<TolerancedDimensionBinding>(out var bd))+ { diagnostics.Add(new(CapabilityMismatch, $"Mate '{mate.Name}' fit requires toleranced dimensions '{fit.ShaftDimension}' and '{fit.BoreDimension}'.")); continue; }+ if (sd.Unit != bd.Unit) { diagnostics.Add(new("assembly-tolerance-unit-mismatch", $"Mate '{mate.Name}' fit dimensions use '{sd.Unit}' and '{bd.Unit}'.")); continue; }+ var nominal = bd.Nominal - sd.Nominal;+ var min = bd.Minimum - sd.Maximum;+ var max = bd.Maximum - sd.Minimum;+ var compatible = min >= 0;+ if (!compatible) diagnostics.Add(new(IncompatibleDimensions, $"Mate '{mate.Name}' fit ranges from {min:G6} to {max:G6} {sd.Unit} (nominal {nominal:G6}).", AssemblyDiagnosticSeverity.Warning));+ result.Add(new(mate.StableId, nominal, min, max, sd.Unit, compatible));+ }+ return result;+ }++ private static IReadOnlyList<ToleranceStackupResultIr> AnalyzeStackups(AssemblySource source,+ IReadOnlyList<DimensionalRelationIr> relations, IReadOnlyList<AssemblyInstanceIr> instances,+ List<AssemblyDiagnostic> diagnostics)+ {+ var result = new List<ToleranceStackupResultIr>();+ foreach (var assertion in source.StackupAsserts)+ {+ if (!TryResolve(assertion.From, instances, out var from) || !TryResolve(assertion.To, instances, out var to))+ { diagnostics.Add(new(TolerancePathMissing, $"Assert ToleranceStackup '{assertion.Name}' endpoints cannot be resolved.")); continue; }+ var paths = FindPaths(from!.Value.StableIdentity, to!.Value.StableIdentity, relations, 2);+ if (paths.Count == 0) { diagnostics.Add(new(TolerancePathMissing, $"Assert ToleranceStackup '{assertion.Name}' has no dimensional path.")); continue; }+ if (paths.Count > 1) { diagnostics.Add(new(TolerancePathAmbiguous, $"Assert ToleranceStackup '{assertion.Name}' has multiple valid dimensional paths.")); continue; }+ var contributions = paths[0].Select(step => new StackupContributionIr(step.edge.StableId, step.sign,+ 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();+ 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);+ var min = nominal + contributions.Sum(x => x.LowerTolerance);+ var max = nominal + contributions.Sum(x => x.UpperTolerance);+ var passed = min >= assertion.RequiredMinimum;+ if (!passed) diagnostics.Add(new(ToleranceAssertionFailure,+ $"Assert ToleranceStackup '{assertion.Name}' failed: worst-case minimum {min:G6} {assertion.Unit} < required {assertion.RequiredMinimum:G6} {assertion.Unit}."));+ result.Add(new(assertion.Name, from.Value.StableIdentity, to.Value.StableIdentity, nominal, min, max,+ assertion.RequiredMinimum, assertion.Unit, passed, passed ? "passed" : "failed", contributions));+ }+ return result;+ }++ private static List<List<(DimensionalRelationIr edge, int sign)>> FindPaths(string start, string end,+ IReadOnlyList<DimensionalRelationIr> edges, int limit)+ {+ var result = new List<List<(DimensionalRelationIr, int)>>();+ void Visit(string node, HashSet<string> visited, List<(DimensionalRelationIr, int)> path)+ {+ if (result.Count >= limit) return;+ if (node == end) { result.Add([.. path]); return; }+ foreach (var edge in edges.OrderBy(x => x.StableId, StringComparer.Ordinal))+ {+ var next = edge.FromSemanticValueId == node ? edge.ToSemanticValueId : edge.ToSemanticValueId == node ? edge.FromSemanticValueId : null;+ if (next is null || visited.Contains(next)) continue;+ visited.Add(next); path.Add((edge, edge.FromSemanticValueId == node ? 1 : -1));+ Visit(next, visited, path); path.RemoveAt(path.Count - 1); visited.Remove(next);+ }+ }+ Visit(start, new([start], StringComparer.Ordinal), []);+ return result;+ }++ internal static bool TryResolve(AssemblyPath path, IEnumerable<AssemblyInstanceIr> instances, out SemanticReference? reference)+ {+ reference = null;+ var all = instances.ToArray();+ var instance = all.Where(x => path.Segments.Count >= x.Path.Segments.Count && path.Segments.Take(x.Path.Segments.Count).SequenceEqual(x.Path.Segments))+ .OrderByDescending(x => x.Path.Segments.Count).FirstOrDefault();+ if (instance is null) return false;+ var current = instance.SemanticRoot;+ var resolved = new List<SemanticPathSegment>();+ foreach (var segment in path.Segments.Skip(instance.Path.Segments.Count))+ {+ if (!current.ExposedMembers.TryGetValue(segment, out current!)) return false;+ resolved.Add(new(segment, SemanticSourceSpan.Generated(path.ToString())));+ }+ reference = new(current, resolved, SemanticSourceSpan.Generated(path.ToString()));+ return true;+ }++ private static IEnumerable<SemanticValue> Flatten(IEnumerable<SemanticValue> roots)+ {+ foreach (var root in roots)+ {+ yield return root;+ foreach (var child in Flatten(root.ExposedMembers.Values)) yield return child;+ }+ }++ private static string OwnerPath(string semanticId, IReadOnlyList<AssemblyInstanceIr> instances) =>+ instances.Where(x => semanticId == x.SemanticRoot.StableIdentity || semanticId.StartsWith(x.SemanticRoot.StableIdentity + ":", StringComparison.Ordinal))+ .OrderByDescending(x => x.Path.Segments.Count).Select(x => x.Path.ToString()).FirstOrDefault() ?? "unknown";+}diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Models.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Models.csnew file mode 100644index 00000000..a33f6c5e--- /dev/null+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Models.cs@@ -0,0 +1,93 @@+using Aetheris.Semantics;++namespace Aetheris.Kernel.Firmament.Assembly;++public enum AssemblyInstanceKind { Assembly, Part }+public enum AssemblyDiagnosticSeverity { Warning, Error }+public enum PlacementConstraintKind { AxisCoincident, AxisAligned, PlaneCoincident, PointCoincident, OffsetAlongAxis }+public enum PlacementStatus { Anchored, Resolved, Underconstrained, Overconstrained, Unresolved }++public sealed record AssemblyDiagnostic(string Code, string Message, AssemblyDiagnosticSeverity Severity = AssemblyDiagnosticSeverity.Error);+public sealed record AssemblyPath(IReadOnlyList<string> Segments)+{+ public override string ToString() => string.Join(".", Segments);+ public static AssemblyPath Parse(string value) => new(value.Split('.', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries));+ public AssemblyPath Append(string segment) => new([.. Segments, segment]);+}++public sealed record InterfaceRoleDefinition(string Name, IReadOnlyList<string> RequiredCapabilities, int Minimum = 1, int Maximum = 1);+public sealed record InterfaceRequirementDefinition(PlacementConstraintKind Kind, string FirstRole, string FirstMember, string SecondRole, string SecondMember, double OffsetMm = 0);+public sealed record InterfaceFitDefinition(string ShaftRole, string ShaftDimension, string BoreRole, string BoreDimension);+public sealed record InterfaceDefinition(+ string StableId, string Name, IReadOnlyList<InterfaceRoleDefinition> Roles,+ IReadOnlyList<InterfaceRequirementDefinition> Requirements,+ InterfaceFitDefinition? Fit = null,+ IReadOnlyList<string>? AdmittedFreeMotions = null,+ SemanticSourceSpan? SourceSpan = null);++public sealed record AssemblyMemberSource(+ string Name, AssemblyInstanceKind Kind, string DefinitionIdentity,+ IReadOnlyList<AssemblyMemberSource> Children,+ IReadOnlyList<SemanticValue> ExposedSemantics,+ IReadOnlyList<DimensionalRelationSource>? DimensionalRelations = null,+ IReadOnlyList<SemanticProvenance>? Provenance = null);++public sealed record MateRoleAssignment(string Role, AssemblyPath Participant);+public sealed record MateSource(string Name, string InterfaceName, IReadOnlyList<MateRoleAssignment> Roles, SemanticSourceSpan? SourceSpan = null);+public sealed record DimensionalRelationSource(string Name, AssemblyPath From, AssemblyPath To, double Nominal, double LowerTolerance, double UpperTolerance, string Unit, string Provenance);+public sealed record ToleranceStackupAssertSource(string Name, AssemblyPath From, AssemblyPath To, double RequiredMinimum, string Unit, SemanticSourceSpan? SourceSpan = null);+public sealed record AssemblySource(+ string Name, AssemblyMemberSource Root, IReadOnlyList<InterfaceDefinition> Interfaces,+ IReadOnlyList<MateSource> Mates, AssemblyPath Anchor,+ IReadOnlyList<DimensionalRelationSource> DimensionalRelations,+ IReadOnlyList<ToleranceStackupAssertSource> StackupAsserts,+ string SourceIdentity);++public sealed record AssemblyTransform(double[] Matrix)+{+ public static AssemblyTransform Identity { get; } = new([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);+}++public sealed record AssemblyInstanceIr(+ string StableId, AssemblyPath Path, AssemblyInstanceKind Kind, string DefinitionIdentity,+ string? ParentStableId, IReadOnlyList<string> ChildrenStableIds,+ SemanticValue SemanticRoot, AssemblyTransform? LocalTransform, AssemblyTransform? ResolvedTransform,+ IReadOnlyList<SemanticProvenance> Provenance);++public sealed record MateEndpointIr(string Role, AssemblyPath ParticipantPath, string ParticipantSemanticValueId, IReadOnlyList<string> RequiredCapabilities);+public sealed record MateIr(string StableId, string Name, string InterfaceStableId, IReadOnlyList<MateEndpointIr> Roles, IReadOnlyList<string> ConstraintIds, string ValidationStatus);+public sealed record PlacementConstraintIr(+ string StableId, PlacementConstraintKind Kind, string MateStableId,+ string FirstSemanticValueId, string SecondSemanticValueId, double OffsetMm,+ double Residual, string Status);+public sealed record PlacementResultIr(string InstanceStableId, PlacementStatus Status, AssemblyTransform? Transform, IReadOnlyList<string> FreeTranslations, IReadOnlyList<string> FreeRotations, IReadOnlyList<string> ConstraintIds);++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);++public sealed record StackupContributionIr(+ string RelationStableId, int Sign, double Nominal, double LowerTolerance, double UpperTolerance,+ string Unit, string OriginInstancePath, string Provenance, string? MateStableId, string? InterfaceStableId);+public sealed record ToleranceStackupResultIr(+ string Name, string StartSemanticValueId, string EndSemanticValueId,+ double Nominal, double WorstCaseMinimum, double WorstCaseMaximum,+ double RequiredMinimum, string Unit, bool Passed, string Status,+ IReadOnlyList<StackupContributionIr> Contributions);+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 AssemblyIr(+ string Schema, string StableId, string Name, string RootInstanceStableId,+ IReadOnlyList<AssemblyInstanceIr> Instances, IReadOnlyList<InterfaceDefinition> Interfaces,+ IReadOnlyList<MateIr> Mates, IReadOnlyList<PlacementConstraintIr> PlacementConstraints,+ IReadOnlyList<PlacementResultIr> Placements, IReadOnlyList<DimensionalRelationIr> DimensionalRelations,+ IReadOnlyList<ToleranceStackupResultIr> ToleranceStackups, IReadOnlyList<InterfaceFitResultIr> FitResults,+ IReadOnlyList<AssemblyDiagnostic> Diagnostics);++public sealed record AssemblyCompilationResult(AssemblyIr? Ir, IReadOnlyList<AssemblyDiagnostic> Diagnostics, AssemblyPerformanceIr? Performance = null)+{+ public bool IsSuccess => Ir is not null && Diagnostics.All(d => d.Severity != AssemblyDiagnosticSeverity.Error);+}diff --git a/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Parser.cs b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Parser.csnew file mode 100644index 00000000..23de47d8--- /dev/null+++ b/Aetheris.Kernel.Firmament/Assembly/AssemblyM0Parser.cs@@ -0,0 +1,226 @@+using System.Diagnostics;+using System.Globalization;+using System.Text.RegularExpressions;+using Aetheris.Semantics;++namespace Aetheris.Kernel.Firmament.Assembly;++/// <summary>Bounded parser for the M0 relational assembly lane. XML-like tags are used only for product-tree containment.</summary>+public sealed class AssemblyM0Parser+{+ public sealed record ParseResult(AssemblySource? Source, IReadOnlyList<AssemblyDiagnostic> Diagnostics, double ElapsedMilliseconds)+ { public bool IsSuccess => Source is not null && Diagnostics.All(x => x.Severity != AssemblyDiagnosticSeverity.Error); }++ public ParseResult ParseFile(string path) => Parse(File.ReadAllText(path), Path.GetFullPath(path));++ public ParseResult Parse(string input, string sourceIdentity = "<memory>")+ {+ var watch = Stopwatch.StartNew();+ var diagnostics = new List<AssemblyDiagnostic>();+ var source = Regex.Replace(input, @"//[^\r\n]*", string.Empty);+ var interfaces = ParseInterfaces(source, sourceIdentity, diagnostics);+ var assemblyHeader = Regex.Match(source, @"\bAssembly\s+(?<name>[A-Za-z_]\w*)\s*\{", RegexOptions.CultureInvariant);+ if (!assemblyHeader.Success)+ { diagnostics.Add(new("assembly-parse-missing-root", "Expected 'Assembly Name { ... }'.")); return Done(null); }+ var body = BalancedBody(source, assemblyHeader.Index + assemblyHeader.Length - 1, diagnostics, "Assembly");+ if (body is null) return Done(null);+ var tree = ParseTree(body, sourceIdentity, diagnostics);+ if (tree is null) return Done(null);+ var mates = ParseMates(body, sourceIdentity, diagnostics);+ var relations = ParseRelations(body, diagnostics);+ 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);+ return Done(result);++ ParseResult Done(AssemblySource? value) { watch.Stop(); return new(value, diagnostics, watch.Elapsed.TotalMilliseconds); }+ }++ private static IReadOnlyList<InterfaceDefinition> ParseInterfaces(string source, string sourceIdentity, List<AssemblyDiagnostic> diagnostics)+ {+ var result = new List<InterfaceDefinition>();+ foreach (Match header in Regex.Matches(source, @"\bInterface\s+(?<name>[A-Za-z_]\w*)\s*\{", RegexOptions.CultureInvariant))+ {+ var body = BalancedBody(source, header.Index + header.Length - 1, diagnostics, "Interface");+ if (body is null) continue;+ var name = header.Groups["name"].Value;+ var roles = Regex.Matches(body, @"\bRole\s+(?<name>[A-Za-z_]\w*)\s+requires\s+(?<caps>[A-Za-z, ]+)\s*;", RegexOptions.CultureInvariant)+ .Select(m => new InterfaceRoleDefinition(m.Groups["name"].Value,+ m.Groups["caps"].Value.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))).ToArray();+ var requirements = Regex.Matches(body, @"\bLower\s+(?<kind>AxisCoincident|AxisAligned|PlaneCoincident|PointCoincident|OffsetAlongAxis)\s+(?<a>[A-Za-z_]\w*)\.(?<am>[A-Za-z_]\w*)\s+(?<b>[A-Za-z_]\w*)\.(?<bm>[A-Za-z_]\w*)(?:\s+(?<offset>[-+]?\d+(?:\.\d+)?)mm)?\s*;", RegexOptions.CultureInvariant)+ .Select(m => new InterfaceRequirementDefinition(Enum.Parse<PlacementConstraintKind>(m.Groups["kind"].Value),+ m.Groups["a"].Value, m.Groups["am"].Value, m.Groups["b"].Value, m.Groups["bm"].Value,+ m.Groups["offset"].Success ? Number(m.Groups["offset"].Value) : 0)).ToArray();+ var fitMatch = Regex.Match(body, @"\bFit\s+(?<a>[A-Za-z_]\w*)\.(?<am>[A-Za-z_]\w*)\s+inside\s+(?<b>[A-Za-z_]\w*)\.(?<bm>[A-Za-z_]\w*)\s*;", RegexOptions.CultureInvariant);+ InterfaceFitDefinition? fit = fitMatch.Success ? new(fitMatch.Groups["a"].Value, fitMatch.Groups["am"].Value, fitMatch.Groups["b"].Value, fitMatch.Groups["bm"].Value) : null;+ var free = Regex.Matches(body, @"\bAllow\s+(?<kind>rotation|translation):(?<axis>[A-Za-z-]+)\s*;", RegexOptions.CultureInvariant)+ .Select(m => m.Groups["kind"].Value + ":" + m.Groups["axis"].Value).ToArray();+ if (roles.Length == 0) diagnostics.Add(new("assembly-interface-no-roles", $"Interface '{name}' must define at least one Role."));+ result.Add(new($"interface:{name}", name, roles, requirements, fit, free, SemanticSourceSpan.Generated(sourceIdentity)));+ }+ return result.OrderBy(x => x.Name, StringComparer.Ordinal).ToArray();+ }++ private sealed class MutableNode(string name, AssemblyInstanceKind kind, string definition)+ {+ public string Name { get; } = name;+ public AssemblyInstanceKind Kind { get; } = kind;+ public string Definition { get; } = definition;+ public List<MutableNode> Children { get; } = [];+ public List<SemanticValue> Semantics { get; } = [];+ public MutableNode? Parent { get; set; }+ }++ private static AssemblyMemberSource? ParseTree(string body, string sourceIdentity, List<AssemblyDiagnostic> diagnostics)+ {+ 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)>();+ foreach (var tag in matches)+ {+ var closing = tag.Groups["close"].Success;+ var kind = tag.Groups["kind"].Value;+ if (!closing)+ {+ 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*)$");+ 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);+ if (stack.Count > 0) { node.Parent = stack.Peek().node; node.Parent.Children.Add(node); }+ else if (root is null) root = node;+ else diagnostics.Add(new("assembly-tree-multiple-roots", "Assembly source must contain exactly one XML-like tree root."));+ stack.Push((node, tag.Index + tag.Length));+ }+ else+ {+ if (stack.Count == 0 || stack.Peek().node.Kind.ToString() != kind)+ { diagnostics.Add(new("assembly-tree-unbalanced", $"Unexpected closing tag '{tag.Value}'.")); continue; }+ var open = stack.Pop();+ if (open.node.Kind == AssemblyInstanceKind.Part)+ {+ var partBody = body[open.bodyStart..tag.Index];+ open.node.Semantics.AddRange(ParseSemantics(partBody, open.node.Definition, sourceIdentity, diagnostics));+ }+ }+ }+ if (stack.Count > 0) diagnostics.Add(new("assembly-tree-unbalanced", $"Missing closing tag for '{stack.Peek().node.Name}'."));+ if (root is null) diagnostics.Add(new("assembly-tree-missing", "Assembly body requires a nested <Assembly Name> product tree."));+ AssemblyMemberSource Freeze(MutableNode node) => new(node.Name, node.Kind, node.Definition,+ node.Children.Select(Freeze).ToArray(), node.Semantics, [], [new("assembly-source", node.Name, node.Definition, SemanticSourceSpan.Generated(sourceIdentity))]);+ return root is null ? null : Freeze(root);+ }++ private static IEnumerable<SemanticValue> ParseSemantics(string body, string definition, string sourceIdentity, List<AssemblyDiagnostic> diagnostics)+ {+ foreach (Match header in Regex.Matches(body, @"\bSemantic\s+(?<name>[A-Za-z_]\w*)\s*\{", RegexOptions.CultureInvariant))+ {+ var block = BalancedBody(body, header.Index + header.Length - 1, diagnostics, "Semantic");+ if (block is null) continue;+ var name = header.Groups["name"].Value;+ var members = new List<SemanticValue>();+ var caps = new List<ISemanticCapability>();+ var bindings = new List<SemanticBinding>();+ foreach (Match axis in Regex.Matches(block, @"\bAxis\s+(?<name>[A-Za-z_]\w*)\s*=\s*\[(?<o>[^]]+)\]\s*->\s*\[(?<d>[^]]+)\]\s*;", RegexOptions.CultureInvariant))+ {+ var o = Vector(axis.Groups["o"].Value); var d = Vector(axis.Groups["d"].Value);+ if (o is null || d is null) { diagnostics.Add(new("assembly-axis-invalid", $"Semantic '{name}' has an invalid Axis.")); continue; }+ var binding = new ExactAxisBinding(o[0], o[1], o[2], d[0], d[1], d[2], $"definition:{definition}:{name}:{axis.Groups["name"].Value}");+ members.Add(new SemanticValue(binding.AxisStableId, new("Axis"), [new AxisCapability()], [binding], exposedName: axis.Groups["name"].Value));+ caps.Add(new AxisCapability()); if (!bindings.OfType<ExactAxisBinding>().Any()) bindings.Add(binding);+ }+ foreach (Match plane in Regex.Matches(block, @"\bPlane\s+(?<name>[A-Za-z_]\w*)\s*=\s*\[(?<o>[^]]+)\]\s+normal\s*\[(?<n>[^]]+)\]\s*;", RegexOptions.CultureInvariant))+ {+ var o = Vector(plane.Groups["o"].Value); var n = Vector(plane.Groups["n"].Value);+ if (o is null || n is null) { diagnostics.Add(new("assembly-plane-invalid", $"Semantic '{name}' has an invalid Plane.")); continue; }+ var binding = new ExactPlaneBinding(o[0], o[1], o[2], n[0], n[1], n[2], $"definition:{definition}:{name}:{plane.Groups["name"].Value}");+ members.Add(new SemanticValue(binding.PlaneStableId, new("Plane"), [new PlaneCapability()], [binding], exposedName: plane.Groups["name"].Value));+ caps.Add(new PlaneCapability()); if (!bindings.OfType<ExactPlaneBinding>().Any()) bindings.Add(binding);+ }+ foreach (Match point in Regex.Matches(block, @"\bPoint\s+(?<name>[A-Za-z_]\w*)\s*=\s*\[(?<p>[^]]+)\]\s*;", RegexOptions.CultureInvariant))+ {+ var p = Vector(point.Groups["p"].Value); if (p is null) continue;+ var binding = new ExactPointBinding(p[0], p[1], p[2], $"definition:{definition}:{name}:{point.Groups["name"].Value}");+ members.Add(new SemanticValue(binding.PointStableId, new("Point"), [new PointCapability()], [binding], exposedName: point.Groups["name"].Value));+ caps.Add(new PointCapability()); if (!bindings.OfType<ExactPointBinding>().Any()) bindings.Add(binding);+ }+ foreach (Match dim in Regex.Matches(block, @"\bDimension\s+(?<name>[A-Za-z_]\w*)\s*=\s*(?<nom>[-+]?\d+(?:\.\d+)?)mm(?:\s+tol\s+(?:(?<bil>\d+(?:\.\d+)?)mm|\+(?<plus>\d+(?:\.\d+)?)mm\s+-(?<minus>\d+(?:\.\d+)?)mm))?\s*;", RegexOptions.CultureInvariant))+ {+ var plus = dim.Groups["bil"].Success ? Number(dim.Groups["bil"].Value) : dim.Groups["plus"].Success ? Number(dim.Groups["plus"].Value) : 0;+ var minus = dim.Groups["bil"].Success ? Number(dim.Groups["bil"].Value) : dim.Groups["minus"].Success ? Number(dim.Groups["minus"].Value) : 0;+ var binding = new TolerancedDimensionBinding(Number(dim.Groups["nom"].Value), -minus, plus, "mm", $"definition:{definition}:{name}:{dim.Groups["name"].Value}");+ members.Add(new SemanticValue(binding.DimensionStableId, new("Length"), [new DimensionalCapability()], [binding], exposedName: dim.Groups["name"].Value,+ provenance: [new("Firmament-tol", dim.Groups["name"].Value, dim.Value, SemanticSourceSpan.Generated(sourceIdentity))]));+ caps.Add(new DimensionalCapability()); if (!bindings.OfType<TolerancedDimensionBinding>().Any()) bindings.Add(binding);+ }+ yield return new SemanticValue($"definition:{definition}:{name}", new("Concept"), caps.DistinctBy(x => x.GetType()), bindings, members,+ [new("part-definition", definition, name, SemanticSourceSpan.Generated(sourceIdentity))], exposedName: name);+ }+ }++ private static IReadOnlyList<MateSource> ParseMates(string body, string sourceIdentity, List<AssemblyDiagnostic> diagnostics)+ {+ var result = new List<MateSource>();+ foreach (Match header in Regex.Matches(body, @"\bMate\s+(?<name>[A-Za-z_]\w*)\s*:\s*(?<interface>[A-Za-z_]\w*)\s*\{", RegexOptions.CultureInvariant))+ {+ var block = BalancedBody(body, header.Index + header.Length - 1, diagnostics, "Mate"); if (block is null) continue;+ var roles = Regex.Matches(block, @"\b(?<role>[A-Za-z_]\w*)\s*:\s*(?<path>[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\s*;", RegexOptions.CultureInvariant)+ .Select(m => new MateRoleAssignment(m.Groups["role"].Value, AssemblyPath.Parse(m.Groups["path"].Value))).ToArray();+ result.Add(new(header.Groups["name"].Value, header.Groups["interface"].Value, roles, SemanticSourceSpan.Generated(sourceIdentity)));+ }+ return result;+ }++ private static IReadOnlyList<DimensionalRelationSource> ParseRelations(string body, List<AssemblyDiagnostic> diagnostics) =>+ Regex.Matches(body, @"\bRelation\s+(?<name>[A-Za-z_]\w*)\s*:\s*(?<from>[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\s*->\s*(?<to>[A-Za-z_]\w*(?:\.[A-Za-z_]\w*)*)\s*=\s*(?<nom>[-+]?\d+(?:\.\d+)?)mm(?:\s+tol\s+(?:(?<bil>\d+(?:\.\d+)?)mm|\+(?<plus>\d+(?:\.\d+)?)mm\s+-(?<minus>\d+(?:\.\d+)?)mm))?\s+from\s+""(?<provenance>[^""]+)""\s*;", RegexOptions.CultureInvariant)+ .Select(m => { var plus = m.Groups["bil"].Success ? Number(m.Groups["bil"].Value) : m.Groups["plus"].Success ? Number(m.Groups["plus"].Value) : 0; var minus = m.Groups["bil"].Success ? Number(m.Groups["bil"].Value) : m.Groups["minus"].Success ? Number(m.Groups["minus"].Value) : 0; return new DimensionalRelationSource(m.Groups["name"].Value, AssemblyPath.Parse(m.Groups["from"].Value), AssemblyPath.Parse(m.Groups["to"].Value), Number(m.Groups["nom"].Value), -minus, plus, "mm", m.Groups["provenance"].Value); }).ToArray();++ private static IReadOnlyList<ToleranceStackupAssertSource> ParseAsserts(string body, string sourceIdentity, List<AssemblyDiagnostic> diagnostics)+ {+ var result = new List<ToleranceStackupAssertSource>();+ foreach (Match header in Regex.Matches(body, @"\bAssert\s+ToleranceStackup\s+(?<name>[A-Za-z_]\w*)\s*\{", RegexOptions.CultureInvariant))+ {+ var block = BalancedBody(body, header.Index + header.Length - 1, diagnostics, "Assert ToleranceStackup"); if (block is null) continue;+ var between = Regex.Match(block, @"\bBetween\s*:\s*\[(?<from>[^,]+),\s*(?<to>[^]]+)\]\s*;");+ var require = Regex.Match(block, @"\bRequire\s*:\s*Clearance\s*>=\s*(?<min>[-+]?\d+(?:\.\d+)?)mm\s*;");+ if (!between.Success || !require.Success) { diagnostics.Add(new("assembly-tolerance-assert-invalid", $"Assert ToleranceStackup '{header.Groups["name"].Value}' requires Between and Clearance fields.")); continue; }+ result.Add(new(header.Groups["name"].Value, AssemblyPath.Parse(between.Groups["from"].Value.Trim()), AssemblyPath.Parse(between.Groups["to"].Value.Trim()), Number(require.Groups["min"].Value), "mm", SemanticSourceSpan.Generated(sourceIdentity)));+ }+ return result;+ }++ private static string? BalancedBody(string source, int openingBrace, List<AssemblyDiagnostic> diagnostics, string construct)+ {+ var depth = 0;+ for (var i = openingBrace; i < source.Length; i++)+ {+ if (source[i] == '{') depth++;+ else if (source[i] == '}' && --depth == 0) return source[(openingBrace + 1)..i];+ }+ diagnostics.Add(new("assembly-parse-unbalanced", $"{construct} has an unclosed body.")); return null;+ }++ private static string RemoveBlocks(string source, params string[] names)+ {+ var value = source;+ foreach (var name in names) value = Regex.Replace(value, $@"\b{name}\b[^{{]*\{{(?:[^{{}}]|\{{[^{{}}]*\}})*\}}", string.Empty, RegexOptions.CultureInvariant);+ return value;+ }+ private static double[]? Vector(string text)+ { var values = text.Split(',', StringSplitOptions.TrimEntries).Select(x => double.TryParse(x, NumberStyles.Float, CultureInfo.InvariantCulture, out var n) ? n : double.NaN).ToArray(); return values.Length == 3 && values.All(double.IsFinite) ? values : null; }+ private static double Number(string text) => double.Parse(text, NumberStyles.Float, CultureInfo.InvariantCulture);+}++public sealed class AssemblyM0Pipeline+{+ public AssemblyCompilationResult CompileFile(string path)+ {+ var parsed = new AssemblyM0Parser().ParseFile(path);+ if (!parsed.IsSuccess) return new(null, parsed.Diagnostics);+ return new AssemblyM0Compiler().Compile(parsed.Source!, parsed.ElapsedMilliseconds);+ }+}diff --git a/Aetheris.Kernel.Firmament/Assembly/FirmasmAssemblyExecutor.cs b/Aetheris.Kernel.Firmament/Assembly/FirmasmAssemblyExecutor.csindex 4bab0da7..80bad05c 100644--- a/Aetheris.Kernel.Firmament/Assembly/FirmasmAssemblyExecutor.cs+++ b/Aetheris.Kernel.Firmament/Assembly/FirmasmAssemblyExecutor.cs@@ -34,7 +34,10 @@ public sealed class FirmasmAssemblyExecutorreturn KernelResult<FirmasmExecutionResult>.Failure(loadResult.Diagnostics);}- return Execute(loadResult.Value);+ var execute = Execute(loadResult.Value);+ return execute.IsSuccess+ ? KernelResult<FirmasmExecutionResult>.Success(execute.Value, [.. loadResult.Diagnostics, .. execute.Diagnostics])+ : execute;}public KernelResult<FirmasmExecutionResult> Execute(FirmasmLoadedAssembly loadedAssembly)diff --git a/Aetheris.Kernel.Firmament/Assembly/FirmasmManifestLoader.cs b/Aetheris.Kernel.Firmament/Assembly/FirmasmManifestLoader.csindex 6486caaa..d9d7b897 100644--- a/Aetheris.Kernel.Firmament/Assembly/FirmasmManifestLoader.cs+++ b/Aetheris.Kernel.Firmament/Assembly/FirmasmManifestLoader.cs@@ -59,7 +59,9 @@ public sealed class FirmasmManifestLoadernew FirmasmLoadedAssembly(SourcePath: Path.GetFullPath(manifestPath),Manifest: parseResult.Value,- LoadedParts: loadPartsResult.Value));+ LoadedParts: loadPartsResult.Value),+ [new KernelDiagnostic(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Warning,+ "legacy-firmasm-deprecation: .firmasm is a transform-first compatibility format; migrate to typed Firmament Assembly/Interface/Mate source.", Source: "firmasm")]);}public KernelResult<FirmasmManifest> Parse(string sourceText)diff --git a/Aetheris.Semantics/SemanticModel.cs b/Aetheris.Semantics/SemanticModel.csindex 5b03f30b..259c7ea1 100644--- a/Aetheris.Semantics/SemanticModel.cs+++ b/Aetheris.Semantics/SemanticModel.cs@@ -29,6 +29,10 @@ public sealed record ComposeOperandCapability : ISemanticCapability { public strpublic sealed record BodyCapability : ISemanticCapability { public string Name => "BodyCapable"; }public sealed record MaterialRegionCapability : ISemanticCapability { public string Name => "MaterialRegionCapable"; }public sealed record AnalysisRegionCapability : ISemanticCapability { public string Name => "AnalysisRegionCapable"; }+public sealed record AxisCapability : ISemanticCapability { public string Name => "AxisCapable"; }+public sealed record PlaneCapability : ISemanticCapability { public string Name => "PlaneCapable"; }+public sealed record PointCapability : ISemanticCapability { public string Name => "PointCapable"; }+public sealed record DimensionalCapability : ISemanticCapability { public string Name => "DimensionalCapable"; }public sealed class SemanticCapabilitySet{@@ -73,6 +77,30 @@ public sealed record ConstructionIdentityBinding(string ConstructionStableId)public sealed record ImportedEntityBinding(string ResourceIdentity, IReadOnlyList<string> EntityIds): SemanticBinding("ImportedEntities", ResourceIdentity + ":" + string.Join(",", EntityIds.Order(StringComparer.Ordinal)));+/// <summary>Exact analytic assembly datum. Coordinates are nominal millimetres in definition-local space.</summary>+public sealed record ExactAxisBinding(+ double OriginX, double OriginY, double OriginZ,+ double DirectionX, double DirectionY, double DirectionZ,+ string AxisStableId) : SemanticBinding("ExactAxis", AxisStableId);++public sealed record ExactPlaneBinding(+ double OriginX, double OriginY, double OriginZ,+ double NormalX, double NormalY, double NormalZ,+ string PlaneStableId) : SemanticBinding("ExactPlane", PlaneStableId);++public sealed record ExactPointBinding(double X, double Y, double Z, string PointStableId)+ : SemanticBinding("ExactPoint", PointStableId);++/// <summary>Symbolic engineering dimension. Tolerance never perturbs nominal geometry.</summary>+public sealed record TolerancedDimensionBinding(+ double Nominal, double LowerTolerance, double UpperTolerance, string Unit,+ string DimensionStableId, string? Direction = null)+ : SemanticBinding("TolerancedDimension", DimensionStableId)+{+ public double Minimum => Nominal + LowerTolerance;+ public double Maximum => Nominal + UpperTolerance;+}+/// <summary>Exact analytic/BRep boundary identity normalized before AnalysisIR; never a mesh identifier.</summary>public sealed record ExactAnalysisRegionBinding(string BodyStableId, string RegionPath, string? ExactBrepFaceId = null): SemanticBinding("ExactAnalysisRegion", BodyStableId + ":" + RegionPath + ":" + (ExactBrepFaceId ?? "analytic"));@@ -180,6 +208,10 @@ public static class SemanticValueValidator&& !value.TryBinding<ExactAnalysisRegionBinding>(out _))diagnostics.Add(new(NoExactBinding, $"BoundaryRegionCapable on '{value.StableIdentity}' requires an exact BRep face or region binding.", value.AuthoredSourceSpan));RequireBinding<BodyCapability, ExactBrepBodyBinding>(value, diagnostics);+ RequireBinding<AxisCapability, ExactAxisBinding>(value, diagnostics);+ RequireBinding<PlaneCapability, ExactPlaneBinding>(value, diagnostics);+ RequireBinding<PointCapability, ExactPointBinding>(value, diagnostics);+ RequireBinding<DimensionalCapability, TolerancedDimensionBinding>(value, diagnostics);RequireAnyExactBinding<ExactGeometryCapability>(value, diagnostics);RequireAnyExactBinding<SelectableCapability>(value, diagnostics);RequireBinding<ComposeOperandCapability, ExactProfileBinding>(value, diagnostics);diff --git a/README.md b/README.mdindex 895d86e1..d2dc21f6 100644--- a/README.md+++ b/README.md@@ -51,7 +51,7 @@ limitations are at [yuechen-li-dev.github.io/aetheris](https://yuechen-li-dev.gi- schema-aware CNC minimum tool radius validation- deterministic canonical formatting for supported `.firmament` source- STEP AP242 export for the current single-body golden path-- assembly runtime via `.firmasm` (`asm exec`) and bounded per-instance roundtrip export (`asm export`)+- typed relational assembly inspection (`asm inspect`) plus legacy `.firmasm` execution/export compatibility## 30-second demo@@ -132,7 +132,7 @@ Use `Aetheris.slnx` as the only solution entrypoint. For legacy Firmament V1/Fri## Docs-- assembly model and contracts (canonical): `docs/assembly.md`+- assembly model and contracts (canonical): `docs/assembly/architecture.md`- overview: `docs/firmament-overview.md`- build/export workflow: `docs/firmament-build-workflow.md`- selector contracts: `docs/firmament-selectors.md`@@ -140,7 +140,7 @@ Use `Aetheris.slnx` as the only solution entrypoint. For legacy Firmament V1/Fri## Assembly model snapshot-- `.firmasm` is authoritative for assembly semantics in Aetheris.+- Firmament Assembly source lowers to normalized AssemblyIR; `.firmasm` is a deprecated transform-first compatibility lane.- STEP is treated as foreign interop input/output.- Multi-root STEP is assembly-like input and must route through assembly extraction/import, not single-part import.- Current roundtrip export is intentionally bounded to per-instance STEP + `roundtrip.package.json`.diff --git a/docs/assembly.md b/docs/assembly.mdindex b636c36f..171b9cb7 100644--- a/docs/assembly.md+++ b/docs/assembly.md@@ -1,11 +1,11 @@-# Aetheris assembly model (ASM-A5 canonical)+# Aetheris legacy assembly model (ASM-A5 compatibility lane)-This document is the authoritative assembly contract for Aetheris v0.+This document records the deprecated flat `.firmasm` compatibility lane. The canonical typed architecture is [assembly/architecture.md](assembly/architecture.md). AETHERIS-ASSEMBLY-M0 intentionally supersedes the authority claims below; they remain here to explain legacy fixtures and commands.## 1) Core philosophy- STEP/AP242 is a **foreign interchange format**.-- `.firmasm` is Aetheris's **authoritative internal assembly representation**.+- `.firmasm` was Aetheris's authoritative v0 representation and is now legacy compatibility input.- Aetheris does not adopt or normalize away STEP assembly ambiguity as native semantics.- Assembly behavior is defined by Aetheris contracts (`.firmasm`, executor, bounded exporter), not by importer guesswork.@@ -185,7 +185,7 @@ These commands are part of the current assembly-adjacent workflow:## 8) Invariants (non-negotiable)-- `.firmasm` is authoritative for Aetheris assemblies.+- Typed Firmament Assembly source and normalized AssemblyIR are authoritative; `.firmasm` is legacy transform-first input.- STEP assembly is not native authority in Aetheris.- Multi-root STEP is assembly-like input, never native multi-body part.- Execution in v0 is flat + rigid only.diff --git a/docs/assembly/architecture.md b/docs/assembly/architecture.mdnew file mode 100644index 00000000..43a52ddb--- /dev/null+++ b/docs/assembly/architecture.md@@ -0,0 +1,15 @@+# Assembly architecture++AETHERIS-ASSEMBLY-M0 defines two independent structures. The **assembly tree** is the authoritative product/BOM hierarchy: assemblies and part instances have a parent, ordered children, a definition identity, and a deterministic instance path. The **Mate graph** connects compatible `SemanticValue` participants reachable through that hierarchy. Tree ancestry never implies a Mate, and a Mate may connect siblings, cousins, or exposed subassembly participants.++A part instance and a subassembly instance are distinct occurrences of a definition. `BearingModule.Rotor.Shaft` is a structured compiler path; its stable ID is `assembly-instance:BearingModule.Rotor.Shaft`. Exposed definition semantics are cloned into the instance scope, so `LeftBolt.Shank` and `RightBolt.Shank` retain common definition provenance but never share final semantic IDs.++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.++## Placement convention++`Anchor: path;` fixes the containing part occurrence at identity. Axis coincidence is solved analytically with double-precision rigid rotation and translation. Axis-plus-plane seating removes axial translation. Remaining translations and rotations are reported; an Interface may explicitly admit a symmetry freedom such as `rotation:about-axis`. Multiple Mate-derived transforms for one instance are compared and conflicting translations produce `assembly-placement-overconstrained`; there is no last-mate-wins behavior.++M0 intentionally does not implement general nonlinear solving, kinematics, contact, assembly FEA, auto-fastener selection, or random/statistical tolerancing.diff --git a/docs/assembly/artifacts/m0/assembly-ir.json b/docs/assembly/artifacts/m0/assembly-ir.jsonnew file mode 100644index 00000000..2fd9a66e--- /dev/null+++ b/docs/assembly/artifacts/m0/assembly-ir.json@@ -0,0 +1,2410 @@+{+ "success": true,+ "assemblyIr": {+ "schema": "aetheris/assembly-ir/m0",+ "stableId": "assembly:BearingModule",+ "name": "BearingModule",+ "rootInstanceStableId": "assembly-instance:BearingModule",+ "instances": [+ {+ "stableId": "assembly-instance:BearingModule",+ "path": {+ "segments": [+ "BearingModule"+ ]+ },+ "kind": "Assembly",+ "definitionIdentity": "BearingModule",+ "parentStableId": null,+ "childrenStableIds": [+ "assembly-instance:BearingModule.FixedSupport",+ "assembly-instance:BearingModule.Rotor"+ ],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule",+ "type": {+ "name": "Assembly",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule",+ "evidence": "BearingModule",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": null+ },+ "localTransform": null,+ "resolvedTransform": null,+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "BearingModule",+ "evidence": "BearingModule",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:BearingModule.FixedSupport",+ "path": {+ "segments": [+ "BearingModule",+ "FixedSupport"+ ]+ },+ "kind": "Assembly",+ "definitionIdentity": "FixedSupport",+ "parentStableId": "assembly-instance:BearingModule",+ "childrenStableIds": [+ "assembly-instance:BearingModule.FixedSupport.Bearing",+ "assembly-instance:BearingModule.FixedSupport.Housing"+ ],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport",+ "type": {+ "name": "Assembly",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport",+ "evidence": "FixedSupport",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": null+ },+ "localTransform": null,+ "resolvedTransform": null,+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "FixedSupport",+ "evidence": "FixedSupport",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:BearingModule.Rotor",+ "path": {+ "segments": [+ "BearingModule",+ "Rotor"+ ]+ },+ "kind": "Assembly",+ "definitionIdentity": "Rotor",+ "parentStableId": "assembly-instance:BearingModule",+ "childrenStableIds": [+ "assembly-instance:BearingModule.Rotor.Shaft",+ "assembly-instance:BearingModule.Rotor.Spacer"+ ],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor",+ "type": {+ "name": "Assembly",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor",+ "evidence": "Rotor",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": null+ },+ "localTransform": null,+ "resolvedTransform": null,+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "Rotor",+ "evidence": "Rotor",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:BearingModule.FixedSupport.Housing",+ "path": {+ "segments": [+ "BearingModule",+ "FixedSupport",+ "Housing"+ ]+ },+ "kind": "Part",+ "definitionIdentity": "HousingPart",+ "parentStableId": "assembly-instance:BearingModule.FixedSupport",+ "childrenStableIds": [],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing",+ "type": {+ "name": "Part",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {+ "Bore": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:Bore",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ },+ {+ "name": "DimensionalCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:HousingPart:Bore:Axis"+ },+ {+ "kind": "TolerancedDimension",+ "stableBindingIdentity": "definition:HousingPart:Bore:Diameter"+ }+ ],+ "exposedMembers": {+ "Axis": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:Bore.Axis",+ "type": {+ "name": "Axis",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:HousingPart:Bore:Axis"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:Bore:Axis",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Axis"+ },+ "Diameter": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:Bore.Diameter",+ "type": {+ "name": "Length",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "DimensionalCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "TolerancedDimension",+ "stableBindingIdentity": "definition:HousingPart:Bore:Diameter"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "Firmament-tol",+ "identity": "Diameter",+ "evidence": "Dimension Diameter = 20.04mm tol \u002B0.02mm -0.01mm;",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:Bore:Diameter",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Diameter"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "HousingPart",+ "evidence": "Bore",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:Bore",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Bore"+ },+ "Datum": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:Datum",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:HousingPart:Datum:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:Datum.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:HousingPart:Datum:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:Datum:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "HousingPart",+ "evidence": "Datum",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:Datum",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Datum"+ },+ "SeatDatum": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatDatum",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:HousingPart:SeatDatum:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatDatum.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:HousingPart:SeatDatum:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:SeatDatum:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "HousingPart",+ "evidence": "SeatDatum",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:SeatDatum",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "SeatDatum"+ },+ "SeatInterface": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatInterface",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ },+ {+ "name": "PlaneCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:HousingPart:SeatInterface:Axis"+ },+ {+ "kind": "ExactPlane",+ "stableBindingIdentity": "definition:HousingPart:SeatInterface:Seat"+ }+ ],+ "exposedMembers": {+ "Axis": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatInterface.Axis",+ "type": {+ "name": "Axis",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:HousingPart:SeatInterface:Axis"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:SeatInterface:Axis",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Axis"+ },+ "Seat": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatInterface.Seat",+ "type": {+ "name": "Plane",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PlaneCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPlane",+ "stableBindingIdentity": "definition:HousingPart:SeatInterface:Seat"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:SeatInterface:Seat",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Seat"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "HousingPart",+ "evidence": "SeatInterface",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:SeatInterface",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "SeatInterface"+ }+ },+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "HousingPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.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": "Housing",+ "evidence": "HousingPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:BearingModule.FixedSupport.Bearing",+ "path": {+ "segments": [+ "BearingModule",+ "FixedSupport",+ "Bearing"+ ]+ },+ "kind": "Part",+ "definitionIdentity": "Bearing6204",+ "parentStableId": "assembly-instance:BearingModule.FixedSupport",+ "childrenStableIds": [],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing",+ "type": {+ "name": "Part",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {+ "Bore": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Bore",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ },+ {+ "name": "DimensionalCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:Bearing6204:Bore:Axis"+ },+ {+ "kind": "TolerancedDimension",+ "stableBindingIdentity": "definition:Bearing6204:Bore:Diameter"+ }+ ],+ "exposedMembers": {+ "Axis": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Bore.Axis",+ "type": {+ "name": "Axis",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:Bearing6204:Bore:Axis"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Bore:Axis",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Axis"+ },+ "Diameter": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Bore.Diameter",+ "type": {+ "name": "Length",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "DimensionalCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "TolerancedDimension",+ "stableBindingIdentity": "definition:Bearing6204:Bore:Diameter"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "Firmament-tol",+ "identity": "Diameter",+ "evidence": "Dimension Diameter = 20.00mm tol \u002B0.00mm -0.008mm;",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Bore:Diameter",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Diameter"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "Bearing6204",+ "evidence": "Bore",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Bore",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Bore"+ },+ "Left": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Left",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:Bearing6204:Left:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Left.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:Bearing6204:Left:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Left:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "Bearing6204",+ "evidence": "Left",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Left",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Left"+ },+ "Right": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Right",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:Bearing6204:Right:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Right.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:Bearing6204:Right:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Right:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "Bearing6204",+ "evidence": "Right",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Right",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Right"+ }+ },+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "Bearing6204",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.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,+ -15,+ 1+ ]+ },+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "Bearing",+ "evidence": "Bearing6204",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:BearingModule.Rotor.Spacer",+ "path": {+ "segments": [+ "BearingModule",+ "Rotor",+ "Spacer"+ ]+ },+ "kind": "Part",+ "definitionIdentity": "SpacerPart",+ "parentStableId": "assembly-instance:BearingModule.Rotor",+ "childrenStableIds": [],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Spacer",+ "type": {+ "name": "Part",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {+ "Left": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Spacer:Left",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:SpacerPart:Left:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Spacer:Left.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:SpacerPart:Left:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Spacer",+ "evidence": "definition:SpacerPart:Left:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "SpacerPart",+ "evidence": "Left",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Spacer",+ "evidence": "definition:SpacerPart:Left",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Left"+ },+ "Right": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Spacer:Right",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:SpacerPart:Right:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Spacer:Right.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:SpacerPart:Right:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Spacer",+ "evidence": "definition:SpacerPart:Right:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "SpacerPart",+ "evidence": "Right",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Spacer",+ "evidence": "definition:SpacerPart:Right",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Right"+ }+ },+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Spacer",+ "evidence": "SpacerPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": null+ },+ "localTransform": null,+ "resolvedTransform": null,+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "Spacer",+ "evidence": "SpacerPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:BearingModule.Rotor.Shaft",+ "path": {+ "segments": [+ "BearingModule",+ "Rotor",+ "Shaft"+ ]+ },+ "kind": "Part",+ "definitionIdentity": "ShaftPart",+ "parentStableId": "assembly-instance:BearingModule.Rotor",+ "childrenStableIds": [],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft",+ "type": {+ "name": "Part",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {+ "Journal": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:Journal",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ },+ {+ "name": "DimensionalCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:ShaftPart:Journal:Axis"+ },+ {+ "kind": "TolerancedDimension",+ "stableBindingIdentity": "definition:ShaftPart:Journal:Diameter"+ }+ ],+ "exposedMembers": {+ "Axis": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:Journal.Axis",+ "type": {+ "name": "Axis",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:ShaftPart:Journal:Axis"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:Journal:Axis",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Axis"+ },+ "Diameter": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:Journal.Diameter",+ "type": {+ "name": "Length",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "DimensionalCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "TolerancedDimension",+ "stableBindingIdentity": "definition:ShaftPart:Journal:Diameter"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "Firmament-tol",+ "identity": "Diameter",+ "evidence": "Dimension Diameter = 19.98mm tol \u002B0.01mm -0.01mm;",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:Journal:Diameter",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Diameter"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "ShaftPart",+ "evidence": "Journal",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:Journal",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Journal"+ },+ "Shoulder": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:Shoulder",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:ShaftPart:Shoulder:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:Shoulder.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:ShaftPart:Shoulder:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:Shoulder:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "ShaftPart",+ "evidence": "Shoulder",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:Shoulder",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Shoulder"+ },+ "ShoulderInterface": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:ShoulderInterface",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ },+ {+ "name": "PlaneCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:ShaftPart:ShoulderInterface:Axis"+ },+ {+ "kind": "ExactPlane",+ "stableBindingIdentity": "definition:ShaftPart:ShoulderInterface:Seat"+ }+ ],+ "exposedMembers": {+ "Axis": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:ShoulderInterface.Axis",+ "type": {+ "name": "Axis",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:ShaftPart:ShoulderInterface:Axis"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:ShoulderInterface:Axis",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Axis"+ },+ "Seat": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:ShoulderInterface.Seat",+ "type": {+ "name": "Plane",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PlaneCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPlane",+ "stableBindingIdentity": "definition:ShaftPart:ShoulderInterface:Seat"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:ShoulderInterface:Seat",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Seat"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "ShaftPart",+ "evidence": "ShoulderInterface",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:ShoulderInterface",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "ShoulderInterface"+ }+ },+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "ShaftPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.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,+ -15,+ 1+ ]+ },+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "Shaft",+ "evidence": "ShaftPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ }+ ],+ "interfaces": [+ {+ "stableId": "interface:ShaftBore",+ "name": "ShaftBore",+ "roles": [+ {+ "name": "Shaft",+ "requiredCapabilities": [+ "AxisCapable",+ "DimensionalCapable"+ ],+ "minimum": 1,+ "maximum": 1+ },+ {+ "name": "Bore",+ "requiredCapabilities": [+ "AxisCapable",+ "DimensionalCapable"+ ],+ "minimum": 1,+ "maximum": 1+ }+ ],+ "requirements": [+ {+ "kind": "AxisCoincident",+ "firstRole": "Shaft",+ "firstMember": "Axis",+ "secondRole": "Bore",+ "secondMember": "Axis",+ "offsetMm": 0+ }+ ],+ "fit": {+ "shaftRole": "Shaft",+ "shaftDimension": "Diameter",+ "boreRole": "Bore",+ "boreDimension": "Diameter"+ },+ "admittedFreeMotions": [+ "translation:along-axis",+ "rotation:about-axis"+ ],+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stableId": "interface:ShoulderBearingSeat",+ "name": "ShoulderBearingSeat",+ "roles": [+ {+ "name": "Shoulder",+ "requiredCapabilities": [+ "AxisCapable",+ "PlaneCapable"+ ],+ "minimum": 1,+ "maximum": 1+ },+ {+ "name": "Seat",+ "requiredCapabilities": [+ "AxisCapable",+ "PlaneCapable"+ ],+ "minimum": 1,+ "maximum": 1+ }+ ],+ "requirements": [+ {+ "kind": "AxisCoincident",+ "firstRole": "Shoulder",+ "firstMember": "Axis",+ "secondRole": "Seat",+ "secondMember": "Axis",+ "offsetMm": 0+ },+ {+ "kind": "PlaneCoincident",+ "firstRole": "Shoulder",+ "firstMember": "Seat",+ "secondRole": "Seat",+ "secondMember": "Seat",+ "offsetMm": 0+ }+ ],+ "fit": null,+ "admittedFreeMotions": [+ "rotation:about-axis"+ ],+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "mates": [+ {+ "stableId": "mate:BearingModule:ShaftInBearing",+ "name": "ShaftInBearing",+ "interfaceStableId": "interface:ShaftBore",+ "roles": [+ {+ "role": "Shaft",+ "participantPath": {+ "segments": [+ "BearingModule",+ "Rotor",+ "Shaft",+ "Journal"+ ]+ },+ "participantSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:Journal",+ "requiredCapabilities": [+ "AxisCapable",+ "DimensionalCapable"+ ]+ },+ {+ "role": "Bore",+ "participantPath": {+ "segments": [+ "BearingModule",+ "FixedSupport",+ "Bearing",+ "Bore"+ ]+ },+ "participantSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Bearing:Bore",+ "requiredCapabilities": [+ "AxisCapable",+ "DimensionalCapable"+ ]+ }+ ],+ "constraintIds": [+ "constraint:mate:BearingModule:ShaftInBearing:00"+ ],+ "validationStatus": "valid"+ },+ {+ "stableId": "mate:BearingModule:ShaftShoulderAtHousing",+ "name": "ShaftShoulderAtHousing",+ "interfaceStableId": "interface:ShoulderBearingSeat",+ "roles": [+ {+ "role": "Shoulder",+ "participantPath": {+ "segments": [+ "BearingModule",+ "Rotor",+ "Shaft",+ "ShoulderInterface"+ ]+ },+ "participantSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:ShoulderInterface",+ "requiredCapabilities": [+ "AxisCapable",+ "PlaneCapable"+ ]+ },+ {+ "role": "Seat",+ "participantPath": {+ "segments": [+ "BearingModule",+ "FixedSupport",+ "Housing",+ "SeatInterface"+ ]+ },+ "participantSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatInterface",+ "requiredCapabilities": [+ "AxisCapable",+ "PlaneCapable"+ ]+ }+ ],+ "constraintIds": [+ "constraint:mate:BearingModule:ShaftShoulderAtHousing:00",+ "constraint:mate:BearingModule:ShaftShoulderAtHousing:01"+ ],+ "validationStatus": "valid"+ }+ ],+ "placementConstraints": [+ {+ "stableId": "constraint:mate:BearingModule:ShaftInBearing:00",+ "kind": "AxisCoincident",+ "mateStableId": "mate:BearingModule:ShaftInBearing",+ "firstSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:Journal.Axis",+ "secondSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Bearing:Bore.Axis",+ "offsetMm": 0,+ "residual": 0,+ "status": "admitted"+ },+ {+ "stableId": "constraint:mate:BearingModule:ShaftShoulderAtHousing:00",+ "kind": "AxisCoincident",+ "mateStableId": "mate:BearingModule:ShaftShoulderAtHousing",+ "firstSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:ShoulderInterface.Axis",+ "secondSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatInterface.Axis",+ "offsetMm": 0,+ "residual": 0,+ "status": "admitted"+ },+ {+ "stableId": "constraint:mate:BearingModule:ShaftShoulderAtHousing:01",+ "kind": "PlaneCoincident",+ "mateStableId": "mate:BearingModule:ShaftShoulderAtHousing",+ "firstSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:ShoulderInterface.Seat",+ "secondSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatInterface.Seat",+ "offsetMm": 0,+ "residual": 0,+ "status": "admitted"+ }+ ],+ "placements": [+ {+ "instanceStableId": "assembly-instance:BearingModule",+ "status": "Unresolved",+ "transform": null,+ "freeTranslations": [+ "X",+ "Y",+ "Z"+ ],+ "freeRotations": [+ "X",+ "Y",+ "Z"+ ],+ "constraintIds": []+ },+ {+ "instanceStableId": "assembly-instance:BearingModule.FixedSupport",+ "status": "Unresolved",+ "transform": null,+ "freeTranslations": [+ "X",+ "Y",+ "Z"+ ],+ "freeRotations": [+ "X",+ "Y",+ "Z"+ ],+ "constraintIds": []+ },+ {+ "instanceStableId": "assembly-instance:BearingModule.Rotor",+ "status": "Unresolved",+ "transform": null,+ "freeTranslations": [+ "X",+ "Y",+ "Z"+ ],+ "freeRotations": [+ "X",+ "Y",+ "Z"+ ],+ "constraintIds": []+ },+ {+ "instanceStableId": "assembly-instance:BearingModule.FixedSupport.Housing",+ "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:BearingModule.FixedSupport.Bearing",+ "status": "Resolved",+ "transform": {+ "matrix": [+ 1,+ 0,+ 0,+ 0,+ 0,+ 1,+ 0,+ 0,+ 0,+ 0,+ 1,+ 0,+ 0,+ 0,+ -15,+ 1+ ]+ },+ "freeTranslations": [],+ "freeRotations": [],+ "constraintIds": [+ "constraint:mate:BearingModule:ShaftInBearing:00"+ ]+ },+ {+ "instanceStableId": "assembly-instance:BearingModule.Rotor.Spacer",+ "status": "Unresolved",+ "transform": null,+ "freeTranslations": [+ "X",+ "Y",+ "Z"+ ],+ "freeRotations": [+ "X",+ "Y",+ "Z"+ ],+ "constraintIds": []+ },+ {+ "instanceStableId": "assembly-instance:BearingModule.Rotor.Shaft",+ "status": "Resolved",+ "transform": {+ "matrix": [+ 1,+ 0,+ 0,+ 0,+ 0,+ 1,+ 0,+ 0,+ 0,+ 0,+ 1,+ 0,+ 0,+ 0,+ -15,+ 1+ ]+ },+ "freeTranslations": [],+ "freeRotations": [],+ "constraintIds": [+ "constraint:mate:BearingModule:ShaftInBearing:00",+ "constraint:mate:BearingModule:ShaftShoulderAtHousing:00",+ "constraint:mate:BearingModule:ShaftShoulderAtHousing:01"+ ]+ }+ ],+ "dimensionalRelations": [+ {+ "stableId": "dimension-relation:BearingModule:HousingSeatDepth",+ "fromSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:Datum",+ "toSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatDatum",+ "nominal": 30,+ "lowerTolerance": -0.04,+ "upperTolerance": 0.05,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "BearingModule.FixedSupport.Housing",+ "provenance": "HousingTable.H6204.SeatDepth",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:BearingModule:HousingToBearing",+ "fromSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatDatum",+ "toSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Bearing:Left",+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "BearingModule.FixedSupport.Housing",+ "provenance": "Mate:HousingBearingSeat",+ "mateStableId": "mate-reference:HousingBearingSeat",+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:BearingModule:BearingWidth",+ "fromSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Bearing:Left",+ "toSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Bearing:Right",+ "nominal": 10,+ "lowerTolerance": -0.02,+ "upperTolerance": 0.02,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "BearingModule.FixedSupport.Bearing",+ "provenance": "BearingTable.6204.Width",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:BearingModule:BearingToSpacer",+ "fromSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Bearing:Right",+ "toSemanticValueId": "assembly-semantic:BearingModule.Rotor.Spacer:Left",+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "BearingModule.FixedSupport.Bearing",+ "provenance": "Mate:BearingSpacer",+ "mateStableId": "mate-reference:BearingSpacer",+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:BearingModule:SpacerWidth",+ "fromSemanticValueId": "assembly-semantic:BearingModule.Rotor.Spacer:Left",+ "toSemanticValueId": "assembly-semantic:BearingModule.Rotor.Spacer:Right",+ "nominal": 5,+ "lowerTolerance": -0.02,+ "upperTolerance": 0.03,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "BearingModule.Rotor.Spacer",+ "provenance": "SpacerTemplate.Width",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:BearingModule:SpacerToShoulder",+ "fromSemanticValueId": "assembly-semantic:BearingModule.Rotor.Spacer:Right",+ "toSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:Shoulder",+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "BearingModule.Rotor.Spacer",+ "provenance": "Mate:SpacerShoulder",+ "mateStableId": "mate-reference:SpacerShoulder",+ "interfaceStableId": null+ }+ ],+ "toleranceStackups": [+ {+ "name": "AxialReach",+ "startSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:Datum",+ "endSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:Shoulder",+ "nominal": 45,+ "worstCaseMinimum": 44.92,+ "worstCaseMaximum": 45.1,+ "requiredMinimum": 44.9,+ "unit": "mm",+ "passed": true,+ "status": "passed",+ "contributions": [+ {+ "relationStableId": "dimension-relation:BearingModule:HousingSeatDepth",+ "sign": 1,+ "nominal": 30,+ "lowerTolerance": -0.04,+ "upperTolerance": 0.05,+ "unit": "mm",+ "originInstancePath": "BearingModule.FixedSupport.Housing",+ "provenance": "HousingTable.H6204.SeatDepth",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:BearingModule:HousingToBearing",+ "sign": 1,+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "originInstancePath": "BearingModule.FixedSupport.Housing",+ "provenance": "Mate:HousingBearingSeat",+ "mateStableId": "mate-reference:HousingBearingSeat",+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:BearingModule:BearingWidth",+ "sign": 1,+ "nominal": 10,+ "lowerTolerance": -0.02,+ "upperTolerance": 0.02,+ "unit": "mm",+ "originInstancePath": "BearingModule.FixedSupport.Bearing",+ "provenance": "BearingTable.6204.Width",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:BearingModule:BearingToSpacer",+ "sign": 1,+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "originInstancePath": "BearingModule.FixedSupport.Bearing",+ "provenance": "Mate:BearingSpacer",+ "mateStableId": "mate-reference:BearingSpacer",+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:BearingModule:SpacerWidth",+ "sign": 1,+ "nominal": 5,+ "lowerTolerance": -0.02,+ "upperTolerance": 0.03,+ "unit": "mm",+ "originInstancePath": "BearingModule.Rotor.Spacer",+ "provenance": "SpacerTemplate.Width",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:BearingModule:SpacerToShoulder",+ "sign": 1,+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "originInstancePath": "BearingModule.Rotor.Spacer",+ "provenance": "Mate:SpacerShoulder",+ "mateStableId": "mate-reference:SpacerShoulder",+ "interfaceStableId": null+ }+ ]+ }+ ],+ "fitResults": [+ {+ "mateStableId": "mate:BearingModule:ShaftInBearing",+ "nominalClearance": 0.019999999999999574,+ "worstCaseMinimum": 0.0019999999999988916,+ "worstCaseMaximum": 0.030000000000001137,+ "unit": "mm",+ "compatible": true+ }+ ],+ "diagnostics": []+ },+ "diagnostics": [],+ "performance": null+}diff --git a/docs/assembly/artifacts/m0/current-firmasm-audit.md b/docs/assembly/artifacts/m0/current-firmasm-audit.mdnew file mode 100644index 00000000..46bdddc1--- /dev/null+++ b/docs/assembly/artifacts/m0/current-firmasm-audit.md@@ -0,0 +1,21 @@+# Current assembly audit++Audit date: 2026-08-09. Ground truth: `aetheris asm --help`, production source, tests, fixtures, and current STEP docs.++| Existing piece | Classification | Evidence / M0 decision |+|---|---|---|+| `FirmasmManifestLoader` strict JSON/schema validation and path loading | legacy compatibility only | Sound validation, but its flat `parts` + `instances` schema cannot express hierarchy, semantics, Interfaces, or Mates. Retained for `asm exec/export`. |+| `FirmasmAssemblyExecutor` rigid BRep transform/composition | salvage later | Exact world-space transform application and deterministic ID remapping can serve a future AssemblyIR geometry executor, but M0 does not pretend authored transforms are Mate solving. |+| `.firmasm` transform-first authoring | architectural dead end | Every instance requires `translate`; hierarchy and relationship intent are absent. It no longer defines the canonical model. |+| `FirmasmAssemblyRoundtripExporter` | legacy compatibility only | Truthfully emits one STEP per instance plus package JSON. It is not AP242 assembly structure. |+| STEP multi-root classifier/extraction studies | salvage | Root classification and NAUO/CDSR/IDT traversal evidence remain valuable for future import, independent of native semantics. |+| Part-instance identity | migrate | Old unique string IDs become structured `AssemblyPath` plus deterministic stable IDs. Definition identity is preserved separately. |+| Nested assemblies | missing / replaced | Old execution flattens; M0 keeps explicit parent/children nodes and does not flatten authority. |+| Mates/constraints | missing / new architecture | No old Mate idea constrained the design. M0 adds relational Interface definitions and an independent Mate graph. |+| BOM | missing / seam added | Deterministic tree inspection and definition identity now provide quantity grouping inputs; ERP behavior stays out of scope. |+| AP242 assembly export | exact missing capability documented | Current exporter has single-body/per-instance support, not `PRODUCT_DEFINITION`/NAUO/mapped-item assembly authoring. No false proof was added. |+| Tests/docs/CLI | migrate | Old tests remain for compatibility. New tests and `asm inspect` cover canonical M0. `docs/assembly.md` is marked legacy. |++The existing `let` audit found typed immutable scalar/Record lets, aliases, expression dependencies, and dimensional units. The existing `tol` audit found bilateral and asymmetric syntax, `mm`/`deg` checks, declaration binding, alias preservation, Table/Template-compatible provenance, and a warning when arithmetic drops tolerance. M0 reuses the same nominal/lower/upper semantics in `TolerancedDimensionBinding`; it does not change nominal geometry.++InlineStep recognized values already produce `SemanticValue`, but current recognition does not generally prove assembly axes plus toleranced dimensions. M0 therefore documents this seam rather than inventing recognition. Forge extension output also already enters through validated `SemanticValue`; no origin branch was added, but an end-to-end Forge-authored assembly fixture was not attempted because assembly source does not yet invoke Forge/Templates.diff --git a/docs/assembly/artifacts/m0/determinism.md b/docs/assembly/artifacts/m0/determinism.mdnew file mode 100644index 00000000..0e9cd037--- /dev/null+++ b/docs/assembly/artifacts/m0/determinism.md@@ -0,0 +1,11 @@+# Determinism proof++Two independent `aetheris asm inspect` compilations of `bearing-module.firmament` produced byte-identical canonical inspection JSON. Performance telemetry is opt-in (`--profile`) and is not embedded in canonical `AssemblyIr`.++Final SHA-256 proof:++```text+8C79ECC1928605A96EAA188418E3CE393834DE3576FFEA3B0791E9BCEBBA798B assembly-ir.json+8C79ECC1928605A96EAA188418E3CE393834DE3576FFEA3B0791E9BCEBBA798B repeat+1217C0A3B8E0E30B2A65A3096DAE28B09A7CD5E380903B672324A93581A39DEC failing-assembly-ir.json+```diff --git a/docs/assembly/artifacts/m0/failing-assembly-ir.json b/docs/assembly/artifacts/m0/failing-assembly-ir.jsonnew file mode 100644index 00000000..b85308f4--- /dev/null+++ b/docs/assembly/artifacts/m0/failing-assembly-ir.json@@ -0,0 +1,1058 @@+{+ "success": false,+ "assemblyIr": {+ "schema": "aetheris/assembly-ir/m0",+ "stableId": "assembly:FailingBearingModule",+ "name": "FailingBearingModule",+ "rootInstanceStableId": "assembly-instance:FailingBearingModule",+ "instances": [+ {+ "stableId": "assembly-instance:FailingBearingModule",+ "path": {+ "segments": [+ "FailingBearingModule"+ ]+ },+ "kind": "Assembly",+ "definitionIdentity": "FailingBearingModule",+ "parentStableId": null,+ "childrenStableIds": [+ "assembly-instance:FailingBearingModule.Bearing",+ "assembly-instance:FailingBearingModule.Housing",+ "assembly-instance:FailingBearingModule.Spacer"+ ],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:FailingBearingModule",+ "type": {+ "name": "Assembly",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule",+ "evidence": "FailingBearingModule",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": null+ },+ "localTransform": null,+ "resolvedTransform": null,+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "FailingBearingModule",+ "evidence": "FailingBearingModule",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:FailingBearingModule.Housing",+ "path": {+ "segments": [+ "FailingBearingModule",+ "Housing"+ ]+ },+ "kind": "Part",+ "definitionIdentity": "HousingPart",+ "parentStableId": "assembly-instance:FailingBearingModule",+ "childrenStableIds": [],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Housing",+ "type": {+ "name": "Part",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {+ "Datum": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Housing:Datum",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:HousingPart:Datum:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Housing:Datum.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:HousingPart:Datum:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Housing",+ "evidence": "definition:HousingPart:Datum:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "HousingPart",+ "evidence": "Datum",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Housing",+ "evidence": "definition:HousingPart:Datum",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Datum"+ },+ "Seat": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Housing:Seat",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:HousingPart:Seat:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Housing:Seat.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:HousingPart:Seat:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Housing",+ "evidence": "definition:HousingPart:Seat:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "HousingPart",+ "evidence": "Seat",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Housing",+ "evidence": "definition:HousingPart:Seat",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Seat"+ }+ },+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Housing",+ "evidence": "HousingPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.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": "Housing",+ "evidence": "HousingPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:FailingBearingModule.Bearing",+ "path": {+ "segments": [+ "FailingBearingModule",+ "Bearing"+ ]+ },+ "kind": "Part",+ "definitionIdentity": "Bearing6204",+ "parentStableId": "assembly-instance:FailingBearingModule",+ "childrenStableIds": [],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Bearing",+ "type": {+ "name": "Part",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {+ "Left": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Bearing:Left",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:Bearing6204:Left:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Bearing:Left.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:Bearing6204:Left:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Bearing",+ "evidence": "definition:Bearing6204:Left:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "Bearing6204",+ "evidence": "Left",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Bearing",+ "evidence": "definition:Bearing6204:Left",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Left"+ },+ "Right": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Bearing:Right",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:Bearing6204:Right:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Bearing:Right.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:Bearing6204:Right:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Bearing",+ "evidence": "definition:Bearing6204:Right:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "Bearing6204",+ "evidence": "Right",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Bearing",+ "evidence": "definition:Bearing6204:Right",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Right"+ }+ },+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Bearing",+ "evidence": "Bearing6204",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": null+ },+ "localTransform": null,+ "resolvedTransform": null,+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "Bearing",+ "evidence": "Bearing6204",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:FailingBearingModule.Spacer",+ "path": {+ "segments": [+ "FailingBearingModule",+ "Spacer"+ ]+ },+ "kind": "Part",+ "definitionIdentity": "SpacerPart",+ "parentStableId": "assembly-instance:FailingBearingModule",+ "childrenStableIds": [],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Spacer",+ "type": {+ "name": "Part",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {+ "Left": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Spacer:Left",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:SpacerPart:Left:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Spacer:Left.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:SpacerPart:Left:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Spacer",+ "evidence": "definition:SpacerPart:Left:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "SpacerPart",+ "evidence": "Left",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Spacer",+ "evidence": "definition:SpacerPart:Left",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Left"+ },+ "Right": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Spacer:Right",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:SpacerPart:Right:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:FailingBearingModule.Spacer:Right.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:SpacerPart:Right:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Spacer",+ "evidence": "definition:SpacerPart:Right:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "SpacerPart",+ "evidence": "Right",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Spacer",+ "evidence": "definition:SpacerPart:Right",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Right"+ }+ },+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "FailingBearingModule.Spacer",+ "evidence": "SpacerPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": null+ },+ "localTransform": null,+ "resolvedTransform": null,+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "Spacer",+ "evidence": "SpacerPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module-failing.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ }+ ],+ "interfaces": [],+ "mates": [],+ "placementConstraints": [],+ "placements": [+ {+ "instanceStableId": "assembly-instance:FailingBearingModule",+ "status": "Unresolved",+ "transform": null,+ "freeTranslations": [+ "X",+ "Y",+ "Z"+ ],+ "freeRotations": [+ "X",+ "Y",+ "Z"+ ],+ "constraintIds": []+ },+ {+ "instanceStableId": "assembly-instance:FailingBearingModule.Housing",+ "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:FailingBearingModule.Bearing",+ "status": "Unresolved",+ "transform": null,+ "freeTranslations": [+ "X",+ "Y",+ "Z"+ ],+ "freeRotations": [+ "X",+ "Y",+ "Z"+ ],+ "constraintIds": []+ },+ {+ "instanceStableId": "assembly-instance:FailingBearingModule.Spacer",+ "status": "Unresolved",+ "transform": null,+ "freeTranslations": [+ "X",+ "Y",+ "Z"+ ],+ "freeRotations": [+ "X",+ "Y",+ "Z"+ ],+ "constraintIds": []+ }+ ],+ "dimensionalRelations": [+ {+ "stableId": "dimension-relation:FailingBearingModule:SeatDepth",+ "fromSemanticValueId": "assembly-semantic:FailingBearingModule.Housing:Datum",+ "toSemanticValueId": "assembly-semantic:FailingBearingModule.Housing:Seat",+ "nominal": 30,+ "lowerTolerance": -0.04,+ "upperTolerance": 0.05,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "FailingBearingModule.Housing",+ "provenance": "HousingTable.H6204.SeatDepth",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:FailingBearingModule:SeatTransition",+ "fromSemanticValueId": "assembly-semantic:FailingBearingModule.Housing:Seat",+ "toSemanticValueId": "assembly-semantic:FailingBearingModule.Bearing:Left",+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "FailingBearingModule.Housing",+ "provenance": "Mate:Seat",+ "mateStableId": "mate-reference:Seat",+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:FailingBearingModule:BearingWidth",+ "fromSemanticValueId": "assembly-semantic:FailingBearingModule.Bearing:Left",+ "toSemanticValueId": "assembly-semantic:FailingBearingModule.Bearing:Right",+ "nominal": 10,+ "lowerTolerance": -0.02,+ "upperTolerance": 0.02,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "FailingBearingModule.Bearing",+ "provenance": "BearingTable.6204.Width",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:FailingBearingModule:SpacerTransition",+ "fromSemanticValueId": "assembly-semantic:FailingBearingModule.Bearing:Right",+ "toSemanticValueId": "assembly-semantic:FailingBearingModule.Spacer:Left",+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "FailingBearingModule.Bearing",+ "provenance": "Mate:Spacer",+ "mateStableId": "mate-reference:Spacer",+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:FailingBearingModule:SpacerWidth",+ "fromSemanticValueId": "assembly-semantic:FailingBearingModule.Spacer:Left",+ "toSemanticValueId": "assembly-semantic:FailingBearingModule.Spacer:Right",+ "nominal": 5,+ "lowerTolerance": -0.02,+ "upperTolerance": 0.03,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "FailingBearingModule.Spacer",+ "provenance": "SpacerTemplate.Width",+ "mateStableId": null,+ "interfaceStableId": null+ }+ ],+ "toleranceStackups": [+ {+ "name": "ImpossibleClearance",+ "startSemanticValueId": "assembly-semantic:FailingBearingModule.Housing:Datum",+ "endSemanticValueId": "assembly-semantic:FailingBearingModule.Spacer:Right",+ "nominal": 45,+ "worstCaseMinimum": 44.92,+ "worstCaseMaximum": 45.1,+ "requiredMinimum": 44.95,+ "unit": "mm",+ "passed": false,+ "status": "failed",+ "contributions": [+ {+ "relationStableId": "dimension-relation:FailingBearingModule:SeatDepth",+ "sign": 1,+ "nominal": 30,+ "lowerTolerance": -0.04,+ "upperTolerance": 0.05,+ "unit": "mm",+ "originInstancePath": "FailingBearingModule.Housing",+ "provenance": "HousingTable.H6204.SeatDepth",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:FailingBearingModule:SeatTransition",+ "sign": 1,+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "originInstancePath": "FailingBearingModule.Housing",+ "provenance": "Mate:Seat",+ "mateStableId": "mate-reference:Seat",+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:FailingBearingModule:BearingWidth",+ "sign": 1,+ "nominal": 10,+ "lowerTolerance": -0.02,+ "upperTolerance": 0.02,+ "unit": "mm",+ "originInstancePath": "FailingBearingModule.Bearing",+ "provenance": "BearingTable.6204.Width",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:FailingBearingModule:SpacerTransition",+ "sign": 1,+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "originInstancePath": "FailingBearingModule.Bearing",+ "provenance": "Mate:Spacer",+ "mateStableId": "mate-reference:Spacer",+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:FailingBearingModule:SpacerWidth",+ "sign": 1,+ "nominal": 5,+ "lowerTolerance": -0.02,+ "upperTolerance": 0.03,+ "unit": "mm",+ "originInstancePath": "FailingBearingModule.Spacer",+ "provenance": "SpacerTemplate.Width",+ "mateStableId": null,+ "interfaceStableId": null+ }+ ]+ }+ ],+ "fitResults": [],+ "diagnostics": [+ {+ "code": "assembly-tolerance-assertion-failure",+ "message": "Assert ToleranceStackup \u0027ImpossibleClearance\u0027 failed: worst-case minimum 44.92 mm \u003C required 44.95 mm.",+ "severity": "Error"+ }+ ]+ },+ "diagnostics": [+ {+ "code": "assembly-tolerance-assertion-failure",+ "message": "Assert ToleranceStackup \u0027ImpossibleClearance\u0027 failed: worst-case minimum 44.92 mm \u003C required 44.95 mm.",+ "severity": "Error"+ }+ ],+ "performance": null+}diff --git a/docs/assembly/artifacts/m0/interface-model.md b/docs/assembly/artifacts/m0/interface-model.mdnew file mode 100644index 00000000..25251e12--- /dev/null+++ b/docs/assembly/artifacts/m0/interface-model.md@@ -0,0 +1,9 @@+# Interface model proof++- `InterfaceDefinition` is relational and contains 1..N `InterfaceRoleDefinition` records.+- Roles carry exact structural capability names and cardinality-ready minimum/maximum.+- `MateIr` contains instance-scoped participant paths and `SemanticValue` IDs.+- `ShaftBore` lowers engineering intent to one `AxisCoincident` placement consequence and a symbolic diameter fit.+- `ShoulderBearingSeat` lowers to `AxisCoincident` plus `PlaneCoincident`.+- Source tree and Mate graph are separate syntax and separate IR collections.+- Diagnostics cover missing/duplicate Roles, scope, capability mismatch, fit incompatibility, under/overconstraint, missing/ambiguous paths, unit mismatch, and assertion failure.diff --git a/docs/assembly/artifacts/m0/legacy-migration.md b/docs/assembly/artifacts/m0/legacy-migration.mdnew file mode 100644index 00000000..d72f63ce--- /dev/null+++ b/docs/assembly/artifacts/m0/legacy-migration.md@@ -0,0 +1,13 @@+# Legacy migration result++Automatic semantic migration was rejected as unsafe: `.firmasm` stores definitions, flat instance IDs, and transforms but contains no evidence from which to infer Interface meaning or Roles. It remains a compatibility-only import lane.++Migration recipe:++1. Convert the flat instance list into the intended nested `<Assembly>`/`<Part>` product hierarchy.+2. Preserve old `id` values as occurrence names where stable.+3. Expose definition semantics (`Axis`, `Plane`, `Point`, toleranced `Dimension`).+4. Replace authored transforms with reusable Interface definitions and Mates.+5. Keep an explicit transform only where no semantic relationship is known, and mark it as a legacy escape hatch in future IR.++Current AP242 export is also bounded: per-instance STEP plus package metadata. True AP242 product structure authoring is the exact missing interchange capability.diff --git a/docs/assembly/artifacts/m0/mate-table.md b/docs/assembly/artifacts/m0/mate-table.mdnew file mode 100644index 00000000..2a03200a--- /dev/null+++ b/docs/assembly/artifacts/m0/mate-table.md@@ -0,0 +1,10 @@+# Mate / Interface table proof++| Mate | Interface | Role | Participant | Required capabilities | Lowered consequence |+|---|---|---|---|---|---|+| ShaftInBearing | ShaftBore | Shaft | BearingModule.Rotor.Shaft.Journal | AxisCapable, DimensionalCapable | AxisCoincident + diameter fit |+| ShaftInBearing | ShaftBore | Bore | BearingModule.FixedSupport.Bearing.Bore | AxisCapable, DimensionalCapable | AxisCoincident + diameter fit |+| ShaftShoulderAtHousing | ShoulderBearingSeat | Shoulder | BearingModule.Rotor.Shaft.ShoulderInterface | AxisCapable, PlaneCapable | AxisCoincident + PlaneCoincident |+| ShaftShoulderAtHousing | ShoulderBearingSeat | Seat | BearingModule.FixedSupport.Housing.SeatInterface | AxisCapable, PlaneCapable | AxisCoincident + PlaneCoincident |++All participant IDs and per-Mate constraint IDs are present in `assembly-ir.json`.diff --git a/docs/assembly/artifacts/m0/multi-part-stackup-proof.md b/docs/assembly/artifacts/m0/multi-part-stackup-proof.mdnew file mode 100644index 00000000..21c816ee--- /dev/null+++ b/docs/assembly/artifacts/m0/multi-part-stackup-proof.md@@ -0,0 +1,12 @@+# Multi-part stackup proof++Automatically derived unique chain:++1. Housing seat depth: 30.00 -0.04/+0.05 mm (`HousingTable.H6204.SeatDepth`)+2. Housing/Bearing Mate transition: 0 mm+3. Bearing width: 10.00 ±0.02 mm (`BearingTable.6204.Width`)+4. Bearing/Spacer Mate transition: 0 mm+5. Spacer width: 5.00 -0.02/+0.03 mm (`SpacerTemplate.Width`)+6. Spacer/Shaft transition: 0 mm++Nominal 45.00 mm; worst case 44.92–45.10 mm. `AxialReach >= 44.90 mm` passes. The failing fixture requires 44.95 mm, returns `assembly-tolerance-assertion-failure`, and retains its complete five-edge chain in `failing-assembly-ir.json`.diff --git a/docs/assembly/artifacts/m0/performance.json b/docs/assembly/artifacts/m0/performance.jsonnew file mode 100644index 00000000..d8b3a4d4--- /dev/null+++ b/docs/assembly/artifacts/m0/performance.json@@ -0,0 +1,2417 @@+{+ "success": true,+ "assemblyIr": {+ "schema": "aetheris/assembly-ir/m0",+ "stableId": "assembly:BearingModule",+ "name": "BearingModule",+ "rootInstanceStableId": "assembly-instance:BearingModule",+ "instances": [+ {+ "stableId": "assembly-instance:BearingModule",+ "path": {+ "segments": [+ "BearingModule"+ ]+ },+ "kind": "Assembly",+ "definitionIdentity": "BearingModule",+ "parentStableId": null,+ "childrenStableIds": [+ "assembly-instance:BearingModule.FixedSupport",+ "assembly-instance:BearingModule.Rotor"+ ],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule",+ "type": {+ "name": "Assembly",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule",+ "evidence": "BearingModule",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": null+ },+ "localTransform": null,+ "resolvedTransform": null,+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "BearingModule",+ "evidence": "BearingModule",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:BearingModule.FixedSupport",+ "path": {+ "segments": [+ "BearingModule",+ "FixedSupport"+ ]+ },+ "kind": "Assembly",+ "definitionIdentity": "FixedSupport",+ "parentStableId": "assembly-instance:BearingModule",+ "childrenStableIds": [+ "assembly-instance:BearingModule.FixedSupport.Bearing",+ "assembly-instance:BearingModule.FixedSupport.Housing"+ ],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport",+ "type": {+ "name": "Assembly",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport",+ "evidence": "FixedSupport",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": null+ },+ "localTransform": null,+ "resolvedTransform": null,+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "FixedSupport",+ "evidence": "FixedSupport",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:BearingModule.Rotor",+ "path": {+ "segments": [+ "BearingModule",+ "Rotor"+ ]+ },+ "kind": "Assembly",+ "definitionIdentity": "Rotor",+ "parentStableId": "assembly-instance:BearingModule",+ "childrenStableIds": [+ "assembly-instance:BearingModule.Rotor.Shaft",+ "assembly-instance:BearingModule.Rotor.Spacer"+ ],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor",+ "type": {+ "name": "Assembly",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor",+ "evidence": "Rotor",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": null+ },+ "localTransform": null,+ "resolvedTransform": null,+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "Rotor",+ "evidence": "Rotor",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:BearingModule.FixedSupport.Housing",+ "path": {+ "segments": [+ "BearingModule",+ "FixedSupport",+ "Housing"+ ]+ },+ "kind": "Part",+ "definitionIdentity": "HousingPart",+ "parentStableId": "assembly-instance:BearingModule.FixedSupport",+ "childrenStableIds": [],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing",+ "type": {+ "name": "Part",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {+ "Bore": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:Bore",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ },+ {+ "name": "DimensionalCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:HousingPart:Bore:Axis"+ },+ {+ "kind": "TolerancedDimension",+ "stableBindingIdentity": "definition:HousingPart:Bore:Diameter"+ }+ ],+ "exposedMembers": {+ "Axis": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:Bore.Axis",+ "type": {+ "name": "Axis",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:HousingPart:Bore:Axis"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:Bore:Axis",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Axis"+ },+ "Diameter": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:Bore.Diameter",+ "type": {+ "name": "Length",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "DimensionalCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "TolerancedDimension",+ "stableBindingIdentity": "definition:HousingPart:Bore:Diameter"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "Firmament-tol",+ "identity": "Diameter",+ "evidence": "Dimension Diameter = 20.04mm tol \u002B0.02mm -0.01mm;",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:Bore:Diameter",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Diameter"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "HousingPart",+ "evidence": "Bore",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:Bore",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Bore"+ },+ "Datum": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:Datum",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:HousingPart:Datum:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:Datum.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:HousingPart:Datum:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:Datum:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "HousingPart",+ "evidence": "Datum",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:Datum",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Datum"+ },+ "SeatDatum": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatDatum",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:HousingPart:SeatDatum:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatDatum.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:HousingPart:SeatDatum:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:SeatDatum:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "HousingPart",+ "evidence": "SeatDatum",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:SeatDatum",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "SeatDatum"+ },+ "SeatInterface": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatInterface",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ },+ {+ "name": "PlaneCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:HousingPart:SeatInterface:Axis"+ },+ {+ "kind": "ExactPlane",+ "stableBindingIdentity": "definition:HousingPart:SeatInterface:Seat"+ }+ ],+ "exposedMembers": {+ "Axis": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatInterface.Axis",+ "type": {+ "name": "Axis",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:HousingPart:SeatInterface:Axis"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:SeatInterface:Axis",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Axis"+ },+ "Seat": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatInterface.Seat",+ "type": {+ "name": "Plane",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PlaneCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPlane",+ "stableBindingIdentity": "definition:HousingPart:SeatInterface:Seat"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:SeatInterface:Seat",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Seat"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "HousingPart",+ "evidence": "SeatInterface",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "definition:HousingPart:SeatInterface",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "SeatInterface"+ }+ },+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Housing",+ "evidence": "HousingPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.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": "Housing",+ "evidence": "HousingPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:BearingModule.FixedSupport.Bearing",+ "path": {+ "segments": [+ "BearingModule",+ "FixedSupport",+ "Bearing"+ ]+ },+ "kind": "Part",+ "definitionIdentity": "Bearing6204",+ "parentStableId": "assembly-instance:BearingModule.FixedSupport",+ "childrenStableIds": [],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing",+ "type": {+ "name": "Part",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {+ "Bore": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Bore",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ },+ {+ "name": "DimensionalCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:Bearing6204:Bore:Axis"+ },+ {+ "kind": "TolerancedDimension",+ "stableBindingIdentity": "definition:Bearing6204:Bore:Diameter"+ }+ ],+ "exposedMembers": {+ "Axis": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Bore.Axis",+ "type": {+ "name": "Axis",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:Bearing6204:Bore:Axis"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Bore:Axis",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Axis"+ },+ "Diameter": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Bore.Diameter",+ "type": {+ "name": "Length",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "DimensionalCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "TolerancedDimension",+ "stableBindingIdentity": "definition:Bearing6204:Bore:Diameter"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "Firmament-tol",+ "identity": "Diameter",+ "evidence": "Dimension Diameter = 20.00mm tol \u002B0.00mm -0.008mm;",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Bore:Diameter",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Diameter"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "Bearing6204",+ "evidence": "Bore",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Bore",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Bore"+ },+ "Left": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Left",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:Bearing6204:Left:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Left.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:Bearing6204:Left:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Left:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "Bearing6204",+ "evidence": "Left",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Left",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Left"+ },+ "Right": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Right",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:Bearing6204:Right:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.FixedSupport.Bearing:Right.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:Bearing6204:Right:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Right:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "Bearing6204",+ "evidence": "Right",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "definition:Bearing6204:Right",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Right"+ }+ },+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.FixedSupport.Bearing",+ "evidence": "Bearing6204",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.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,+ -15,+ 1+ ]+ },+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "Bearing",+ "evidence": "Bearing6204",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:BearingModule.Rotor.Spacer",+ "path": {+ "segments": [+ "BearingModule",+ "Rotor",+ "Spacer"+ ]+ },+ "kind": "Part",+ "definitionIdentity": "SpacerPart",+ "parentStableId": "assembly-instance:BearingModule.Rotor",+ "childrenStableIds": [],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Spacer",+ "type": {+ "name": "Part",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {+ "Left": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Spacer:Left",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:SpacerPart:Left:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Spacer:Left.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:SpacerPart:Left:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Spacer",+ "evidence": "definition:SpacerPart:Left:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "SpacerPart",+ "evidence": "Left",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Spacer",+ "evidence": "definition:SpacerPart:Left",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Left"+ },+ "Right": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Spacer:Right",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:SpacerPart:Right:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Spacer:Right.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:SpacerPart:Right:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Spacer",+ "evidence": "definition:SpacerPart:Right:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "SpacerPart",+ "evidence": "Right",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Spacer",+ "evidence": "definition:SpacerPart:Right",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Right"+ }+ },+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Spacer",+ "evidence": "SpacerPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": null+ },+ "localTransform": null,+ "resolvedTransform": null,+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "Spacer",+ "evidence": "SpacerPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ },+ {+ "stableId": "assembly-instance:BearingModule.Rotor.Shaft",+ "path": {+ "segments": [+ "BearingModule",+ "Rotor",+ "Shaft"+ ]+ },+ "kind": "Part",+ "definitionIdentity": "ShaftPart",+ "parentStableId": "assembly-instance:BearingModule.Rotor",+ "childrenStableIds": [],+ "semanticRoot": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft",+ "type": {+ "name": "Part",+ "isCollection": false+ },+ "capabilities": {+ "values": []+ },+ "bindings": [],+ "exposedMembers": {+ "Journal": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:Journal",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ },+ {+ "name": "DimensionalCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:ShaftPart:Journal:Axis"+ },+ {+ "kind": "TolerancedDimension",+ "stableBindingIdentity": "definition:ShaftPart:Journal:Diameter"+ }+ ],+ "exposedMembers": {+ "Axis": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:Journal.Axis",+ "type": {+ "name": "Axis",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:ShaftPart:Journal:Axis"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:Journal:Axis",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Axis"+ },+ "Diameter": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:Journal.Diameter",+ "type": {+ "name": "Length",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "DimensionalCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "TolerancedDimension",+ "stableBindingIdentity": "definition:ShaftPart:Journal:Diameter"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "Firmament-tol",+ "identity": "Diameter",+ "evidence": "Dimension Diameter = 19.98mm tol \u002B0.01mm -0.01mm;",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:Journal:Diameter",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Diameter"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "ShaftPart",+ "evidence": "Journal",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:Journal",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Journal"+ },+ "Shoulder": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:Shoulder",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:ShaftPart:Shoulder:Point"+ }+ ],+ "exposedMembers": {+ "Point": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:Shoulder.Point",+ "type": {+ "name": "Point",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PointCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPoint",+ "stableBindingIdentity": "definition:ShaftPart:Shoulder:Point"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:Shoulder:Point",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Point"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "ShaftPart",+ "evidence": "Shoulder",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:Shoulder",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Shoulder"+ },+ "ShoulderInterface": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:ShoulderInterface",+ "type": {+ "name": "Concept",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ },+ {+ "name": "PlaneCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:ShaftPart:ShoulderInterface:Axis"+ },+ {+ "kind": "ExactPlane",+ "stableBindingIdentity": "definition:ShaftPart:ShoulderInterface:Seat"+ }+ ],+ "exposedMembers": {+ "Axis": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:ShoulderInterface.Axis",+ "type": {+ "name": "Axis",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "AxisCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactAxis",+ "stableBindingIdentity": "definition:ShaftPart:ShoulderInterface:Axis"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:ShoulderInterface:Axis",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Axis"+ },+ "Seat": {+ "stableIdentity": "assembly-semantic:BearingModule.Rotor.Shaft:ShoulderInterface.Seat",+ "type": {+ "name": "Plane",+ "isCollection": false+ },+ "capabilities": {+ "values": [+ {+ "name": "PlaneCapable"+ }+ ]+ },+ "bindings": [+ {+ "kind": "ExactPlane",+ "stableBindingIdentity": "definition:ShaftPart:ShoulderInterface:Seat"+ }+ ],+ "exposedMembers": {},+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:ShoulderInterface:Seat",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "Seat"+ }+ },+ "provenance": [+ {+ "stage": "part-definition",+ "identity": "ShaftPart",+ "evidence": "ShoulderInterface",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "definition:ShaftPart:ShoulderInterface",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ },+ "exposedName": "ShoulderInterface"+ }+ },+ "provenance": [+ {+ "stage": "assembly-instance",+ "identity": "BearingModule.Rotor.Shaft",+ "evidence": "ShaftPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "authoredSourceSpan": null,+ "generatedSourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.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,+ -15,+ 1+ ]+ },+ "provenance": [+ {+ "stage": "assembly-source",+ "identity": "Shaft",+ "evidence": "ShaftPart",+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ]+ }+ ],+ "interfaces": [+ {+ "stableId": "interface:ShaftBore",+ "name": "ShaftBore",+ "roles": [+ {+ "name": "Shaft",+ "requiredCapabilities": [+ "AxisCapable",+ "DimensionalCapable"+ ],+ "minimum": 1,+ "maximum": 1+ },+ {+ "name": "Bore",+ "requiredCapabilities": [+ "AxisCapable",+ "DimensionalCapable"+ ],+ "minimum": 1,+ "maximum": 1+ }+ ],+ "requirements": [+ {+ "kind": "AxisCoincident",+ "firstRole": "Shaft",+ "firstMember": "Axis",+ "secondRole": "Bore",+ "secondMember": "Axis",+ "offsetMm": 0+ }+ ],+ "fit": {+ "shaftRole": "Shaft",+ "shaftDimension": "Diameter",+ "boreRole": "Bore",+ "boreDimension": "Diameter"+ },+ "admittedFreeMotions": [+ "translation:along-axis",+ "rotation:about-axis"+ ],+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ },+ {+ "stableId": "interface:ShoulderBearingSeat",+ "name": "ShoulderBearingSeat",+ "roles": [+ {+ "name": "Shoulder",+ "requiredCapabilities": [+ "AxisCapable",+ "PlaneCapable"+ ],+ "minimum": 1,+ "maximum": 1+ },+ {+ "name": "Seat",+ "requiredCapabilities": [+ "AxisCapable",+ "PlaneCapable"+ ],+ "minimum": 1,+ "maximum": 1+ }+ ],+ "requirements": [+ {+ "kind": "AxisCoincident",+ "firstRole": "Shoulder",+ "firstMember": "Axis",+ "secondRole": "Seat",+ "secondMember": "Axis",+ "offsetMm": 0+ },+ {+ "kind": "PlaneCoincident",+ "firstRole": "Shoulder",+ "firstMember": "Seat",+ "secondRole": "Seat",+ "secondMember": "Seat",+ "offsetMm": 0+ }+ ],+ "fit": null,+ "admittedFreeMotions": [+ "rotation:about-axis"+ ],+ "sourceSpan": {+ "source": "C:\\Users\\yuech\\source\\repos\\Aetheris\\fixtures\\AssemblyM0\\bearing-module.firmament",+ "start": 0,+ "length": 0+ }+ }+ ],+ "mates": [+ {+ "stableId": "mate:BearingModule:ShaftInBearing",+ "name": "ShaftInBearing",+ "interfaceStableId": "interface:ShaftBore",+ "roles": [+ {+ "role": "Shaft",+ "participantPath": {+ "segments": [+ "BearingModule",+ "Rotor",+ "Shaft",+ "Journal"+ ]+ },+ "participantSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:Journal",+ "requiredCapabilities": [+ "AxisCapable",+ "DimensionalCapable"+ ]+ },+ {+ "role": "Bore",+ "participantPath": {+ "segments": [+ "BearingModule",+ "FixedSupport",+ "Bearing",+ "Bore"+ ]+ },+ "participantSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Bearing:Bore",+ "requiredCapabilities": [+ "AxisCapable",+ "DimensionalCapable"+ ]+ }+ ],+ "constraintIds": [+ "constraint:mate:BearingModule:ShaftInBearing:00"+ ],+ "validationStatus": "valid"+ },+ {+ "stableId": "mate:BearingModule:ShaftShoulderAtHousing",+ "name": "ShaftShoulderAtHousing",+ "interfaceStableId": "interface:ShoulderBearingSeat",+ "roles": [+ {+ "role": "Shoulder",+ "participantPath": {+ "segments": [+ "BearingModule",+ "Rotor",+ "Shaft",+ "ShoulderInterface"+ ]+ },+ "participantSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:ShoulderInterface",+ "requiredCapabilities": [+ "AxisCapable",+ "PlaneCapable"+ ]+ },+ {+ "role": "Seat",+ "participantPath": {+ "segments": [+ "BearingModule",+ "FixedSupport",+ "Housing",+ "SeatInterface"+ ]+ },+ "participantSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatInterface",+ "requiredCapabilities": [+ "AxisCapable",+ "PlaneCapable"+ ]+ }+ ],+ "constraintIds": [+ "constraint:mate:BearingModule:ShaftShoulderAtHousing:00",+ "constraint:mate:BearingModule:ShaftShoulderAtHousing:01"+ ],+ "validationStatus": "valid"+ }+ ],+ "placementConstraints": [+ {+ "stableId": "constraint:mate:BearingModule:ShaftInBearing:00",+ "kind": "AxisCoincident",+ "mateStableId": "mate:BearingModule:ShaftInBearing",+ "firstSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:Journal.Axis",+ "secondSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Bearing:Bore.Axis",+ "offsetMm": 0,+ "residual": 0,+ "status": "admitted"+ },+ {+ "stableId": "constraint:mate:BearingModule:ShaftShoulderAtHousing:00",+ "kind": "AxisCoincident",+ "mateStableId": "mate:BearingModule:ShaftShoulderAtHousing",+ "firstSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:ShoulderInterface.Axis",+ "secondSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatInterface.Axis",+ "offsetMm": 0,+ "residual": 0,+ "status": "admitted"+ },+ {+ "stableId": "constraint:mate:BearingModule:ShaftShoulderAtHousing:01",+ "kind": "PlaneCoincident",+ "mateStableId": "mate:BearingModule:ShaftShoulderAtHousing",+ "firstSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:ShoulderInterface.Seat",+ "secondSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatInterface.Seat",+ "offsetMm": 0,+ "residual": 0,+ "status": "admitted"+ }+ ],+ "placements": [+ {+ "instanceStableId": "assembly-instance:BearingModule",+ "status": "Unresolved",+ "transform": null,+ "freeTranslations": [+ "X",+ "Y",+ "Z"+ ],+ "freeRotations": [+ "X",+ "Y",+ "Z"+ ],+ "constraintIds": []+ },+ {+ "instanceStableId": "assembly-instance:BearingModule.FixedSupport",+ "status": "Unresolved",+ "transform": null,+ "freeTranslations": [+ "X",+ "Y",+ "Z"+ ],+ "freeRotations": [+ "X",+ "Y",+ "Z"+ ],+ "constraintIds": []+ },+ {+ "instanceStableId": "assembly-instance:BearingModule.Rotor",+ "status": "Unresolved",+ "transform": null,+ "freeTranslations": [+ "X",+ "Y",+ "Z"+ ],+ "freeRotations": [+ "X",+ "Y",+ "Z"+ ],+ "constraintIds": []+ },+ {+ "instanceStableId": "assembly-instance:BearingModule.FixedSupport.Housing",+ "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:BearingModule.FixedSupport.Bearing",+ "status": "Resolved",+ "transform": {+ "matrix": [+ 1,+ 0,+ 0,+ 0,+ 0,+ 1,+ 0,+ 0,+ 0,+ 0,+ 1,+ 0,+ 0,+ 0,+ -15,+ 1+ ]+ },+ "freeTranslations": [],+ "freeRotations": [],+ "constraintIds": [+ "constraint:mate:BearingModule:ShaftInBearing:00"+ ]+ },+ {+ "instanceStableId": "assembly-instance:BearingModule.Rotor.Spacer",+ "status": "Unresolved",+ "transform": null,+ "freeTranslations": [+ "X",+ "Y",+ "Z"+ ],+ "freeRotations": [+ "X",+ "Y",+ "Z"+ ],+ "constraintIds": []+ },+ {+ "instanceStableId": "assembly-instance:BearingModule.Rotor.Shaft",+ "status": "Resolved",+ "transform": {+ "matrix": [+ 1,+ 0,+ 0,+ 0,+ 0,+ 1,+ 0,+ 0,+ 0,+ 0,+ 1,+ 0,+ 0,+ 0,+ -15,+ 1+ ]+ },+ "freeTranslations": [],+ "freeRotations": [],+ "constraintIds": [+ "constraint:mate:BearingModule:ShaftInBearing:00",+ "constraint:mate:BearingModule:ShaftShoulderAtHousing:00",+ "constraint:mate:BearingModule:ShaftShoulderAtHousing:01"+ ]+ }+ ],+ "dimensionalRelations": [+ {+ "stableId": "dimension-relation:BearingModule:HousingSeatDepth",+ "fromSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:Datum",+ "toSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatDatum",+ "nominal": 30,+ "lowerTolerance": -0.04,+ "upperTolerance": 0.05,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "BearingModule.FixedSupport.Housing",+ "provenance": "HousingTable.H6204.SeatDepth",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:BearingModule:HousingToBearing",+ "fromSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:SeatDatum",+ "toSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Bearing:Left",+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "BearingModule.FixedSupport.Housing",+ "provenance": "Mate:HousingBearingSeat",+ "mateStableId": "mate-reference:HousingBearingSeat",+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:BearingModule:BearingWidth",+ "fromSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Bearing:Left",+ "toSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Bearing:Right",+ "nominal": 10,+ "lowerTolerance": -0.02,+ "upperTolerance": 0.02,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "BearingModule.FixedSupport.Bearing",+ "provenance": "BearingTable.6204.Width",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:BearingModule:BearingToSpacer",+ "fromSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Bearing:Right",+ "toSemanticValueId": "assembly-semantic:BearingModule.Rotor.Spacer:Left",+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "BearingModule.FixedSupport.Bearing",+ "provenance": "Mate:BearingSpacer",+ "mateStableId": "mate-reference:BearingSpacer",+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:BearingModule:SpacerWidth",+ "fromSemanticValueId": "assembly-semantic:BearingModule.Rotor.Spacer:Left",+ "toSemanticValueId": "assembly-semantic:BearingModule.Rotor.Spacer:Right",+ "nominal": 5,+ "lowerTolerance": -0.02,+ "upperTolerance": 0.03,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "BearingModule.Rotor.Spacer",+ "provenance": "SpacerTemplate.Width",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "stableId": "dimension-relation:BearingModule:SpacerToShoulder",+ "fromSemanticValueId": "assembly-semantic:BearingModule.Rotor.Spacer:Right",+ "toSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:Shoulder",+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "sign": 1,+ "originInstancePath": "BearingModule.Rotor.Spacer",+ "provenance": "Mate:SpacerShoulder",+ "mateStableId": "mate-reference:SpacerShoulder",+ "interfaceStableId": null+ }+ ],+ "toleranceStackups": [+ {+ "name": "AxialReach",+ "startSemanticValueId": "assembly-semantic:BearingModule.FixedSupport.Housing:Datum",+ "endSemanticValueId": "assembly-semantic:BearingModule.Rotor.Shaft:Shoulder",+ "nominal": 45,+ "worstCaseMinimum": 44.92,+ "worstCaseMaximum": 45.1,+ "requiredMinimum": 44.9,+ "unit": "mm",+ "passed": true,+ "status": "passed",+ "contributions": [+ {+ "relationStableId": "dimension-relation:BearingModule:HousingSeatDepth",+ "sign": 1,+ "nominal": 30,+ "lowerTolerance": -0.04,+ "upperTolerance": 0.05,+ "unit": "mm",+ "originInstancePath": "BearingModule.FixedSupport.Housing",+ "provenance": "HousingTable.H6204.SeatDepth",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:BearingModule:HousingToBearing",+ "sign": 1,+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "originInstancePath": "BearingModule.FixedSupport.Housing",+ "provenance": "Mate:HousingBearingSeat",+ "mateStableId": "mate-reference:HousingBearingSeat",+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:BearingModule:BearingWidth",+ "sign": 1,+ "nominal": 10,+ "lowerTolerance": -0.02,+ "upperTolerance": 0.02,+ "unit": "mm",+ "originInstancePath": "BearingModule.FixedSupport.Bearing",+ "provenance": "BearingTable.6204.Width",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:BearingModule:BearingToSpacer",+ "sign": 1,+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "originInstancePath": "BearingModule.FixedSupport.Bearing",+ "provenance": "Mate:BearingSpacer",+ "mateStableId": "mate-reference:BearingSpacer",+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:BearingModule:SpacerWidth",+ "sign": 1,+ "nominal": 5,+ "lowerTolerance": -0.02,+ "upperTolerance": 0.03,+ "unit": "mm",+ "originInstancePath": "BearingModule.Rotor.Spacer",+ "provenance": "SpacerTemplate.Width",+ "mateStableId": null,+ "interfaceStableId": null+ },+ {+ "relationStableId": "dimension-relation:BearingModule:SpacerToShoulder",+ "sign": 1,+ "nominal": 0,+ "lowerTolerance": -0,+ "upperTolerance": 0,+ "unit": "mm",+ "originInstancePath": "BearingModule.Rotor.Spacer",+ "provenance": "Mate:SpacerShoulder",+ "mateStableId": "mate-reference:SpacerShoulder",+ "interfaceStableId": null+ }+ ]+ }+ ],+ "fitResults": [+ {+ "mateStableId": "mate:BearingModule:ShaftInBearing",+ "nominalClearance": 0.019999999999999574,+ "worstCaseMinimum": 0.0019999999999988916,+ "worstCaseMaximum": 0.030000000000001137,+ "unit": "mm",+ "compatible": true+ }+ ],+ "diagnostics": []+ },+ "diagnostics": [],+ "performance": {+ "parseMilliseconds": 22.2195,+ "bindMilliseconds": 9.8373,+ "mateValidationMilliseconds": 2.5277,+ "placementMilliseconds": 10.1998,+ "dimensionalGraphMilliseconds": 0.8166,+ "toleranceAnalysisMilliseconds": 4.1572+ }+}diff --git a/docs/assembly/artifacts/m0/performance.md b/docs/assembly/artifacts/m0/performance.mdnew file mode 100644index 00000000..cb959cc4--- /dev/null+++ b/docs/assembly/artifacts/m0/performance.md@@ -0,0 +1,9 @@+# Performance evidence++M0 records six independently timed phases in `AssemblyPerformanceIr`: parse, semantic/instance bind, Mate validation, placement solve, dimensional graph build, and tolerance analysis. Use:++```text+aetheris asm inspect fixtures/AssemblyM0/bearing-module.firmament --json --profile+```++The final profiled CLI observation on the seven-instance/two-Mate/six-relation dogfood was 22.22 ms parse, 9.84 ms bind, 2.53 ms Mate validation, 10.20 ms placement, 0.82 ms dimensional graph, and 4.16 ms tolerance analysis. Focused in-process test runs complete all nine M0 compiler tests in roughly 0.15 seconds on this development machine. These are diagnostic observations, not benchmarks or budgets. The raw report is `performance.json`.diff --git a/docs/assembly/artifacts/m0/placement-proof.md b/docs/assembly/artifacts/m0/placement-proof.mdnew file mode 100644index 00000000..ca05e351--- /dev/null+++ b/docs/assembly/artifacts/m0/placement-proof.md@@ -0,0 +1,3 @@+# Placement proof++The Housing anchor is identity. The Shaft/Bearing and Shoulder/Seat axis directions are solved analytically. The axis-plus-plane Interface removes translation; axial symmetry is explicitly admitted as `rotation:about-axis`, so the Shaft placement is `Resolved`, not silently arbitrary. Axis-only tests without admitted freedoms report translation along and rotation about the axis. Conflicting axis Mates produce `assembly-placement-overconstrained` with the involved Mate IDs and transform residual threshold.diff --git a/docs/assembly/artifacts/m0/product-tree.md b/docs/assembly/artifacts/m0/product-tree.mdnew file mode 100644index 00000000..4f3c825b--- /dev/null+++ b/docs/assembly/artifacts/m0/product-tree.md@@ -0,0 +1,13 @@+# Product tree proof++```text+BearingModule [Assembly]+├─ FixedSupport [Assembly]+│ ├─ Housing [Part] = HousingPart+│ └─ Bearing [Part] = Bearing6204+└─ Rotor [Assembly]+ ├─ Spacer [Part] = SpacerPart+ └─ Shaft [Part] = ShaftPart+```++Seven explicit IR instances preserve parents, children, kinds, definition identities, and structured deterministic paths.diff --git a/docs/assembly/artifacts/m0/shaft-bore-proof.md b/docs/assembly/artifacts/m0/shaft-bore-proof.mdnew file mode 100644index 00000000..acd8ace0--- /dev/null+++ b/docs/assembly/artifacts/m0/shaft-bore-proof.md@@ -0,0 +1,10 @@+# Shaft / bore fit proof++Selected participants: ShaftPart Journal diameter 19.98 -0.01/+0.01 mm; Bearing6204 Bore diameter 20.00 -0.008/+0.000 mm.++- nominal clearance: 0.020 mm+- worst-case minimum: 0.002 mm+- worst-case maximum: 0.030 mm+- compatibility: pass (minimum is non-negative)++This analysis is symbolic and leaves nominal BRep unchanged.diff --git a/docs/assembly/assembly-m0.md b/docs/assembly/assembly-m0.mdnew file mode 100644index 00000000..ba7f1d46--- /dev/null+++ b/docs/assembly/assembly-m0.md@@ -0,0 +1,33 @@+# Assembly M0 authoring and inspection++Product containment uses XML-like syntax because visual nesting materially improves assembly readability. Graph relations remain ordinary sibling declarations outside that nesting:++```firmament+Assembly BearingModule {+ <Assembly BearingModule>+ <Assembly Rotor>+ <Part Shaft = ShaftPart>+ Semantic Journal {+ Axis Axis = [0,0,0] -> [0,0,1];+ Dimension Diameter = 19.98mm tol +0.01mm -0.01mm;+ }+ </Part>+ </Assembly>+ </Assembly>++ Anchor: BearingModule.Rotor.Shaft.Journal;+ Mate ...+}+```++The XML-like parser is deliberately bounded to `Assembly` and paired `Part` tags. It does not import Copeland syntax machinery. Assembly Template expansion is not in M0, but the normalized source model separates definition identity from occurrence identity and therefore does not block Template-generated trees. Table/Record provenance is retained as an ordered string/source provenance trail in dimensional relations; the dogfood uses `HousingTable`, `BearingTable`, and `SpacerTemplate` origins.++Inspect with:++```text+aetheris asm inspect fixtures/AssemblyM0/bearing-module.firmament --json+```++JSON exposes tree/BOM data, Interface definitions and Roles, Mate participants and semantic IDs, constraints, transforms/status, fit bands, dimensional graph, complete stackup chains, diagnostics, and phase timings. Text mode gives a compact product tree, Mate table, and stackup summary. This is the Cadmata seam for M0; transformed geometry display is deferred.++Legacy `.firmasm` remains accepted only by `asm exec`/`asm export`. It is flat JSON with authored transforms and cannot be losslessly migrated to typed Interfaces because it contains no semantic relationship intent. A bounded automatic importer would fabricate meaning, so M0 documents migration: rewrite the flat `parts`/`instances` list as a nested product tree, expose semantic endpoints on definitions, replace transforms with Interface/Mate declarations, and retain explicit transforms only as an escape hatch. Per-instance STEP packaging remains the current export seam; the exporter does not author AP242 product structure or mapped-item assembly relationships.diff --git a/docs/assembly/interfaces.md b/docs/assembly/interfaces.mdnew file mode 100644index 00000000..304bc412--- /dev/null+++ b/docs/assembly/interfaces.md@@ -0,0 +1,25 @@+# Interfaces and Mates++M0 source keeps engineering meaning above geometric lowering:++```firmament+Interface ShaftBore {+ Role Shaft requires AxisCapable, DimensionalCapable;+ Role Bore requires AxisCapable, DimensionalCapable;+ Lower AxisCoincident Shaft.Axis Bore.Axis;+ Fit Shaft.Diameter inside Bore.Diameter;+ Allow translation:along-axis;+ Allow rotation:about-axis;+}++Mate ShaftInBearing: ShaftBore {+ Shaft: BearingModule.Rotor.Shaft.Journal;+ Bore: BearingModule.FixedSupport.Bearing.Bore;+}+```++Roles are named and cardinality-ready (`Minimum`/`Maximum` in IR); the parser admits N-role Interfaces even though M0 dogfood is binary. Capability validation is exact and structural through `SemanticCapabilitySet`. M0 adds `AxisCapable`, `PlaneCapable`, `PointCapable`, and `DimensionalCapable`, backed respectively by exact analytic or toleranced bindings—never reflection, mesh IDs, or raw topology IDs.++Relational requirements lower to the bounded `PlacementConstraintKind` set: `AxisCoincident`, `AxisAligned`, `PlaneCoincident`, `PointCoincident`, and `OffsetAlongAxis`. Only AxisCoincident and the axial-seating combination are solved in M0. The Interface identity and Mate provenance survive lowering, so the source statement remains “shaft mates with bearing,” while the exact constraint is inspectable as a consequence.++The first dogfood, `ShaftBore`, checks coaxial placement and symbolic diameter fit. The second, `ShoulderBearingSeat`, lowers to axis plus plane coincidence and proves one Interface can create multiple constraints.diff --git a/docs/assembly/tolerance-stackup.md b/docs/assembly/tolerance-stackup.mdnew file mode 100644index 00000000..20101ad0--- /dev/null+++ b/docs/assembly/tolerance-stackup.md@@ -0,0 +1,17 @@+# Worst-case tolerance stackup++Existing Firmament `let` syntax supports typed scalar and one-level Record values, bilateral `tol 0.05mm`, asymmetric `tol +0.10mm -0.05mm`, `mm`/`deg` unit checks, exact-alias tolerance preservation, and explicit warnings when arithmetic drops tolerance. M0 uses the same nominal/lower/upper convention in `TolerancedDimensionBinding`; it does not perturb BRep geometry.++Assembly dimensional relations form a signed graph over instance-scoped semantic datums. Edges contain nominal, lower/upper tolerance, unit, sign/orientation, originating instance, source/Table/Template provenance, and optional Mate/Interface transition provenance. Only explicitly known engineering dimensions and zero-offset interface transitions enter the graph.++```firmament+Assert ToleranceStackup AxialReach {+ Between: [BearingModule.FixedSupport.Housing.Datum,+ BearingModule.Rotor.Shaft.Shoulder];+ Require: Clearance >= 44.90mm;+}+```++The compiler enumerates deterministic simple paths. Zero paths are `assembly-tolerance-path-missing`; more than one is `assembly-tolerance-path-ambiguous`. It never picks an arbitrary route, so JudgmentEngine is unnecessary for M0. For the unique signed chain, nominal values sum directly. A forward contributor adds `[lower, upper]`; a reversed contributor adds `[-upper, -lower]`. This is bounded worst-case interval propagation—no RSS, distributions, Monte Carlo, or Six Sigma.++The bearing-module proof automatically crosses Housing (30 -0.04/+0.05 mm), a Mate transition, Bearing (10 ±0.02 mm), another Mate transition, Spacer (5 -0.02/+0.03 mm), and the final seating transition. Result: nominal 45.00 mm, worst case 44.92–45.10 mm. The 44.90 mm assertion passes. The paired failing fixture requires 44.95 mm and reports a typed assertion failure while retaining all five contributors.diff --git a/fixtures/AssemblyM0/bearing-module-failing.firmament b/fixtures/AssemblyM0/bearing-module-failing.firmamentnew file mode 100644index 00000000..e8ea524e--- /dev/null+++ b/fixtures/AssemblyM0/bearing-module-failing.firmament@@ -0,0 +1,27 @@+// Deliberately failing bounded worst-case stackup proof.+Assembly FailingBearingModule {+ <Assembly FailingBearingModule>+ <Part Housing = HousingPart>+ Semantic Datum { Point Point = [0,0,0]; }+ Semantic Seat { Point Point = [0,0,30]; }+ </Part>+ <Part Bearing = Bearing6204>+ Semantic Left { Point Point = [0,0,0]; }+ Semantic Right { Point Point = [0,0,10]; }+ </Part>+ <Part Spacer = SpacerPart>+ Semantic Left { Point Point = [0,0,0]; }+ Semantic Right { Point Point = [0,0,5]; }+ </Part>+ </Assembly>+ Anchor: FailingBearingModule.Housing.Datum;+ Relation SeatDepth: FailingBearingModule.Housing.Datum -> FailingBearingModule.Housing.Seat = 30mm tol +0.05mm -0.04mm from "HousingTable.H6204.SeatDepth";+ Relation SeatTransition: FailingBearingModule.Housing.Seat -> FailingBearingModule.Bearing.Left = 0mm from "Mate:Seat";+ Relation BearingWidth: FailingBearingModule.Bearing.Left -> FailingBearingModule.Bearing.Right = 10mm tol 0.02mm from "BearingTable.6204.Width";+ Relation SpacerTransition: FailingBearingModule.Bearing.Right -> FailingBearingModule.Spacer.Left = 0mm from "Mate:Spacer";+ Relation SpacerWidth: FailingBearingModule.Spacer.Left -> FailingBearingModule.Spacer.Right = 5mm tol +0.03mm -0.02mm from "SpacerTemplate.Width";+ Assert ToleranceStackup ImpossibleClearance {+ Between: [FailingBearingModule.Housing.Datum, FailingBearingModule.Spacer.Right];+ Require: Clearance >= 44.95mm;+ }+}diff --git a/fixtures/AssemblyM0/bearing-module.firmament b/fixtures/AssemblyM0/bearing-module.firmamentnew file mode 100644index 00000000..43c433ca--- /dev/null+++ b/fixtures/AssemblyM0/bearing-module.firmament@@ -0,0 +1,85 @@+// AETHERIS-ASSEMBLY-M0: typed Interfaces plus a product tree and independent Mate graph.+Interface ShaftBore {+ Role Shaft requires AxisCapable, DimensionalCapable;+ Role Bore requires AxisCapable, DimensionalCapable;+ Lower AxisCoincident Shaft.Axis Bore.Axis;+ Fit Shaft.Diameter inside Bore.Diameter;+ Allow translation:along-axis;+ Allow rotation:about-axis;+}++Interface ShoulderBearingSeat {+ Role Shoulder requires AxisCapable, PlaneCapable;+ Role Seat requires AxisCapable, PlaneCapable;+ Lower AxisCoincident Shoulder.Axis Seat.Axis;+ Lower PlaneCoincident Shoulder.Seat Seat.Seat;+ Allow rotation:about-axis;+}++Assembly BearingModule {+ <Assembly BearingModule>+ <Assembly FixedSupport>+ <Part Housing = HousingPart>+ Semantic Bore {+ Axis Axis = [0,0,0] -> [0,0,1];+ Dimension Diameter = 20.04mm tol +0.02mm -0.01mm;+ }+ Semantic SeatInterface {+ Axis Axis = [0,0,0] -> [0,0,1];+ Plane Seat = [0,0,30] normal [0,0,1];+ }+ Semantic Datum { Point Point = [0,0,0]; }+ Semantic SeatDatum { Point Point = [0,0,30]; }+ </Part>+ <Part Bearing = Bearing6204>+ Semantic Bore {+ Axis Axis = [0,0,0] -> [0,0,1];+ Dimension Diameter = 20.00mm tol +0.00mm -0.008mm;+ }+ Semantic Left { Point Point = [0,0,0]; }+ Semantic Right { Point Point = [0,0,10]; }+ </Part>+ </Assembly>+ <Assembly Rotor>+ <Part Spacer = SpacerPart>+ Semantic Left { Point Point = [0,0,0]; }+ Semantic Right { Point Point = [0,0,5]; }+ </Part>+ <Part Shaft = ShaftPart>+ Semantic Journal {+ Axis Axis = [0,0,0] -> [0,0,1];+ Dimension Diameter = 19.98mm tol +0.01mm -0.01mm;+ }+ Semantic ShoulderInterface {+ Axis Axis = [0,0,0] -> [0,0,1];+ Plane Seat = [0,0,45] normal [0,0,1];+ }+ Semantic Shoulder { Point Point = [0,0,45]; }+ </Part>+ </Assembly>+ </Assembly>++ Anchor: BearingModule.FixedSupport.Housing.Bore;++ Mate ShaftInBearing: ShaftBore {+ Shaft: BearingModule.Rotor.Shaft.Journal;+ Bore: BearingModule.FixedSupport.Bearing.Bore;+ }++ Mate ShaftShoulderAtHousing: ShoulderBearingSeat {+ Shoulder: BearingModule.Rotor.Shaft.ShoulderInterface;+ Seat: BearingModule.FixedSupport.Housing.SeatInterface;+ }++ Relation HousingSeatDepth: BearingModule.FixedSupport.Housing.Datum -> BearingModule.FixedSupport.Housing.SeatDatum = 30mm tol +0.05mm -0.04mm from "HousingTable.H6204.SeatDepth";+ Relation HousingToBearing: BearingModule.FixedSupport.Housing.SeatDatum -> BearingModule.FixedSupport.Bearing.Left = 0mm from "Mate:HousingBearingSeat";+ Relation BearingWidth: BearingModule.FixedSupport.Bearing.Left -> BearingModule.FixedSupport.Bearing.Right = 10mm tol 0.02mm from "BearingTable.6204.Width";+ Relation BearingToSpacer: BearingModule.FixedSupport.Bearing.Right -> BearingModule.Rotor.Spacer.Left = 0mm from "Mate:BearingSpacer";+ Relation SpacerWidth: BearingModule.Rotor.Spacer.Left -> BearingModule.Rotor.Spacer.Right = 5mm tol +0.03mm -0.02mm from "SpacerTemplate.Width";+ Relation SpacerToShoulder: BearingModule.Rotor.Spacer.Right -> BearingModule.Rotor.Shaft.Shoulder = 0mm from "Mate:SpacerShoulder";++ Assert ToleranceStackup AxialReach {+ Between: [BearingModule.FixedSupport.Housing.Datum, BearingModule.Rotor.Shaft.Shoulder];+ Require: Clearance >= 44.90mm;+ }+}