geospec 0.0.0 → 0.1.0-beta.3

package/dist/mesh/types.d.mts

@@ -0,0 +1,575 @@
+import { GeoSpecUnit } from "../geometry-unit.mjs";
+import { XdeReadResult } from "../step/types.mjs";
+import { JSONValue, KernelIssueCode } from "@taucad/runtime/types";
+//#region src/mesh/types.d.ts
+/**
+ * Numeric 3D vector.
+ *
+ * @public
+ */
+type Vec3 = readonly [number, number, number];
+/**
+ * Geometry file formats supported by the P0 mesh loader.
+ *
+ * @public
+ */
+type MeshFileFormat = 'glb' | 'gltf' | 'mesh-buffer';
+/**
+ * Geometry file formats understood by GeoSpec provenance.
+ *
+ * @public
+ */
+type GeometryFileFormat = MeshFileFormat | 'step' | 'stp';
+/**
+ * Source metadata for a loaded geometry subject.
+ *
+ * @public
+ */
+type GeometrySource = {
+  kind: 'bytes' | 'array-buffer' | 'blob' | 'file' | 'path' | 'url' | 'mesh-buffer' | 'readable-stream' | 'async-iterable';
+  format: GeometryFileFormat;
+  path?: string;
+  name?: string;
+  byteLength?: number;
+};
+/**
+ * Runtime export intent recorded when GeoSpec obtains evidence from a CAD
+ * runtime instead of a direct geometry file.
+ *
+ * @public
+ */
+type GeometryExportIntent = {
+  requested: {
+    format: GeometryFileFormat;
+    coordinateSystem?: 'y-up' | 'z-up';
+    unit?: {
+      length?: 'meter' | 'millimeter';
+    };
+    tessellation?: {
+      linearTolerance?: number;
+      angularToleranceDegrees?: number;
+    };
+  };
+  honored?: {
+    format: GeometryFileFormat;
+    coordinateSystem?: 'y-up' | 'z-up';
+    unit?: {
+      length?: 'meter' | 'millimeter';
+    };
+    tessellation?: {
+      linearTolerance?: number;
+      angularToleranceDegrees?: number;
+    };
+    sourceUnit?: GeoSpecUnit;
+  };
+  route?: {
+    kernelId?: string;
+    sourceFormat?: string;
+    targetFormat?: string;
+    transcoderId?: string;
+    fidelity?: 'mesh' | 'brep' | (string & {});
+    direct: boolean;
+  };
+};
+/**
+ * Provenance recorded by GeoSpec loaders. Tau runtime still emits geometry
+ * bytes/files; GeoSpec records how those bytes were consumed.
+ *
+ * @public
+ */
+type GeometryProvenance = {
+  source: GeometrySource;
+  unit: GeoSpecUnit;
+  loader: 'gltf-transform' | 'in-memory' | 'opencascade-step';
+  contentHash?: string;
+  parameters?: Record<string, JSONValue>;
+  exportIntent?: GeometryExportIntent;
+};
+/**
+ * Capability exposed by a loaded subject.
+ *
+ * @public
+ */
+type GeometryCapability = {
+  kind: 'mesh';
+  feature: 'triangles' | 'bounding-box' | 'connected-components' | 'watertightness' | 'surface-area' | 'volume' | 'center-of-mass' | 'distance' | 'component-overlap';
+} | {
+  kind: 'brep';
+  feature: 'validity' | 'topology-counts' | 'bounding-box' | 'mass-properties' | 'planar-faces' | 'cylindrical-faces' | 'circular-holes' | 'circular-hole-patterns' | 'chamfer-features' | 'fillet-features' | 'wall-thickness';
+} | {
+  kind: 'step';
+  feature: 'schema' | 'units' | 'product-structure' | 'reader-provenance';
+} | {
+  kind: 'unsupported';
+  feature: string;
+  reason: string;
+};
+/**
+ * Diagnostic emitted by GeoSpec loaders, analyzers, and matchers.
+ *
+ * @public
+ */
+type GeometryDiagnostic = {
+  code: KernelIssueCode | (string & {});
+  severity: 'error' | 'warning' | 'info';
+  message: string;
+  suggestion?: string;
+  spatial?: {
+    min?: Vec3;
+    max?: Vec3;
+    center?: Vec3;
+  };
+  details?: unknown;
+};
+/** Diagnostic form permitted inside a wire-safe subject snapshot. @public */
+type GeometryEvidenceDiagnostic = Omit<GeometryDiagnostic, 'details'> & {
+  details?: JSONValue;
+};
+/**
+ * Mesh evidence loaded from geometry bytes or buffers.
+ *
+ * @public
+ */
+type MeshEvidence = {
+  format: MeshFileFormat;
+  stats: GeometryStats;
+};
+/** Wire-safe mesh summary carried by an opaque geometry subject. @public */
+type GeometrySubjectMeshEvidence = {
+  format: MeshFileFormat;
+  stats: Pick<GeometryStats, 'vertexCount' | 'meshCount' | 'triangleCount'>;
+};
+/**
+ * One triangle from mesh evidence, in geometry document coordinates.
+ *
+ * @public
+ */
+type MeshTriangle = {
+  primitive: string;
+  triangleIndex: number;
+  a: [number, number, number];
+  b: [number, number, number];
+  c: [number, number, number];
+  center: [number, number, number];
+  area: number;
+};
+/**
+ * Basic exact or topology-derived BRep evidence consumed by early feature
+ * matchers. Loaders may provide any subset; matchers report unsupported
+ * diagnostics when the required evidence is absent.
+ *
+ * @public
+ */
+type BrepEvidence = {
+  validity?: {
+    valid: boolean;
+    checks?: Array<{
+      shape: string;
+      status: string;
+    }>;
+    maxTolerance?: number;
+    freeBounds?: {
+      count: number;
+    };
+    smallEdges?: Array<{
+      length: number;
+      shape?: string;
+      location?: Vec3;
+    }>;
+    sameParameter?: boolean;
+    closedShells?: boolean;
+    closedSolids?: boolean;
+    solidCount?: number;
+    invalidSolidCount?: number;
+    openEdgeCount?: number;
+    reason?: string;
+    closedWires?: boolean;
+  };
+  topologyCounts?: {
+    vertices?: number;
+    edges?: number;
+    wires?: number;
+    faces?: number;
+    shells?: number;
+    solids?: number;
+    compounds?: number;
+  };
+  boundingBox?: {
+    min: Vec3;
+    max: Vec3;
+    size: Vec3;
+    center: Vec3;
+  };
+  massProperties?: {
+    surfaceArea?: number;
+    volume?: number;
+    centerOfMass?: Vec3;
+    mass?: number;
+  };
+  planarFaces?: Array<{
+    normal: Vec3;
+    offset: number;
+    area?: number;
+    center?: Vec3;
+  }>;
+  cylindricalFaces?: Array<{
+    radius: number;
+    axis: 'x' | 'y' | 'z';
+    center?: Vec3;
+    axisRange?: {
+      min: number;
+      max: number;
+    };
+  }>;
+  circularHoles?: Array<{
+    diameter: number;
+    through: boolean;
+    axis: 'x' | 'y' | 'z';
+    center?: Vec3;
+    axisRange?: {
+      min: number;
+      max: number;
+    };
+  }>;
+  circularHolePatterns?: Array<{
+    count: number;
+    holeDiameter: number;
+    boltCircleDiameter: number;
+    axis: 'x' | 'y' | 'z';
+    center?: Vec3;
+  }>;
+  chamferFeatures?: Array<{
+    distance: number;
+    selection?: string;
+  }>;
+  filletFeatures?: Array<{
+    radius: number;
+    selection?: string;
+  }>;
+  minimumWallThickness?: {
+    value: number;
+    location?: Vec3;
+    pointA?: Vec3;
+    pointB?: Vec3;
+    solidIndex?: number;
+    tieCount?: number;
+    algorithm?: string;
+    tolerance?: number;
+    supportA?: {
+      faceIndex?: number;
+      surfaceType?: string;
+      supportType?: string;
+    };
+    supportB?: {
+      faceIndex?: number;
+      surfaceType?: string;
+      supportType?: string;
+    };
+    rejections?: Record<string, number>;
+  };
+};
+/**
+ * STEP/XDE evidence extracted while loading a STEP subject.
+ *
+ * @public
+ */
+type StepEvidence = {
+  schema?: string;
+  unit?: GeoSpecUnit;
+  productStructure?: Array<{
+    name: string;
+    path: string;
+    transform?: number[];
+  }>;
+  readStrategy: {
+    strategy: 'native-stream' | 'filesystem';
+    inputKind: GeometrySource['kind'];
+    bytesRead: number;
+    nativeReadStream: boolean;
+    copiedToEmscriptenFs: boolean;
+  };
+  capabilities: Array<{
+    feature: string;
+    supported: boolean;
+    reason?: string;
+  }>;
+  /** Structured AP242 XDE read result (occurrences, subshape names, datum placements). */
+  xde?: XdeReadResult;
+};
+/**
+ * Canonical P0 object under test for GeoSpec.
+ *
+ * This is intentionally a GeoSpec-loaded subject rather than a Tau runtime
+ * contract. Runtime integrations pass GLB/glTF bytes or files into loaders.
+ *
+ * @public
+ */
+type GeometrySubject = {
+  kind: 'geometry-subject';
+  /** Opaque engine-owned identifier used by every protocol claim. */
+  subjectId: string;
+  mesh: GeometrySubjectMeshEvidence;
+  brep?: BrepEvidence;
+  step?: StepEvidence;
+  provenance: GeometryProvenance;
+  capabilities: GeometryCapability[];
+  diagnostics: GeometryEvidenceDiagnostic[];
+};
+/**
+ * Axis-aligned bounding box in glTF document units (meters).
+ * @public
+ */
+type AabbMeters = {
+  min: [number, number, number];
+  max: [number, number, number];
+};
+/**
+ * One TRIANGLES primitive with identity for spatial-test feedback.
+ * @public
+ */
+type PrimitiveRecord = {
+  /** The glTF node / mesh name (from kernel ShapeConfig.name when present). */
+  name: string;
+  color?: string;
+  vertices: number;
+  aabb: AabbMeters;
+};
+/**
+ * One spatial cluster from AABB overlap grouping.
+ * @public
+ */
+type ClusterReport = {
+  label: string;
+  primitives: PrimitiveRecord[];
+  aabb: AabbMeters;
+  centroid: [number, number, number];
+  totalVertices: number;
+};
+/**
+ * Smallest clearance between two clusters along the dominant separation axis.
+ * @public
+ */
+type ClusterGap = {
+  fromLabel: string;
+  toLabel: string;
+  axis: 'x' | 'y' | 'z';
+  /** Millimetres — clearance between the two named primitives' AABBs. */
+  gapMm: number;
+  fromPrimitive: string;
+  toPrimitive: string;
+};
+/**
+ * Structured payload when `connectedComponents` fails.
+ * @public
+ */
+type ConnectedComponentsFailure = {
+  expected: number;
+  got: number;
+  toleranceMm: number;
+  clusters: ClusterReport[];
+  gaps: ClusterGap[];
+};
+/**
+ * Dominant primitive on an axis extremum for `boundingBox` failures.
+ * @public
+ */
+type BoundingBoxAxisExtremum = {
+  name: string;
+  aabb: AabbMeters;
+  value: number;
+};
+/**
+ * One axis failure for `boundingBox` checks.
+ * @public
+ */
+type BoundingBoxAxisFailure = {
+  axis: 'x' | 'y' | 'z';
+  field: 'size' | 'center';
+  expected: number;
+  actual: number;
+  tolerance: number;
+  minExtremum?: BoundingBoxAxisExtremum;
+  maxExtremum?: BoundingBoxAxisExtremum;
+};
+/**
+ * Structured payload when `boundingBox` fails.
+ * @public
+ */
+type BoundingBoxFailure = {
+  axisFailures: BoundingBoxAxisFailure[];
+};
+/**
+ * Per-primitive watertight diagnostic (local tessellation only).
+ * @public
+ */
+type WatertightPrimitiveBreakdown = {
+  name: string;
+  boundaryEdges: number;
+  loopCentroid: [number, number, number];
+};
+/**
+ * Class of irregular mesh edge found during watertight analysis.
+ * @public
+ */
+type WatertightIrregularEdgeKind = 'open-boundary' | 'non-manifold';
+/**
+ * Representative irregular edge, in glTF document coordinates.
+ * @public
+ */
+type WatertightIrregularEdgeSample = {
+  start: Vec3;
+  end: Vec3;
+  center: Vec3;
+  incidentTriangleCount: number;
+  primitives: string[];
+  color?: string;
+};
+/**
+ * Spatial cluster of related irregular edges.
+ * @public
+ */
+type WatertightIrregularEdgeCluster = {
+  kind: WatertightIrregularEdgeKind;
+  edgeCount: number;
+  aabb: {
+    min: Vec3;
+    max: Vec3;
+    center: Vec3;
+  };
+  samples: WatertightIrregularEdgeSample[];
+};
+/**
+ * Structured payload when `watertight` fails.
+ * @public
+ */
+type WatertightFailure = {
+  /** Edges with incidence ≠ 2 (open or non-manifold). */
+  irregularEdges: number;
+  /** Edges shared by exactly one triangle (open boundary). */
+  openBoundaryEdges: number;
+  /** Edges shared by more than two triangles (over-adjacent/non-manifold). */
+  nonManifoldEdges: number;
+  irregularEdgeKindCounts: {
+    openBoundary: number;
+    nonManifold: number;
+  };
+  irregularEdgeClusters: WatertightIrregularEdgeCluster[];
+  irregularEdgeFraction: number;
+  perPrimitive: WatertightPrimitiveBreakdown[];
+};
+/**
+ * Full connected-components analysis at one tolerance.
+ * @public
+ */
+type ConnectedComponentsResult = {
+  count: number;
+  clusters: ClusterReport[];
+  gaps: ClusterGap[];
+};
+/**
+ * Full watertight analysis (global + per-primitive breakdown).
+ * @public
+ */
+type WatertightResult = {
+  watertight: boolean;
+  irregularEdges: number;
+  openBoundaryEdges: number;
+  nonManifoldEdges: number;
+  irregularEdgeKindCounts: {
+    openBoundary: number;
+    nonManifold: number;
+  };
+  irregularEdgeClusters: WatertightIrregularEdgeCluster[];
+  totalEdges: number;
+  irregularEdgeFraction: number;
+  perPrimitive: WatertightPrimitiveBreakdown[];
+};
+/**
+ * Triangle quality and scalar mesh metrics used by P0 GeoSpec matchers.
+ *
+ * Values are reported in the glTF document coordinate units.
+ *
+ * @public
+ */
+type MeshQualityStats = {
+  triangleCount: number;
+  nonFiniteVertices: Array<{
+    primitive: string;
+    vertexIndex: number;
+    position: [number, number, number];
+  }>;
+  degenerateTriangles: Array<{
+    primitive: string;
+    triangleIndex: number;
+    area: number;
+    center: [number, number, number];
+  }>;
+  duplicateFaces: Array<{
+    primitive: string;
+    triangleIndex: number;
+    firstTriangleIndex: number;
+  }>;
+  triangles: MeshTriangle[];
+  surfaceArea: number;
+  signedVolume: number;
+  centerOfMass?: Vec3;
+};
+/**
+ * Scene bounding box with per-primitive contributors in the subject's unit and frame.
+ * @public
+ */
+type BoundingBoxStats = {
+  size: [number, number, number];
+  center: [number, number, number];
+  primitives: PrimitiveRecord[];
+};
+/**
+ * Statistics about a parsed GLB geometry.
+ *
+ * `vertexCount` and `meshCount` are kept on the type for internal diagnostic
+ * use (and for the kernel-author Vitest harness in
+ * `kernel-geometry-testing.utils.ts`); they are no longer exposed via the
+ * agent-facing requirement schema.
+ *
+ * @public
+ */
+type GeometryStats = {
+  vertexCount: number;
+  meshCount: number;
+  triangleCount: number;
+  meshQuality: MeshQualityStats;
+  watertight: boolean;
+  boundingBox?: BoundingBoxStats;
+};
+/**
+ * Result of evaluating a single test requirement against geometry stats.
+ * @public
+ */
+type CheckResult = {
+  passed: true;
+} | {
+  passed: false;
+  check: 'boundingBox';
+  reason: string;
+  suggestion: string;
+  failure: BoundingBoxFailure;
+} | {
+  passed: false;
+  check: 'connectedComponents';
+  reason: string;
+  suggestion: string;
+  failure: ConnectedComponentsFailure;
+} | {
+  passed: false;
+  check: 'watertight';
+  reason: string;
+  suggestion: string;
+  failure: WatertightFailure;
+} | {
+  passed: false;
+  check: 'invalid';
+  reason: string;
+  suggestion: string;
+};
+//#endregion
+export { AabbMeters, BoundingBoxAxisExtremum, BoundingBoxAxisFailure, BoundingBoxFailure, BoundingBoxStats, BrepEvidence, CheckResult, ClusterGap, ClusterReport, ConnectedComponentsFailure, ConnectedComponentsResult, GeometryCapability, GeometryDiagnostic, GeometryEvidenceDiagnostic, GeometryExportIntent, GeometryFileFormat, GeometryProvenance, GeometrySource, GeometryStats, GeometrySubject, GeometrySubjectMeshEvidence, MeshEvidence, MeshFileFormat, MeshQualityStats, MeshTriangle, PrimitiveRecord, StepEvidence, Vec3, WatertightFailure, WatertightIrregularEdgeCluster, WatertightIrregularEdgeKind, WatertightIrregularEdgeSample, WatertightPrimitiveBreakdown, WatertightResult };

