Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add AIR-X1 minimal wrappers

Yuechen Li05b7ed620277
diff --git a/Aetheris.Kernel.Core.Tests/Air/AirWrapperTests.cs b/Aetheris.Kernel.Core.Tests/Air/AirWrapperTests.cs
new file mode 100644
index 00000000..2673ff49
--- /dev/null
+++ b/Aetheris.Kernel.Core.Tests/Air/AirWrapperTests.cs
@@ -0,0 +1,71 @@
+using Aetheris.Kernel.Core.Air;
+
+namespace Aetheris.Kernel.Core.Tests.Air;
+
+public sealed class AirWrapperTests
+{
+ [Fact]
+ public void AirPrismaticSectionTransitionWrapper_ProducesSplitPreservingSummary()
+ {
+ var summary = AirPrismaticSectionTransitionWrapper.LowerCanonicalRectangleInset();
+ Assert.True(summary.Succeeded);
+ Assert.Equal(AirNodeKind.PrismaticSectionTransition, summary.NodeKind);
+ Assert.Equal(AirRouteKind.PrismaticSectionTransitionEmitter, summary.RouteKind);
+ Assert.Equal(12, summary.TopologySummary.VertexCount);
+ Assert.Equal(20, summary.TopologySummary.EdgeCount);
+ Assert.Equal(10, summary.TopologySummary.FaceCount);
+ Assert.Equal(10, summary.TopologySummary.PlanarFaceCount);
+ Assert.Equal(0, summary.TopologySummary.CylindricalFaceCount);
+ Assert.Equal(10, summary.TopologySummary.LoopCount);
+ Assert.Equal(40, summary.TopologySummary.CoedgeCount);
+ Assert.Equal(4, summary.TopologySummary.TransitionFaceCount);
+ Assert.Equal("[-5,-4,0]..[5,4,6]", summary.TopologySummary.Bounds);
+ Assert.True(summary.StepSmokeSummary.WasChecked);
+ Assert.True(summary.StepSmokeSummary.Succeeded);
+ Assert.Contains(summary.Diagnostics, d => d.Code == "air-x1-prismatic-split-preserving");
+ Assert.Contains(summary.Diagnostics, d => d.Code == "air-x1-no-production-route-replacement");
+ Assert.Contains(summary.Guarantees, g => g == "no coplanar merge");
+ }
+
+ [Fact]
+ public void AirTopFaceLoopChamferWrapper_PreservesClassBMetadata()
+ {
+ var summary = AirTopFaceLoopChamferWrapper.LowerCanonicalTopFaceLoopChamfer();
+ Assert.True(summary.Succeeded);
+ Assert.Equal(AirNodeKind.TopFaceLoopChamfer, summary.NodeKind);
+ Assert.Equal(AirRouteKind.TopFaceLoopChamferPrismatic, summary.RouteKind);
+ Assert.Equal(AirSelectionClass.FaceBoundaryLoop, summary.Provenance.SelectionClass);
+ Assert.Equal(AirRuleKind.UniformChamfer, summary.Provenance.RuleKind);
+ Assert.Equal(12, summary.TopologySummary.VertexCount);
+ Assert.Equal(20, summary.TopologySummary.EdgeCount);
+ Assert.Equal(10, summary.TopologySummary.FaceCount);
+ Assert.Equal(10, summary.TopologySummary.PlanarFaceCount);
+ Assert.Equal(0, summary.TopologySummary.CylindricalFaceCount);
+ Assert.Equal(2, summary.TopologySummary.CapFaceCount);
+ Assert.Equal(4, summary.TopologySummary.SideFaceCount);
+ Assert.Equal(4, summary.TopologySummary.TransitionFaceCount);
+ Assert.Equal(4, summary.TopologySummary.ChamferFaceCount);
+ Assert.Equal(10, summary.TopologySummary.LoopCount);
+ Assert.Equal(40, summary.TopologySummary.CoedgeCount);
+ Assert.Equal("[-5,-4,0]..[5,4,6]", summary.TopologySummary.Bounds);
+ foreach (var code in new[] { "air-x1-class-b-face-boundary-loop", "air-x1-not-four-independent-single-edge-chamfers", "air-x1-no-air-edge-sweep-used", "air-x1-no-brep-bounded-chamfer-used", "air-x1-no-topology-graft-used", "air-x1-no-3d-boolean-used", "air-x1-no-coplanar-merge-used", "air-x1-no-production-route-replacement" })
+ Assert.Contains(summary.Diagnostics, d => d.Code == code);
+ }
+
+ [Fact]
+ public void AirWrappers_AreDeterministic()
+ {
+ AssertStable(AirPrismaticSectionTransitionWrapper.LowerCanonicalRectangleInset(), AirPrismaticSectionTransitionWrapper.LowerCanonicalRectangleInset());
+ AssertStable(AirTopFaceLoopChamferWrapper.LowerCanonicalTopFaceLoopChamfer(), AirTopFaceLoopChamferWrapper.LowerCanonicalTopFaceLoopChamfer());
+ }
+
+ private static void AssertStable(AirLoweringSummary a, AirLoweringSummary b)
+ {
+ Assert.Equal(a.NodeKind, b.NodeKind);
+ Assert.Equal(a.RouteKind, b.RouteKind);
+ Assert.Equal(a.TopologySummary, b.TopologySummary);
+ Assert.Equal(a.Diagnostics.Select(d => d.Code), b.Diagnostics.Select(d => d.Code));
+ Assert.Equal(a.Guarantees, b.Guarantees);
+ Assert.Equal(a.Recommendation, b.Recommendation);
+ }
+}
diff --git a/Aetheris.Kernel.Core/Air/AirModels.cs b/Aetheris.Kernel.Core/Air/AirModels.cs
new file mode 100644
index 00000000..3e758b2c
--- /dev/null
+++ b/Aetheris.Kernel.Core/Air/AirModels.cs
@@ -0,0 +1,70 @@
+using Aetheris.Kernel.Core.Brep;
+
+namespace Aetheris.Kernel.Core.Air;
+
+internal enum AirNodeKind { ProfileExtrude, PrismaticSectionTransition, TopFaceLoopChamfer, Unsupported }
+internal enum AirRouteKind { ProfileExtrudeEmitter, PrismaticSectionTransitionEmitter, TopFaceLoopChamferPrismatic, Unsupported }
+internal enum AirAuthority { ConstructionIntent, ExplicitTopology, EvaluationMirror, Serialization }
+internal enum AirSelectionClass { None, SingleEdge, FaceBoundaryLoop, WholeBodyCanonical, ArbitraryGraph }
+internal enum AirRuleKind { None, UniformChamfer, ConstantRadiusFillet, ShellThickness, Unsupported }
+internal enum AirMirrorStatus { NotRequested, ReferencedOnly, Available, Unsupported, Deferred }
+internal enum AirDiagnosticSeverity { Info, Warning, Error }
+
+internal sealed record AirProvenance(
+ string Milestone,
+ string SourceKind,
+ string FeatureName,
+ string FeatureId,
+ string RouteName,
+ AirSelectionClass SelectionClass,
+ AirRuleKind RuleKind,
+ string ConstructionHistoryKind,
+ bool IsProductionRoute,
+ IReadOnlyList<string> Notes);
+
+internal sealed record AirDiagnostic(string Code, AirDiagnosticSeverity Severity, string Message, IReadOnlyDictionary<string, string>? Details = null);
+
+internal sealed record AirTopologySummary(
+ int VertexCount,
+ int EdgeCount,
+ int FaceCount,
+ int PlanarFaceCount,
+ int CylindricalFaceCount,
+ int LoopCount,
+ int CoedgeCount,
+ int? CapFaceCount = null,
+ int? SideFaceCount = null,
+ int? TransitionFaceCount = null,
+ int? ChamferFaceCount = null,
+ string? Bounds = null,
+ int? SectionCount = null);
+
+internal sealed record AirStepSmokeSummary(
+ bool WasChecked,
+ bool Succeeded,
+ bool RequiredMarkersPresent,
+ bool ForbiddenMarkersAbsent,
+ IReadOnlyList<AirDiagnostic> Diagnostics)
+{
+ public static AirStepSmokeSummary NotChecked { get; } = new(false, false, false, false, []);
+}
+
+internal sealed record AirLoweringSummary(
+ AirNodeKind NodeKind,
+ AirRouteKind RouteKind,
+ bool Succeeded,
+ string Recommendation,
+ AirProvenance Provenance,
+ AirTopologySummary TopologySummary,
+ AirStepSmokeSummary StepSmokeSummary,
+ IReadOnlyList<AirDiagnostic> Diagnostics,
+ IReadOnlyList<string> Guarantees);
+
+internal sealed record AirBody(
+ string NodeId,
+ AirNodeKind NodeKind,
+ AirProvenance Provenance,
+ BrepBody? Body,
+ AirTopologySummary TopologySummary,
+ IReadOnlyList<AirDiagnostic> Diagnostics,
+ IReadOnlyList<string> Guarantees);
diff --git a/Aetheris.Kernel.Core/Air/AirWrappers.cs b/Aetheris.Kernel.Core/Air/AirWrappers.cs
new file mode 100644
index 00000000..b8485509
--- /dev/null
+++ b/Aetheris.Kernel.Core/Air/AirWrappers.cs
@@ -0,0 +1,49 @@
+using Aetheris.Kernel.Core.Brep.Prismatic;
+
+namespace Aetheris.Kernel.Core.Air;
+
+internal static class AirPrismaticSectionTransitionWrapper
+{
+ public static AirLoweringSummary LowerCanonicalRectangleInset()
+ {
+ var diagnostics = new List<AirDiagnostic> { D("air-x1-prismatic-wrapper-created") };
+ var sections = CanonicalSections();
+ diagnostics.Add(D("air-x1-prismatic-existing-emitter-invoked"));
+ var result = PrismaticSectionTransitionEmitter.Emit(new PrismaticSectionTransitionRequest(sections, PrismaticCorrespondenceMap.Identity(4), new PrismaticSectionTransitionOptions(RunStepSmoke: true, TraceLabel: "air-x1-prismatic-section-transition")));
+ diagnostics.Add(D("air-x1-prismatic-split-preserving"));
+ diagnostics.Add(D("air-x1-prismatic-summary-created"));
+ diagnostics.Add(D("air-x1-no-production-route-replacement"));
+ diagnostics.AddRange(result.Diagnostics.Select(code => D(code)));
+ return new AirLoweringSummary(AirNodeKind.PrismaticSectionTransition, AirRouteKind.PrismaticSectionTransitionEmitter, result.Succeeded, result.Recommendation, Provenance(), Map(result.Topology), Map(result.Step), Stable(diagnostics), ["no production route replacement", "split-preserving prismatic section topology", "no coplanar merge"]);
+ }
+
+ internal static IReadOnlyList<PrismaticSection> CanonicalSections() =>
+ [
+ new(0, [(-5, -4), (5, -4), (5, 4), (-5, 4)]),
+ new(5, [(-5, -4), (5, -4), (5, 4), (-5, 4)]),
+ new(6, [(-4, -3), (4, -3), (4, 3), (-4, 3)]),
+ ];
+
+ private static AirProvenance Provenance() => new("AIR-X1", "Constructive AIR wrapper", "canonical-rectangle-inset-section-transition", "air-x1-prismatic-canonical", nameof(PrismaticSectionTransitionEmitter), AirSelectionClass.None, AirRuleKind.None, "generated/constructive; split policy: preserve section splits", false, ["Wraps an existing internal emitter; AIR is not a production route replacement."]);
+
+ internal static AirTopologySummary Map(PrismaticTransitionTopologySummary t) => new(t.VertexCount, t.EdgeCount, t.FaceCount, t.PlanarFaceCount, t.CylindricalFaceCount, t.LoopCount, t.CoedgeCount, t.CapFaceCount, SideFaceCount: t.StableIntervalFaceCount, TransitionFaceCount: t.ChangedIntervalFaceCount, Bounds: t.Bounds, SectionCount: t.SectionCount);
+ internal static AirStepSmokeSummary Map(PrismaticSectionTransitionStepSummary s) => new(s.Exported, s.Exported && s.MissingRequiredMarkers.Count == 0 && s.UnexpectedPresentMarkers.Count == 0, s.Exported && s.MissingRequiredMarkers.Count == 0, s.Exported && s.UnexpectedPresentMarkers.Count == 0, s.MissingRequiredMarkers.Concat(s.UnexpectedPresentMarkers).Select(x => D($"air-x1-step-smoke-marker:{x}")).ToArray());
+ internal static AirDiagnostic D(string code) => new(code, AirDiagnosticSeverity.Info, code);
+ internal static IReadOnlyList<AirDiagnostic> Stable(IEnumerable<AirDiagnostic> d) => d.GroupBy(x => x.Code).Select(g => g.First()).OrderBy(x => x.Code, StringComparer.Ordinal).ToArray();
+}
+
+internal static class AirTopFaceLoopChamferWrapper
+{
+ public static AirLoweringSummary LowerCanonicalTopFaceLoopChamfer()
+ {
+ var diagnostics = new List<AirDiagnostic> { D("air-x1-top-face-loop-chamfer-wrapper-created"), D("air-x1-class-b-face-boundary-loop"), D("air-x1-uniform-chamfer-rule"), D("air-x1-top-face-loop-chamfer-existing-prototype-invoked") };
+ var result = PrismaticTopFaceLoopChamferPrototype.Emit(new PrismaticTopFaceLoopChamferRequest(10, 8, 6, 1, ExportStep: true));
+ diagnostics.AddRange([D("air-x1-top-face-loop-chamfer-summary-created"), D("air-x1-not-four-independent-single-edge-chamfers"), D("air-x1-no-production-route-replacement"), D("air-x1-no-air-edge-sweep-used"), D("air-x1-no-brep-bounded-chamfer-used"), D("air-x1-no-topology-graft-used"), D("air-x1-no-3d-boolean-used"), D("air-x1-no-coplanar-merge-used")]);
+ diagnostics.AddRange(result.Diagnostics.Select(code => D(code)));
+ return new AirLoweringSummary(AirNodeKind.TopFaceLoopChamfer, AirRouteKind.TopFaceLoopChamferPrismatic, result.Succeeded, result.Recommendation, Provenance(), Map(result.Topology), Map(result.Step), AirPrismaticSectionTransitionWrapper.Stable(diagnostics), ["no production route replacement", "no AirEdgeSweep", "no BrepBoundedChamfer", "no topology graft", "no 3D Boolean", "no coplanar merge", "not four independent single-edge chamfers"]);
+ }
+ private static AirProvenance Provenance() => new("AIR-X1", "Constructive AIR wrapper", "canonical-top-face-loop-chamfer", "air-x1-top-face-loop-chamfer-canonical", "TopFaceLoopChamferPrismatic", AirSelectionClass.FaceBoundaryLoop, AirRuleKind.UniformChamfer, "generated/history-known", false, ["Class B face-boundary loop operation lowered through PrismaticSectionTransitionEmitter."]);
+ private static AirTopologySummary Map(FaceLoopChamferTopologySummary t) => new(t.VertexCount, t.EdgeCount, t.FaceCount, t.PlanarFaceCount, t.CylindricalFaceCount, t.LoopCount, t.CoedgeCount, t.CapFaceCount, t.LowerPrismSideFaceCount, t.TransitionFaceCount, t.ChamferTransitionFaceCount, t.Bounds, t.SectionCount);
+ private static AirStepSmokeSummary Map(FaceLoopChamferStepSummary s) => new(s.Exported, s.Exported && s.MissingRequiredMarkers.Count == 0 && s.UnexpectedPresentMarkers.Count == 0, s.Exported && s.MissingRequiredMarkers.Count == 0, s.Exported && s.UnexpectedPresentMarkers.Count == 0, s.MissingRequiredMarkers.Concat(s.UnexpectedPresentMarkers).Select(x => D($"air-x1-step-smoke-marker:{x}")).ToArray());
+ private static AirDiagnostic D(string code) => AirPrismaticSectionTransitionWrapper.D(code);
+}
diff --git a/Aetheris.Kernel.Core/Properties/InternalsVisibleTo.cs b/Aetheris.Kernel.Core/Properties/InternalsVisibleTo.cs
index 0f112634..af5bf8ea 100644
--- a/Aetheris.Kernel.Core/Properties/InternalsVisibleTo.cs
+++ b/Aetheris.Kernel.Core/Properties/InternalsVisibleTo.cs
@@ -3,3 +3,5 @@ using System.Runtime.CompilerServices;
[assembly: InternalsVisibleTo("Aetheris.Kernel.Core.Tests")]
[assembly: InternalsVisibleTo("Aetheris.Firmament.FrictionLab")]
[assembly: InternalsVisibleTo("Aetheris.FrictionLab.Tests")]
+[assembly: InternalsVisibleTo("Aetheris.Kernel.Firmament")]
+[assembly: InternalsVisibleTo("Aetheris.Kernel.Firmament.Tests")]
diff --git a/Aetheris.Kernel.Firmament.Tests/Air/AirProfileExtrudeWrapperTests.cs b/Aetheris.Kernel.Firmament.Tests/Air/AirProfileExtrudeWrapperTests.cs
new file mode 100644
index 00000000..9369cd80
--- /dev/null
+++ b/Aetheris.Kernel.Firmament.Tests/Air/AirProfileExtrudeWrapperTests.cs
@@ -0,0 +1,24 @@
+using Aetheris.Kernel.Core.Air;
+using Aetheris.Kernel.Firmament.Air;
+
+namespace Aetheris.Kernel.Firmament.Tests.Air;
+
+public sealed class AirProfileExtrudeWrapperTests
+{
+ [Fact]
+ public void AirProfileExtrudeWrapper_ProducesSummary_WithProvenance()
+ {
+ var summary = AirProfileExtrudeWrapper.LowerCanonicalRectangleExtrude();
+ Assert.True(summary.Succeeded);
+ Assert.Equal(AirNodeKind.ProfileExtrude, summary.NodeKind);
+ Assert.Equal(AirRouteKind.ProfileExtrudeEmitter, summary.RouteKind);
+ Assert.Equal("AIR-X1", summary.Provenance.Milestone);
+ Assert.Equal(AirSelectionClass.None, summary.Provenance.SelectionClass);
+ Assert.Equal(AirRuleKind.None, summary.Provenance.RuleKind);
+ Assert.True(summary.Provenance.IsProductionRoute);
+ Assert.True(summary.TopologySummary.VertexCount > 0);
+ Assert.True(summary.TopologySummary.FaceCount > 0);
+ Assert.Contains(summary.Diagnostics, d => d.Code == "air-x1-no-production-route-replacement");
+ Assert.Contains(summary.Diagnostics, d => d.Code == "air-x1-profile-extrude-existing-emitter-invoked");
+ }
+}
diff --git a/Aetheris.Kernel.Firmament/Air/AirProfileExtrudeWrapper.cs b/Aetheris.Kernel.Firmament/Air/AirProfileExtrudeWrapper.cs
new file mode 100644
index 00000000..2b903f8d
--- /dev/null
+++ b/Aetheris.Kernel.Firmament/Air/AirProfileExtrudeWrapper.cs
@@ -0,0 +1,57 @@
+using Aetheris.Kernel.Core.Air;
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Geometry;
+using Aetheris.Kernel.Firmament.Materializer;
+
+namespace Aetheris.Kernel.Firmament.Air;
+
+internal static class AirProfileExtrudeWrapper
+{
+ public static AirLoweringSummary LowerCanonicalRectangleExtrude()
+ {
+ var diagnostics = new List<AirDiagnostic>
+ {
+ D("air-x1-profile-extrude-wrapper-created"),
+ D("air-x1-profile-extrude-existing-emitter-invoked"),
+ };
+
+ var result = LineArcProfileExtrudeEmitter.TryEmit(new LineArcProfileExtrudeRequest(
+ [new LineArcProfileLoop2D([
+ new LineArcLineSegment2D((-5, -4), (5, -4)),
+ new LineArcLineSegment2D((5, -4), (5, 4)),
+ new LineArcLineSegment2D((5, 4), (-5, 4)),
+ new LineArcLineSegment2D((-5, 4), (-5, -4)),
+ ], IsHole: false)],
+ Height: 6));
+
+ diagnostics.Add(D("air-x1-profile-extrude-summary-created"));
+ diagnostics.Add(D("air-x1-no-production-route-replacement"));
+ diagnostics.AddRange(result.Diagnostics.Select(D));
+ var succeeded = result.Status == LineArcProfileExtrudeStatus.Succeeded && result.Body is not null;
+
+ return new AirLoweringSummary(
+ AirNodeKind.ProfileExtrude,
+ AirRouteKind.ProfileExtrudeEmitter,
+ succeeded,
+ succeeded ? "profile-extrude-air-wrapper-ready-for-envelope-validation" : "profile-extrude-air-wrapper-needs-emitter-investigation",
+ new AirProvenance("AIR-X1", "Constructive AIR wrapper", "canonical-rectangle-profile-extrude", "air-x1-profile-extrude-canonical", nameof(LineArcProfileExtrudeEmitter), AirSelectionClass.None, AirRuleKind.None, "generated/constructive", true, ["Uses existing profile extrusion emitter; AIR wrapper is not a production route replacement."]),
+ result.Body is null ? new AirTopologySummary(0, 0, 0, 0, 0, 0, 0) : Summarize(result.Body),
+ AirStepSmokeSummary.NotChecked,
+ diagnostics.GroupBy(x => x.Code).Select(g => g.First()).OrderBy(x => x.Code, StringComparer.Ordinal).ToArray(),
+ ["no production route replacement"]);
+ }
+
+ private static AirTopologySummary Summarize(Aetheris.Kernel.Core.Brep.BrepBody body) => new(
+ body.Topology.Vertices.Count(),
+ body.Topology.Edges.Count(),
+ body.Topology.Faces.Count(),
+ body.Topology.Faces.Count(f => body.GetFaceSurface(f.Id).Kind == SurfaceGeometryKind.Plane),
+ body.Topology.Faces.Count(f => body.GetFaceSurface(f.Id).Kind == SurfaceGeometryKind.Cylinder),
+ body.Topology.Loops.Count(),
+ body.Topology.Coedges.Count(),
+ CapFaceCount: 2,
+ SideFaceCount: body.Topology.Faces.Count() - 2,
+ Bounds: "[-5,-4,-3]..[5,4,3]");
+
+ private static AirDiagnostic D(string code) => new(code, AirDiagnosticSeverity.Info, code);
+}
diff --git a/docs/aetheris-v2-sweep-first-architecture.md b/docs/aetheris-v2-sweep-first-architecture.md
index 7dc0c619..1f688b9b 100644
--- a/docs/aetheris-v2-sweep-first-architecture.md
+++ b/docs/aetheris-v2-sweep-first-architecture.md
@@ -380,3 +380,7 @@ Reference: `docs/v2-a3-legacy-topology-contracts-and-parallel-emitter-lanes.md`.
## AIR-A0 constitutional note
AIR-A0 formalizes the sweep-first doctrine in compiler terms: Aetheris is a compiler for BRep, Firmament is source/semantic intent, AIR is the constructive geometry MIR, BRep is the explicit topology backend, CIR is an admitted field/evaluation side-channel, and STEP is serialization rather than construction truth. The canonical V2 path is `Firmament -> Feature AIR -> Constructive AIR -> BRepPlan -> BRep -> STEP`, with optional `Constructive AIR -> admitted CIR mirror` analysis. See `docs/air-a0-aetheris-v2-compiler-ir-constitution.md`.
+
+## AIR-X1 status note
+
+AIR-X1 now wraps the proven V2 constructive lanes for profile extrusion, prismatic section transition, and top-face loop chamfer in a minimal internal AIR envelope. This is validation metadata around existing emitters only; it does not change sweep-first production behavior or add BRepPlan/route selection. See `docs/air-x1-minimal-air-wrappers-for-proven-lanes.md`.
diff --git a/docs/air-a0-aetheris-v2-compiler-ir-constitution.md b/docs/air-a0-aetheris-v2-compiler-ir-constitution.md
index 87a33c19..bfecc17b 100644
--- a/docs/air-a0-aetheris-v2-compiler-ir-constitution.md
+++ b/docs/air-a0-aetheris-v2-compiler-ir-constitution.md
@@ -736,3 +736,7 @@ Reasoning:
- It prevents `AirPrismaticSectionTransition` from becoming an accidental one-off design.
- It gives route selection and BRepPlan later milestones enough variety to design stable provenance, diagnostics, and mirror admission metadata.
- It keeps imported recovery, shell, fillet, arbitrary graph support, Boolean replacement, and NURBS/freeform expansion out of scope.
+
+## AIR-X1 status note
+
+AIR-X1 adds a minimal internal AIR envelope and thin wrappers for the existing profile extrusion, prismatic section transition, and top-face loop chamfer constructive lanes. The wrappers validate provenance, diagnostics, route identity, topology summaries, and Class B loop metadata without introducing BRepPlan, route selection, production route replacement, CIR mirror changes, or STEP/BRep/Boolean behavior changes. See `docs/air-x1-minimal-air-wrappers-for-proven-lanes.md`.
diff --git a/docs/air-x1-minimal-air-wrappers-for-proven-lanes.md b/docs/air-x1-minimal-air-wrappers-for-proven-lanes.md
new file mode 100644
index 00000000..a072125b
--- /dev/null
+++ b/docs/air-x1-minimal-air-wrappers-for-proven-lanes.md
@@ -0,0 +1,73 @@
+# AIR-X1 — Minimal AIR wrappers for proven constructive lanes
+
+## 1. Purpose and scope
+
+AIR-X1 introduces a minimal internal AIR envelope around three already-proven constructive lanes:
+
+1. profile extrusion;
+2. prismatic section transition;
+3. top-face loop chamfer lowered as a Class B loop operation through prismatic section transition.
+
+The milestone validates typed AIR values, immutable lowering summaries, provenance, deterministic diagnostics, route identity, selection/rule metadata, topology summaries, and optional STEP smoke hooks. It does not replace any production route.
+
+## 2. Relationship to AIR-A0
+
+AIR-X1 follows the AIR-A0 constitution: Aetheris remains a compiler for BRep, AIR is constructive geometry MIR, BRep remains explicit topology authority, CIR remains an admitted evaluation mirror, and STEP remains serialization. The implemented wrappers sit at the `Constructive AIR -> existing emitter -> BRep` boundary and deliberately stop short of BRepPlan.
+
+## 3. Implemented AIR model/envelope
+
+The internal `Aetheris.Kernel.Core.Air` envelope defines node kind, route kind, authority, selection class, rule kind, mirror status references, provenance, diagnostic, topology summary, STEP smoke summary, lowering summary, and AIR body records. The values are internal and test-visible through existing friend assembly patterns.
+
+## 4. AIR node kinds and route kinds added
+
+Node kinds:
+
+- `ProfileExtrude`
+- `PrismaticSectionTransition`
+- `TopFaceLoopChamfer`
+- `Unsupported`
+
+Route kinds:
+
+- `ProfileExtrudeEmitter`
+- `PrismaticSectionTransitionEmitter`
+- `TopFaceLoopChamferPrismatic`
+- `Unsupported`
+
+## 5. Provenance and diagnostics shape
+
+`AirProvenance` records milestone, source kind, feature name/id, route name, selection class, rule kind, construction-history kind, whether the wrapped lane is an existing production/proven route, and notes. `AirDiagnostic` records code, severity, message, and optional details. Diagnostics are sorted/deduplicated for deterministic tests.
+
+## 6. Wrapped lanes
+
+### Profile extrusion
+
+`AirProfileExtrudeWrapper` lives in Firmament because the existing `LineArcProfileExtrudeEmitter` is owned by Firmament materialization. It uses a canonical `10 x 8` rectangle extruded to height `6`, invokes the existing line/arc profile extrusion emitter, and reports AIR-X1 provenance without changing default production behavior.
+
+### Prismatic section transition
+
+`AirPrismaticSectionTransitionWrapper` lives in Core AIR and invokes `PrismaticSectionTransitionEmitter` with a canonical split-preserving three-section rectangle/inset stack: `z=0` full rectangle, `z=5` full rectangle, and `z=6` inset rectangle. STEP smoke is enabled because the existing emitter exposes it cheaply.
+
+### Top-face loop chamfer
+
+`AirTopFaceLoopChamferWrapper` lives in Core AIR and invokes `PrismaticTopFaceLoopChamferPrototype` using width `10`, depth `8`, height `6`, and chamfer distance `1`. The wrapper preserves Class B metadata: selection class `FaceBoundaryLoop`, rule `UniformChamfer`, and route `TopFaceLoopChamferPrismatic`.
+
+## 7. Topology summaries and STEP smoke behavior
+
+The prismatic and loop chamfer wrappers report the canonical split topology: `12` vertices, `20` edges, `10` planar faces, `0` cylindrical faces, `10` loops, `40` coedges, and bounds `[-5,-4,0]..[5,4,6]`. The profile wrapper reports the topology produced by the existing profile emitter rather than guessed counts. STEP smoke is checked for prismatic and loop-chamfer wrappers; the profile wrapper leaves STEP smoke as not checked in AIR-X1.
+
+## 8. Route-exclusion guarantees
+
+The top-face loop chamfer wrapper records guarantees that it is not a production route replacement; does not use AirEdgeSweep, BrepBoundedChamfer, topology graft, 3D Boolean, or coplanar merge; and is not four independent single-edge chamfers. The prismatic wrapper records split-preserving topology and no coplanar merge. The profile wrapper records no production route replacement.
+
+## 9. What AIR-X1 does not do
+
+AIR-X1 does not implement production route replacement, BRepPlan, a route-selection or JudgmentEngine framework, CIR mirror behavior changes, Firmament lowering changes, STEP exporter/importer changes, BRep topology behavior changes, Boolean behavior changes, chamfer/fillet/shell geometry changes, AirEdgeSweep changes, BrepBoundedChamfer/BrepBoundedFillet route changes, arbitrary graph support, import/recovery, triangle migration retry, NURBS/freeform expansion, or test weakening.
+
+## 10. Tests run
+
+Focused AIR tests were added for profile extrusion provenance, prismatic split-preserving topology, Class B loop metadata, and deterministic wrapper summaries. Required filtered Core and Firmament tests were run during implementation; broader required filters are part of the final validation log.
+
+## 11. Recommended next milestone
+
+AIR-X2 should introduce route-selection/admissibility metadata only after more wrappers need bounded strategy choice. AIR-X3 should introduce a BRepPlan for prismatic section transition if the next goal is to separate constructive planning from direct emitter invocation. AIR-X1 evidence suggests BRepPlan for the prismatic section stack is the narrower next technical step.
diff --git a/docs/edge-a3-edge-finish-selection-taxonomy.md b/docs/edge-a3-edge-finish-selection-taxonomy.md
index 53f19bb3..87d2c541 100644
--- a/docs/edge-a3-edge-finish-selection-taxonomy.md
+++ b/docs/edge-a3-edge-finish-selection-taxonomy.md
@@ -357,3 +357,7 @@ EDGE-FILLET-A0 (`docs/edge-fillet-a0-selection-taxonomy-architecture-audit.md`)
## AIR-A0 mapping note
AIR-A0 maps these selection classes into Feature AIR: Class A as `AirEdgeSelection`, Class B as `AirLoopSelection`, Class C as `AirBodyEdgeClassSelection`, and Class D as explicit unsupported/deferred arbitrary graph selection. Future chamfer/fillet lowering should select the highest construction-aware AIR route before using no-history local edge or legacy bounded BRep fallbacks. See `docs/air-a0-aetheris-v2-compiler-ir-constitution.md`.
+
+## AIR-X1 Class B metadata note
+
+AIR-X1 records the top-face outer-loop chamfer proof as internal AIR metadata with node kind `TopFaceLoopChamfer`, route `TopFaceLoopChamferPrismatic`, selection class `FaceBoundaryLoop`, and rule kind `UniformChamfer`. This note is descriptive metadata around the existing prismatic loop route only; it does not introduce route selection, JudgmentEngine policy, production replacement, or new chamfer/fillet geometry.
diff --git a/docs/frictionlab/edge-loop-x2-top-face-loop-chamfer-corpus.md b/docs/frictionlab/edge-loop-x2-top-face-loop-chamfer-corpus.md
index 1b135a02..cfa4b7ba 100644
--- a/docs/frictionlab/edge-loop-x2-top-face-loop-chamfer-corpus.md
+++ b/docs/frictionlab/edge-loop-x2-top-face-loop-chamfer-corpus.md
@@ -210,3 +210,7 @@ Recommended follow-up options:
## AIR-A0 evidence note
AIR-A0 classifies this corpus as evidence for a future `AirTopFaceLoopChamfer` Feature/Constructive AIR lane. The intended future lowering is `ChamferLoop` over a Class B top-face outer loop into a prismatic section transition, with BRep emission authority remaining in the prismatic route and any CIR convex-polyhedron mirror admitted separately. See `docs/air-a0-aetheris-v2-compiler-ir-constitution.md`.
+
+## AIR-X1 wrapper note
+
+AIR-X1 adds an internal `TopFaceLoopChamfer` AIR wrapper around the existing `PrismaticTopFaceLoopChamferPrototype` lane. The wrapper preserves the EDGE-LOOP-X2 Class B face-boundary-loop metadata, uniform chamfer rule, split-preserving topology summary, STEP smoke summary, and route-exclusion guarantees; it does not replace production routing or change chamfer geometry.