Skip to content

Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel

Add virtual sculpture CLI and documentation

Yuechen Lid7b1482f5dcd
diff --git a/Aetheris.CLI.Tests/Sol1CliTests.cs b/Aetheris.CLI.Tests/Sol1CliTests.cs
new file mode 100644
index 00000000..c4eeaca8
--- /dev/null
+++ b/Aetheris.CLI.Tests/Sol1CliTests.cs
@@ -0,0 +1,45 @@
+using System.Text.Json;
+
+namespace Aetheris.CLI.Tests;
+
+public sealed class Sol1CliTests
+{
+ [Fact]
+ public void SculptureBuild_WritesStepEvidenceAndPreviewThroughDedicatedLane()
+ {
+ var root = RepositoryRoot();
+ var source = Path.Combine(root, "fixtures", "Canonical", "VirtualSculpture", "sol-1.sculpture.json");
+ var outputDirectory = Path.Combine(Path.GetTempPath(), "aetheris-sol-1-cli-" + Guid.NewGuid().ToString("N"));
+ Directory.CreateDirectory(outputDirectory);
+ try
+ {
+ var step = Path.Combine(outputDirectory, "sol-1.step");
+ var evidence = Path.Combine(outputDirectory, "sol-1.evidence.json");
+ var preview = Path.Combine(outputDirectory, "sol-1.preview.svg");
+ var stdout = new StringWriter(); var stderr = new StringWriter();
+ var exit = CliRunner.Run(["sculpture", "build", source, "--out", step, "--evidence", evidence, "--preview", preview, "--json"], stdout, stderr);
+ Assert.Equal(0, exit);
+ Assert.Equal(string.Empty, stderr.ToString());
+ Assert.True(File.Exists(step)); Assert.True(File.Exists(evidence)); Assert.True(File.Exists(preview));
+ Assert.StartsWith("ISO-10303-21;", File.ReadAllText(step), StringComparison.Ordinal);
+ Assert.Contains("<svg", File.ReadAllText(preview), StringComparison.Ordinal);
+ using var command = JsonDocument.Parse(stdout.ToString());
+ Assert.Equal("VirtualSculpture", command.RootElement.GetProperty("domain").GetString());
+ Assert.Equal("Virtual", command.RootElement.GetProperty("mode").GetString());
+ using var report = JsonDocument.Parse(File.ReadAllText(evidence));
+ Assert.False(report.RootElement.GetProperty("isManufacturingGeometry").GetBoolean());
+ Assert.Equal(0, report.RootElement.GetProperty("surfaceInventory").GetProperty("rationalProductSurfaces").GetInt32());
+ }
+ finally
+ {
+ Directory.Delete(outputDirectory, recursive: true);
+ }
+ }
+
+ private static string RepositoryRoot()
+ {
+ var current = new DirectoryInfo(AppContext.BaseDirectory);
+ while (current is not null && !File.Exists(Path.Combine(current.FullName, "Aetheris.slnx"))) current = current.Parent;
+ return current?.FullName ?? throw new DirectoryNotFoundException();
+ }
+}
diff --git a/Aetheris.CLI/Aetheris.CLI.csproj b/Aetheris.CLI/Aetheris.CLI.csproj
index a5d18f3c..59b19866 100644
--- a/Aetheris.CLI/Aetheris.CLI.csproj
+++ b/Aetheris.CLI/Aetheris.CLI.csproj
@@ -29,6 +29,7 @@
<ProjectReference Include="..\Aetheris.Reconstruction\Aetheris.Reconstruction.csproj" />
<ProjectReference Include="..\Aetheris.SheetMetal\Aetheris.SheetMetal.csproj" />
<ProjectReference Include="..\Aetheris.PlasticShell\Aetheris.PlasticShell.csproj" />
+ <ProjectReference Include="..\Aetheris.Sculpture\Aetheris.Sculpture.csproj" />
</ItemGroup>
<ItemGroup>
diff --git a/Aetheris.CLI/CliRunner.cs b/Aetheris.CLI/CliRunner.cs
index 54509755..4fcb4cfc 100644
--- a/Aetheris.CLI/CliRunner.cs
+++ b/Aetheris.CLI/CliRunner.cs
@@ -25,6 +25,7 @@ using Aetheris.PlasticShell;
using Aetheris.Surfacing;
using Aetheris.Geometry;
using Aetheris.SheetMetal;
+using Aetheris.Sculpture;
using Aetheris.Kernel.Firmament.Structural;
using Aetheris.Kernel.Firmament.Piping;
@@ -164,6 +165,7 @@ public static class CliRunner
private const string DrawingUsage = "Usage: aetheris drawing compile <drawing.firmament> --out-dir <directory> [--json]";
private const string SheetMetalUsage = "Usage: aetheris sheetmetal recognize <part.step> [--plan <recognition.json>] [--json] | aetheris sheetmetal recover-flat <part.step> --out-dir <directory> [--recognition-plan <recognition.json>] [--json] | aetheris sheetmetal compare-flat <recovered-flat.json> <native.firmament> [--semantic] [--json] | aetheris sheetmetal inspect <part.step|part.firmament> [--k-factor <0..1>] [--json] | aetheris sheetmetal paths <part.firmament> [--json] | aetheris sheetmetal recover <part.step> --out-dir <directory> [--json] | aetheris sheetmetal compare <part.step|part.firmament> <intent.firmament> [--semantic] [--json] | aetheris sheetmetal flatten <part.step|part.firmament> [--step <flat.step>] [--firmament <recovered.firmament>] [--svg <flat.svg>] [--k-factor <0..1>] [--json]";
private const string ExperimentalLoopChamferCorpusUsage = "Usage: aetheris experimental loop-chamfer-corpus --out-dir <dir> [--json]";
+ private const string SculptureUsage = "Usage: aetheris sculpture build <sol-1.sculpture.json> [--out <sol-1.step>] [--evidence <sol-1.evidence.json>] [--preview <sol-1.preview.svg>] [--json]";
internal static readonly JsonSerializerOptions JsonOptions = new()
{
@@ -226,6 +228,7 @@ public static class CliRunner
"experimental" => RunExperimental(args.Skip(1).ToArray(), stdout, stderr),
"modules" => RunModules(args.Skip(1).ToArray(), stdout, stderr),
"sheetmetal" => RunSheetMetal(args.Skip(1).ToArray(), stdout, stderr),
+ "sculpture" => RunSculpture(args.Skip(1).ToArray(), stdout, stderr),
"reconstruct" => ReconstructionCli.Run(args.Skip(1).ToArray(), stdout, stderr, JsonOptions),
_ => UnknownCommand(args[0], stderr)
};
@@ -3205,6 +3208,86 @@ Model CanonicalPanel {
return 1;
}
+ private static int RunSculpture(string[] args, TextWriter stdout, TextWriter stderr)
+ {
+ if (args.Length == 0 || IsHelpFlag(args[0]))
+ {
+ WriteSculptureHelp(stdout);
+ return args.Length == 0 ? 1 : 0;
+ }
+ if (!string.Equals(args[0], "build", StringComparison.Ordinal) || args.Length < 2 || args[1].StartsWith("-", StringComparison.Ordinal))
+ {
+ stderr.WriteLine(SculptureUsage);
+ return 1;
+ }
+
+ var sourcePath = Path.GetFullPath(args[1]);
+ string? output = null, evidencePath = null, previewPath = null;
+ var json = false;
+ for (var i = 2; i < args.Length; i++)
+ {
+ switch (args[i])
+ {
+ case "--out" when i + 1 < args.Length: output = Path.GetFullPath(args[++i]); break;
+ case "--evidence" when i + 1 < args.Length: evidencePath = Path.GetFullPath(args[++i]); break;
+ case "--preview" when i + 1 < args.Length: previewPath = Path.GetFullPath(args[++i]); break;
+ case "--json": json = true; break;
+ case "-h":
+ case "--help": WriteSculptureHelp(stdout); return 0;
+ default: stderr.WriteLine($"Unknown sculpture option '{args[i]}'."); stderr.WriteLine(SculptureUsage); return 1;
+ }
+ }
+ if (!File.Exists(sourcePath)) { stderr.WriteLine($"Sol 1 source was not found: {sourcePath}"); return 1; }
+
+ output ??= Path.GetFullPath(Path.Combine("artifacts", "local", "virtual-sculpture", "sol-1.step"));
+ evidencePath ??= Path.ChangeExtension(output, ".evidence.json");
+ previewPath ??= Path.ChangeExtension(output, ".preview.svg");
+ var loaded = Sol1Source.Load(sourcePath);
+ if (!loaded.IsSuccess)
+ {
+ foreach (var diagnostic in loaded.Diagnostics) stderr.WriteLine($"- [Error] {diagnostic.Source}: {diagnostic.Message}");
+ return 1;
+ }
+ var built = Sol1Materializer.Build(loaded.Value);
+ if (!built.IsSuccess)
+ {
+ foreach (var diagnostic in built.Diagnostics) stderr.WriteLine($"- [Error] {diagnostic.Source}: {diagnostic.Message}");
+ return 1;
+ }
+
+ Directory.CreateDirectory(Path.GetDirectoryName(output)!);
+ Directory.CreateDirectory(Path.GetDirectoryName(evidencePath)!);
+ Directory.CreateDirectory(Path.GetDirectoryName(previewPath)!);
+ File.WriteAllText(output, built.Value.Step);
+ File.WriteAllText(evidencePath, JsonSerializer.Serialize(built.Value.Evidence, JsonOptions));
+ File.WriteAllText(previewPath, built.Value.PreviewSvg);
+ if (json)
+ {
+ stdout.WriteLine(JsonSerializer.Serialize(new
+ {
+ command = "sculpture build",
+ success = true,
+ domain = "VirtualSculpture",
+ mode = "Virtual",
+ source = sourcePath,
+ step = output,
+ evidencePath,
+ preview = previewPath,
+ report = built.Value.Evidence
+ }, JsonOptions));
+ }
+ else
+ {
+ stdout.WriteLine("Built Sol 1 — ART-X0 virtual mathematical sculpture");
+ stdout.WriteLine($"STEP: {output}");
+ stdout.WriteLine($"Evidence: {evidencePath}");
+ stdout.WriteLine($"Preview: {previewPath}");
+ stdout.WriteLine($"SHA-256: {built.Value.Evidence.StepSha256}");
+ stdout.WriteLine($"Geometry: {built.Value.Evidence.PhyllotaxisNodes} phyllotaxis nodes, {built.Value.Evidence.LatticeConnections} Fibonacci connections, {built.Value.Evidence.ExactClosedBodyOccurrences} exact closed-body occurrences");
+ }
+ return 0;
+ }
+
private static int RunExperimentalHeightFieldArt(string[] args, TextWriter stdout, TextWriter stderr)
{
if (args.Length == 0 || IsHelpFlag(args[0]))
@@ -4110,6 +4193,7 @@ Model CanonicalPanel {
stdout.WriteLine(" asm Inspect, execute, import, and export Firmament V2 assemblies.");
stdout.WriteLine(" modules Inspect built-in engineering Modules and capabilities.");
stdout.WriteLine(" sheetmetal Inspect/recover sheet semantics and generate manufacturing flat-pattern SVG.");
+ stdout.WriteLine(" sculpture Build bounded non-manufacturing virtual sculpture artifacts.");
stdout.WriteLine(" verify Build/reimport and verify a model.");
stdout.WriteLine(" reconstruct Experimentally reconstruct a structured mesh from triangle PLY input.");
stdout.WriteLine();
@@ -4126,11 +4210,24 @@ Model CanonicalPanel {
stdout.WriteLine(" aetheris drawing compile bearing-block-drawing.firmament --out-dir artifacts/drawing --json");
stdout.WriteLine(" aetheris asm inspect bearing-module.firmament --json");
stdout.WriteLine(" aetheris sheetmetal flatten bracket.firmament --step bracket-flat.step --svg bracket-flat.svg --json");
+ stdout.WriteLine(" aetheris sculpture build fixtures/Canonical/VirtualSculpture/sol-1.sculpture.json");
stdout.WriteLine(" aetheris reconstruct mesh scan.ply --mode fast --out scan-remesh.obj --report scan-report.json");
stdout.WriteLine();
stdout.WriteLine("Run 'aetheris <command> --help' for command-specific usage.");
}
+ private static void WriteSculptureHelp(TextWriter stdout)
+ {
+ stdout.WriteLine("Build the bounded ART-X0 flagship virtual sculpture, Sol 1.");
+ stdout.WriteLine("This lane is explicitly non-manufacturing and does not alter Firmament engineering domains.");
+ stdout.WriteLine();
+ stdout.WriteLine(SculptureUsage);
+ stdout.WriteLine(" --out <path> STEP/AP242 assembly output; defaults under artifacts/local/virtual-sculpture/.");
+ stdout.WriteLine(" --evidence <path> Structured deterministic and representation evidence JSON.");
+ stdout.WriteLine(" --preview <path> Deterministic authored SVG composition preview.");
+ stdout.WriteLine(" --json Emit machine-readable command output.");
+ }
+
private static void WriteBuildHelp(TextWriter stdout)
{
stdout.WriteLine("Build canonical Firmament V2 .firmament input into STEP output.");
diff --git a/Aetheris.Sculpture.Tests/Aetheris.Sculpture.Tests.csproj b/Aetheris.Sculpture.Tests/Aetheris.Sculpture.Tests.csproj
new file mode 100644
index 00000000..f4e2ec94
--- /dev/null
+++ b/Aetheris.Sculpture.Tests/Aetheris.Sculpture.Tests.csproj
@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <TargetFramework>net10.0</TargetFramework>
+ <ImplicitUsings>enable</ImplicitUsings>
+ <Nullable>enable</Nullable>
+ <IsPackable>false</IsPackable>
+ </PropertyGroup>
+ <ItemGroup>
+ <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.1" />
+ <PackageReference Include="xunit" Version="2.9.2" />
+ <PackageReference Include="xunit.runner.visualstudio" Version="2.8.2" />
+ </ItemGroup>
+ <ItemGroup>
+ <Using Include="Xunit" />
+ </ItemGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\Aetheris.Sculpture\Aetheris.Sculpture.csproj" />
+ </ItemGroup>
+</Project>
diff --git a/Aetheris.Sculpture.Tests/Sol1Tests.cs b/Aetheris.Sculpture.Tests/Sol1Tests.cs
new file mode 100644
index 00000000..68abbe3b
--- /dev/null
+++ b/Aetheris.Sculpture.Tests/Sol1Tests.cs
@@ -0,0 +1,56 @@
+using Aetheris.Kernel.Core.Step242;
+
+namespace Aetheris.Sculpture.Tests;
+
+public sealed class Sol1Tests
+{
+ [Fact]
+ public void FlagshipSource_BuildsDeterministicExactVirtualSculptureAssembly()
+ {
+ var source = Sol1Source.Load(FixturePath());
+ Assert.True(source.IsSuccess, string.Join(Environment.NewLine, source.Diagnostics.Select(d => d.Message)));
+ Assert.Equal(SculptureMode.Virtual, source.Value.Mode);
+
+ var first = Sol1Materializer.Build(source.Value);
+ var second = Sol1Materializer.Build(source.Value);
+ Assert.True(first.IsSuccess, string.Join(Environment.NewLine, first.Diagnostics.Select(d => d.Message)));
+ Assert.True(second.IsSuccess, string.Join(Environment.NewLine, second.Diagnostics.Select(d => d.Message)));
+ Assert.Equal(first.Value.Step, second.Value.Step);
+ Assert.Equal(first.Value.Evidence.StepSha256, second.Value.Evidence.StepSha256);
+ Assert.Equal(233, first.Value.Evidence.PhyllotaxisNodes);
+ Assert.Equal([13, 21], first.Value.Evidence.FibonacciOffsets);
+ Assert.Equal(432, first.Value.Evidence.LatticeConnections);
+ Assert.True(first.Value.Evidence.ProminentNodes > 0);
+ Assert.True(first.Value.Evidence.ProminentConnections > 0);
+ Assert.True(first.Value.Evidence.StepAssemblyReimportSucceeded);
+ Assert.False(first.Value.Evidence.IsManufacturingGeometry);
+ Assert.Equal(0, first.Value.Evidence.SurfaceInventory.RationalProductSurfaces);
+ Assert.Equal(0, first.Value.Evidence.SurfaceInventory.BSplineSurfaces);
+ Assert.True(first.Value.Evidence.SurfaceInventory.Tori >= 3);
+ Assert.True(first.Value.Evidence.SurfaceInventory.Spheres >= 2);
+ Assert.True(first.Value.Evidence.SurfaceInventory.Cylinders > 0);
+ Assert.DoesNotContain("RATIONAL_B_SPLINE_SURFACE", first.Value.Step, StringComparison.Ordinal);
+
+ var imported = Step242AssemblyImporter.Import(first.Value.Step);
+ Assert.True(imported.IsSuccess, string.Join(Environment.NewLine, imported.Diagnostics.Select(d => d.Message)));
+ Assert.Equal(first.Value.Evidence.ReimportedDefinitions, imported.Value.Definitions.Count);
+ Assert.Equal(first.Value.Evidence.ReimportedOccurrences, imported.Value.Occurrences.Count);
+ }
+
+ [Fact]
+ public void SourceValidation_PreservesEyeAndFrameClearance()
+ {
+ var source = Sol1Source.Load(FixturePath());
+ Assert.True(source.IsSuccess);
+ var points = Sol1Materializer.GeneratePoints(source.Value);
+ Assert.All(points, point => Assert.True(point.RadiusMm > source.Value.Eye.MajorRadiusMm + source.Value.Eye.MinorRadiusMm));
+ Assert.All(points, point => Assert.True(point.RadiusMm + source.Value.Lattice.NodeRadiusMm < source.Value.OuterFrame.MajorRadiusMm - source.Value.OuterFrame.MinorRadiusMm));
+ }
+
+ private static string FixturePath()
+ {
+ var current = new DirectoryInfo(AppContext.BaseDirectory);
+ while (current is not null && !File.Exists(Path.Combine(current.FullName, "Aetheris.slnx"))) current = current.Parent;
+ return Path.Combine(current?.FullName ?? throw new DirectoryNotFoundException(), "fixtures", "Canonical", "VirtualSculpture", "sol-1.sculpture.json");
+ }
+}
diff --git a/Aetheris.Sculpture/Aetheris.Sculpture.csproj b/Aetheris.Sculpture/Aetheris.Sculpture.csproj
new file mode 100644
index 00000000..93e6a13f
--- /dev/null
+++ b/Aetheris.Sculpture/Aetheris.Sculpture.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+ <PropertyGroup>
+ <TargetFramework>net10.0</TargetFramework>
+ <ImplicitUsings>enable</ImplicitUsings>
+ <Nullable>enable</Nullable>
+ <Description>Bounded non-manufacturing virtual sculpture generation for Aetheris.</Description>
+ </PropertyGroup>
+
+ <ItemGroup>
+ <ProjectReference Include="..\Aetheris.Kernel.Core\Aetheris.Kernel.Core.csproj" />
+ </ItemGroup>
+</Project>
diff --git a/Aetheris.Sculpture/Sol1.cs b/Aetheris.Sculpture/Sol1.cs
new file mode 100644
index 00000000..c057e284
--- /dev/null
+++ b/Aetheris.Sculpture/Sol1.cs
@@ -0,0 +1,378 @@
+using System.Globalization;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Aetheris.Kernel.Core.Brep;
+using Aetheris.Kernel.Core.Math;
+using Aetheris.Kernel.Core.Results;
+using Aetheris.Kernel.Core.Step242;
+
+namespace Aetheris.Sculpture;
+
+public enum SculptureMode
+{
+ Virtual
+}
+
+public sealed record Sol1FrameDefinition(double MajorRadiusMm, double MinorRadiusMm, double ZMm);
+public sealed record Sol1EyeDefinition(double MajorRadiusMm, double MinorRadiusMm, double ZMm);
+public sealed record Sol1WaveDefinition(double PrimaryAmplitudeMm, double SecondaryAmplitudeMm, int AngularFrequency, double RadialFrequency);
+public sealed record Sol1ProminenceDefinition(IReadOnlyList<int> Residues, int Modulus, double StartFraction, double RiseMm);
+public sealed record Sol1LatticeDefinition(
+ int NodeCount,
+ double InnerRadiusMm,
+ double OuterRadiusMm,
+ double NodeRadiusMm,
+ double StrandRadiusMm,
+ IReadOnlyList<int> FibonacciOffsets,
+ Sol1WaveDefinition Wave,
+ Sol1ProminenceDefinition Prominences);
+
+/// <summary>Canonical, bounded source contract for the ART-X0 flagship artwork.</summary>
+public sealed record Sol1Definition(
+ string Schema,
+ string Id,
+ string Title,
+ SculptureMode Mode,
+ Sol1FrameDefinition OuterFrame,
+ Sol1EyeDefinition Eye,
+ Sol1LatticeDefinition Lattice);
+
+public sealed record Sol1Point(int Index, double RadiusMm, double ThetaRadians, Point3D Position, bool IsProminent);
+public sealed record Sol1Connection(int From, int To, int FibonacciOffset, bool IsProminent, double LengthMm);
+
+public sealed record Sol1RepresentationInventory(
+ int Planes,
+ int Cylinders,
+ int Spheres,
+ int Tori,
+ int BSplineSurfaces,
+ int RationalProductSurfaces);
+
+public sealed record Sol1Evidence(
+ string Milestone,
+ string ArtworkId,
+ string Title,
+ SculptureMode Mode,
+ string ConstructionLaw,
+ double GoldenAngleRadians,
+ int PhyllotaxisNodes,
+ IReadOnlyList<int> FibonacciOffsets,
+ int LatticeConnections,
+ int ProminentNodes,
+ int ProminentConnections,
+ int ExactClosedBodyDefinitions,
+ int ExactClosedBodyOccurrences,
+ int AssemblyOccurrences,
+ bool StepAssemblyReimportSucceeded,
+ int ReimportedDefinitions,
+ int ReimportedOccurrences,
+ bool DeterministicSource,
+ bool IsManufacturingGeometry,
+ string Connectedness,
+ Sol1RepresentationInventory SurfaceInventory,
+ string StepSha256);
+
+public sealed record Sol1Artifact(
+ string Step,
+ string PreviewSvg,
+ Sol1Evidence Evidence,
+ IReadOnlyList<Sol1Point> Points,
+ IReadOnlyList<Sol1Connection> Connections);
+
+public static class Sol1Source
+{
+ private static readonly JsonSerializerOptions JsonOptions = CreateOptions();
+
+ public static KernelResult<Sol1Definition> Load(string path)
+ {
+ if (!File.Exists(path)) return Failure($"Sol 1 source was not found: {path}");
+ try
+ {
+ var definition = JsonSerializer.Deserialize<Sol1Definition>(File.ReadAllText(path), JsonOptions);
+ return definition is null ? Failure("Sol 1 source deserialized to null.") : Validate(definition);
+ }
+ catch (JsonException exception)
+ {
+ return Failure($"Sol 1 source is invalid JSON: {exception.Message}");
+ }
+ }
+
+ public static KernelResult<Sol1Definition> Validate(Sol1Definition definition)
+ {
+ var errors = new List<string>();
+ if (definition.Schema != "aetheris.virtual-sculpture/1") errors.Add("Schema must be 'aetheris.virtual-sculpture/1'.");
+ if (definition.Id != "sol-1" || definition.Title != "Sol 1") errors.Add("ART-X0 admits only the flagship id/title 'sol-1'/'Sol 1'.");
+ if (definition.Mode != SculptureMode.Virtual) errors.Add("Sol 1 must be explicitly marked Mode: Virtual.");
+ if (!Positive(definition.OuterFrame.MajorRadiusMm) || !Positive(definition.OuterFrame.MinorRadiusMm) || definition.OuterFrame.MajorRadiusMm <= definition.OuterFrame.MinorRadiusMm)
+ errors.Add("Outer frame radii must define a non-self-intersecting torus.");
+ if (!Positive(definition.Eye.MajorRadiusMm) || !Positive(definition.Eye.MinorRadiusMm) || definition.Eye.MajorRadiusMm <= definition.Eye.MinorRadiusMm)
+ errors.Add("Eye radii must define a non-self-intersecting torus.");
+ var lattice = definition.Lattice;
+ if (lattice.NodeCount is < 34 or > 610) errors.Add("NodeCount must remain in the bounded range 34..610.");
+ if (!Positive(lattice.InnerRadiusMm) || !Positive(lattice.OuterRadiusMm) || lattice.OuterRadiusMm <= lattice.InnerRadiusMm)
+ errors.Add("Lattice radii must be positive and ordered.");
+ if (lattice.InnerRadiusMm <= definition.Eye.MajorRadiusMm + definition.Eye.MinorRadiusMm)
+ errors.Add("The lattice must reserve a clean annular gap around the eye.");
+ if (lattice.OuterRadiusMm + lattice.NodeRadiusMm >= definition.OuterFrame.MajorRadiusMm - definition.OuterFrame.MinorRadiusMm)
+ errors.Add("The lattice must remain inside the exact outer frame.");
+ if (!Positive(lattice.NodeRadiusMm) || !Positive(lattice.StrandRadiusMm) || lattice.StrandRadiusMm >= lattice.NodeRadiusMm)
+ errors.Add("Node/strand radii must be positive, with strands smaller than nodes.");
+ if (lattice.FibonacciOffsets.Count is < 1 or > 3 || lattice.FibonacciOffsets.Any(offset => offset <= 0 || offset >= lattice.NodeCount))
+ errors.Add("One to three positive bounded Fibonacci offsets are required.");
+ if (lattice.FibonacciOffsets.Distinct().Count() != lattice.FibonacciOffsets.Count) errors.Add("Fibonacci offsets must be unique.");
+ if (!Positive(lattice.Wave.PrimaryAmplitudeMm) || lattice.Wave.SecondaryAmplitudeMm < 0d || lattice.Wave.AngularFrequency <= 0 || !double.IsFinite(lattice.Wave.RadialFrequency))
+ errors.Add("Wave parameters must be finite and intentional.");
+ var prominence = lattice.Prominences;
+ if (prominence.Modulus <= 0 || prominence.Residues.Count is < 1 or > 5 || prominence.Residues.Any(r => r < 0 || r >= prominence.Modulus))
+ errors.Add("Prominence residues must be a small valid subset of their modulus.");
+ if (prominence.StartFraction is < 0.4 or >= 1d || !Positive(prominence.RiseMm)) errors.Add("Prominence rise must begin in the outer field and be positive.");
+ return errors.Count == 0
+ ? KernelResult<Sol1Definition>.Success(definition)
+ : KernelResult<Sol1Definition>.Failure(errors.Select(message => new Aetheris.Kernel.Core.Diagnostics.KernelDiagnostic(
+ Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed,
+ Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error,
+ message,
+ "VirtualSculpture.Sol1.Source")).ToArray());
+ }
+
+ private static bool Positive(double value) => double.IsFinite(value) && value > 0d;
+ private static KernelResult<Sol1Definition> Failure(string message) => KernelResult<Sol1Definition>.Failure([
+ new(Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed,
+ Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error,
+ message,
+ "VirtualSculpture.Sol1.Source")]);
+ private static JsonSerializerOptions CreateOptions()
+ {
+ var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
+ options.Converters.Add(new JsonStringEnumConverter());
+ return options;
+ }
+}
+
+/// <summary>
+/// ART-X0's sole materializer. It produces a deterministic AP242 exact-body assembly:
+/// analytic toroidal frame/eye, spherical phyllotaxis nodes, and cylindrical Fibonacci
+/// parastichy chords. The multi-body structure is deliberate virtual sculpture semantics.
+/// </summary>
+public static class Sol1Materializer
+{
+ public const double GoldenAngleRadians = double.Pi * (3d - 2.2360679774997896964091736687313d);
+ private const double LengthQuantumMm = 0.02d;
+
+ public static KernelResult<Sol1Artifact> Build(Sol1Definition definition)
+ {
+ var validation = Sol1Source.Validate(definition);
+ if (!validation.IsSuccess) return KernelResult<Sol1Artifact>.Failure(validation.Diagnostics);
+
+ try
+ {
+ var points = GeneratePoints(definition);
+ var connections = GenerateConnections(definition, points);
+ var bodies = new Dictionary<string, BrepBody>(StringComparer.Ordinal);
+ var definitions = new List<Step242AssemblyDefinition>();
+ var occurrences = new List<Step242AssemblyOccurrence>();
+ const string root = "virtual-sculpture:sol-1";
+ occurrences.Add(new(root, "Sol 1", null, null, Identity()));
+
+ AddBody("frame", "Sol 1 — exact outer calm", Require(BrepPrimitives.CreateTorus(definition.OuterFrame.MajorRadiusMm, definition.OuterFrame.MinorRadiusMm)));
+ AddOccurrence("frame", "Outer analytic frame", TorusToXy(definition.OuterFrame.ZMm));
+ AddBody("eye", "Sol 1 — central eye", Require(BrepPrimitives.CreateTorus(definition.Eye.MajorRadiusMm, definition.Eye.MinorRadiusMm)));
+ AddOccurrence("eye", "Central analytic eye", TorusToXy(definition.Eye.ZMm));
+
+ var haloMinor = definition.Lattice.StrandRadiusMm * 1.15d;
+ var haloMajor = definition.Lattice.OuterRadiusMm + definition.Lattice.NodeRadiusMm + 0.75d;
+ AddBody("halo", "Sol 1 — inner corona delimiter", Require(BrepPrimitives.CreateTorus(haloMajor, haloMinor)));
+ AddOccurrence("halo", "Inner corona delimiter", TorusToXy(-0.65d));
+
+ foreach (var point in points)
+ {
+ var kind = point.IsProminent ? "prominent-node" : "node";
+ var radius = point.IsProminent ? definition.Lattice.NodeRadiusMm * 1.28d : definition.Lattice.NodeRadiusMm;
+ if (!bodies.ContainsKey(kind)) AddBody(kind, point.IsProminent ? "Sol 1 — prominence bead" : "Sol 1 — phyllotaxis bead", Require(BrepPrimitives.CreateSphere(radius)));
+ AddOccurrence(kind, $"Phyllotaxis n={point.Index:D3}", Translation(point.Position));
+ }
+
+ foreach (var connection in connections)
+ {
+ var radius = connection.IsProminent ? definition.Lattice.StrandRadiusMm * 1.5d : definition.Lattice.StrandRadiusMm;
+ var length = Quantize(connection.LengthMm);
+ var key = $"strand-r{Token(radius)}-l{Token(length)}";
+ if (!bodies.ContainsKey(key)) AddBody(key, connection.IsProminent ? "Sol 1 — escaping parastichy segment" : "Sol 1 — Fibonacci parastichy segment", Require(BrepPrimitives.CreateCylinder(radius, length)));
+ AddOccurrence(key, $"Fibonacci +{connection.FibonacciOffset}: {connection.From:D3}->{connection.To:D3}", SegmentTransform(points[connection.From].Position, points[connection.To].Position));
+ }
+
+ var export = Step242AssemblyExporter.Export(new("Sol 1", root, definitions, occurrences));
+ if (!export.IsSuccess) return KernelResult<Sol1Artifact>.Failure(export.Diagnostics);
+ var step = export.Value;
+ var reimport = Step242AssemblyImporter.Import(step);
+ if (!reimport.IsSuccess) return KernelResult<Sol1Artifact>.Failure(reimport.Diagnostics);
+
+ var inventory = Inventory(step);
+ if (inventory.RationalProductSurfaces != 0)
+ return Failure("Sol 1 representation law violated: rational product surfaces were emitted.");
+
+ var evidence = new Sol1Evidence(
+ "ART-X0",
+ definition.Id,
+ definition.Title,
+ definition.Mode,
+ "r_n=sqrt(r_eye^2+n*(r_outer^2-r_eye^2)/(N-1)); theta_n=n*golden_angle; edges=(n,n+FibonacciOffset); z=two-frequency radial/angular wave plus three residue-selected outer prominence ramps",
+ GoldenAngleRadians,
+ points.Count,
+ definition.Lattice.FibonacciOffsets,
+ connections.Count,
+ points.Count(point => point.IsProminent),
+ connections.Count(connection => connection.IsProminent),
+ definitions.Count,
+ occurrences.Count - 1,
+ occurrences.Count,
+ true,
+ reimport.Value.Definitions.Count,
+ reimport.Value.Occurrences.Count,
+ true,
+ false,
+ "Exact closed bodies are intentionally composed as an AP242 virtual-sculpture assembly. Overlapping node/strand occurrences create a perceptually continuous lattice without claiming a manufacturing boolean union.",
+ inventory,
+ Sha256(step));
+ return KernelResult<Sol1Artifact>.Success(new(step, Sol1Preview.Render(definition, points, connections), evidence, points, connections));
+
+ void AddBody(string stableId, string name, BrepBody body)
+ {
+ bodies.Add(stableId, body);
+ definitions.Add(new($"sol-1:def:{stableId}", name, body));
+ }
+ void AddOccurrence(string definitionId, string name, IReadOnlyList<double> transform) => occurrences.Add(new(
+ $"sol-1:occ:{occurrences.Count:D5}", name, root, $"sol-1:def:{definitionId}", transform));
+ }
+ catch (Exception exception) when (exception is ArgumentException or InvalidOperationException)
+ {
+ return Failure($"Sol 1 materialization failed: {exception.Message}");
+ }
+ }
+
+ public static IReadOnlyList<Sol1Point> GeneratePoints(Sol1Definition definition)
+ {
+ var l = definition.Lattice;
+ var result = new Sol1Point[l.NodeCount];
+ for (var n = 0; n < l.NodeCount; n++)
+ {
+ var fraction = n / (double)(l.NodeCount - 1);
+ var radius = double.Sqrt(l.InnerRadiusMm * l.InnerRadiusMm + fraction * (l.OuterRadiusMm * l.OuterRadiusMm - l.InnerRadiusMm * l.InnerRadiusMm));
+ var theta = n * GoldenAngleRadians;
+ var envelope = 0.22d + 0.78d * (1d - fraction);
+ var z = l.Wave.PrimaryAmplitudeMm * envelope * double.Sin(l.Wave.AngularFrequency * theta + l.Wave.RadialFrequency * radius)
+ + l.Wave.SecondaryAmplitudeMm * double.Sin(13d * theta - 0.11d * radius);
+ var residue = n % l.Prominences.Modulus;
+ var prominentFamily = l.Prominences.Residues.Contains(residue);
+ var prominent = prominentFamily && fraction >= l.Prominences.StartFraction;
+ if (prominent)
+ {
+ var u = (fraction - l.Prominences.StartFraction) / (1d - l.Prominences.StartFraction);
+ var smooth = u * u * (3d - 2d * u);
+ z += l.Prominences.RiseMm * smooth;
+ }
+ result[n] = new(n, radius, theta, new(radius * double.Cos(theta), radius * double.Sin(theta), z), prominent);
+ }
+ return result;
+ }
+
+ public static IReadOnlyList<Sol1Connection> GenerateConnections(Sol1Definition definition, IReadOnlyList<Sol1Point> points)
+ {
+ var result = new List<Sol1Connection>();
+ foreach (var offset in definition.Lattice.FibonacciOffsets.Order())
+ for (var from = 0; from + offset < points.Count; from++)
+ {
+ var to = from + offset;
+ var prominent = offset == definition.Lattice.Prominences.Modulus && points[from].IsProminent && points[to].IsProminent;
+ result.Add(new(from, to, offset, prominent, (points[to].Position - points[from].Position).Length));
+ }
+ return result;
+ }
+
+ private static BrepBody Require(KernelResult<BrepBody> result) => result.IsSuccess ? result.Value : throw new InvalidOperationException(string.Join("; ", result.Diagnostics.Select(d => d.Message)));
+ private static double Quantize(double length) => double.Max(LengthQuantumMm, double.Round(length / LengthQuantumMm, MidpointRounding.AwayFromZero) * LengthQuantumMm);
+ private static string Token(double value) => value.ToString("0.00", CultureInfo.InvariantCulture).Replace('.', '_');
+ private static string Sha256(string value) => Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(value))).ToLowerInvariant();
+ private static int Count(string text, string token) => (text.Length - text.Replace(token, string.Empty, StringComparison.Ordinal).Length) / token.Length;
+ private static Sol1RepresentationInventory Inventory(string step) => new(
+ Count(step, "=PLANE("),
+ Count(step, "=CYLINDRICAL_SURFACE("),
+ Count(step, "=SPHERICAL_SURFACE("),
+ Count(step, "=TOROIDAL_SURFACE("),
+ Count(step, "=B_SPLINE_SURFACE_WITH_KNOTS("),
+ Count(step, "RATIONAL_B_SPLINE_SURFACE"));
+
+ private static IReadOnlyList<double> Identity() => [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1];
+ private static IReadOnlyList<double> Translation(Point3D point) => [1,0,0,0, 0,1,0,0, 0,0,1,0, point.X,point.Y,point.Z,1];
+ private static IReadOnlyList<double> TorusToXy(double z) => [1,0,0,0, 0,0,1,0, 0,-1,0,0, 0,0,z,1];
+
+ private static IReadOnlyList<double> SegmentTransform(Point3D a, Point3D b)
+ {
+ var delta = b - a;
+ var zAxis = delta / delta.Length;
+ var helper = double.Abs(zAxis.Z) < 0.9d ? new Vector3D(0, 0, 1) : new Vector3D(0, 1, 0);
+ var xAxis = Cross(helper, zAxis);
+ xAxis /= xAxis.Length;
+ var yAxis = Cross(zAxis, xAxis);
+ var center = new Point3D((a.X + b.X) / 2d, (a.Y + b.Y) / 2d, (a.Z + b.Z) / 2d);
+ return [xAxis.X,xAxis.Y,xAxis.Z,0, yAxis.X,yAxis.Y,yAxis.Z,0, zAxis.X,zAxis.Y,zAxis.Z,0, center.X,center.Y,center.Z,1];
+ }
+
+ private static Vector3D Cross(Vector3D a, Vector3D b) => new(a.Y*b.Z-a.Z*b.Y, a.Z*b.X-a.X*b.Z, a.X*b.Y-a.Y*b.X);
+ private static KernelResult<Sol1Artifact> Failure(string message) => KernelResult<Sol1Artifact>.Failure([
+ new(Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticCode.ValidationFailed,
+ Aetheris.Kernel.Core.Diagnostics.KernelDiagnosticSeverity.Error,
+ message,
+ "VirtualSculpture.Sol1.Materializer")]);
+}
+
+public static class Sol1Preview
+{
+ public static string Render(Sol1Definition definition, IReadOnlyList<Sol1Point> points, IReadOnlyList<Sol1Connection> connections)
+ {
+ const double size = 1200d;
+ const double center = size / 2d;
+ var scale = 500d / (definition.OuterFrame.MajorRadiusMm + definition.OuterFrame.MinorRadiusMm);
+ var minZ = points.Min(p => p.Position.Z); var maxZ = points.Max(p => p.Position.Z);
+ var builder = new StringBuilder();
+ builder.AppendLine("<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"1200\" height=\"1200\" viewBox=\"0 0 1200 1200\">");
+ builder.AppendLine("<defs><radialGradient id=\"bg\"><stop offset=\"0\" stop-color=\"#21120d\"/><stop offset=\"0.55\" stop-color=\"#090a12\"/><stop offset=\"1\" stop-color=\"#020308\"/></radialGradient><filter id=\"glow\"><feGaussianBlur stdDeviation=\"2.2\" result=\"b\"/><feMerge><feMergeNode in=\"b\"/><feMergeNode in=\"SourceGraphic\"/></feMerge></filter></defs>");
+ builder.AppendLine("<rect width=\"1200\" height=\"1200\" fill=\"url(#bg)\"/><g filter=\"url(#glow)\" stroke-linecap=\"round\">");
+ foreach (var edge in connections.OrderBy(edge => (points[edge.From].Position.Z + points[edge.To].Position.Z) / 2d))
+ {
+ var a = Project(points[edge.From].Position); var b = Project(points[edge.To].Position);
+ var z = (points[edge.From].Position.Z + points[edge.To].Position.Z) / 2d;
+ var t = (z - minZ) / double.Max(0.001d, maxZ - minZ);
+ var color = edge.IsProminent ? "#fff3b0" : Blend(t);
+ var width = edge.IsProminent ? 3.6d : 1.45d;
+ builder.Append(CultureInfo.InvariantCulture, $"<line x1=\"{a.X:F2}\" y1=\"{a.Y:F2}\" x2=\"{b.X:F2}\" y2=\"{b.Y:F2}\" stroke=\"{color}\" stroke-width=\"{width:F2}\" opacity=\"0.92\"/>\n");
+ }
+ foreach (var point in points.OrderBy(point => point.Position.Z))
+ {
+ var p = Project(point.Position); var t = (point.Position.Z - minZ) / double.Max(0.001d, maxZ - minZ);
+ var radius = point.IsProminent ? 5.1d : 3.0d;
+ builder.Append(CultureInfo.InvariantCulture, $"<circle cx=\"{p.X:F2}\" cy=\"{p.Y:F2}\" r=\"{radius:F2}\" fill=\"{(point.IsProminent ? "#fff7cf" : Blend(t))}\"/>\n");
+ }
+ var outer = definition.OuterFrame.MajorRadiusMm * scale;
+ var outerWidth = definition.OuterFrame.MinorRadiusMm * 2d * scale;
+ var eye = definition.Eye.MajorRadiusMm * scale;
+ var eyeWidth = definition.Eye.MinorRadiusMm * 2d * scale;
+ builder.Append(CultureInfo.InvariantCulture, $"<circle cx=\"{center:F1}\" cy=\"{center:F1}\" r=\"{outer:F2}\" fill=\"none\" stroke=\"#ffd879\" stroke-width=\"{outerWidth:F2}\"/>\n");
+ builder.Append(CultureInfo.InvariantCulture, $"<circle cx=\"{center:F1}\" cy=\"{center:F1}\" r=\"{eye:F2}\" fill=\"#03040a\" stroke=\"#fff0a3\" stroke-width=\"{eyeWidth:F2}\"/>\n");
+ builder.AppendLine("</g><text x=\"600\" y=\"1140\" text-anchor=\"middle\" fill=\"#ffe6a0\" font-family=\"serif\" font-size=\"34\" letter-spacing=\"12\">SOL 1</text></svg>");
+ return builder.ToString();
+
+ (double X, double Y) Project(Point3D point) => (center + point.X * scale, center - point.Y * scale - point.Z * scale * 0.18d);
+ }
+
+ private static string Blend(double t)
+ {
+ t = double.Clamp(t, 0d, 1d);
+ var r = (int)double.Round(220d + 35d * t);
+ var g = (int)double.Round(82d + 157d * t);
+ var b = (int)double.Round(31d + 120d * t);
+ return $"#{r:X2}{g:X2}{b:X2}";
+ }
+}
diff --git a/Aetheris.slnx b/Aetheris.slnx
index 5c6338a9..39e8d488 100644
--- a/Aetheris.slnx
+++ b/Aetheris.slnx
@@ -15,6 +15,8 @@
<Project Path="Aetheris.SheetMetal.Tests/Aetheris.SheetMetal.Tests.csproj" />
<Project Path="Aetheris.PlasticShell/Aetheris.PlasticShell.csproj" />
<Project Path="Aetheris.PlasticShell.Tests/Aetheris.PlasticShell.Tests.csproj" />
+ <Project Path="Aetheris.Sculpture/Aetheris.Sculpture.csproj" />
+ <Project Path="Aetheris.Sculpture.Tests/Aetheris.Sculpture.Tests.csproj" />
<Project Path="Aetheris.Modules.BuiltIn/Aetheris.Modules.BuiltIn.csproj" />
<Project Path="Aetheris.Modules.Tests/Aetheris.Modules.Tests.csproj" />
<Project Path="Aetheris.Continuum/Aetheris.Continuum.csproj" />
diff --git a/docs/public/README.md b/docs/public/README.md
index 59496d05..9827ade2 100644
--- a/docs/public/README.md
+++ b/docs/public/README.md
@@ -5,6 +5,7 @@ This directory is the only authoritative in-repository guide to behavior shipped
Start with [Getting Started](getting-started.md), then use these guides:
- Firmament: [overview](firmament/overview.md), [language style](firmament/language-style.md), [syntax](firmament/syntax.md), [geometry](firmament/geometry.md), [bounded mathematical sculpting](firmament/sculpting.md), [PlasticShell](firmament/plastic-shell.md), [Circular Sweep](firmament/sweep.md), [Structural members and weldments](firmament/structural.md), [Semantic piping and local autorouting](firmament/piping.md), [Paperclip Template](firmament/paperclip.md), [Templates](firmament/templates.md), [materials](firmament/materials.md), [PMI](firmament/pmi.md), [Sheet Metal](firmament/sheet-metal.md), [FEA](firmament/fea.md), and [STEP import](firmament/step-import.md)
+- Non-manufacturing work: [Virtual Sculpture and Sol 1](virtual-sculpture.md)
- Standard Library: [product-family index, invocation, authoring, and compatibility](standard-library/README.md)
- Interoperability: [Forge Host Protocol v1](forge/interop.md)
- Inspection: [Cadmata](cadmata/overview.md) and [Cadmata PMI](cadmata/pmi.md)
diff --git a/docs/public/reference/cli.md b/docs/public/reference/cli.md
index 5a04a5e1..2f452b35 100644
--- a/docs/public/reference/cli.md
+++ b/docs/public/reference/cli.md
@@ -11,6 +11,7 @@ Primary public commands:
| `view <file>` | Open in bundled Cadmata |
| `fea <file> --out-dir dir [--json]` | Compile and solve the bounded linear-elastic analysis |
| `sheetmetal ...` | Inspect, recognize, recover, compare, or flatten Sheet Metal |
+| `sculpture build <source> ...` | Build the bounded non-manufacturing Sol 1 AP242 artwork, evidence, and SVG preview |
| `asm ...` | Inspect/execute/import/export assemblies |
Run `aetheris <command> --help` for exact options. JSON is a public automation surface, but its root is command-specific: process exit status is authoritative, `validate` reports `firmamentV2Validation.status`, and materializing/analysis commands report `success` where documented. Diagnostics are structured; artifact paths are explicit; Sheet Metal reports regions, bends, and lowered features separately; FEA reports requested/result artifacts; sculpting builds report every `BodyState`, `GeometricDelta`, validation evidence, surface-family inventory, and the sibling `.delta.json` path; other builds report emitted features and PMI export evidence. Counts describe semantic items at the stated layer, not arbitrary STEP entity counts.
diff --git a/docs/public/reference/supported-features.md b/docs/public/reference/supported-features.md
index d5cebd8c..252f5fdc 100644
--- a/docs/public/reference/supported-features.md
+++ b/docs/public/reference/supported-features.md
@@ -7,6 +7,7 @@
| Firmament V2 native primitives/profiles | Bounded | Named Box/Cylinder/Frustum/RoundedBox and admitted line/arc profile construction/composition |
| Bounded mathematical sculpting | Bounded (SURF-X2 subset) | Immutable single-predecessor `BodyState`; rectangular-housing `OffsetRegion`; direct or imported-face `ReplaceRegion`; qualified crown-to-planar-shoulder `BlendBoundary` with hard G1/G2 evidence, four deterministic polynomial candidates, fairness/curvature/compactness/complexity judgment, override/fallback trace, qualified intersections and pcurves, exact lower-body locality, AP242 association persistence, and rational-free STEP. General blend networks remain unsupported. See the [sculpting guide](../firmament/sculpting.md). |
| Molded plastic shell | Bounded (MOLD-X0a) | First-class `PlasticShell` IR; exact drafted coaxial-frustum shell; analytic annular standoffs with retained core holes; constant-shell-thickness planar B-rep rib walls with flat tops; one closed product boundary; face-associated AP242 notes; and explicit zero-release-draft warning for constant-section vertical features. The retired polar height field is available only through the non-manufacturing experimental art command. Freeform exterior offsets and general junctions remain unsupported. See the [PlasticShell guide](../firmament/plastic-shell.md). |
+| Virtual Sculpture | Bounded (ART-X0) | The explicit `Mode: Virtual` Sol 1 flagship: deterministic golden-angle/Fibonacci 3D lattice, analytic toroidal frame and eye, exact closed-body AP242 assembly, evidence/preview output, and zero rational product surfaces. This is not manufacturing geometry and does not extend Firmament engineering domains. See [Virtual Sculpture](../virtual-sculpture.md). |
| Firmament V2 analytic primitives | Bounded | Direct named Sphere, Cone (including zero-radius pointed end), and Torus routes round-trip through AP242; legacy `solid` declarations remain compatibility inputs, not canonical authoring |
| Circular Sweep | Bounded (X0) | Open planar XY Concept Path, tangent line/arc segments, constant circular diameter, analytic cylinder/torus faces, capped solid; no general 3D/variable/rail/twist sweep |
| Structural / weldment | Bounded (X2) | Explicit 3D nodes and straight paths; identifiable members; square/rectangular/round tube, angle, flat/round bar; orientation; catalog material; two-member butt and polygonal miter joints; semantic fillet welds; AP242 member assembly and deterministic JSON Cut List. No coping, curved routing, multi-member miter, connection design, weld analysis, or structural FEA. See [guide](../firmament/structural.md). |
diff --git a/docs/public/virtual-sculpture.md b/docs/public/virtual-sculpture.md
new file mode 100644
index 00000000..b6907559
--- /dev/null
+++ b/docs/public/virtual-sculpture.md
@@ -0,0 +1,42 @@
+# Virtual Sculpture
+
+Virtual Sculpture is Aetheris's deliberately non-manufacturing geometry lane. It exists for bounded computational artworks whose semantic purpose is visual and mathematical rather than fabrication. It does not extend or weaken Firmament `Model`, PlasticShell, Sheet Metal, Structural, Piping, Surfacing, or FEA behavior.
+
+ART-X0 contains one flagship piece: **Sol 1**. Its canonical source is [`fixtures/Canonical/VirtualSculpture/sol-1.sculpture.json`](../../fixtures/Canonical/VirtualSculpture/sol-1.sculpture.json), marked explicitly with `"mode": "Virtual"`. The lane is intentionally narrow; it is not a general art platform or an alias for the retired PlasticShell height-field experiment.
+
+## Composition law
+
+Sol 1 places 233 nodes in an annular phyllotaxis field:
+
+```text
+theta_n = n * pi * (3 - sqrt(5))
+r_n = sqrt(r_inner^2 + n * (r_outer^2 - r_inner^2) / (N - 1))
+```
+
+Each node connects to nodes `n + 13` and `n + 21`. These Fibonacci offsets expose the two dominant parastichy families of the golden-angle field. Node height is a deterministic two-frequency radial/angular wave. Three residue-selected `+21` families rise through a smooth outer ramp, producing the controlled escaping prominences.
+
+The composition reserves an analytic toroidal eye, adds an analytic inner-corona delimiter, and surrounds the field with a calm exact toroidal frame. The center is a designed void, not a collapsed numerical pole.
+
+## Representation contract
+
+Sol 1 exports as an AP242 product-structure assembly of exact closed analytic bodies:
+
+- toruses for the frame, eye, and corona delimiter;
+- spheres for phyllotaxis nodes;
+- rigidly placed cylinders for Fibonacci-family chords;
+- planar analytic caps on the bounded cylinders;
+- no B-spline surfaces and no rational product surfaces.
+
+The nodes and strands overlap visually at their joints. They are intentionally retained as separate exact closed bodies rather than boolean-unified into a manufacturing solid. That preserves deterministic analytic structure and honestly describes the artifact as virtual sculpture. A generic single-part `aetheris analyze` route is therefore not the correct inspection route; use assembly import/inspection for the STEP product structure.
+
+## Build Sol 1
+
+From the repository root:
+
+```powershell
+dotnet run --project Aetheris.CLI -c Release -- sculpture build fixtures/Canonical/VirtualSculpture/sol-1.sculpture.json --out artifacts/local/virtual-sculpture/sol-1.step --evidence artifacts/local/virtual-sculpture/sol-1.evidence.json --preview artifacts/local/virtual-sculpture/sol-1.preview.svg --json
+```
+
+When `--out` is omitted, generated files default under `artifacts/local/virtual-sculpture/` in accordance with the generated-artifact policy. The evidence report records pattern counts, representation inventory, STEP assembly reimport, deterministic SHA-256, and the explicit non-manufacturing marker.
+
+The older `experimental heightfield-art` command remains documented with [PlasticShell](firmament/plastic-shell.md). It is a quarantined historical experiment and is not Sol 1.
diff --git a/docs/release/ART-X0-SOL-1.md b/docs/release/ART-X0-SOL-1.md
new file mode 100644
index 00000000..0867e2db
--- /dev/null
+++ b/docs/release/ART-X0-SOL-1.md
@@ -0,0 +1,90 @@
+# ART-X0 — Sol 1 milestone report
+
+**Verdict: Success**
+
+Sol 1 exists through a dedicated non-manufacturing source, materializer, CLI, AP242 assembly export, Aetheris reimport, external FreeCAD import, deterministic rerun, authored preview, and focused/full regression coverage. The production PlasticShell and other engineering paths were not modified.
+
+## Flagship artifact
+
+- Source: `fixtures/Canonical/VirtualSculpture/sol-1.sculpture.json`
+- STEP: `artifacts/local/virtual-sculpture/sol-1.step`
+- Structured evidence: `artifacts/local/virtual-sculpture/sol-1.evidence.json`
+- Authored preview: `artifacts/local/virtual-sculpture/sol-1.preview.svg`
+- Preview raster used for review: `artifacts/local/virtual-sculpture/sol-1.preview.png`
+- STEP SHA-256: `53034776a882cd49992741946d0c564819ace87a5651fa76fe2272ceae2d047a`
+- STEP size: 1,149,628 bytes
+
+Generated artifacts remain under ignored `artifacts/local/` by policy. The canonical source and this compact release record are tracked.
+
+## Artistic construction
+
+The interior begins with 233 golden-angle points distributed by equal-area annular phyllotaxis. Two deterministic connection laws, `n -> n + 13` and `n -> n + 21`, expose interleaved Fibonacci parastichy families. A primary fivefold radial/angular wave and a secondary thirteenfold interference wave move the field out of plane.
+
+Three evenly distributed residue classes (`0`, `7`, and `14` modulo `21`) become controlled prominences after 62% radial growth. Their outer nodes rise through a cubic smoothstep ramp to 9 mm and their `+21` chords thicken. This produces three escaping gestures without disturbing the global order.
+
+The center is reserved before field generation. An exact torus forms the eye, a fine exact torus delimits the corona, and a 58 mm-major-radius exact torus forms the calm outer boundary. The intended outer diameter is `2 * (58 + 2.25) = 120.50 mm`; FreeCAD's independent torus-face tessellation measured `120.50 mm` across and the imported assembly spans approximately `12.86 mm` in Z. FreeCAD's analytic-face `BoundBox` overestimates the XY torus extent, so it was not used as dimensional evidence.
+
+## Semantic and architectural boundary
+
+`Aetheris.Sculpture` is a new project with one bounded source contract and one materializer. `Mode: Virtual` is mandatory. The CLI exposes `aetheris sculpture build`; it does not route through ordinary Firmament manufacturing builds or the `experimental heightfield-art` command.
+
+Sol 1 is intentionally an AP242 product-structure assembly of exact closed bodies. Perceptual joints overlap, but no manufacturing boolean-union claim is made. This is meaningful structured geometry rather than triangle soup: the final STEP contains only analytic toroidal, spherical, cylindrical, and planar surfaces.
+
+No PlasticShell implementation file, manufacturing semantic, or exact production materialization route changed in ART-X0.
+
+## Geometry and representation evidence
+
+| Fact | Qualified value |
+|---|---:|
+| Phyllotaxis nodes | 233 |
+| Fibonacci connection offsets | 13, 21 |
+| Lattice connections | 432 |
+| Prominent nodes | 13 |
+| Prominent connections | 10 |
+| Exact closed-body definitions | 220 |
+| Exact closed-body occurrences | 668 |
+| AP242 root + child occurrences | 669 |
+| Planar surface definitions | 430 |
+| Cylindrical surface definitions | 215 |
+| Spherical surface definitions | 2 |
+| Toroidal surface definitions | 3 |
+| B-spline surfaces | 0 |
+| Rational product surfaces | 0 |
+
+Surface counts describe reusable STEP definitions, not multiplied occurrences. Aetheris STEP assembly reimport recovered 220 geometric definitions and 668 child occurrences. The extra imported root definition is the non-geometric Sol 1 assembly product.
+
+## Qualification
+
+The following real paths were run from the repository root:
+
+```powershell
+dotnet build Aetheris.slnx -c Release
+dotnet test Aetheris.Sculpture.Tests/Aetheris.Sculpture.Tests.csproj -c Release --no-build
+dotnet test Aetheris.CLI.Tests/Aetheris.CLI.Tests.csproj -c Release --no-build --filter FullyQualifiedName~Sol1CliTests
+dotnet test Aetheris.slnx -c Release --no-build -m:1
+dotnet run --project Aetheris.CLI -c Release --no-build -- sculpture build fixtures/Canonical/VirtualSculpture/sol-1.sculpture.json --out artifacts/local/virtual-sculpture/sol-1.step --evidence artifacts/local/virtual-sculpture/sol-1.evidence.json --preview artifacts/local/virtual-sculpture/sol-1.preview.svg --json
+dotnet run --project Aetheris.CLI -c Release --no-build -- asm import-step artifacts/local/virtual-sculpture/sol-1.step --out artifacts/local/virtual-sculpture/reimport --json
+tools/Validate-Step-FreeCAD.ps1 artifacts/local/virtual-sculpture/sol-1.step
+git diff --check
+```
+
+The deterministic test builds the same source twice and requires byte-identical STEP plus equal SHA-256. The dedicated CLI test exercises source load, materialization, STEP/evidence/preview writes, and the explicit virtual-domain JSON marker.
+
+The serial full-suite qualification passed all 3,161 discovered tests. An earlier solution-wide parallel run exposed one unrelated timing-test outlier in `RecognizedConstructionRecipeTests` while all ART-X0, CLI, and PlasticShell tests passed; that exact case passed immediately in isolation and the complete serial rerun passed all 961 Kernel.Core tests. `Aetheris.FrictionLab.Tests` remains an existing assembly with no discoverable tests.
+
+FreeCAD 1.0.2 imported the assembly without healing: 676 document objects, 1,336 hierarchy-counted solids/shells, `shape_valid=true`, and analytic surface recognition of Cylinder, Plane, Sphere, and Toroid. The hierarchy exposes geometry at definition and occurrence levels, so the external traversal reports each placed solid twice. Its aggregate `closed=false` includes non-geometric assembly nodes; all emitted Aetheris component definitions pass exact closed-body preflight and import as solids.
+
+## Manual visual review
+
+Open the STEP itself for the acceptance review. Check:
+
+- the overall solar/vortex silhouette;
+- whether the outer toroidal frame reads as calm and pristine;
+- whether the dual parastichy lattice reads as intentional spiral interference rather than a generic web;
+- the cleanliness and authority of the central eye;
+- the three rising, thickened outer prominences;
+- whether close inspection rewards the viewer with ordered repetition;
+- any ugly accidental spikes, overlaps, inverted placements, or display artifacts;
+- whether the complexity feels beautiful rather than merely noisy.
+
+The SVG is a deterministic composition preview, not substitute evidence for the STEP. Camera, material, and lighting choices in a CAD viewer will materially affect the prominence read.
diff --git a/fixtures/Canonical/VirtualSculpture/sol-1.sculpture.json b/fixtures/Canonical/VirtualSculpture/sol-1.sculpture.json
new file mode 100644
index 00000000..bffdc192
--- /dev/null
+++ b/fixtures/Canonical/VirtualSculpture/sol-1.sculpture.json
@@ -0,0 +1,36 @@
+{
+ "schema": "aetheris.virtual-sculpture/1",
+ "id": "sol-1",
+ "title": "Sol 1",
+ "mode": "Virtual",
+ "outerFrame": {
+ "majorRadiusMm": 58.0,
+ "minorRadiusMm": 2.25,
+ "zMm": 0.0
+ },
+ "eye": {
+ "majorRadiusMm": 8.5,
+ "minorRadiusMm": 1.45,
+ "zMm": 0.5
+ },
+ "lattice": {
+ "nodeCount": 233,
+ "innerRadiusMm": 11.25,
+ "outerRadiusMm": 51.5,
+ "nodeRadiusMm": 0.67,
+ "strandRadiusMm": 0.34,
+ "fibonacciOffsets": [13, 21],
+ "wave": {
+ "primaryAmplitudeMm": 1.65,
+ "secondaryAmplitudeMm": 0.48,
+ "angularFrequency": 5,
+ "radialFrequency": 0.29
+ },
+ "prominences": {
+ "residues": [0, 7, 14],
+ "modulus": 21,
+ "startFraction": 0.62,
+ "riseMm": 9.0
+ }
+ }
+}