package/dist/model/errors.d.mts

@@ -0,0 +1,20 @@
+import { GeometryDiagnostic } from "../mesh/types.mjs";
+import { z } from "zod";
+//#region src/model/errors.d.ts
+/**
+ * Error thrown by {@link import('./load-model.js').loadModel} when geometry cannot be loaded.
+ *
+ * @public
+ */
+declare class GeoSpecModelLoadError extends Error {
+  /** Structured diagnostics explaining why model loading failed. */
+  readonly diagnostics: readonly GeometryDiagnostic[];
+  /**
+   * Create a model-load error from structured diagnostics.
+   *
+   * @param diagnostics - Geometry diagnostics to expose to callers.
+   */
+  constructor(diagnostics: readonly GeometryDiagnostic[]);
+}
+//#endregion
+export { GeoSpecModelLoadError };

package/dist/model/errors.mjs

@@ -0,0 +1,2 @@
+import{isGeoSpecJsonValue as e}from"../engine/protocol.mjs";import{z as t}from"zod";const n=t.tuple([t.number(),t.number(),t.number()]),r=t.strictObject({code:t.string(),severity:t.enum([`error`,`warning`,`info`]),message:t.string(),suggestion:t.string().optional(),spatial:t.strictObject({min:n.optional(),max:n.optional(),center:n.optional()}).optional(),details:t.unknown().optional()}),i=e=>{if(typeof e==`string`)return e;try{let t=JSON.stringify(e);return typeof t==`string`?t:`[unserializable diagnostic details]`}catch{return`[unserializable diagnostic details]`}},a=t=>{let n=t.details instanceof Error?{name:t.details.name,message:t.details.message}:t.details;return structuredClone({...t,...n===void 0?{}:{details:e(n)?n:i(n)}})},o=e=>{try{return structuredClone(e)}catch{return{...e,...e.details===void 0?{}:{details:i(e.details)}}}};var s=class extends Error{diagnostics;constructor(e){let t=e.map(e=>o(e));super(t.map(e=>e.message).join(`
+`)||`GeoSpec model load failed.`),this.name=`GeoSpecModelLoadError`,this.diagnostics=Object.freeze(t)}};export{s as GeoSpecModelLoadError,a as diagnosticForTransport,r as geometryDiagnosticSchema};

