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.csnew file mode 100644index 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.csprojindex 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.csindex 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 CliRunnerprivate 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.csprojnew file mode 100644index 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.csnew file mode 100644index 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.csprojnew file mode 100644index 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.csnew file mode 100644index 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.slnxindex 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.mdindex 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 shippedStart 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.mdindex 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.mdindex 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.mdnew file mode 100644index 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.mdnew file mode 100644index 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.jsonnew file mode 100644index 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+ }+ }+}