Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
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.Brep.Features;
using Aetheris.Kernel.Core.Diagnostics;
using Aetheris.Kernel.Core.Import;
using Aetheris.Kernel.Core.Math;
using Aetheris.Kernel.Core.Results;
using Aetheris.Kernel.Core.Step242;
using Aetheris.Kernel.Firmament.FirmamentV2.Syntax;
namespace Aetheris.Kernel.Firmament;
public sealed class ImportedFeatureInspection
{
internal ImportedFeatureInspection(string text, BrepBody body, double tolerance)
{
SourceText = text; Body = body;
SourceHash = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(
text.Replace("\r\n", "\n", StringComparison.Ordinal).Replace('\r', '\n')))).ToLowerInvariant();
Discovery = BrepThroughHoleRevision.Discover(body, tolerance);
}
internal string SourceText { get; }
internal BrepBody Body { get; }
public string SourceHash { get; }
public string SourceHashKind => "sha256-utf8-lf";
public double? SourceDistanceAccuracyMillimetres => Body.ImportQualification?.SourceDistanceAccuracyMillimetres;
public ThroughHoleDiscovery Discovery { get; }
}
public sealed record ImportedFeatureMovePlan(string Source, string Candidate, string Alias,
string SourceHash, string Admission, FirmamentImportedHoleRevisionReport Revision)
{
public double AuthoringIncrementMillimetres => FirmamentImportedFeatures.AuthoringIncrementMillimetres;
[JsonIgnore] public FirmamentStepExportResult Export { get; init; } = null!;
}
public sealed record ImportedFeatureRemovalPlan(string Source, string Candidate, string Alias, string SourceHash, string Admission,
FirmamentImportedHoleRemovalReport Removal)
{
[JsonIgnore] public FirmamentStepExportResult Export { get; init; } = null!;
}
/// <summary>Agent-facing recovery assistance. Selection is explicit; geometric
/// admission belongs exclusively to the existing production kernel/compiler.</summary>
public static class FirmamentImportedFeatures
{
public const double AuthoringIncrementMillimetres = .1;
static double Nominal(double value)
{
var rounded = double.Round(value, 1, MidpointRounding.AwayFromZero);
return rounded == 0 ? 0 : rounded;
}
static double Outward(double value, bool minimum)
{
// Remove arithmetic jitter at a grid boundary before directing the round.
// Final compiler admission checks the actual emitted bounds against BRep.
var grid = double.Round(value / AuthoringIncrementMillimetres, 8);
return (minimum ? double.Floor(grid) : double.Ceiling(grid)) * AuthoringIncrementMillimetres;
}
public static KernelResult<ImportedFeatureInspection> Inspect(string stepText, double importToleranceMillimetres = .001)
{
ArgumentNullException.ThrowIfNull(stepText);
if (!double.IsFinite(importToleranceMillimetres) || importToleranceMillimetres <= 0 || importToleranceMillimetres > .1)
return Failure<ImportedFeatureInspection>("Import tolerance must be positive, finite and at most .1 mm.");
var import = Step242Importer.ImportBody(stepText, new ImportPolicy(PcurveQualificationToleranceMillimetres: importToleranceMillimetres));
return import.IsSuccess ? KernelResult<ImportedFeatureInspection>.Success(new(stepText, import.Value, importToleranceMillimetres), import.Diagnostics)
: KernelResult<ImportedFeatureInspection>.Failure(import.Diagnostics);
}
public static KernelResult<ImportedFeatureMovePlan> PlanMove(ImportedFeatureInspection inspection,
string candidateId, string alias, Point3D destination, bool geometryOnly,
string sourceReference = "input.step", string? sourceDirectory = null, double clearanceMillimetres = .1)
{
ArgumentNullException.ThrowIfNull(inspection);
if (!geometryOnly) return Failure<ImportedFeatureMovePlan>("Explicit geometry-only approval is required; source PMI migration is not admitted.");
var name = FirmamentSyntaxParser.ParseExpression(alias);
if (name.Diagnostics.Count > 0 || name.Expression is not ReferenceSyntax identifier || identifier.Name.Text != alias)
return Failure<ImportedFeatureMovePlan>("Alias must be one Firmament identifier.");
if (string.IsNullOrWhiteSpace(sourceReference) || Path.IsPathRooted(sourceReference)) return Failure<ImportedFeatureMovePlan>("The generated InlineStep path must be relative to its source document.");
string? resourcePath = null;
if (sourceDirectory is null)
{
try { resourcePath = Assembly.FirmamentProjectSnapshot.NormalizePath(sourceReference); }
catch (ArgumentException) { return Failure<ImportedFeatureMovePlan>("Snapshot source reference must remain inside the resource project."); }
}
var candidate = inspection.Discovery.Candidates.SingleOrDefault(c => c.Id == candidateId);
if (candidate?.AxisIndex is not { } axis || candidate.Center is not { } original)
return Failure<ImportedFeatureMovePlan>("Select a proved principal-axis round through-hole before planning.");
double Component(Point3D p) => axis switch { 0 => p.X, 1 => p.Y, _ => p.Z };
if (System.Math.Abs(Component(destination) - Component(original)) > 1e-6)
return Failure<ImportedFeatureMovePlan>("The destination must remain on the proved entry plane; only in-plane positions are rounded.");
var authoredDestination = axis switch
{
0 => new Point3D(original.X, Nominal(destination.Y), Nominal(destination.Z)),
1 => new(Nominal(destination.X), original.Y, Nominal(destination.Z)),
_ => new(Nominal(destination.X), Nominal(destination.Y), original.Z)
};
var planned = BrepThroughHoleRevision.PlanMove(inspection.Body, candidateId, alias, authoredDestination,
inspection.Discovery.ImportToleranceMillimetres, clearanceMillimetres);
if (!planned.IsSuccess) return KernelResult<ImportedFeatureMovePlan>.Failure(planned.Diagnostics);
var request = planned.Value.Request;
var entryEntity = inspection.Body.Bindings.GetFaceBinding(request.EntryFace).SourceStepEntityId;
if (entryEntity is null) return Failure<ImportedFeatureMovePlan>("Entry support has no imported source entity binding.");
var source = axis == 2 && System.Math.Abs(Nominal(request.Diameter) - request.Diameter) < 1e-6
&& System.Math.Abs(Nominal(request.Within.Min.Z) - request.Within.Min.Z) < 1e-6 && System.Math.Abs(Nominal(request.Within.Max.Z) - request.Within.Max.Z) < 1e-6
? Emit(inspection, candidateId, alias, sourceReference, entryEntity.Value, request)
: EmitMeasured(inspection, candidate, alias, sourceReference, request.Within, request.DestinationWithin, request.Center, entryEntity.Value);
// Resource snapshots use exactly the inspected immutable text. File-backed
// callers re-enter the ordinary loader, which rechecks the persisted pin.
IReadOnlyDictionary<string, string>? resources = sourceDirectory is null
? new Dictionary<string, string> { [resourcePath!] = inspection.SourceText } : null;
var build = FirmamentBuildAndExport.CompileSource(source, sourceDirectory ?? "", resources);
if (!build.IsSuccess) return KernelResult<ImportedFeatureMovePlan>.Failure(build.Diagnostics);
return KernelResult<ImportedFeatureMovePlan>.Success(new(source, candidateId, alias, inspection.SourceHash,
"Built", build.Value.ImportedHoleRevision!)
{ Export = build.Value }, build.Diagnostics);
}
public static KernelResult<ImportedFeatureRemovalPlan> PlanRemove(ImportedFeatureInspection inspection, string candidateId, string alias,
bool geometryOnly, string sourceReference = "input.step", string? sourceDirectory = null, double clearanceMillimetres = .1)
{
ArgumentNullException.ThrowIfNull(inspection);
if (!geometryOnly) return Failure<ImportedFeatureRemovalPlan>("Explicit geometry-only approval is required; source PMI migration is not admitted.");
var name = FirmamentSyntaxParser.ParseExpression(alias);
if (name.Diagnostics.Count > 0 || name.Expression is not ReferenceSyntax r || r.Name.Text != alias)
return Failure<ImportedFeatureRemovalPlan>("Alias must be one Firmament identifier.");
if (string.IsNullOrWhiteSpace(sourceReference) || Path.IsPathRooted(sourceReference)) return Failure<ImportedFeatureRemovalPlan>("The STEP path must be relative to its source document.");
string? resourcePath = null;
if (sourceDirectory is null)
{
try { resourcePath = Assembly.FirmamentProjectSnapshot.NormalizePath(sourceReference); }
catch (ArgumentException) { return Failure<ImportedFeatureRemovalPlan>("Snapshot source reference must remain inside the resource project."); }
}
var planned = BrepThroughHoleRevision.PlanRemove(inspection.Body, candidateId, alias, inspection.Discovery.ImportToleranceMillimetres, clearanceMillimetres);
if (!planned.IsSuccess) return KernelResult<ImportedFeatureRemovalPlan>.Failure(planned.Diagnostics);
var candidate = inspection.Discovery.Candidates.Single(c => c.Id == candidateId);
var source = EmitMeasured(inspection, candidate, alias, sourceReference, planned.Value.Request.Within, null, null, null);
IReadOnlyDictionary<string, string>? resources = sourceDirectory is null ? new Dictionary<string, string> { [resourcePath!] = inspection.SourceText } : null;
var build = FirmamentBuildAndExport.CompileSource(source, sourceDirectory ?? "", resources);
return build.IsSuccess ? KernelResult<ImportedFeatureRemovalPlan>.Success(new(source, candidateId, alias, inspection.SourceHash, "Built", build.Value.ImportedHoleRemoval!) { Export = build.Value }, build.Diagnostics)
: KernelResult<ImportedFeatureRemovalPlan>.Failure(build.Diagnostics);
}
static string EmitMeasured(ImportedFeatureInspection inspection, ThroughHoleCandidate candidate, string alias, string path,
ThroughHoleEditBounds within, ThroughHoleEditBounds? destination, Point3D? center, int? entryEntity)
{
var strings = new JsonSerializerOptions { Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping };
var axis = candidate.AxisIndex!.Value; var prefix = "Source." + alias; var axisName = new[] { "X", "Y", "Z" }[axis];
static double Component(Point3D p, int i) => i switch { 0 => p.X, 1 => p.Y, _ => p.Z };
string Point(Point3D p, string? axial = null, bool? minimum = null) => "Point3(" + string.Join(", ", Enumerable.Range(0, 3).Select(i => i == axis
? prefix + "." + (axial ?? "center") + "." + axisName
: (minimum is { } min ? Outward(Component(p, i), min) : Nominal(Component(p, i))).ToString("0.#", CultureInfo.InvariantCulture) + "mm")) + ")";
string Bounds(ThroughHoleEditBounds b) => "{ min: " + Point(b.Min, "exit", true) + "; max: " + Point(b.Max, "entry", false) + " }";
var operation = destination is null ? "Remove " + prefix + " {\n within: " + Bounds(within) + "\n }"
: $"Replace {prefix} with Hole<Shaft> {alias} {{\n on: Source.Face(\"#{entryEntity}\")\n center: {Point(center!.Value)}\n diameter: {prefix}.diameter\n end: ThroughAll\n within: [{Bounds(within)}, {Bounds(destination)}]\n }}";
return $$"""
// New in-plane positions use a 0.1mm grid. Source size/supports remain exact.
Model ImportedRevision {
units: mm
InlineStep Source {
path: {{JsonSerializer.Serialize(path)}}
textSha256: "{{inspection.SourceHash}}"
importTolerance: {{inspection.Discovery.ImportToleranceMillimetres.ToString("R", CultureInfo.InvariantCulture)}}mm
geometryOnly: true
}
Recognize Source {
Region {{alias}} { kind: HoleShaft; candidate: {{JsonSerializer.Serialize(candidate.Id, strings)}}; }
}
{{operation}}
}
""";
}
static string Emit(ImportedFeatureInspection inspection, string candidate, string alias,
string path, int entryEntity, ThroughHoleRevisionRequest request)
{
static string N(double value) => Nominal(value).ToString("0.#", CultureInfo.InvariantCulture);
static string P(Point3D point) => $"Point3({N(point.X)}mm, {N(point.Y)}mm, {N(point.Z)}mm)";
static string B(ThroughHoleEditBounds bounds) => $"{{ min: {P(new(Outward(bounds.Min.X, true), Outward(bounds.Min.Y, true), bounds.Min.Z))}; max: {P(new(Outward(bounds.Max.X, false), Outward(bounds.Max.Y, false), bounds.Max.Z))} }}";
var target = "RevisionLayout.Targets." + alias;
var pad = N(Outward(request.DestinationWithin!.Max.X - request.Center.X, false));
var destinationBounds = $"{{ min: Point3({target}.X - {pad}mm, {target}.Y - {pad}mm, {N(request.Within.Min.Z)}mm); max: Point3({target}.X + {pad}mm, {target}.Y + {pad}mm, {N(request.Within.Max.Z)}mm) }}";
var strings = new JsonSerializerOptions { Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping };
return $$"""
// Recovery proves the admitted feature family, not the original modeling history.
// Authored lengths use a 0.1mm grid; numerical import accuracy is separate.
Model ImportedRevision {
units: mm
Concept Struct RevisionLayout {
Points<Point3> Targets { {{alias}}: {{P(request.Center)}}; }
}
InlineStep Source {
path: {{JsonSerializer.Serialize(path, strings)}}
textSha256: "{{inspection.SourceHash}}"
importTolerance: {{request.ImportToleranceMillimetres.ToString("R", CultureInfo.InvariantCulture)}}mm
geometryOnly: true
}
Recognize Source {
Region {{alias}} {
kind: HoleShaft
candidate: {{JsonSerializer.Serialize(candidate, strings)}}
}
}
Replace Source.{{alias}} with Hole<Shaft> {{alias}} {
on: Source.Face("#{{entryEntity}}")
center: RevisionLayout.Targets.{{alias}}
diameter: {{N(request.Diameter)}}mm
end: ThroughAll
within: [
{{B(request.Within)}},
{{destinationBounds}}
]
}
}
""";
}
static KernelResult<T> Failure<T>(string message) => KernelResult<T>.Failure([
new(KernelDiagnosticCode.ValidationFailed, KernelDiagnosticSeverity.Error,
"firmament-imported-feature-assistance-rejected: " + message, "Firmament.ImportedFeatures")]);
}