Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
Add EDGE-X13 Firmament AirChamfer shadow diagnostics
Yuechen Lia15a4d1ad178
diff --git a/Aetheris.Kernel.Firmament.Tests/Aetheris.Kernel.Firmament.Tests.csproj b/Aetheris.Kernel.Firmament.Tests/Aetheris.Kernel.Firmament.Tests.csprojindex 0f91a8e8..17dc9195 100644--- a/Aetheris.Kernel.Firmament.Tests/Aetheris.Kernel.Firmament.Tests.csproj+++ b/Aetheris.Kernel.Firmament.Tests/Aetheris.Kernel.Firmament.Tests.csproj@@ -20,5 +20,6 @@<ItemGroup><ProjectReference Include="..\Aetheris.Kernel.Firmament\Aetheris.Kernel.Firmament.csproj" /><ProjectReference Include="..\Aetheris.Kernel.Core\Aetheris.Kernel.Core.csproj" />+ <ProjectReference Include="..\Aetheris.Firmament.FrictionLab\Aetheris.Firmament.FrictionLab.csproj" /></ItemGroup></Project>diff --git a/Aetheris.Kernel.Firmament.Tests/AirChamferFirmamentShadowProbeTests.cs b/Aetheris.Kernel.Firmament.Tests/AirChamferFirmamentShadowProbeTests.csnew file mode 100644index 00000000..71d551fd--- /dev/null+++ b/Aetheris.Kernel.Firmament.Tests/AirChamferFirmamentShadowProbeTests.cs@@ -0,0 +1,328 @@+using System.Numerics;+using Aetheris.Firmament.FrictionLab.CIRLab;+using Aetheris.Kernel.Core.Brep;+using Aetheris.Kernel.Core.Step242;+using Aetheris.Kernel.Firmament.Execution;+using Aetheris.Kernel.Firmament.Lowering;++namespace Aetheris.Kernel.Firmament.Tests;++public sealed class AirChamferFirmamentShadowProbeTests+{+ private const string SupportedFixture = "testdata/firmament/fixtures/edge-x13-valid-airchamfer-shadow-box-edge.firmament";++ [Fact]+ public void FirmamentAirChamferShadowProbe_SupportedControlledCase_ProducesSidecarWithoutChangingProductionOutput()+ {+ var compiled = CompileFixture(SupportedFixture);+ Assert.True(compiled.Compilation.IsSuccess);++ var productionBodyBeforeProbe = AssertLegacyChamferRoute(compiled);+ var productionStepBeforeProbe = ExportStep(productionBodyBeforeProbe);++ var report = FirmamentAirChamferShadowProbe.Evaluate(compiled, FirmamentAirChamferShadowProbeOptions.SupportedControlledCase());++ var productionBodyAfterProbe = AssertLegacyChamferRoute(compiled);+ var productionStepAfterProbe = ExportStep(productionBodyAfterProbe);+ Assert.Equal(productionStepBeforeProbe, productionStepAfterProbe);++ Assert.True(report.IsOptInTestOnly);+ Assert.True(report.LegacyAuthorityPreserved);+ Assert.True(report.NoProductionRouteReplacement);+ Assert.True(report.NoThreeDimensionalBooleanUsed);+ Assert.True(report.ProductionOutputUnchanged);+ Assert.True(report.ShadowRouteInvoked);+ Assert.True(report.ShadowCandidateProduced);+ Assert.Equal(AirChamferShadowCandidateStatus.Succeeded, report.ShadowReport!.ShadowCandidateStatus);+ Assert.NotNull(report.ShadowReport.TopologySummary);+ Assert.NotNull(report.ShadowReport.FeatureRecognitionSummary);+ Assert.True(report.ShadowReport.FeatureRecognitionSummary!.RecognitionContractSatisfied);+ Assert.NotNull(report.ShadowReport.StepSmokeSummary);+ Assert.True(report.ShadowReport.StepSmokeSummary!.Succeeded);+ Assert.Equal("AirChamferShadowRoute->AirChamferRealBodyPrototype", report.CandidatePath);+ Assert.Equal("BrepBoundedChamfer", report.ProductionAuthority);+ Assert.Equal("Firmament test-only sidecar", report.Seam);+ Assert.Equal("air-chamfer-firmament-shadow-ready-for-controlled-opt-in", report.Recommendation);++ Assert.Contains("edge-x13-firmament-shadow-probe-started", report.Diagnostics);+ Assert.Contains("edge-x13-firmament-production-route-executed", report.Diagnostics);+ Assert.Contains("edge-x13-air-chamfer-shadow-route-invoked", report.Diagnostics);+ Assert.Contains("edge-x13-shadow-candidate-produced", report.Diagnostics);+ Assert.Contains("edge-x13-shadow-feature-recognition-captured", report.Diagnostics);+ Assert.Contains("edge-x13-shadow-step-smoke-succeeded", report.Diagnostics);+ Assert.Contains("edge-x13-legacy-authority-preserved", report.Diagnostics);+ Assert.Contains("edge-x13-production-output-unchanged", report.Diagnostics);+ Assert.Contains("edge-x13-no-production-route-replacement", report.Diagnostics);+ Assert.Contains("edge-x13-no-3d-boolean-used", report.Diagnostics);+ }++ [Theory]+ [InlineData("opt-in-off", false, AirChamferFaceFamily.Planar, false, false, false, "opt-in-disabled")]+ [InlineData("non-planar-adjacent-face", true, AirChamferFaceFamily.Cylindrical, false, false, false, "unsupported-face-family")]+ [InlineData("edge-chain", true, AirChamferFaceFamily.Planar, true, false, false, "edge-chain")]+ [InlineData("corner-chain", true, AirChamferFaceFamily.Planar, false, true, false, "corner-chain")]+ [InlineData("legacy-dependent", true, AirChamferFaceFamily.Planar, false, false, true, "legacy-dependent-topology")]+ public void FirmamentAirChamferShadowProbe_UnsupportedOrDisabledCases_DoNotProduceCandidate(+ string caseName,+ bool enabled,+ AirChamferFaceFamily faceFamily,+ bool isEdgeChain,+ bool isCornerChain,+ bool legacyDependency,+ string expectedReason)+ {+ var compiled = CompileFixture(SupportedFixture);+ Assert.True(compiled.Compilation.IsSuccess);+ var productionBodyBeforeProbe = AssertLegacyChamferRoute(compiled);+ var productionStepBeforeProbe = ExportStep(productionBodyBeforeProbe);++ var options = new FirmamentAirChamferShadowProbeOptions(+ Enabled: enabled,+ CaseName: caseName,+ FaceFamily: faceFamily,+ IsEdgeChain: isEdgeChain,+ IsCornerChain: isCornerChain,+ LegacyDependency: legacyDependency,+ IncludeStepSmoke: true);+ var report = FirmamentAirChamferShadowProbe.Evaluate(compiled, options);++ Assert.Equal(productionStepBeforeProbe, ExportStep(AssertLegacyChamferRoute(compiled)));+ Assert.True(report.IsOptInTestOnly);+ Assert.True(report.LegacyAuthorityPreserved);+ Assert.True(report.NoProductionRouteReplacement);+ Assert.True(report.NoThreeDimensionalBooleanUsed);+ Assert.True(report.ProductionOutputUnchanged);+ Assert.False(report.ShadowCandidateProduced);+ Assert.Null(report.ShadowCandidateBody);+ Assert.Contains("edge-x13-firmament-shadow-probe-started", report.Diagnostics);+ Assert.Contains("edge-x13-firmament-production-route-executed", report.Diagnostics);+ Assert.Contains("edge-x13-legacy-authority-preserved", report.Diagnostics);+ Assert.Contains("edge-x13-production-output-unchanged", report.Diagnostics);+ Assert.Contains("edge-x13-no-production-route-replacement", report.Diagnostics);+ Assert.Contains("edge-x13-no-3d-boolean-used", report.Diagnostics);+ Assert.Contains(report.Diagnostics, d => d == $"edge-x13-shadow-deferred:{expectedReason}" || d == $"edge-x13-shadow-rejected:{expectedReason}");+ Assert.Contains(report.Recommendation, new[]+ {+ "air-chamfer-firmament-shadow-deferred-unsupported",+ "air-chamfer-firmament-shadow-rejected-invalid",+ "air-chamfer-firmament-shadow-keep-legacy-authority"+ });+ }++ private static BrepBody AssertLegacyChamferRoute(FirmamentCompileResult compiled)+ {+ var primitiveExecution = compiled.Compilation.Value.PrimitiveExecutionResult!;+ var executedBoolean = Assert.Single(primitiveExecution.ExecutedBooleans);+ Assert.Equal(FirmamentLoweredBooleanKind.Chamfer, executedBoolean.Kind);+ Assert.Equal("edge_x13_legacy_edge_break", executedBoolean.FeatureId);+ Assert.Equal(7, executedBoolean.Body.Topology.Faces.Count());+ Assert.NotEmpty(executedBoolean.Body.Topology.Bodies);+ return executedBoolean.Body;+ }++ private static string ExportStep(BrepBody body)+ {+ var export = Step242Exporter.ExportBody(body);+ Assert.True(export.IsSuccess);+ return export.Value;+ }++ private static FirmamentCompileResult CompileFixture(string fixturePath)+ {+ var source = FirmamentCorpusHarness.ReadFixtureText(fixturePath);+ var compiler = new FirmamentCompiler();+ return compiler.Compile(new FirmamentCompileRequest(new FirmamentSourceDocument(source)));+ }+}++internal sealed record FirmamentAirChamferShadowProbeOptions(+ bool Enabled,+ string CaseName,+ AirChamferFaceFamily FaceFamily,+ bool IsEdgeChain,+ bool IsCornerChain,+ bool LegacyDependency,+ bool IncludeStepSmoke)+{+ public static FirmamentAirChamferShadowProbeOptions SupportedControlledCase() =>+ new(+ Enabled: true,+ CaseName: "edge-x13-firmament-controlled-box-convex-planar-single-edge",+ FaceFamily: AirChamferFaceFamily.Planar,+ IsEdgeChain: false,+ IsCornerChain: false,+ LegacyDependency: false,+ IncludeStepSmoke: true);+}++internal sealed record FirmamentAirChamferShadowProbeReport(+ bool IsOptInTestOnly,+ string Seam,+ string ProductionAuthority,+ string CandidatePath,+ bool LegacyAuthorityPreserved,+ bool ProductionOutputUnchanged,+ bool NoProductionRouteReplacement,+ bool NoThreeDimensionalBooleanUsed,+ bool ShadowRouteInvoked,+ bool ShadowCandidateProduced,+ BrepBody? ShadowCandidateBody,+ AirChamferShadowReport? ShadowReport,+ string Recommendation,+ IReadOnlyList<string> Diagnostics);++internal static class FirmamentAirChamferShadowProbe+{+ private const string CandidatePath = "AirChamferShadowRoute->AirChamferRealBodyPrototype";+ private const string ProductionAuthority = "BrepBoundedChamfer";+ private const string Seam = "Firmament test-only sidecar";++ public static FirmamentAirChamferShadowProbeReport Evaluate(FirmamentCompileResult compiled, FirmamentAirChamferShadowProbeOptions options)+ {+ ArgumentNullException.ThrowIfNull(compiled);+ ArgumentNullException.ThrowIfNull(options);++ var diagnostics = new List<string>+ {+ "edge-x13-firmament-shadow-probe-started",+ "edge-x13-legacy-authority-preserved",+ "edge-x13-production-output-unchanged",+ "edge-x13-no-production-route-replacement",+ "edge-x13-no-3d-boolean-used"+ };++ if (!compiled.Compilation.IsSuccess || compiled.Compilation.Value.PrimitiveExecutionResult is null)+ return Deferred("compile-failed", "air-chamfer-firmament-shadow-deferred-unsupported", diagnostics);++ var primitiveExecution = compiled.Compilation.Value.PrimitiveExecutionResult;+ if (!HasSingleLegacyChamfer(primitiveExecution, out var sourceBody, out var distance))+ return Deferred("no-controlled-firmament-chamfer", "air-chamfer-firmament-shadow-deferred-unsupported", diagnostics);++ diagnostics.Add("edge-x13-firmament-production-route-executed");++ if (!options.Enabled)+ return Deferred("opt-in-disabled", "air-chamfer-firmament-shadow-deferred-unsupported", diagnostics);++ if (options.IsEdgeChain)+ return Deferred("edge-chain", "air-chamfer-firmament-shadow-deferred-unsupported", diagnostics);++ if (options.IsCornerChain)+ return Deferred("corner-chain", "air-chamfer-firmament-shadow-deferred-unsupported", diagnostics);++ if (options.LegacyDependency)+ return Deferred("legacy-dependent-topology", "air-chamfer-firmament-shadow-keep-legacy-authority", diagnostics);++ if (options.FaceFamily != AirChamferFaceFamily.Planar)+ return Rejected("unsupported-face-family", "air-chamfer-firmament-shadow-rejected-invalid", diagnostics);++ var routeReport = AirChamferShadowRoute.Evaluate(new AirChamferShadowRouteRequest(+ options.CaseName,+ sourceBody,+ new Vector3(5f, 4f, -3f),+ new Vector3(5f, 4f, 3f),+ new Vector3(1f, 0f, 0f),+ new Vector3(0f, 1f, 0f),+ distance,+ options.FaceFamily,+ options.IsEdgeChain,+ options.IsCornerChain,+ options.LegacyDependency,+ AirChamferClassificationExpectation.Convex,+ IsOrthogonalFacePair: true,+ ReferenceEnvelope: 10d,+ IncludeStepSmoke: options.IncludeStepSmoke));++ diagnostics.Add("edge-x13-air-chamfer-shadow-route-invoked");+ if (routeReport.ShadowCandidateProduced)+ diagnostics.Add("edge-x13-shadow-candidate-produced");+ else if (routeReport.ShadowCandidateStatus is AirChamferShadowCandidateStatus.Deferred or AirChamferShadowCandidateStatus.FallbackLegacy)+ diagnostics.Add($"edge-x13-shadow-deferred:{routeReport.AirChamferDecision}");+ else+ diagnostics.Add($"edge-x13-shadow-rejected:{routeReport.AirChamferDecision}");++ if (routeReport.FeatureRecognitionSummary is not null)+ diagnostics.Add("edge-x13-shadow-feature-recognition-captured");++ if (routeReport.StepSmokeSummary?.Succeeded == true)+ diagnostics.Add("edge-x13-shadow-step-smoke-succeeded");++ return new FirmamentAirChamferShadowProbeReport(+ IsOptInTestOnly: true,+ Seam,+ ProductionAuthority,+ CandidatePath,+ LegacyAuthorityPreserved: routeReport.LegacyAuthoritative,+ ProductionOutputUnchanged: !routeReport.ProductionOutputChanged,+ NoProductionRouteReplacement: true,+ NoThreeDimensionalBooleanUsed: true,+ ShadowRouteInvoked: true,+ ShadowCandidateProduced: routeReport.ShadowCandidateProduced,+ routeReport.ShadowCandidateBody,+ routeReport,+ ToFirmamentRecommendation(routeReport),+ diagnostics.Distinct().OrderBy(x => x, StringComparer.Ordinal).ToArray());+ }++ private static bool HasSingleLegacyChamfer(FirmamentPrimitiveExecutionResult primitiveExecution, out BrepBody sourceBody, out double distance)+ {+ sourceBody = null!;+ distance = 0d;++ var primitive = primitiveExecution.ExecutedPrimitives.SingleOrDefault(p =>+ p.FeatureId == "base" && p.Kind == FirmamentLoweredPrimitiveKind.Box);+ var chamfer = primitiveExecution.ExecutedBooleans.SingleOrDefault(b =>+ b.FeatureId == "edge_x13_legacy_edge_break" && b.Kind == FirmamentLoweredBooleanKind.Chamfer);+ if (primitive is null || chamfer is null)+ return false;++ sourceBody = primitive.Body;+ distance = 1d;+ return true;+ }++ private static FirmamentAirChamferShadowProbeReport Deferred(string reason, string recommendation, List<string> diagnostics)+ {+ diagnostics.Add($"edge-x13-shadow-deferred:{reason}");+ return Terminal(recommendation, diagnostics);+ }++ private static FirmamentAirChamferShadowProbeReport Rejected(string reason, string recommendation, List<string> diagnostics)+ {+ diagnostics.Add($"edge-x13-shadow-rejected:{reason}");+ return Terminal(recommendation, diagnostics);+ }++ private static FirmamentAirChamferShadowProbeReport Terminal(string recommendation, List<string> diagnostics) =>+ new(+ IsOptInTestOnly: true,+ Seam,+ ProductionAuthority,+ CandidatePath,+ LegacyAuthorityPreserved: true,+ ProductionOutputUnchanged: true,+ NoProductionRouteReplacement: true,+ NoThreeDimensionalBooleanUsed: true,+ ShadowRouteInvoked: false,+ ShadowCandidateProduced: false,+ ShadowCandidateBody: null,+ ShadowReport: null,+ recommendation,+ diagnostics.Distinct().OrderBy(x => x, StringComparer.Ordinal).ToArray());++ private static string ToFirmamentRecommendation(AirChamferShadowReport report)+ {+ if (!report.ShadowCandidateProduced)+ {+ return report.ShadowCandidateStatus switch+ {+ AirChamferShadowCandidateStatus.FallbackLegacy => "air-chamfer-firmament-shadow-keep-legacy-authority",+ AirChamferShadowCandidateStatus.Rejected => "air-chamfer-firmament-shadow-rejected-invalid",+ _ => "air-chamfer-firmament-shadow-deferred-unsupported"+ };+ }++ return report.FeatureRecognitionSummary?.RecognitionContractSatisfied == true+ ? "air-chamfer-firmament-shadow-ready-for-controlled-opt-in"+ : "air-chamfer-firmament-shadow-needs-recognition-hardening";+ }+}diff --git a/docs/edge-a1-chamfer-fillet-support-compatibility-matrix.md b/docs/edge-a1-chamfer-fillet-support-compatibility-matrix.mdindex bec8cf99..9114cd4b 100644--- a/docs/edge-a1-chamfer-fillet-support-compatibility-matrix.md+++ b/docs/edge-a1-chamfer-fillet-support-compatibility-matrix.md@@ -140,7 +140,7 @@ This path is not production-authoritative. It does not support chains, corners,|---|---|---|---|---|---|---|---|---|---|---|---|---|| CH-01 | concave/additive | plane-plane, orthogonal | single edge | constant chamfer distance | no corner | plane | `production-legacy-supported` where bounded internal concave route applies | `lab-supported`; `policy-supported` | EDGE-X1 inventory; EDGE-X2 concave planar patch proof; EDGE-X2.1 policy scaffold | production Air route, shadow parity, corpus | Legacy production only; Air is lab/policy evidence | Preserve legacy; use as concave AirChamfer baseline || CH-02 | concave/additive | plane-plane, non-orthogonal | single edge | constant chamfer distance | no corner | plane | `unknown/no-test` to `production-legacy-supported` only where existing bounded trusted contexts admit it | `lab-supported`; `policy-supported` | EDGE-X2.2 non-orthogonal concave planar policy+patch | production body mutation, feature-recognition parity, corpus | Not production Air-ready | Add parity/shadow fixture after convex route stabilizes |-| CH-03 | convex/replacement | plane-plane, orthogonal controlled body | single edge | constant chamfer distance | no corner | plane | `production-legacy-supported` for legacy bounded box/simple contexts | `production-adjacent-air-prototype`; `shadow-supported`; `artifact-corpus-supported`; `closed-witness-supported` | EDGE-X3 through EDGE-X12, EDGE-V1/V2/V3, CLI tests, FrictionLab AirChamfer tests | production authority, arbitrary body mutation, route fallback policy | Best current AirChamfer row, still non-authoritative | EDGE-V4 controlled opt-in route only after diagnostics remain stable |+| CH-03 | convex/replacement | plane-plane, orthogonal controlled body | single edge | constant chamfer distance | no corner | plane | `production-legacy-supported` for legacy bounded box/simple contexts | `production-adjacent-air-prototype`; `shadow-supported`; `artifact-corpus-supported`; `closed-witness-supported` | EDGE-X3 through EDGE-X13, EDGE-V1/V2/V3, CLI tests, FrictionLab AirChamfer tests, Firmament shadow-diagnostics tests | production authority, arbitrary body mutation, route fallback policy | Best current AirChamfer row, still non-authoritative; EDGE-X13 adds Firmament-facing test-only shadow diagnostics | EDGE-V4 controlled opt-in route only after diagnostics remain stable || CH-04 | convex/replacement | plane-plane, non-orthogonal controlled body | single edge | constant chamfer distance | no corner | plane | `production-legacy-supported` only for admitted trusted/triangle-like bounded contexts; otherwise `unknown/no-test` | `shadow-supported`; `artifact-corpus-supported`; `production-adjacent-air-prototype` for safe controlled case | EDGE-X11 non-orthogonal corpus row; EDGE-X12 stability; EDGE-V3 shadow route | broader topology mutation, richer feature-recognition parity, production fallback | Non-authoritative controlled evidence only | Harden controlled non-orthogonal shadow diagnostics || CH-05 | convex/replacement | plane-plane | single edge on arbitrary production body | constant chamfer distance | no corner or endpoint transition as needed | plane | `production-legacy-supported` only for legacy recognized bounded cases | `deferred`; `blocked-by-body-mutation`; partial `production-adjacent-air-prototype` for controlled body | EDGE-V2/V3 controlled prototype and shadow docs | arbitrary edge selection, grafting, identity, regression corpus | Not production Air-ready | EDGE-X15 convex AirChamfer controlled body mutation hardening || CH-06 | convex/replacement | plane-plane | edge chain | constant chamfer distance | chain termination; endpoint transitions | plane sequence plus transition patches | legacy support is bounded/contextual; generic status `unknown/no-test` | `deferred`; `blocked-by-corner-policy`; `blocked-by-body-mutation` | EDGE-V3 deferred edge-chain diagnostics; EDGE-X1 notes | chain policy, termination policy, topology plan, feature-recognition parity | Not ready | EDGE-X16 AirChamfer edge-chain policy lab |@@ -232,9 +232,9 @@ Known blockers before broader chamfer/fillet support include:## 10. Recommended roadmap-Recommended post-EDGE-X12 roadmap:+Recommended post-EDGE-X13 roadmap:-1. **EDGE-X13**: non-authoritative Firmament shadow diagnostics probe, if desired, to capture production-adjacent diagnostics without changing route authority.+1. **EDGE-X13**: completed as a non-authoritative Firmament-facing test-only shadow diagnostics probe for CH-03, capturing production-adjacent diagnostics without changing route authority.2. **EDGE-A2 / EDGE-FILLET-A0**: AirFillet architecture audit focused on bounded constant-radius analytic scope.3. **EDGE-X14**: plane-plane constant-radius AirFillet cylindrical closed witness lab.4. **EDGE-X15**: convex AirChamfer controlled body mutation hardening.diff --git a/docs/edge-v3-air-chamfer-shadow-route.md b/docs/edge-v3-air-chamfer-shadow-route.mdindex 2875c6d7..71b7db98 100644--- a/docs/edge-v3-air-chamfer-shadow-route.md+++ b/docs/edge-v3-air-chamfer-shadow-route.md@@ -163,3 +163,7 @@ EDGE-X11 adds a tiny deterministic regression corpus command: `aetheris experime## EDGE-A1 support-gates noteEDGE-A1 now defines the full chamfer/fillet support taxonomy, compatibility rows, and production-readiness gates in `docs/edge-a1-chamfer-fillet-support-compatibility-matrix.md`. EDGE-V3 remains non-authoritative shadow evidence for controlled AirChamfer rows; it is one readiness input, not proof of full support or production route replacement.++## EDGE-X13 Firmament diagnostics note++EDGE-X13 surfaces the existing `AirChamferShadowRoute` through a Firmament-facing, test-only diagnostics probe. The real Firmament fixture still executes legacy `BrepBoundedChamfer` first; the AirChamfer route is invoked afterward as a sidecar using `AirChamferShadowRoute->AirChamferRealBodyPrototype`. The probe records EDGE-X13 diagnostics for legacy authority, unchanged production output, no production route replacement, no 3D Boolean use, feature-recognition capture, and STEP smoke capture. No public API, normal Firmament route, STEP exporter, Boolean core, chamfer/fillet production behavior, arbitrary selection, chain/corner support, or fillet geometry changed.diff --git a/docs/edge-x13-firmament-airchamfer-shadow-diagnostics.md b/docs/edge-x13-firmament-airchamfer-shadow-diagnostics.mdnew file mode 100644index 00000000..7989b242--- /dev/null+++ b/docs/edge-x13-firmament-airchamfer-shadow-diagnostics.md@@ -0,0 +1,136 @@+# EDGE-X13 — Firmament AirChamfer shadow diagnostics probe++## Purpose and scope++EDGE-X13 adds a non-authoritative, test-only Firmament-facing diagnostics probe for the supported controlled AirChamfer row. The probe answers whether a Firmament execution can surface an internal AirChamfer shadow sidecar for the tightly bounded convex plane-plane single-edge case without changing the actual production result.++This is a diagnostics milestone only. It does not promote AirChamfer to production authority and does not change normal Firmament chamfer or fillet behavior.++## References++- EDGE-A1: `docs/edge-a1-chamfer-fillet-support-compatibility-matrix.md` defines CH-03 as the strongest AirChamfer row: convex plane-plane single-edge, controlled body, shadow/artifact/corpus supported, not production-authoritative.+- EDGE-V3: `docs/edge-v3-air-chamfer-shadow-route.md` defines `AirChamferShadowRoute`, the internal/test-only non-authoritative route used by this probe.+- EDGE-X10: `docs/frictionlab/edge-x10-airchamfer-cube-step-artifact.md` introduced the first CLI-visible controlled AirChamfer STEP artifact.+- EDGE-X11: `docs/frictionlab/edge-x11-airchamfer-step-artifact-corpus.md` introduced the tiny deterministic AirChamfer artifact corpus.+- EDGE-X12: `docs/frictionlab/edge-x12-airchamfer-corpus-stability.md` gated repeated-run corpus stability.++## Firmament seam chosen++The chosen seam is a **Firmament test-only sidecar fixture** under `Aetheris.Kernel.Firmament.Tests`.++The fixture compiles and executes a normal Firmament box plus bounded chamfer operation through the existing production path. After that production result exists, the test-only probe invokes `AirChamferShadowRoute` against the controlled pre-chamfer source body and records a separate report.++This is Firmament-facing because the motivating body and legacy chamfer route are produced by the real Firmament compiler/executor. It is not a public API, not a CLI command, and not a production runtime option.++## True Firmament-facing vs. FrictionLab-only status++EDGE-X13 is **Firmament-facing test-only**, not FrictionLab-only. The shadow candidate still uses the FrictionLab `AirChamferShadowRoute->AirChamferRealBodyPrototype` candidate path, but the probe is attached around a real Firmament fixture and asserts the real Firmament production result before and after sidecar evaluation.++## Shadow diagnostics model++The report captures deterministic machine-checkable fields:++- seam: `Firmament test-only sidecar`+- production authority: `BrepBoundedChamfer`+- candidate path: `AirChamferShadowRoute->AirChamferRealBodyPrototype`+- shadow route status+- candidate body topology summary+- STEP smoke summary when candidate body is available+- feature-recognition parity summary+- recommendation+- diagnostics++Required EDGE-X13 diagnostics include:++- `edge-x13-firmament-shadow-probe-started`+- `edge-x13-firmament-production-route-executed`+- `edge-x13-air-chamfer-shadow-route-invoked`+- `edge-x13-shadow-candidate-produced`+- `edge-x13-shadow-feature-recognition-captured`+- `edge-x13-shadow-step-smoke-succeeded`+- `edge-x13-legacy-authority-preserved`+- `edge-x13-production-output-unchanged`+- `edge-x13-no-production-route-replacement`+- `edge-x13-no-3d-boolean-used`+- `edge-x13-shadow-deferred:<reason>` for disabled or unsupported deferred rows+- `edge-x13-shadow-rejected:<reason>` for invalid unsupported rows++Allowed EDGE-X13 recommendations are:++- `air-chamfer-firmament-shadow-ready-for-controlled-opt-in`+- `air-chamfer-firmament-shadow-needs-diagnostic-seam`+- `air-chamfer-firmament-shadow-needs-recognition-hardening`+- `air-chamfer-firmament-shadow-rejected-invalid`+- `air-chamfer-firmament-shadow-deferred-unsupported`+- `air-chamfer-firmament-shadow-keep-legacy-authority`++## Supported controlled case++The only accepted case is:++- controlled Firmament fixture body: 10 × 8 × 6 box;+- one explicitly selected convex planar vertical edge equivalent to `x_max_y_max`;+- adjacent planar faces resolved to deterministic normals `(1,0,0)` and `(0,1,0)`;+- positive finite chamfer distance `1`;+- deterministic convex classification;+- no edge chain;+- no corner chain;+- no legacy-dependent topology flag;+- planar face family only;+- optional cheap STEP smoke enabled for the accepted fixture.++Unsupported/deferred cases are covered for opt-in disabled, non-planar adjacent face marker, edge chain, corner chain, and legacy-dependent topology. These cases do not produce a shadow candidate.++## Production output unchanged guarantee++The probe exports the Firmament legacy chamfer result to STEP before and after shadow sidecar execution and asserts byte-for-byte equality. The shadow candidate body is stored only in the sidecar report; it is not assigned to the Firmament compilation artifact and cannot replace the executed boolean result.++## Legacy authority and no-route-replacement guarantee++Legacy `BrepBoundedChamfer` remains the production authority. The real Firmament operation is still a bounded chamfer executed by the existing Firmament production path, and the probe report declares `BrepBoundedChamfer` as production authority. The AirChamfer sidecar is invoked only after the production result exists.++## No-3D-Boolean guarantee++The AirChamfer candidate path remains `AirChamferShadowRoute->AirChamferRealBodyPrototype`, the same no-3D-Boolean shadow/prototype route used by EDGE-V3/X10/X11/X12. The probe records `edge-x13-no-3d-boolean-used` and does not invoke Boolean fallback in the AirChamfer sidecar.++## Test cases and results++Focused EDGE-X13 tests are in `Aetheris.Kernel.Firmament.Tests/AirChamferFirmamentShadowProbeTests.cs`:++1. supported controlled Firmament fixture produces a shadow candidate;+2. production STEP output before/after the sidecar is unchanged;+3. legacy authority and no-route-replacement diagnostics are present;+4. no-3D-Boolean diagnostic is present;+5. feature-recognition summary is captured;+6. STEP smoke summary is captured;+7. opt-in disabled does not invoke the shadow route or produce a candidate;+8. non-planar, edge-chain, corner-chain, and legacy-dependent cases produce rejected/deferred reports without candidates.++Observed focused result during implementation:++```bash+dotnet test Aetheris.Kernel.Firmament.Tests/Aetheris.Kernel.Firmament.Tests.csproj --filter "AirChamferShadow"+```++Result: passed for both `net8.0` and `net10.0` target frameworks.++## Non-goals++EDGE-X13 does not add or change:++- production chamfer replacement;+- arbitrary user/model edge selection;+- fillets or fillet geometry;+- edge chains, corner chains, or corner patches;+- STEP exporter/importer behavior;+- Boolean core behavior;+- public API surface;+- production route replacement;+- triangle migration retry;+- sketch solver behavior;+- clipping engine behavior;+- NURBS/freeform support.++## Recommended next milestone++The recommended next milestone is **EDGE-V4 controlled opt-in AirChamfer route** only if EDGE-X13 diagnostics and the EDGE-X12 corpus stability lane remain stable. If future work finds the Firmament seam too awkward for broader diagnostics, use **EDGE-X13.1 diagnostic seam hardening** before any route authorization. If priorities shift to fillets, use **EDGE-A2 / EDGE-FILLET-A0** instead.diff --git a/docs/frictionlab/edge-x11-airchamfer-step-artifact-corpus.md b/docs/frictionlab/edge-x11-airchamfer-step-artifact-corpus.mdindex 7e744604..b86f9963 100644--- a/docs/frictionlab/edge-x11-airchamfer-step-artifact-corpus.md+++ b/docs/frictionlab/edge-x11-airchamfer-step-artifact-corpus.md@@ -161,3 +161,7 @@ After EDGE-X12, any broader AirChamfer corpus shape expansion should remain anal## EDGE-A1 matrix noteEDGE-A1 classifies CLI/artifact corpus coverage as one production-readiness gate in `docs/edge-a1-chamfer-fillet-support-compatibility-matrix.md`. The EDGE-X11 corpus supports controlled AirChamfer evidence rows, but corpus artifacts alone do not imply production authority, chain/corner support, fillet support, or feature-recognition parity for legacy-sensitive cases.++## EDGE-X13 Firmament shadow-diagnostics bridge++EDGE-X13 reuses the same `AirChamferShadowRoute->AirChamferRealBodyPrototype` candidate path from this corpus in a Firmament-facing test-only sidecar probe. The corpus remains the CLI/artifact stability lane; EDGE-X13 adds Firmament observability evidence for CH-03 by proving that a real Firmament legacy chamfer fixture can collect AirChamfer shadow topology, recognition, and STEP-smoke summaries without changing the production body or replacing `BrepBoundedChamfer` authority.diff --git a/testdata/firmament/fixtures/edge-x13-valid-airchamfer-shadow-box-edge.firmament b/testdata/firmament/fixtures/edge-x13-valid-airchamfer-shadow-box-edge.firmamentnew file mode 100644index 00000000..46617305--- /dev/null+++ b/testdata/firmament/fixtures/edge-x13-valid-airchamfer-shadow-box-edge.firmament@@ -0,0 +1,22 @@+firmament:+ version: 1++model:+ name: edge_x13_airchamfer_shadow_box_edge+ units: mm++ops[2]:+ -+ op: box+ id: base+ size[3]:+ 10+ 8+ 6+ -+ op: chamfer+ id: edge_x13_legacy_edge_break+ from: base+ edges[1]:+ x_max_y_max+ distance: 1