package/dist/model/export-intent.d.mts

@@ -0,0 +1,79 @@
+import { GeoSpecUnit } from "../geometry-unit.mjs";
+import { GeometryDiagnostic, GeometryExportIntent } from "../mesh/types.mjs";
+import { GeoSpecModelFormat, GeoSpecRuntimeClient } from "./types.mjs";
+import { ExportRoute } from "@taucad/runtime/types";
+//#region src/model/export-intent.d.ts
+/**
+ *
+ *
+ * @public
+ */
+type RuntimeBackedModelFormat = Exclude<GeoSpecModelFormat, 'mesh-buffer'>;
+/** Runtime route metadata used to decide whether a runtime export can honor GeoSpec evidence requirements.
+ *
+ * @public
+ */
+type GeoSpecExportRoute = Partial<ExportRoute> & {
+  kernelId?: string;
+  sourceFormat?: string;
+  targetFormat?: string;
+  transcoderId?: string;
+  fidelity?: string;
+  exportOptions?: {
+    schema?: {
+      properties?: Record<string, unknown>;
+    };
+    defaults?: Record<string, unknown>;
+  };
+};
+/** Runtime client shape for route-aware Tau runtimes.
+ *
+ * @public
+ */
+type RuntimeClientWithRoutes = GeoSpecRuntimeClient & {
+  bestRouteFor(format: string, options?: {
+    readonly kernelId?: string;
+  }): GeoSpecExportRoute | undefined;
+};
+/** Resolved runtime export request and provenance for a GeoSpec model load.
+ *
+ * @public
+ */
+type RuntimeExportIntent = {
+  options: Record<string, unknown>;
+  provenance: GeometryExportIntent;
+  sourceUnit: GeoSpecUnit;
+};
+/** Structured failure returned when a runtime cannot provide the requested GeoSpec evidence.
+ *
+ * @public
+ */
+type RuntimeExportIntentFailure = {
+  success: false;
+  diagnostics: GeometryDiagnostic[];
+};
+/**
+ * The matchers mesh evidence answers, as the GeoSpec authoring skill lists
+ * them (`packages/geospec/agent/geospec-authoring/SKILL.md`): bounds, volume,
+ * surface area, connected components and watertightness. Every other
+ * exact-feature matcher needs STEP BRep evidence.
+ *
+ * @public
+ */
+declare const geoSpecMeshEvidenceMatchers: readonly ["toHaveBoundingBox", "toHaveVolume", "toHaveSurfaceArea", "toHaveConnectedComponents", "toBeWatertight"];
+/** @public */
+declare const resolveRuntimeExportIntent: (options: {
+  runtime: GeoSpecRuntimeClient;
+  format: RuntimeBackedModelFormat;
+  meshLinearTolerance?: number;
+  meshAngularToleranceDegrees?: number;
+  /**
+   * The kernel that evaluates this source, when the host knows it. Routes are
+   * then chosen among that kernel's own, so a mesh-only kernel is told its
+   * BRep matchers are unsupported instead of being sent to another kernel's
+   * STEP route.
+   */
+  kernelId?: string;
+}) => RuntimeExportIntent | RuntimeExportIntentFailure;
+//#endregion
+export { GeoSpecExportRoute, RuntimeBackedModelFormat, RuntimeClientWithRoutes, RuntimeExportIntent, RuntimeExportIntentFailure, geoSpecMeshEvidenceMatchers, resolveRuntimeExportIntent };

