Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add EDGE-X10 AirChamfer STEP artifact CLI lane

Yuechen Li734a04e48d6a
diff --git a/Aetheris.CLI.Tests/CliHelpAndUsageTests.cs b/Aetheris.CLI.Tests/CliHelpAndUsageTests.cs
index 1bb8b953..c795d656 100644
--- a/Aetheris.CLI.Tests/CliHelpAndUsageTests.cs
+++ b/Aetheris.CLI.Tests/CliHelpAndUsageTests.cs
@@ -19,12 +19,13 @@ public sealed class CliHelpAndUsageTests
Assert.Equal(0, exitCode);
Assert.True(string.IsNullOrWhiteSpace(stderr.ToString()));
var text = stdout.ToString();
- Assert.Contains("Usage: aetheris <build|analyze|canon|asm>", text, StringComparison.Ordinal);
+ Assert.Contains("Usage: aetheris <build|analyze|canon|asm|experimental>", text, StringComparison.Ordinal);
Assert.Contains("Commands:", text, StringComparison.Ordinal);
Assert.Contains("build", text, StringComparison.Ordinal);
Assert.Contains("analyze", text, StringComparison.Ordinal);
Assert.Contains("canon", text, StringComparison.Ordinal);
Assert.Contains("asm", text, StringComparison.Ordinal);
+ Assert.Contains("experimental", text, StringComparison.Ordinal);
}
[Theory]
@@ -35,6 +36,8 @@ public sealed class CliHelpAndUsageTests
[InlineData("analyze")]
[InlineData("analyze", "map")]
[InlineData("analyze", "section")]
+ [InlineData("experimental")]
+ [InlineData("experimental", "airchamfer-cube")]
public void Subcommand_Help_Lists_Usage_And_Examples(params string[] prefix)
{
var stdout = new StringWriter();
diff --git a/Aetheris.CLI.Tests/ExperimentalAirChamferStepArtifactTests.cs b/Aetheris.CLI.Tests/ExperimentalAirChamferStepArtifactTests.cs
new file mode 100644
index 00000000..71f9d515
--- /dev/null
+++ b/Aetheris.CLI.Tests/ExperimentalAirChamferStepArtifactTests.cs
@@ -0,0 +1,76 @@
+using System.Text.Json;
+
+namespace Aetheris.CLI.Tests;
+
+public sealed class ExperimentalAirChamferStepArtifactTests
+{
+ [Fact]
+ public void Experimental_AirChamfer_Cube_Help_Is_Discoverable_And_Explicitly_Lab_Only()
+ {
+ var stdout = new StringWriter();
+ var stderr = new StringWriter();
+
+ var exitCode = Aetheris.CLI.CliRunner.Run(["experimental", "airchamfer-cube", "--help"], stdout, stderr);
+
+ Assert.Equal(0, exitCode);
+ Assert.True(string.IsNullOrWhiteSpace(stderr.ToString()));
+ var text = stdout.ToString();
+ Assert.Contains("Usage: aetheris experimental airchamfer-cube --out <path> [--json]", text, StringComparison.Ordinal);
+ Assert.Contains("Experimental/lab-only", text, StringComparison.Ordinal);
+ Assert.Contains("no production chamfer route replacement", text, StringComparison.OrdinalIgnoreCase);
+ Assert.Contains("no 3D Boolean", text, StringComparison.Ordinal);
+ }
+
+ [Fact]
+ public void Experimental_AirChamfer_Cube_Writes_Candidate_Step_With_Deterministic_Markers_And_Diagnostics()
+ {
+ var outputPath = Path.Combine(Path.GetTempPath(), $"edge-x10-airchamfer-cube-one-edge-{Guid.NewGuid():N}.step");
+ var stdout = new StringWriter();
+ var stderr = new StringWriter();
+
+ try
+ {
+ var exitCode = Aetheris.CLI.CliRunner.Run(["experimental", "airchamfer-cube", "--out", outputPath, "--json"], stdout, stderr);
+
+ Assert.Equal(0, exitCode);
+ Assert.True(string.IsNullOrWhiteSpace(stderr.ToString()));
+ Assert.True(File.Exists(outputPath));
+
+ var stepText = File.ReadAllText(outputPath);
+ Assert.False(string.IsNullOrWhiteSpace(stepText));
+ Assert.Contains("ISO-10303-21", stepText, StringComparison.Ordinal);
+ Assert.Contains("MANIFOLD_SOLID_BREP", stepText, StringComparison.Ordinal);
+ Assert.Contains("ADVANCED_FACE", stepText, StringComparison.Ordinal);
+ Assert.Contains("PLANE", stepText, StringComparison.Ordinal);
+ Assert.DoesNotContain("CYLINDRICAL_SURFACE", stepText, StringComparison.Ordinal);
+ Assert.DoesNotContain("BREP_WITH_VOIDS", stepText, StringComparison.Ordinal);
+
+ using var doc = JsonDocument.Parse(stdout.ToString());
+ var root = doc.RootElement;
+ Assert.True(root.GetProperty("success").GetBoolean());
+ Assert.Equal(Path.GetFullPath(outputPath), root.GetProperty("outputPath").GetString());
+ Assert.Equal("experimental-cli-airchamfer-cube", root.GetProperty("route").GetString());
+ Assert.Equal("AirChamferShadowRoute->AirChamferRealBodyPrototype", root.GetProperty("candidatePath").GetString());
+
+ var diagnostics = root.GetProperty("diagnostics").EnumerateArray().Select(x => x.GetString()).ToArray();
+ Assert.Contains("edge-x10-airchamfer-step-artifact-started", diagnostics);
+ Assert.Contains("edge-x10-cli-export-path-used", diagnostics);
+ Assert.Contains("edge-x10-air-chamfer-shadow-route-invoked", diagnostics);
+ Assert.Contains("edge-x10-candidate-body-created", diagnostics);
+ Assert.Contains("edge-x10-step-artifact-written", diagnostics);
+ Assert.Contains("edge-x10-step-smoke-succeeded", diagnostics);
+ Assert.Contains("edge-x10-legacy-authority-preserved", diagnostics);
+ Assert.Contains("edge-x10-no-production-route-replacement", diagnostics);
+ Assert.Contains("edge-x10-no-3d-boolean-used", diagnostics);
+ Assert.Contains("edge-v3-no-production-route-replacement", diagnostics);
+ Assert.Contains("edge-v3-no-3d-boolean-used", diagnostics);
+ }
+ finally
+ {
+ if (File.Exists(outputPath))
+ {
+ File.Delete(outputPath);
+ }
+ }
+ }
+}
diff --git a/Aetheris.CLI/Aetheris.CLI.csproj b/Aetheris.CLI/Aetheris.CLI.csproj
index a4df84b8..12a2c7c9 100644
--- a/Aetheris.CLI/Aetheris.CLI.csproj
+++ b/Aetheris.CLI/Aetheris.CLI.csproj
@@ -10,5 +10,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.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.cs
index 9b4b818e..c3790dbb 100644
--- a/Aetheris.CLI/CliRunner.cs
+++ b/Aetheris.CLI/CliRunner.cs
@@ -2,6 +2,7 @@ using System.Text.Json;
using System.Text.Json.Serialization;
using Aetheris.Kernel.Firmament;
using Aetheris.Kernel.Firmament.Assembly;
+using Aetheris.Firmament.FrictionLab.CIRLab;
namespace Aetheris.CLI;
@@ -16,7 +17,7 @@ public static class CliRunner
string? Error,
string? Classification = null,
int? RigidRootCount = null);
- private const string TopLevelUsage = "Usage: aetheris <build|analyze|canon|asm> <path> [options]";
+ private const string TopLevelUsage = "Usage: aetheris <build|analyze|canon|asm|experimental> <path> [options]";
private const string BuildUsage = "Usage: aetheris build <file.firmament> [--out <path>] [--json]";
private const string AnalyzeUsage = "Usage: aetheris analyze <file.step> [--face <id>] [--edge <id>] [--vertex <id>] [--json]";
private const string AnalyzeMapUsage = "Usage: aetheris analyze map <file.step> (--top|--bottom|--front|--back|--left|--right) --rows <N> --cols <N> --json";
@@ -26,6 +27,7 @@ public static class CliRunner
private const string CanonUsage = "Usage: aetheris canon <file.step> --out <canonical.step> [--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 ExperimentalUsage = "Usage: aetheris experimental airchamfer-cube --out <path> [--json]";
private static readonly JsonSerializerOptions JsonOptions = new()
{
@@ -67,6 +69,7 @@ public static class CliRunner
"analyze" => RunAnalyze(args.Skip(1).ToArray(), stdout, stderr),
"canon" => RunCanon(args.Skip(1).ToArray(), stdout, stderr),
"asm" => RunAsm(args.Skip(1).ToArray(), stdout, stderr),
+ "experimental" => RunExperimental(args.Skip(1).ToArray(), stdout, stderr),
_ => UnknownCommand(args[0], stderr)
};
}
@@ -837,6 +840,97 @@ public static class CliRunner
};
}
+
+ private static int RunExperimental(string[] args, TextWriter stdout, TextWriter stderr)
+ {
+ if (args.Length == 0 || IsHelpFlag(args[0]))
+ {
+ WriteExperimentalHelp(stdout);
+ return args.Length == 0 ? 1 : 0;
+ }
+
+ if (string.Equals(args[0], "airchamfer-cube", StringComparison.Ordinal))
+ {
+ return RunExperimentalAirChamferCube(args.Skip(1).ToArray(), stdout, stderr);
+ }
+
+ stderr.WriteLine($"Unknown experimental subcommand '{args[0]}'.");
+ stderr.WriteLine(ExperimentalUsage);
+ return 1;
+ }
+
+ private static int RunExperimentalAirChamferCube(string[] args, TextWriter stdout, TextWriter stderr)
+ {
+ string? outPath = null;
+ var json = false;
+
+ for (var i = 0; i < args.Length; i++)
+ {
+ switch (args[i])
+ {
+ case "--out" when i + 1 < args.Length:
+ outPath = args[++i];
+ break;
+ case "--out":
+ stderr.WriteLine("Experimental airchamfer-cube option --out requires a path value.");
+ stderr.WriteLine(ExperimentalUsage);
+ return 1;
+ case "--json":
+ json = true;
+ break;
+ case "-h":
+ case "--help":
+ WriteExperimentalAirChamferCubeHelp(stdout);
+ return 0;
+ default:
+ stderr.WriteLine($"Unknown experimental airchamfer-cube option '{args[i]}'.");
+ stderr.WriteLine(ExperimentalUsage);
+ return 1;
+ }
+ }
+
+ if (string.IsNullOrWhiteSpace(outPath))
+ {
+ stderr.WriteLine("Experimental airchamfer-cube requires --out <path>.");
+ stderr.WriteLine(ExperimentalUsage);
+ return 1;
+ }
+
+ var artifact = AirChamferStepArtifactLab.WriteControlledCubeOneEdgeStep(outPath);
+ if (json)
+ {
+ stdout.WriteLine(JsonSerializer.Serialize(new
+ {
+ success = artifact.Succeeded,
+ outputPath = artifact.OutputPath,
+ artifactFileName = artifact.ArtifactFileName,
+ route = artifact.Route,
+ candidatePath = artifact.CandidatePath,
+ shadowCandidateStatus = artifact.ShadowCandidateStatus.ToString(),
+ markers = artifact.MarkerSummary,
+ topologySummary = artifact.TopologySummary,
+ diagnostics = artifact.Diagnostics,
+ error = artifact.Error
+ }, JsonOptions));
+ return artifact.Succeeded ? 0 : 1;
+ }
+
+ foreach (var diagnostic in artifact.Diagnostics)
+ {
+ stdout.WriteLine(diagnostic);
+ }
+
+ if (!artifact.Succeeded)
+ {
+ stderr.WriteLine(artifact.Error ?? "Experimental AirChamfer STEP artifact export failed.");
+ return 1;
+ }
+
+ stdout.WriteLine($"Experimental AirChamfer cube STEP artifact written: {artifact.OutputPath}");
+ stdout.WriteLine("Route: experimental/lab AirChamfer shadow candidate export; production chamfer remains legacy-authoritative.");
+ return 0;
+ }
+
private static int RunAsm(string[] args, TextWriter stdout, TextWriter stderr)
{
if (args.Length == 0 || IsHelpFlag(args[0]))
@@ -1372,7 +1466,7 @@ public static class CliRunner
private static int UnknownCommand(string command, TextWriter stderr)
{
- stderr.WriteLine($"Unknown command '{command}'. Expected one of: build, analyze, canon, asm.");
+ stderr.WriteLine($"Unknown command '{command}'. Expected one of: build, analyze, canon, asm, experimental.");
stderr.WriteLine("Run 'aetheris --help' for usage and examples.");
return 1;
}
@@ -1402,6 +1496,7 @@ public static class CliRunner
stdout.WriteLine(" analyze Analyze STEP topology, geometry, map, and sections.");
stdout.WriteLine(" canon Import and re-export STEP/AP242 as canonical STEP.");
stdout.WriteLine(" asm Execute/export .firmasm assembly IR using rigid world-space composition.");
+ stdout.WriteLine(" experimental Experimental/lab-only artifact export commands.");
stdout.WriteLine();
stdout.WriteLine("Global options:");
stdout.WriteLine(" -h, --help Show help.");
@@ -1414,6 +1509,7 @@ public static class CliRunner
stdout.WriteLine(" aetheris canon input.step --out canonical.step --json");
stdout.WriteLine(" aetheris asm exec assembly.firmasm --json");
stdout.WriteLine(" aetheris asm export assembly.firmasm --out out/assembly-roundtrip --json");
+ stdout.WriteLine(" aetheris experimental airchamfer-cube --out edge-x10-airchamfer-cube-one-edge.step --json");
stdout.WriteLine(" aetheris analyze map model.step --top --rows 40 --cols 60 --json");
stdout.WriteLine(" aetheris analyze section model.step --xy --offset 2.5 --json");
stdout.WriteLine(" aetheris analyze volume model.step --json");
@@ -1536,6 +1632,46 @@ public static class CliRunner
stdout.WriteLine(" aetheris canon input.step --out canonical.step --json");
}
+
+ private static void WriteExperimentalHelp(TextWriter stdout)
+ {
+ stdout.WriteLine("Experimental/lab-only artifact export commands.");
+ stdout.WriteLine();
+ stdout.WriteLine(ExperimentalUsage);
+ stdout.WriteLine();
+ stdout.WriteLine("Subcommands:");
+ stdout.WriteLine(" airchamfer-cube Export a controlled one-edge AirChamfer candidate cube/box STEP artifact.");
+ stdout.WriteLine();
+ stdout.WriteLine("Notes:");
+ stdout.WriteLine(" - Experimental only; does not route production Firmament chamfer operations through AirChamfer.");
+ stdout.WriteLine(" - Legacy BrepBoundedChamfer remains production-authoritative.");
+ stdout.WriteLine(" - The candidate path uses no 3D Boolean fallback.");
+ stdout.WriteLine();
+ stdout.WriteLine("Example:");
+ stdout.WriteLine(" aetheris experimental airchamfer-cube --out edge-x10-airchamfer-cube-one-edge.step --json");
+ }
+
+ private static void WriteExperimentalAirChamferCubeHelp(TextWriter stdout)
+ {
+ stdout.WriteLine("Export a controlled one-edge AirChamfer candidate cube/box STEP artifact.");
+ stdout.WriteLine();
+ stdout.WriteLine(ExperimentalUsage);
+ stdout.WriteLine();
+ stdout.WriteLine("Options:");
+ stdout.WriteLine(" --out <path> Required deterministic STEP output path.");
+ stdout.WriteLine(" --json Emit machine-readable success/failure JSON.");
+ stdout.WriteLine(" -h, --help Show this help.");
+ stdout.WriteLine();
+ stdout.WriteLine("Expected artifact name:");
+ stdout.WriteLine($" {AirChamferStepArtifactLab.DefaultArtifactFileName}");
+ stdout.WriteLine();
+ stdout.WriteLine("Production safety:");
+ stdout.WriteLine(" Experimental/lab-only route; no production chamfer route replacement and no 3D Boolean.");
+ stdout.WriteLine();
+ stdout.WriteLine("Example:");
+ stdout.WriteLine(" aetheris experimental airchamfer-cube --out edge-x10-airchamfer-cube-one-edge.step --json");
+ }
+
private static void WriteAsmHelp(TextWriter stdout)
{
stdout.WriteLine("Execute flattened .firmasm assemblies as rigidly placed body instances, or export STEP interop packages.");
diff --git a/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferStepArtifactLab.cs b/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferStepArtifactLab.cs
new file mode 100644
index 00000000..f7c5417e
--- /dev/null
+++ b/Aetheris.Firmament.FrictionLab/CIRLab/AirChamferStepArtifactLab.cs
@@ -0,0 +1,150 @@
+using System.Numerics;
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Step242;
+
+namespace Aetheris.Firmament.FrictionLab.CIRLab;
+
+public sealed record AirChamferStepArtifactMarkerSummary(
+ bool HasIso,
+ bool HasManifoldSolidBrep,
+ bool HasAdvancedFace,
+ bool HasPlane,
+ bool HasCylindricalSurface,
+ bool HasBrepWithVoids);
+
+public sealed record AirChamferStepArtifactResult(
+ bool Succeeded,
+ string OutputPath,
+ string ArtifactFileName,
+ string Route,
+ string CandidatePath,
+ AirChamferShadowCandidateStatus ShadowCandidateStatus,
+ AirChamferStepArtifactMarkerSummary MarkerSummary,
+ AirChamferRealBodyTopologySummary? TopologySummary,
+ IReadOnlyList<string> Diagnostics,
+ string? Error);
+
+public static class AirChamferStepArtifactLab
+{
+ public const string DefaultArtifactFileName = "edge-x10-airchamfer-cube-one-edge.step";
+ public const string ExperimentalRoute = "experimental-cli-airchamfer-cube";
+ public const string CandidatePath = "AirChamferShadowRoute->AirChamferRealBodyPrototype";
+
+ public static AirChamferStepArtifactResult WriteControlledCubeOneEdgeStep(string outputPath)
+ {
+ if (string.IsNullOrWhiteSpace(outputPath))
+ {
+ throw new ArgumentException("Output path is required.", nameof(outputPath));
+ }
+
+ var fullPath = Path.GetFullPath(outputPath);
+ var diagnostics = new List<string>
+ {
+ "edge-x10-airchamfer-step-artifact-started",
+ "edge-x10-cli-export-path-used",
+ "edge-x10-air-chamfer-shadow-route-invoked",
+ "edge-x10-legacy-authority-preserved",
+ "edge-x10-no-production-route-replacement",
+ "edge-x10-no-3d-boolean-used"
+ };
+
+ var sourceBody = BrepPrimitives.CreateBox(10d, 8d, 6d).Value;
+ var report = AirChamferShadowRoute.Evaluate(new AirChamferShadowRouteRequest(
+ "edge-x10-controlled-cube-one-edge-step-artifact",
+ sourceBody,
+ new Vector3(5f, 4f, -3f),
+ new Vector3(5f, 4f, 3f),
+ new Vector3(1f, 0f, 0f),
+ new Vector3(0f, 1f, 0f),
+ 1d,
+ AirChamferFaceFamily.Planar,
+ IsEdgeChain: false,
+ IsCornerChain: false,
+ LegacyDependency: false,
+ AirChamferClassificationExpectation.Convex,
+ IsOrthogonalFacePair: true,
+ ReferenceEnvelope: 10d,
+ IncludeStepSmoke: true));
+
+ diagnostics.AddRange(report.Diagnostics);
+
+ if (!report.ShadowCandidateProduced || report.ShadowCandidateBody is null)
+ {
+ diagnostics.Add($"edge-x10-candidate-body-not-created:{report.ShadowCandidateStatus}");
+ return CreateFailure(fullPath, report.ShadowCandidateStatus, report.TopologySummary, diagnostics, "AirChamfer shadow route did not produce a candidate body.");
+ }
+
+ diagnostics.Add("edge-x10-candidate-body-created");
+ var export = Step242Exporter.ExportBody(report.ShadowCandidateBody);
+ if (!export.IsSuccess)
+ {
+ diagnostics.Add("edge-x10-step-artifact-write-failed:step-export");
+ return CreateFailure(fullPath, report.ShadowCandidateStatus, report.TopologySummary, diagnostics, "STEP export failed for the AirChamfer candidate body.");
+ }
+
+ var directory = Path.GetDirectoryName(fullPath);
+ if (!string.IsNullOrWhiteSpace(directory))
+ {
+ Directory.CreateDirectory(directory);
+ }
+
+ File.WriteAllText(fullPath, export.Value);
+ diagnostics.Add("edge-x10-step-artifact-written");
+
+ var markers = SummarizeMarkers(export.Value);
+ var smokeSucceeded = markers.HasIso
+ && markers.HasManifoldSolidBrep
+ && markers.HasAdvancedFace
+ && markers.HasPlane
+ && !markers.HasCylindricalSurface
+ && !markers.HasBrepWithVoids;
+
+ if (smokeSucceeded)
+ {
+ diagnostics.Add("edge-x10-step-smoke-succeeded");
+ }
+ else
+ {
+ diagnostics.Add("edge-x10-step-smoke-failed:marker-validation");
+ }
+
+ return new AirChamferStepArtifactResult(
+ smokeSucceeded,
+ fullPath,
+ Path.GetFileName(fullPath),
+ ExperimentalRoute,
+ CandidatePath,
+ report.ShadowCandidateStatus,
+ markers,
+ report.TopologySummary,
+ diagnostics.Distinct().OrderBy(x => x, StringComparer.Ordinal).ToArray(),
+ smokeSucceeded ? null : "STEP marker validation failed for the AirChamfer candidate artifact.");
+ }
+
+ private static AirChamferStepArtifactResult CreateFailure(
+ string fullPath,
+ AirChamferShadowCandidateStatus status,
+ AirChamferRealBodyTopologySummary? topology,
+ List<string> diagnostics,
+ string error)
+ => new(
+ false,
+ fullPath,
+ Path.GetFileName(fullPath),
+ ExperimentalRoute,
+ CandidatePath,
+ status,
+ new AirChamferStepArtifactMarkerSummary(false, false, false, false, false, false),
+ topology,
+ diagnostics.Distinct().OrderBy(x => x, StringComparer.Ordinal).ToArray(),
+ error);
+
+ private static AirChamferStepArtifactMarkerSummary SummarizeMarkers(string stepText)
+ => new(
+ stepText.Contains("ISO-10303-21", StringComparison.Ordinal),
+ stepText.Contains("MANIFOLD_SOLID_BREP", StringComparison.Ordinal),
+ stepText.Contains("ADVANCED_FACE", StringComparison.Ordinal),
+ stepText.Contains("PLANE", StringComparison.Ordinal),
+ stepText.Contains("CYLINDRICAL_SURFACE", StringComparison.Ordinal),
+ stepText.Contains("BREP_WITH_VOIDS", StringComparison.Ordinal));
+}
diff --git a/docs/edge-v2-real-body-air-chamfer-prototype.md b/docs/edge-v2-real-body-air-chamfer-prototype.md
index b6b88b52..fe3c4f21 100644
--- a/docs/edge-v2-real-body-air-chamfer-prototype.md
+++ b/docs/edge-v2-real-body-air-chamfer-prototype.md
@@ -71,3 +71,6 @@ EDGE-X9 adds a lab-only feature-recognition parity probe (`AirChamferFeatureReco
## EDGE-V3 shadow-route wrapper note
EDGE-V3 wraps `AirChamferRealBodyPrototype` in `AirChamferShadowRoute`, a non-authoritative internal/test-only seam that invokes the EDGE-V2 candidate body path, captures topology/STEP/recognition evidence, and reports readiness while keeping legacy `BrepBoundedChamfer` authoritative and production output unchanged.
+
+## EDGE-X10 export-artifact follow-on note
+EDGE-X10 consumes the EDGE-V2 candidate body through the EDGE-V3 shadow route and writes the first deterministic AirChamfer candidate STEP artifact via `aetheris experimental airchamfer-cube --out <path> [--json]`. This does not promote EDGE-V2 to production chamfer authority; it only exposes the controlled one-edge candidate body through experimental export plumbing, with no production route replacement and no 3D Boolean fallback.
diff --git a/docs/edge-v3-air-chamfer-shadow-route.md b/docs/edge-v3-air-chamfer-shadow-route.md
index 025e1c70..ed9a9e9a 100644
--- a/docs/edge-v3-air-chamfer-shadow-route.md
+++ b/docs/edge-v3-air-chamfer-shadow-route.md
@@ -152,3 +152,6 @@ No public API, STEP exporter/importer, Boolean core, production chamfer/fillet b
## Next recommended milestone
Because the canonical and safe non-orthogonal shadow route fixtures are expected to stay green, the next recommended milestone is EDGE-X10 controlled opt-in route fixture. If future shadow parity issues appear, run EDGE-X9.1 recognition/body hardening instead, scoped by the first-divergence payload.
+
+## EDGE-X10 export-artifact note
+EDGE-X10 adds the first CLI-visible AirChamfer candidate STEP artifact route: `aetheris experimental airchamfer-cube --out <path> [--json]`. The route uses `AirChamferShadowRoute` to invoke the EDGE-V2 real-body prototype and exports the resulting controlled one-edge candidate body to `edge-x10-airchamfer-cube-one-edge.step` by convention. The route remains experimental/lab-only; legacy `BrepBoundedChamfer` stays production-authoritative, normal Firmament chamfer routing is not replaced, and the AirChamfer candidate path still uses no 3D Boolean.
diff --git a/docs/frictionlab/edge-x10-airchamfer-cube-step-artifact.md b/docs/frictionlab/edge-x10-airchamfer-cube-step-artifact.md
new file mode 100644
index 00000000..cdb0cdb3
--- /dev/null
+++ b/docs/frictionlab/edge-x10-airchamfer-cube-step-artifact.md
@@ -0,0 +1,106 @@
+# EDGE-X10 AirChamfer cube STEP artifact
+
+## Purpose and scope
+EDGE-X10 answers whether existing Aetheris CLI/export infrastructure can produce an explicit experimental AirChamfer candidate STEP file. The supported artifact is intentionally narrow: a controlled cube/box-like body, one explicit convex planar edge, the existing EDGE-V3/EDGE-V2 AirChamfer candidate path, and a deterministic STEP file written through a lab/experimental CLI lane.
+
+This is the first AirChamfer candidate STEP artifact exposed through CLI/export plumbing. It is not a production AirChamfer feature.
+
+## References
+- EDGE-V2: `docs/edge-v2-real-body-air-chamfer-prototype.md`
+- EDGE-X9: `docs/frictionlab/edge-x9-air-chamfer-feature-recognition-parity-lab.md`
+- EDGE-V3: `docs/edge-v3-air-chamfer-shadow-route.md`
+- V2 sweep-first architecture: `docs/aetheris-v2-sweep-first-architecture.md`
+- Legacy topology / parallel emitter lanes: `docs/v2-a3-legacy-topology-contracts-and-parallel-emitter-lanes.md`
+- AirEdgeSweep audit: `docs/edge-a0-air-edge-sweep-fillet-chamfer-audit.md`
+
+## Artifact route and exact path convention
+CLI integration is implemented as an explicitly experimental command:
+
+```bash
+dotnet run --project Aetheris.CLI --framework net10.0 -- experimental airchamfer-cube --out <path> --json
+```
+
+Recommended deterministic filename:
+
+```text
+edge-x10-airchamfer-cube-one-edge.step
+```
+
+The route identifier emitted by the command is:
+
+```text
+experimental-cli-airchamfer-cube
+```
+
+The candidate path identifier emitted by the command is:
+
+```text
+AirChamferShadowRoute->AirChamferRealBodyPrototype
+```
+
+## How to generate manually
+From the repository root:
+
+```bash
+mkdir -p artifacts/edge-x10
+dotnet run --project Aetheris.CLI --framework net10.0 -- experimental airchamfer-cube --out artifacts/edge-x10/edge-x10-airchamfer-cube-one-edge.step --json
+```
+
+The command writes the requested STEP path and emits JSON diagnostics. The CLI command is lab/experimental-only and does not imply normal Firmament chamfer support through AirChamfer.
+
+## STEP marker result
+EDGE-X10 validates the written candidate STEP with deterministic marker checks.
+
+Required present:
+- `ISO-10303-21`
+- `MANIFOLD_SOLID_BREP`
+- `ADVANCED_FACE`
+- `PLANE`
+
+Required absent:
+- `CYLINDRICAL_SURFACE`
+- `BREP_WITH_VOIDS`
+
+The successful diagnostic is:
+
+```text
+edge-x10-step-smoke-succeeded
+```
+
+## AirChamfer candidate path used
+The artifact writer invokes the non-authoritative EDGE-V3 shadow route, which invokes the EDGE-V2 real-body prototype. The controlled fixture uses a 10 x 8 x 6 box-like source body and a single explicit convex planar edge from `(5, 4, -3)` to `(5, 4, 3)` with adjacent planar normals `(1, 0, 0)` and `(0, 1, 0)`. The chamfer distance is fixed at `1`.
+
+Key diagnostics include:
+- `edge-x10-airchamfer-step-artifact-started`
+- `edge-x10-cli-export-path-used`
+- `edge-x10-air-chamfer-shadow-route-invoked`
+- `edge-x10-candidate-body-created`
+- `edge-x10-step-artifact-written`
+- `edge-x10-step-smoke-succeeded`
+- `edge-x10-legacy-authority-preserved`
+- `edge-x10-no-production-route-replacement`
+- `edge-x10-no-3d-boolean-used`
+
+EDGE-V3 diagnostics remain present as additional evidence, including `edge-v3-no-production-route-replacement` and `edge-v3-no-3d-boolean-used`.
+
+## Explicit production-safety statement
+EDGE-X10 does not route normal Firmament chamfer operations through AirChamfer. Legacy `BrepBoundedChamfer` remains production-authoritative. EDGE-X10 does not replace production chamfer behavior, does not change production chamfer/fillet behavior, does not change STEP exporter/importer behavior, does not change Boolean core behavior, does not introduce fillet geometry, does not add arbitrary edge selection, and does not add edge-chain/corner-chain support.
+
+No 3D Boolean is used in the AirChamfer candidate path.
+
+## CLI integration status
+Implemented: `aetheris experimental airchamfer-cube --out <path> [--json]`.
+
+The command is deliberately under `experimental` and is documented as lab-only. It exports exactly the controlled one-edge AirChamfer candidate body and preserves the existing production route boundary.
+
+## Tests run
+Intended EDGE-X10 gates:
+- `dotnet run --project Aetheris.CLI --framework net10.0 -- --help`
+- `dotnet test Aetheris.CLI.Tests/Aetheris.CLI.Tests.csproj --filter "AirChamfer|Experimental|Lab|Step|CliBaseline|Export"`
+- `dotnet test Aetheris.FrictionLab.Tests/Aetheris.FrictionLab.Tests.csproj -c Release -f net10.0 --filter "AirChamferShadow|AirChamferFeatureRecognition|AirChamferControlledBody|AirChamferTopologyGraft|AirChamferClosedWitness|AirChamferGeometryArtifact|AirChamferTopologyPlan|AirChamferJudgment|AirChamferPolicy|AirChamferPatch|EdgeSweep|Chamfer|Fillet|EdgeFinish|CIRLab"`
+- `dotnet test Aetheris.Kernel.Firmament.Tests/Aetheris.Kernel.Firmament.Tests.csproj --filter "Chamfer|Fillet|Corner|TriangularPrism|FirmamentPrimitive|FirmamentStepExporter|LineArcProfileExtrude|SemanticRecovery|FrepMaterializer|Rematerialize"`
+- `dotnet test Aetheris.Kernel.Core.Tests/Aetheris.Kernel.Core.Tests.csproj --filter "Judgment|Chamfer|Fillet|Corner|TriangularPrism|BrepPrimitives|Step242|Primitive|Extrude|Boolean|SafeComposition"`
+- `./scripts/test-all.sh` after focused CLI/shared gates pass.
+
+## Next recommended milestone
+Recommended next milestone: EDGE-X11 should compare the exported AirChamfer candidate artifact against legacy chamfer output through analyzer-only evidence, while preserving legacy authority and avoiding production route replacement. If candidate recognition diverges first, run a narrow EDGE-X9.1 recognition hardening milestone before broader export comparisons.