Next Gen STEP AP242 Native-ish BREP Geometric Modeling Kernel
import type { MeasurementRequest, MeasurementResult } from '@aetheris/three-telos';
import { reportDesktopDiagnostic } from "../desktopDiagnostics";
export interface DiagnosticDto {
code: string;
severity: string;
message: string;
source: string | null;
}
export interface ApiEnvelope<T> {
success: boolean;
data: T | null;
diagnostics: DiagnosticDto[];
}
export interface DocumentCreateResponseDto {
documentId: string;
name: string | null;
volatile: boolean;
}
export interface BodyOccurrenceSummaryDto {
occurrenceId: string;
definitionId: string;
name: string | null;
translation: Vector3Dto;
}
export interface DocumentSummaryResponseDto {
revision?: number;
documentId: string;
name: string | null;
bodyCount: number;
bodyIds: string[];
definitionCount: number;
occurrences: BodyOccurrenceSummaryDto[];
}
export interface BodyCreatedResponseDto {
documentId: string;
bodyId: string;
definitionId: string;
faceCount: number;
edgeCount: number;
vertexCount: number;
}
export interface BodyTransformedResponseDto {
documentId: string;
bodyId: string;
definitionId: string;
appliedTranslation: Vector3Dto;
}
export interface StepExportResponseDto {
documentId: string;
definitionId: string;
stepText: string;
canonicalHash: string;
diagnostics: DiagnosticDto[];
}
export interface StepImportResponseDto {
revision?: number;
documentId: string;
definitionId: string;
occurrenceId: string;
name: string | null;
diagnostics: DiagnosticDto[];
semanticPresentation?: unknown | null;
assemblyPresentation?: AssemblyDisplayPacketDto | null;
importStatus?: "Qualified" | "Inspectable" | "Degraded" | "Failed";
importQualifications?: unknown[];
}
export interface PaperclipDemoRequestDto {
wireDiameter: number;
outerLegLength: number;
innerLegLength: number;
outerBendRadius: number;
innerBendRadius: number;
material: string;
}
export interface PaperclipDemoResponseDto {
stepText: string;
specializationIdentity: string;
centerlineLength: number;
massGrams: number;
paperclipsPerMeter: number;
bounds: number[];
material: string;
manufacturable: boolean;
stepAp242: boolean;
deterministic: boolean;
}
export type ForgeArtifactKindDto = "StepAp242" | "FlatStep" | "Svg" | "CutListJson";
export interface ForgeTemplateParameterDto { name: string; type: string; required: boolean; default?: string | null; dimension?: string | null; unit?: string | null; allowedValues?: string[] | null; fields?: ForgeTemplateParameterDto[] | null; category: string; constraint?: string | null; }
export interface ForgeTemplateDescriptionDto { id: string; displayName: string; version: string; documentation: string; parameters: ForgeTemplateParameterDto[]; artifacts: ForgeArtifactKindDto[]; signature: string; outputKind: string; constraints: { name: string; expression: string }[]; }
export interface GalleryArtifactDto { kind: ForgeArtifactKindDto; name: string; exportPath?: string | null; contentType: string; size: number; sha256: string; content: string; }
export interface GalleryInvocationResponseDto { success: boolean; identity: { template: string; templateVersion: string; specialization?: string | null }; diagnostics: { code: string; severity: string; message: string; target?: string | null }[]; artifacts: GalleryArtifactDto[]; executionMilliseconds: number; }
export type BooleanOperation = "union" | "subtract" | "intersect";
export interface BooleanRequestDto {
leftBodyId: string;
rightBodyId: string;
operation: BooleanOperation;
}
export interface Point3Dto {
x: number;
y: number;
z: number;
}
export interface Vector3Dto {
x: number;
y: number;
z: number;
}
export interface FacePatchDto {
faceId: number;
positions: Point3Dto[];
normals: Vector3Dto[];
triangleIndices: number[];
}
export interface EdgePolylineDto {
edgeId: number;
points: Point3Dto[];
isClosed: boolean;
}
export interface TessellationResponseDto {
facePatches: FacePatchDto[];
edgePolylines: EdgePolylineDto[];
}
export interface AnalyticDisplayFaceDomainHintDto {
minU?: number | null;
maxU?: number | null;
minV: number | null;
maxV: number | null;
}
export interface StartupStepDto {
path: string;
fileName: string;
stepText: string;
kind?: "step" | "assembly";
}
export interface DisplayFaceSourceDto {
faceId: number;
sourceStepEntityId: number | null;
surfaceKind: string;
edgeIds: number[];
}
export interface AssemblyDisplayDefinitionDto {
stableId: string;
definitionIdentity: string;
facePatches: FacePatchDto[];
edgePolylines?: EdgePolylineDto[];
faceSources?: DisplayFaceSourceDto[];
}
export interface AssemblyDisplayOccurrenceDto {
stableId: string;
name: string;
instancePath: string;
parentStableId: string | null;
definitionStableId: string | null;
kind: "Assembly" | "Part";
worldTransform: number[];
placementAuthority: "MateDerived" | "ImportedOccurrence" | "LegacyExplicit";
selectionMembers?: string[];
}
export interface AssemblyDisplayPublicSemanticDto {
name: string;
type: string;
capabilities: string[];
bindingKinds: string[];
internalImplementationPath: string | null;
}
export interface AssemblyDisplayModuleDefinitionDto {
stableId: string;
definitionIdentity: string;
templateName: string;
specializationIdentity: string;
provenance: string[];
publicSemantics: AssemblyDisplayPublicSemanticDto[];
localSolveMilliseconds: number;
}
export interface AssemblyDisplayMateDto {
stableId: string;
name: string;
interfaceStableId: string;
participants: string[];
constraintIds: string[];
validationStatus: string;
}
export interface AssemblyDisplayToleranceDto {
name: string;
passed: boolean;
nominal: number;
minimum: number;
maximum: number;
unit: string;
contributors: string[];
expandedContributors?: string[];
}
export interface AssemblyDisplayPacketDto {
display?: import('@aetheris/three-telos').DisplayPacket & { cameras?: readonly { name: string; transform: readonly number[]; lookAtMm?: readonly number[]; fovDegrees: number }[] };
schema: string;
name: string;
rootOccurrenceStableId: string;
definitions: AssemblyDisplayDefinitionDto[];
occurrences: AssemblyDisplayOccurrenceDto[];
mates: AssemblyDisplayMateDto[];
toleranceStackups: AssemblyDisplayToleranceDto[];
bounds: { minimum: number[]; maximum: number[] };
diagnostics: DisplayDiagnosticDto[];
performance: Record<string, number>;
moduleDefinitions?: AssemblyDisplayModuleDefinitionDto[];
}
export interface AnalyticDisplayPlaneGeometryDto {
origin: Point3Dto;
normal: Vector3Dto;
uAxis: Vector3Dto;
vAxis: Vector3Dto;
outerBoundary: Point3Dto[] | null;
}
export interface AnalyticDisplayCylinderGeometryDto {
origin: Point3Dto;
axis: Vector3Dto;
xAxis: Vector3Dto;
yAxis: Vector3Dto;
radius: number;
}
export interface AnalyticDisplayConeGeometryDto {
apex: Point3Dto;
axis: Vector3Dto;
xAxis: Vector3Dto;
yAxis: Vector3Dto;
semiAngleRadians: number;
}
export interface AnalyticDisplaySphereGeometryDto {
center: Point3Dto;
axis: Vector3Dto;
xAxis: Vector3Dto;
yAxis: Vector3Dto;
radius: number;
}
export interface AnalyticDisplayTorusGeometryDto {
center: Point3Dto;
axis: Vector3Dto;
xAxis: Vector3Dto;
yAxis: Vector3Dto;
majorRadius: number;
minorRadius: number;
}
export interface AnalyticDisplayFaceDto {
faceId: number;
shellId: number;
shellRole: "Outer" | "InnerVoid" | "Unknown";
surfaceGeometryId: number;
surfaceKind: "Plane" | "Sphere" | "Cylinder" | "Cone" | "Torus" | string;
loopCount: number;
domainHint: AnalyticDisplayFaceDomainHintDto | null;
planeGeometry: AnalyticDisplayPlaneGeometryDto | null;
cylinderGeometry: AnalyticDisplayCylinderGeometryDto | null;
coneGeometry: AnalyticDisplayConeGeometryDto | null;
sphereGeometry: AnalyticDisplaySphereGeometryDto | null;
torusGeometry: AnalyticDisplayTorusGeometryDto | null;
}
export interface AnalyticDisplayFallbackFaceDto {
faceId: number;
shellId: number;
shellRole: "Outer" | "InnerVoid" | "Unknown";
reason:
| "MissingFaceBinding"
| "MissingSurfaceGeometry"
| "UnsupportedSurfaceKind"
| "UnsupportedTrim"
| string;
surfaceKind: string | null;
detail: string | null;
}
export interface AnalyticDisplayPacketDto {
bodyId: number;
analyticFaces: AnalyticDisplayFaceDto[];
fallbackFaces: AnalyticDisplayFallbackFaceDto[];
}
export interface DisplayDiagnosticDto {
code: string;
message: string;
faceId: number | null;
surfaceKind: string | null;
phase: string | null;
suggestedNextAction: string | null;
}
export interface DisplayWirePatchDto {
kind: "WirePatch" | string;
source: "BRepEdges" | string;
quality: "PreviewPolyline" | string;
loops: DisplayLoopDto[];
}
export interface DisplayLoopDto {
loopId: number;
role: "Outer" | "Inner" | "Unknown" | string;
edges: DisplayEdgeDto[];
}
export interface DisplayEdgeDto {
edgeId: number;
points: Point3Dto[];
sourceCurveKind: string;
sampleCount: number;
diagnostics: DisplayDiagnosticDto[];
}
export interface DisplayFaceDto {
source?: DisplayFaceSourceDto | null;
faceId: number;
shellId: number | null;
surfaceKind: string | null;
status:
| "Analytic"
| "Mesh"
| "WireframeOnly"
| "BoundingProxy"
| "DiagnosticOnly"
| "Omitted"
| string;
patchKind:
| "AnalyticPatch"
| "MeshPatch"
| "WirePatch"
| "ProxyPatch"
| "DiagnosticPatch"
| string;
meshPatch: FacePatchDto | null;
analyticPatch: AnalyticDisplayFaceDto | null;
wirePatch: DisplayWirePatchDto | null;
materializationLane?:
| "AnalyticPatch"
| "BoundedMesh"
| "DiagnosticOnly"
| "WirePatch"
| "ProxyPatch"
| string
| null;
diagnostics: DisplayDiagnosticDto[];
}
export interface DisplayLaneDto {
kind: "AnalyticPatch" | "BoundedMesh" | "DiagnosticOnly" | "WirePatch" | "ProxyPatch" | string;
status: "Complete" | "Partial" | "DiagnosticOnly" | "Failed" | string;
source: string;
displayAuthority: string;
implementation: string | null;
quality: string | null;
timeoutMs: number | null;
faceCount: number;
diagnosticCount: number;
}
export interface DisplayPreparationResponseDto {
topologyEdges?: EdgePolylineDto[] | null;
lane: "analytic-only" | "mixed-fallback" | "fallback-only" | string;
analyticPacket: AnalyticDisplayPacketDto;
tessellationFallback: TessellationResponseDto | null;
status?: "Complete" | "Partial" | "DiagnosticOnly" | "Failed" | string;
sourceAuthority?: string;
displayAuthority?: string;
lanes?: string[] | null;
faces?: DisplayFaceDto[] | null;
diagnostics?: DisplayDiagnosticDto[] | null;
displayLanes?: DisplayLaneDto[] | null;
}
export interface CadmataVisualizationArtifactDto {
schemaVersion: "cadmata-concept-viz-x1";
fixtureId: string;
sourcePath: string;
entities: unknown[];
selections: unknown[];
diagnostics: unknown[];
metrics: Record<string, number>;
}
export interface CadmataFixtureLoadResponseDto {
documentId: string;
bodyId: string;
definitionId: string;
fixtureId: string;
visualization: CadmataVisualizationArtifactDto;
}
export interface PickOptionsDto {
nearestOnly?: boolean;
includeBackfaces?: boolean;
edgeTolerance?: number;
sortTieTolerance?: number;
maxDistance?: number;
}
export interface PickRequestDto {
origin: Point3Dto;
direction: Vector3Dto;
tessellationOptions: null;
pickOptions: PickOptionsDto;
}
export interface PickHitDto {
occurrenceId: string;
t: number;
point: Point3Dto;
normal: Vector3Dto | null;
entityKind: "Face" | "Edge";
faceId: number | null;
edgeId: number | null;
bodyId: number | null;
sourcePatchIndex: number | null;
sourcePrimitiveIndex: number | null;
}
export interface PickResponseDto {
hits: PickHitDto[];
}
export class ApiError extends Error {
public readonly diagnostics: DiagnosticDto[];
public constructor(message: string, diagnostics: DiagnosticDto[]) {
super(message);
this.name = "ApiError";
this.diagnostics = diagnostics;
}
}
async function parseEnvelope<T>(response: Response): Promise<T> {
let envelope: ApiEnvelope<T>;
try {
envelope = (await response.json()) as ApiEnvelope<T>;
} catch {
throw new ApiError(`Invalid JSON response (HTTP ${response.status}).`, []);
}
if (!envelope.success || envelope.data === null) {
const diagnostics = envelope.diagnostics ?? [];
const firstMessage = diagnostics[0]?.message ?? `Request failed with HTTP ${response.status}.`;
throw new ApiError(firstMessage, diagnostics);
}
return envelope.data;
}
async function request<T>(path: string, init: RequestInit): Promise<T> {
const response = await fetch(path, {
...init,
headers: {
"Content-Type": "application/json",
...(init.headers ?? {}),
},
});
try {
const result = await parseEnvelope<T>(response);
if (result && typeof result === "object" && "diagnostics" in result
&& Array.isArray(result.diagnostics) && result.diagnostics.length > 0)
reportDesktopDiagnostic("CAD diagnostics", { path, status: response.status, diagnostics: result.diagnostics });
if (/import\/step|export\/step|assembly/.test(path))
reportDesktopDiagnostic("CAD request", { path, status: response.status });
return result;
} catch (error) {
reportDesktopDiagnostic("CAD request failed", { path, status: response.status, message: String(error),
diagnostics: error instanceof ApiError ? error.diagnostics : [] });
throw error;
}
}
export async function createDocument(name?: string): Promise<DocumentCreateResponseDto> {
return request<DocumentCreateResponseDto>("/api/v1/documents", {
method: "POST",
body: JSON.stringify({ name: name ?? null }),
});
}
export async function getDocumentSummary(documentId: string): Promise<DocumentSummaryResponseDto> {
return request<DocumentSummaryResponseDto>(`/api/v1/documents/${documentId}`, {
method: "GET",
});
}
export async function createBox(
documentId: string,
width: number,
height: number,
depth: number,
): Promise<BodyCreatedResponseDto> {
return request<BodyCreatedResponseDto>(`/api/v1/documents/${documentId}/bodies/primitives/box`, {
method: "POST",
body: JSON.stringify({ width, height, depth }),
});
}
export async function tessellateBody(
documentId: string,
bodyId: string,
): Promise<TessellationResponseDto> {
return request<TessellationResponseDto>(
`/api/v1/documents/${documentId}/bodies/${bodyId}/tessellate`,
{
method: "POST",
body: JSON.stringify({ options: null }),
},
);
}
export async function prepareBodyDisplay(
documentId: string,
bodyId: string,
): Promise<DisplayPreparationResponseDto> {
return request<DisplayPreparationResponseDto>(
`/api/v1/documents/${documentId}/bodies/${bodyId}/display/prepare`,
{
method: "POST",
body: JSON.stringify({ tessellationOptions: null }),
},
);
}
export async function loadCadmataFixture(
documentId: string,
fixtureId: string,
): Promise<CadmataFixtureLoadResponseDto> {
return request<CadmataFixtureLoadResponseDto>(
`/api/v1/documents/${documentId}/cadmata/fixtures/${fixtureId}`,
{ method: "POST" },
);
}
export async function pickBody(
documentId: string,
bodyId: string,
pickRequest: PickRequestDto,
): Promise<PickResponseDto> {
return request<PickResponseDto>(`/api/v1/documents/${documentId}/bodies/${bodyId}/pick`, {
method: "POST",
body: JSON.stringify(pickRequest),
});
}
export async function translateBody(
documentId: string,
bodyId: string,
translation: Vector3Dto,
): Promise<BodyTransformedResponseDto> {
return request<BodyTransformedResponseDto>(
`/api/v1/documents/${documentId}/bodies/${bodyId}/transform`,
{
method: "POST",
body: JSON.stringify({ translation }),
},
);
}
export async function executeBoolean(
documentId: string,
requestDto: BooleanRequestDto,
): Promise<BodyCreatedResponseDto> {
return request<BodyCreatedResponseDto>(`/api/v1/documents/${documentId}/operations/boolean`, {
method: "POST",
body: JSON.stringify(requestDto),
});
}
export async function exportDefinitionStep(
documentId: string,
definitionId: string,
): Promise<StepExportResponseDto> {
return request<StepExportResponseDto>(
`/api/v1/documents/${documentId}/definitions/${definitionId}/export/step`,
{
method: "GET",
},
);
}
export async function importStep(
documentId: string,
stepText: string,
name?: string,
): Promise<StepImportResponseDto> {
return request<StepImportResponseDto>(`/api/v1/documents/${documentId}/import/step`, {
method: "POST",
body: JSON.stringify({ stepText, name: name ?? null }),
});
}
export function composeBlock(dimensions: { width: number; depth: number; height: number; padWidth: number; padDepth: number; padHeight: number }) {
return request<{ stepText: string; exportPath: string; source: string; materializationRoute: string }>("/api/v1/demos/composed-block", {
method: "POST", body: JSON.stringify(dimensions),
});
}
export async function claimStartupStep(): Promise<StartupStepDto | null> {
const response = await fetch("/api/v1/startup/step", { method: "POST" });
if (response.status === 204) {
return null;
}
return parseEnvelope<StartupStepDto>(response);
}
export async function maximizePaperclips(
parameters: PaperclipDemoRequestDto,
): Promise<PaperclipDemoResponseDto> {
return request<PaperclipDemoResponseDto>("/api/v1/demos/maximum-paperclips", {
method: "POST",
body: JSON.stringify(parameters),
});
}
export async function listGalleryTemplates(): Promise<ForgeTemplateDescriptionDto[]> {
return request<ForgeTemplateDescriptionDto[]>("/api/v1/gallery/templates", {});
}
export async function invokeGalleryTemplate(templateId: string, parameters: Record<string, unknown>, artifacts: ForgeArtifactKindDto[], exportPath?: string): Promise<GalleryInvocationResponseDto> {
return request<GalleryInvocationResponseDto>(`/api/v1/gallery/templates/${encodeURIComponent(templateId)}`, {
method: "POST", body: JSON.stringify({ arguments: parameters, artifacts, exportPath }),
});
}
export async function prepareAssemblyDisplay(path: string): Promise<AssemblyDisplayPacketDto> {
return request<AssemblyDisplayPacketDto>("/api/v1/assemblies/display", {
method: "POST",
body: JSON.stringify({ path }),
});
}
export { parseEnvelope };
export async function measureDocument(documentId: string, revision: number, measurement: MeasurementRequest): Promise<MeasurementResult> {
const reply = await request<{ revision: number; measurement: MeasurementResult }>(`/api/v1/documents/${documentId}/measure`, {
method: 'POST', body: JSON.stringify({ revision, measurement }),
});
if (reply.revision !== revision) throw new Error('The measurement belongs to a different document revision.');
return reply.measurement;
}