package/dist/model/export-intent.mjs

@@ -0,0 +1 @@
+const e=new Set([`step`,`stp`]),t=[`toHaveBoundingBox`,`toHaveVolume`,`toHaveSurfaceArea`,`toHaveConnectedComponents`,`toBeWatertight`],n=(e,t)=>({format:e,coordinateSystem:`z-up`,unit:{length:`millimeter`},...t===void 0?{}:{tessellation:t}}),r=e=>e===void 0?{}:{tessellation:{...e.linearTolerance===void 0?{}:{linearTolerance:e.linearTolerance},...e.angularToleranceDegrees===void 0?{}:{angularTolerance:e.angularToleranceDegrees}}},i=e=>{let t=n(e.format,e.tessellation);return{options:e.exportOptions,sourceUnit:`mm`,provenance:{requested:t,honored:{format:t.format,coordinateSystem:`z-up`,unit:{length:`millimeter`},sourceUnit:`mm`,...e.tessellation===void 0?{}:{tessellation:e.tessellation}}}}},a=e=>e?{...e.kernelId===void 0?{}:{kernelId:e.kernelId},...e.sourceFormat===void 0?{}:{sourceFormat:e.sourceFormat},...e.targetFormat===void 0?{}:{targetFormat:e.targetFormat},...e.transcoderId===void 0?{}:{transcoderId:e.transcoderId},...e.fidelity===void 0?{}:{fidelity:e.fidelity},direct:d(e)}:void 0,o=`loadModel({ file, format: 'glb' }) with mesh-supported matchers (${t.join(`, `)})`,s=e=>({success:!1,diagnostics:[{code:`GEOSPEC_KERNEL_BREP_UNSUPPORTED`,severity:`error`,message:`${e.kernelId===void 0?`No kernel in this runtime`:`Kernel '${e.kernelId}'`} has no direct STEP/BRep export route, so exact BRep evidence is unavailable and BRep matchers are unsupported on ${e.kernelId===void 0?`it`:`this kernel`}.`,suggestion:`Keep the requirement and report it as unsupported on this kernel. Load mesh evidence with ${o} for the requirements a mesh can answer.`,details:{format:`step`,...e.kernelId===void 0?{}:{kernelId:e.kernelId},...e.route===void 0?{}:{route:a(e.route)},meshAlternative:{format:`glb`,matchers:[...t]}}}]}),c=e=>typeof e.bestRouteFor==`function`,l=(e,t)=>{let{capabilities:n}=e;if((n?.routes?.length??0)>0)return!0;let{routesFor:r}=e;return typeof r==`function`&&r(t).length>0},u=(e,t)=>t in(e?.exportOptions?.schema.properties??{}),d=e=>e.transcoderId===void 0,f=e=>({success:!1,diagnostics:[{code:`GEOSPEC_CANONICAL_EXPORT_UNSUPPORTED`,severity:`error`,message:`GeoSpec cannot request canonical Z-up millimeter ${e.format.toUpperCase()} evidence from this runtime route.`,suggestion:`Use a runtime route whose export schema exposes coordinateSystem and unit.length, or pass a custom runtime that returns canonical millimeter geometry bytes.`,details:{format:e.format,missing:e.missing,route:a(e.route)}}]}),p=p=>{let{runtime:m,format:h}=p,g=p.meshLinearTolerance===void 0&&p.meshAngularToleranceDegrees===void 0?void 0:{...p.meshLinearTolerance===void 0?{}:{linearTolerance:p.meshLinearTolerance},...p.meshAngularToleranceDegrees===void 0?{}:{angularToleranceDegrees:p.meshAngularToleranceDegrees}},_=c(m),{kernelId:v}=p,y=_?v===void 0?m.bestRouteFor(h):m.bestRouteFor(h,{kernelId:v}):void 0;if(e.has(h)){let e=y!==void 0&&d(y)&&y.fidelity===`brep`;if(_&&!e&&v!==void 0&&l(m,h))return s({kernelId:v,route:y});if(y&&!e)return{success:!1,diagnostics:[{code:`GEOSPEC_DIRECT_STEP_ROUTE_REQUIRED`,severity:`error`,message:`GeoSpec exact BRep evidence requires a direct STEP/BRep runtime export route.`,suggestion:`No kernel in this runtime offers a direct STEP/BRep route, so keep the requirement and report it as unsupported here. Load mesh evidence with ${o} for the requirements a mesh can answer.`,details:{route:a(y),meshAlternative:{format:`glb`,matchers:[...t]}}}]};let n={},r={format:h,sourceUnit:`mm`};return u(y,`coordinateSystem`)&&(n.coordinateSystem=`z-up`,r.coordinateSystem=`z-up`),{options:n,sourceUnit:`mm`,provenance:{requested:{format:h},honored:r,route:a(y)}}}let b=n(h,g);if(!_)return i({format:h,exportOptions:{coordinateSystem:`z-up`,unit:{length:`millimeter`},...r(g)},...g===void 0?{}:{tessellation:g}});if(!y)return l(m,h)?f({format:h,missing:[`route`]}):i({format:h,exportOptions:{coordinateSystem:`z-up`,unit:{length:`millimeter`},...r(g)},...g===void 0?{}:{tessellation:g}});let x=[`coordinateSystem`,`unit`,...g===void 0?[]:[`tessellation`]].filter(e=>!u(y,e));return x.length>0?f({format:h,route:y,missing:x}):{options:{coordinateSystem:`z-up`,unit:{length:`millimeter`},...r(g)},sourceUnit:`mm`,provenance:{requested:b,honored:{format:b.format,coordinateSystem:`z-up`,unit:{length:`millimeter`},sourceUnit:`mm`,...g===void 0?{}:{tessellation:g}},route:a(y)}}};export{t as geoSpecMeshEvidenceMatchers,p as resolveRuntimeExportIntent};

package/dist/model/index.d.mts

@@ -0,0 +1,7 @@
+import { GeoSpecSubject } from "./subject.mjs";
+import { CreateModelLoaderOptions, GeoSpecLoadRegion, GeoSpecModelFormat, GeoSpecModelLoader, GeoSpecRuntimeClient, GeoSpecRuntimeClientFactory, GeoSpecRuntimeSourceAdapter, LoadModelCodeOptions, LoadModelFileOptions, LoadModelOptions, LoadModelSourceOptions, ManagedGeoSpecModelLoader } from "./types.mjs";
+import { GeoSpecExportRoute, RuntimeBackedModelFormat, RuntimeClientWithRoutes, RuntimeExportIntent, RuntimeExportIntentFailure, geoSpecMeshEvidenceMatchers, resolveRuntimeExportIntent } from "./export-intent.mjs";
+import { GeoSpecModelLoadError } from "./errors.mjs";
+import { createModelLoader, loadModel } from "./load-model.mjs";
+import { geoSpecRegionScopedKinds, geoSpecRegionWholeModelClaimCode } from "./region-scope.mjs";
+export { type CreateModelLoaderOptions, type GeoSpecExportRoute, type GeoSpecLoadRegion, type GeoSpecModelFormat, GeoSpecModelLoadError, type GeoSpecModelLoader, type GeoSpecRuntimeClient, type GeoSpecRuntimeClientFactory, type GeoSpecRuntimeSourceAdapter, type GeoSpecSubject, type LoadModelCodeOptions, type LoadModelFileOptions, type LoadModelOptions, type LoadModelSourceOptions, type ManagedGeoSpecModelLoader, type RuntimeBackedModelFormat, type RuntimeClientWithRoutes, type RuntimeExportIntent, type RuntimeExportIntentFailure, createModelLoader, geoSpecMeshEvidenceMatchers, geoSpecRegionScopedKinds, geoSpecRegionWholeModelClaimCode, loadModel, resolveRuntimeExportIntent };

package/dist/model/index.mjs

@@ -0,0 +1 @@
+import{GeoSpecModelLoadError as e}from"./errors.mjs";import{geoSpecRegionScopedKinds as t,geoSpecRegionWholeModelClaimCode as n}from"./region-scope.mjs";import{geoSpecMeshEvidenceMatchers as r,resolveRuntimeExportIntent as i}from"./export-intent.mjs";import{createModelLoader as a,loadModel as o}from"./load-model.mjs";export{e as GeoSpecModelLoadError,a as createModelLoader,r as geoSpecMeshEvidenceMatchers,t as geoSpecRegionScopedKinds,n as geoSpecRegionWholeModelClaimCode,o as loadModel,i as resolveRuntimeExportIntent};