geospec 0.0.0 → 0.1.0-beta.3

package/dist/engine/client.d.mts

@@ -0,0 +1,113 @@
+import { GeoSpecFixedMatcherName } from "./matchers.mjs";
+import { JSONValue } from "@taucad/runtime/types";
+//#region src/engine/client.d.ts
+/**
+ * Default largest work-unit budget a spec may author through `loadModel` or `expectGeo` options:
+ * 64 times the engine's current 8 000 000-unit default. It is host policy, not a ceiling: a host
+ * raises it with `maximumWorkUnitLimit` on its assertion client, runner or model loader. The
+ * host's own `workUnitLimit` keeps the full safe-integer range.
+ * @public
+ */
+declare const geoSpecMaximumWorkUnitLimit = 512000000;
+/**
+ * Resolve a host's largest authored work-unit budget.
+ *
+ * @param maximum - The host's configured maximum, when it sets one.
+ * @returns The maximum, defaulting to {@link geoSpecMaximumWorkUnitLimit}.
+ * @throws TypeError when the configured maximum is not a positive safe integer.
+ * @public
+ */
+declare const resolveGeoSpecMaximumWorkUnitLimit: (maximum?: number) => number;
+/**
+ * Exact core bytes of one claim evaluated in one engine call: the canonical plan, its one
+ * canonical claim and the canonical result, as fresh bytes the client retains without copying.
+ * @public
+ */
+type GeoSpecNativeClaimEvaluation = {
+  readonly canonicalClaim: Uint8Array<ArrayBuffer>;
+  readonly canonicalPlan: Uint8Array<ArrayBuffer>;
+  readonly canonicalResult: Uint8Array<ArrayBuffer>;
+};
+/** Byte-only engine surface consumed by the runner-independent assertion client. @public */
+type GeoSpecNativeEngine = {
+  evaluateClaim(request: Uint8Array<ArrayBuffer>): GeoSpecNativeClaimEvaluation;
+  processRequest(request: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+};
+/** Content-addressed subject accepted by a protocol-3 assertion plan. @public */
+type GeoSpecNativeSubject = {
+  readonly contentHash?: string;
+  readonly subjectHash?: string;
+};
+/** Polarity evaluated exactly once by the native core. @public */
+type GeoSpecClaimPolarity = 'negative' | 'positive';
+/** Canonical claim status returned by the native core. @public */
+type GeoSpecCanonicalClaimStatus = 'cancelled' | 'engine-error' | 'failed' | 'invalid' | 'passed' | 'refused' | 'unsupported' | (string & {});
+/** Full native assertion result with the exact core-owned bytes retained. @public */
+type GeoSpecCanonicalClaimReport = {
+  readonly canonicalClaim: Uint8Array<ArrayBuffer>;
+  readonly canonicalPlan: Uint8Array<ArrayBuffer>;
+  readonly canonicalResult: Uint8Array<ArrayBuffer>;
+  readonly claim: Readonly<Record<string, JSONValue>>;
+  readonly claimId: string;
+  /** Engine diagnostics; a `MATCHER_TIMEOUT` row also carries `details.limit`, `details.used` and `details.maximumLimit`. */
+  readonly diagnostics: readonly JSONValue[];
+  readonly evidence?: JSONValue;
+  readonly polarity: GeoSpecClaimPolarity;
+  readonly result: Readonly<Record<string, JSONValue>>;
+  readonly status: GeoSpecCanonicalClaimStatus;
+};
+/**
+ * Success-evidence profile a product selects for its plans (PERF-OUTPUT-01).
+ * `complete`, the default, keeps every evidence field. `bounded` keeps verdicts
+ * and drops evidence that grows with the subject on success: component gaps
+ * (nearest-neighbour gaps on failure), a closed mesh's per-primitive rows,
+ * undeclared duplicate faces, and all but the first matching circular hole.
+ * @public
+ */
+type GeoSpecNativeEvidenceProfile = 'bounded' | 'complete';
+type GeoSpecNativeClaimContext = {
+  readonly claimId: string;
+  readonly engine: GeoSpecNativeEngine;
+  readonly evidenceProfile?: GeoSpecNativeEvidenceProfile;
+  readonly polarity: GeoSpecClaimPolarity;
+  readonly subject: GeoSpecNativeSubject;
+  readonly subjectSlot: string;
+  readonly workUnitLimit: number;
+  /** The host's largest authored budget, reported as `details.maximumLimit` on `MATCHER_TIMEOUT`. */
+  readonly maximumWorkUnitLimit?: number;
+};
+/** One authored matcher call lowered and evaluated by Rust in one engine call. @public */
+type GeoSpecNativeClaimOptions = GeoSpecNativeClaimContext & ({
+  readonly arguments: readonly unknown[];
+  readonly capability: GeoSpecFixedMatcherName;
+} | {
+  readonly arguments: readonly unknown[];
+  readonly capability: string;
+  readonly kind: string;
+});
+declare const geoSpecQueryCapabilities: readonly ["analyzeMesh", "analyzeBrep", "inspectGeometry", "analyzeMeshOverlap", "queryPmi", "minimumDistance"];
+/** Existing positive-only ancillary operations owned by the native core. @public */
+type GeoSpecQueryCapability = Exclude<(typeof geoSpecQueryCapabilities)[number], 'minimumDistance'>;
+/**
+ * Flat native query transport options. Payloads use the existing authoring
+ * serializer, including ordinary RegExp values; omitted payloads encode null.
+ * The core validates selectors, pairs and all operation-specific constraints.
+ * @public
+ */
+type GeoSpecNativeQueryOptions = Omit<GeoSpecNativeClaimOptions, 'arguments' | 'capability' | 'kind' | 'polarity'> & {
+  readonly capability: GeoSpecQueryCapability | 'minimumDistance';
+  readonly payload?: unknown;
+};
+/**
+ * Submit an ancillary query with positive polarity through the native core.
+ *
+ * Queries return full reports even when failed or refused. Protocol errors
+ * propagate unchanged. Rust owns defaults, validation and canonical encoding.
+ *
+ * @param options - Query identity, subject and authored payload.
+ * @returns The complete report with exact canonical claim, plan and result bytes.
+ * @public
+ */
+declare const evaluateGeoSpecNativeQuery: (options: GeoSpecNativeQueryOptions) => GeoSpecCanonicalClaimReport;
+//#endregion
+export { GeoSpecCanonicalClaimReport, GeoSpecCanonicalClaimStatus, GeoSpecClaimPolarity, GeoSpecNativeClaimEvaluation, GeoSpecNativeClaimOptions, GeoSpecNativeEngine, GeoSpecNativeEvidenceProfile, GeoSpecNativeQueryOptions, GeoSpecNativeSubject, GeoSpecQueryCapability, evaluateGeoSpecNativeQuery, geoSpecMaximumWorkUnitLimit, resolveGeoSpecMaximumWorkUnitLimit };

package/dist/engine/client.mjs

@@ -0,0 +1 @@
+import{assertGeoSpecJsonValue as e,toGeoSpecProtocolJson as t}from"./protocol.mjs";import{geoSpecMatcherDescriptors as n}from"./matchers.mjs";const r=`geospec-jcs-v1`,i=512e6,a=e=>{if(e===void 0)return i;if(!Number.isSafeInteger(e)||e<=0)throw TypeError(`GeoSpec maximumWorkUnitLimit must be a positive safe integer; received ${String(e)}.`);return e},o=[`analyzeMesh`,`analyzeBrep`,`inspectGeometry`,`analyzeMeshOverlap`,`queryPmi`,`minimumDistance`],s=t=>{let n=JSON.parse(new TextDecoder(`utf-8`,{fatal:!0}).decode(t));return e(n),n},c=new TextEncoder().encode(`{"canonicalProfile":"geospec-jcs-v1","method":"initialize","protocolVersion":3,"registryVersion":5,"requestId":"configuration"}`),l=new WeakMap,u=new WeakMap,d=(e,t)=>{if(typeof e!=`object`||!e||Array.isArray(e))throw TypeError(`GeoSpec engine returned a malformed ${t}.`);return e},f=(e,t)=>{let{contentHash:n,subjectHash:r}=e;if(n===void 0==(r===void 0))throw TypeError(`A native GeoSpec subject requires exactly one of contentHash or subjectHash.`);let i=n??r;if(!/^[0-9a-f]{64}$/u.test(i))throw TypeError(`A native GeoSpec subject hash must contain 64 lowercase hexadecimal characters.`);return n===void 0?{slot:t,subjectHash:i}:{slot:t,contentHash:i}},p=e=>{if(!Number.isSafeInteger(e)||e<=0||e>9007199254740991)throw TypeError(`GeoSpec workUnitLimit must be a positive exact safe integer.`)},m=e=>{if(e.claimId.length===0||e.subjectSlot.length===0)throw TypeError(`GeoSpec claim IDs and subject slots must be non-empty strings.`);p(e.workUnitLimit)},h=(e,t,n=i)=>e===void 0||typeof e==`number`&&Number.isSafeInteger(e)&&e>0&&e<=n?void 0:`GeoSpec ${t} must be a positive integer no greater than this host's maximum of ${n} (the host can raise it with maximumWorkUnitLimit); received ${typeof e==`number`?String(e):typeof e}.`,g=(e,t,n)=>{let r=h(e,t,n);if(r!==void 0)throw TypeError(r)},_=(e,t)=>{if(t!==void 0)return p(t),t;let n=l.get(e);if(n!==void 0)return n;let i=d(s(Uint8Array.from(e.processRequest(Uint8Array.from(c)))),`initialize response envelope`);if(i.requestId!==`configuration`)throw TypeError(`GeoSpec engine returned an initialize response with the wrong requestId.`);let a=d(i.result,`initialize result`);if(a.canonicalProfile!==r||a.protocolVersion!==3||a.registryVersion!==5)throw TypeError(`GeoSpec engine returned an initialize response for an incompatible protocol profile.`);let o=d(a.configuration,`initialize configuration`),{capabilities:f}=a,m=Array.isArray(f)?f.filter(e=>typeof e==`object`&&!!e&&!Array.isArray(e)&&e.name===`minimumDistance`):[];if(u.set(e,m.length===1&&m.every(e=>e.profile===`geospec-minimum-distance-v1`&&e.implementation===`implemented`&&e.registryVersion===5)),o.configurationProfile!==`geospec-entry-config-v1`)throw TypeError(`GeoSpec engine returned an unsupported configuration profile.`);let h=o.defaultWorkUnitBudget;if(typeof h!=`number`)throw TypeError(`GeoSpec engine initialize configuration omitted defaultWorkUnitBudget.`);return p(h),l.set(e,h),h},v=e=>(_(e),u.get(e)===!0),y=e=>{if(e.capability===`toSatisfyRationalPlate`||e.capability===`toSatisfyParallelPlaneDistance`){if(e.arguments.length>0)throw TypeError(`GeoSpec matcher ${e.capability} does not accept arguments.`);return w({...e,payload:{contract:n[e.capability].contract}})}if(!(`kind`in e))throw TypeError(`This GeoSpec matcher requires its canonical kind.`);return w({...e,payload:{kind:e.kind,arguments:e.arguments.map(e=>t(e))}})},b=e=>{if(!o.includes(e.capability))throw TypeError(`GeoSpec query capability must name an ancillary operation.`);return w({...e,payload:t(e.payload),polarity:`positive`})},x=e=>typeof e==`number`&&Number.isSafeInteger(e)&&e>=0?e:void 0,S=e=>typeof e==`object`&&!!e&&!Array.isArray(e)&&e.code===`MATCHER_TIMEOUT`,C=(e,t,n)=>{if(!S(e))return e;let{details:r}=e,i=typeof r==`object`&&r&&!Array.isArray(r)?r:{},a=x(i.budget)??x(i.workUnitBudget)??t,o=x(i.unitsUsed)??x(i.requiredWorkUnits);return{...e,details:{...i,limit:a,...o===void 0?{}:{used:o},maximumLimit:n}}},w=e=>{m(e);let t={method:`submitClaims`,requestId:e.claimId,protocolVersion:3,registryVersion:5,canonicalProfile:r,plan:{subjects:[f(e.subject,e.subjectSlot)],claims:[{claimId:e.claimId,capability:e.capability,subjectSlots:[e.subjectSlot],payload:e.payload,polarity:e.polarity,workUnitBudget:e.workUnitLimit}],...e.evidenceProfile===void 0?{}:{evidenceProfile:e.evidenceProfile}}},{canonicalClaim:n,canonicalPlan:i,canonicalResult:a}=e.engine.evaluateClaim(new TextEncoder().encode(JSON.stringify(t))),o=d(s(n),`canonical claim`);if(o.claimId!==e.claimId)throw TypeError(`GeoSpec engine returned a malformed canonical claim for '${e.claimId}'.`);let{results:c}=d(s(a),`canonical result envelope`);if(!Array.isArray(c)||c.length!==1)throw TypeError(`GeoSpec engine returned a canonical result envelope without exactly one result.`);let[l]=c,u=d(l,`canonical claim result`),{claimId:p,diagnostics:h,status:g}=u;if(p!==e.claimId||typeof g!=`string`||!Array.isArray(h))throw TypeError(`GeoSpec engine returned a malformed result for claim '${e.claimId}'.`);return{canonicalClaim:n,canonicalPlan:i,canonicalResult:a,claim:o,claimId:p,diagnostics:h.some(e=>S(e))?h.map(t=>C(t,e.workUnitLimit,e.maximumWorkUnitLimit??512e6)):h,...u.evidence===void 0?{}:{evidence:u.evidence},polarity:e.polarity,result:u,status:g}};export{g as assertGeoSpecAuthoredWorkUnitLimit,y as evaluateGeoSpecNativeClaim,b as evaluateGeoSpecNativeQuery,h as geoSpecAuthoredWorkUnitLimitProblem,i as geoSpecMaximumWorkUnitLimit,a as resolveGeoSpecMaximumWorkUnitLimit,_ as resolveGeoSpecNativeWorkUnitLimit,v as supportsGeoSpecNativeMinimumDistance};

package/dist/engine/index.d.mts

@@ -0,0 +1,3 @@
+import { GeoSpecMatcherDescriptor, GeoSpecMatcherExpectedShape, GeoSpecMatcherMode, GeoSpecMatcherName, geoSpecMatcherDescriptors, normalizeGeoSpecExpected } from "./matchers.mjs";
+import { assertGeoSpecJsonValue, decodeGeoSpecCanonicalJson, encodeGeoSpecCanonicalJson, isGeoSpecJsonValue, toGeoSpecProtocolJson } from "./protocol.mjs";
+export { type GeoSpecMatcherDescriptor, type GeoSpecMatcherExpectedShape, type GeoSpecMatcherMode, type GeoSpecMatcherName, assertGeoSpecJsonValue, decodeGeoSpecCanonicalJson, encodeGeoSpecCanonicalJson, geoSpecMatcherDescriptors, isGeoSpecJsonValue, normalizeGeoSpecExpected, toGeoSpecProtocolJson };

package/dist/engine/index.mjs

@@ -0,0 +1 @@
+import{assertGeoSpecJsonValue as e,decodeGeoSpecCanonicalJson as t,encodeGeoSpecCanonicalJson as n,isGeoSpecJsonValue as r,toGeoSpecProtocolJson as i}from"./protocol.mjs";import{geoSpecMatcherDescriptors as a,normalizeGeoSpecExpected as o}from"./matchers.mjs";export{e as assertGeoSpecJsonValue,t as decodeGeoSpecCanonicalJson,n as encodeGeoSpecCanonicalJson,a as geoSpecMatcherDescriptors,r as isGeoSpecJsonValue,o as normalizeGeoSpecExpected,i as toGeoSpecProtocolJson};

package/dist/engine/matchers.d.mts

@@ -0,0 +1,70 @@
+import { GeoSpecAssertion, GeoSpecMatcher } from "../runner/types.mjs";
+//#region src/engine/matchers.d.ts
+/**
+ * Every matcher name exposed by `expectGeo(...)`.
+ *
+ * @public
+ */
+type GeoSpecMatcherName = Exclude<keyof GeoSpecMatcher, 'not'>;
+/**
+ * How the substrate derives an assertion's recorded `expected` value from the
+ * arguments the spec author passed. Data, not code, so the registry stays
+ * emittable to non-TypeScript clients (DL13).
+ *
+ * - `first` — the first argument verbatim.
+ * - `first-or-empty` — the first argument, defaulting to `{}`.
+ * - `bounds` — `(min, max)` pairs collapse to `{ min, max }`; a lone object
+ *   argument passes through.
+ * - `true` — nullary matchers record the literal `true`.
+ *
+ * @public
+ */
+type GeoSpecMatcherExpectedShape = 'first' | 'first-or-empty' | 'bounds' | 'true';
+/**
+ * Whether a matcher settles synchronously (throwing its
+ * `GeoSpecAssertionError` inside the `it()` body) or asynchronously (settled
+ * before the test completes). Part of the contract: it decides whether the
+ * deterministic work-unit budget (R13) brackets the evaluation.
+ *
+ * @public
+ */
+type GeoSpecMatcherMode = 'sync' | 'async';
+/**
+ * One matcher's contract entry.
+ *
+ * @public
+ */
+type GeoSpecMatcherDescriptor = {
+  readonly kind: GeoSpecAssertion['kind'];
+  readonly expected: GeoSpecMatcherExpectedShape;
+  readonly mode: GeoSpecMatcherMode;
+};
+/**
+ * The 26-entry matcher registry. Insertion order is contract: it fixes
+ * `geoSpecMatcherNames`, which `libs/api-extractor` and the LLM prompt
+ * pipeline consume.
+ *
+ * @public
+ */
+declare const geoSpecMatcherDescriptors: Readonly<{ [Name in GeoSpecMatcherName]: Name extends GeoSpecFixedMatcherName ? GeoSpecFixedMatcherDescriptor & {
+  readonly kind: Name;
+} : GeoSpecMatcherDescriptor; }>;
+/** A canonical fixed-contract matcher. @public */
+type GeoSpecFixedMatcherDescriptor = {
+  readonly contract: 'geospec.plate-two-windows/v1' | 'geospec.pmi.parallel-plane-distance/v1';
+  readonly expected: 'true';
+  readonly mode: 'sync';
+};
+/** Every canonical fixed-contract matcher name. @public */
+type GeoSpecFixedMatcherName = 'toSatisfyRationalPlate' | 'toSatisfyParallelPlaneDistance';
+/**
+ * Derive the `expected` value an assertion records from the call arguments.
+ *
+ * @param shape - Normalization shape from the matcher's registry entry.
+ * @param callArguments - Arguments the spec author passed, in order.
+ * @returns The value recorded as the assertion's `expected`.
+ * @public
+ */
+declare const normalizeGeoSpecExpected: (shape: GeoSpecMatcherExpectedShape, callArguments: readonly unknown[]) => unknown;
+//#endregion
+export { GeoSpecFixedMatcherDescriptor, GeoSpecFixedMatcherName, GeoSpecMatcherDescriptor, GeoSpecMatcherExpectedShape, GeoSpecMatcherMode, GeoSpecMatcherName, geoSpecMatcherDescriptors, normalizeGeoSpecExpected };

package/dist/engine/matchers.mjs

@@ -0,0 +1 @@
+const e=Object.freeze({toHaveBoundingBox:{kind:`boundingBox`,expected:`bounds`,mode:`sync`},toHaveConnectedComponents:{kind:`connectedComponents`,expected:`first`,mode:`sync`},toBeWatertight:{kind:`watertight`,expected:`true`,mode:`sync`},toHaveNoComponentInterference:{kind:`componentInterference`,expected:`first-or-empty`,mode:`sync`},toHaveAssemblyOccurrences:{kind:`assemblyOccurrences`,expected:`first`,mode:`sync`},toHaveSpatialRelationships:{kind:`spatialRelationships`,expected:`first`,mode:`sync`},toHaveMeshIntegrity:{kind:`meshIntegrity`,expected:`first`,mode:`sync`},toHaveNoDiagnostics:{kind:`noDiagnostics`,expected:`first-or-empty`,mode:`sync`},toHaveSurfaceArea:{kind:`surfaceArea`,expected:`first`,mode:`sync`},toHaveVolume:{kind:`volume`,expected:`first`,mode:`sync`},toHaveMass:{kind:`mass`,expected:`first`,mode:`sync`},toHaveCenterOfMass:{kind:`centerOfMass`,expected:`first`,mode:`sync`},toBeValidBrep:{kind:`validBrep`,expected:`first-or-empty`,mode:`sync`},toHaveTopologyCounts:{kind:`topologyCounts`,expected:`first`,mode:`sync`},toHaveStepUnits:{kind:`stepUnits`,expected:`first`,mode:`sync`},toHaveProductStructure:{kind:`productStructure`,expected:`first`,mode:`sync`},toHavePlanarFace:{kind:`planarFace`,expected:`first`,mode:`sync`},toHaveCylindricalFace:{kind:`cylindricalFace`,expected:`first`,mode:`sync`},toHaveCircularHole:{kind:`circularHole`,expected:`first`,mode:`sync`},toHaveCircularHolePattern:{kind:`circularHolePattern`,expected:`first`,mode:`sync`},toHaveChamferFeature:{kind:`chamferFeature`,expected:`first`,mode:`sync`},toHaveFilletFeature:{kind:`filletFeature`,expected:`first`,mode:`sync`},toHaveMinimumWallThickness:{kind:`minimumWallThickness`,expected:`first`,mode:`sync`},toHaveVoidContinuity:{kind:`voidContinuity`,expected:`first`,mode:`sync`},toSatisfyRationalPlate:{kind:`toSatisfyRationalPlate`,contract:`geospec.plate-two-windows/v1`,expected:`true`,mode:`sync`},toSatisfyParallelPlaneDistance:{kind:`toSatisfyParallelPlaneDistance`,contract:`geospec.pmi.parallel-plane-distance/v1`,expected:`true`,mode:`sync`}}),t=(e,t)=>{switch(e){case`true`:return!0;case`first-or-empty`:return t[0]??{};case`bounds`:return t[1]===void 0?t[0]:{min:t[0],max:t[1]};default:return t[0]}};export{e as geoSpecMatcherDescriptors,t as normalizeGeoSpecExpected};

package/dist/engine/pmi.types.d.mts

@@ -0,0 +1,78 @@
+//#region src/engine/pmi.types.d.ts
+/** Explicit support state for one source-attributed inventory field. @public */
+type GeoSpecPmiField<Value> = {
+  readonly status: 'supported' | 'missing' | 'invalid' | 'ambiguous' | 'unsupported';
+  readonly value: Value | null;
+  readonly reason: string | null;
+};
+/** Original Part21 entity ID and exact source argument tokens. @public */
+type GeoSpecPmiRawEntity = {
+  readonly sourceId: number;
+  readonly kind: string;
+  readonly arguments: readonly string[];
+};
+/** Source-authored scalar and Rust-normalized reduced rational millimetres. @public */
+type GeoSpecPmiNumber = {
+  readonly sourceId: number;
+  readonly authoredText: string;
+  readonly unitId: number;
+  readonly unitRecords: readonly GeoSpecPmiRawEntity[];
+  readonly millimetres: string;
+  readonly name: string;
+};
+/** A uniquely forward-transferred face; null occurrence denotes the whole part. @public */
+type GeoSpecPmiFaceAssociation = {
+  readonly sourceFaceId: number;
+  readonly occurrenceRoute: readonly number[];
+  readonly occurrence: number | null;
+  readonly publicFaceOrdinal: number;
+};
+/** One ordered role reference, including incomplete source/transfer evidence. @public */
+type GeoSpecPmiShapeReference = {
+  readonly sourceAspectId: number | null;
+  readonly sourceUsageIds: readonly number[];
+  readonly sourceItemIds: readonly number[];
+  readonly requestedRoute: GeoSpecPmiField<readonly number[]>;
+  readonly associations: GeoSpecPmiField<readonly GeoSpecPmiFaceAssociation[]>;
+};
+/** Normalized authored limits; never an inferred geometric conformance verdict. @public */
+type GeoSpecPmiLimits = {
+  readonly lowerMillimetres: string;
+  readonly upperMillimetres: string;
+  readonly basis: 'authored-limits' | 'nominal-plus-minus';
+};
+/** Source record preserving semantic/presentation separation and ordered roles. @public */
+type GeoSpecPmiRecord = {
+  readonly sourceId: number;
+  readonly family: 'dimension' | 'datum' | 'tolerance' | 'presentation';
+  readonly channel: 'semantic' | 'presentation';
+  readonly kind: string;
+  readonly name: GeoSpecPmiField<string>;
+  readonly first: readonly GeoSpecPmiShapeReference[];
+  readonly second: readonly GeoSpecPmiShapeReference[];
+  readonly numbers: GeoSpecPmiField<readonly GeoSpecPmiNumber[]>;
+  readonly limits: GeoSpecPmiField<GeoSpecPmiLimits>;
+  readonly interpretation: GeoSpecPmiField<string>;
+  readonly raw: readonly GeoSpecPmiRawEntity[];
+};
+/** Positive-only inventory value inside the ordinary canonical query report. @public */
+type GeoSpecPmiInventory = {
+  readonly contract: 'geospec.pmi.inventory/v1';
+  readonly status: 'semantic' | 'graphical-only' | 'empty';
+  readonly fileSchema: string;
+  readonly editionValidation: 'not-validated';
+  readonly records: readonly GeoSpecPmiRecord[];
+};
+/** Strict inventory output limits. Exceeding either refuses without truncation. @public */
+type GeoSpecPmiQueryPayload = {
+  readonly maxRecords?: number;
+  readonly maxOutputBytes?: number;
+};
+/** Complete inventory value; provenance is the unchanged core identity descriptor. @public */
+type GeoSpecPmiQueryValue = {
+  readonly inventory: GeoSpecPmiInventory;
+  readonly subjectHash: string;
+  readonly provenance: Readonly<Record<string, unknown>>;
+};
+//#endregion
+export { GeoSpecPmiFaceAssociation, GeoSpecPmiField, GeoSpecPmiInventory, GeoSpecPmiLimits, GeoSpecPmiNumber, GeoSpecPmiQueryPayload, GeoSpecPmiQueryValue, GeoSpecPmiRawEntity, GeoSpecPmiRecord, GeoSpecPmiShapeReference };

package/dist/engine/protocol.d.mts

@@ -0,0 +1,20 @@
+import { JSONValue } from "@taucad/runtime/types";
+//#region src/engine/protocol.d.ts
+/** Runtime JSON-value guard used at every protocol trust boundary. @public */
+declare const isGeoSpecJsonValue: (value: unknown, ancestors?: Set<WeakKey>) => value is JSONValue;
+/** Reject a non-wire value rather than letting JSON.stringify erase it. @public */
+declare const assertGeoSpecJsonValue: (value: unknown) => asserts value is JSONValue;
+/** Encode client-owned canonical claim bytes. @public */
+declare const encodeGeoSpecCanonicalJson: (value: JSONValue) => Uint8Array<ArrayBuffer>;
+/** Parse and validate canonical bytes without re-canonicalizing them. @public */
+declare const decodeGeoSpecCanonicalJson: (bytes: Uint8Array<ArrayBuffer>) => JSONValue;
+/**
+ * Convert an authoring value to protocol JSON, including the two explicit
+ * bindings the TypeScript client needs: regex data and opaque subject refs.
+ * Unsupported live objects fail before a request reaches the engine.
+ *
+ * @public
+ */
+declare const toGeoSpecProtocolJson: (value: unknown, ancestors?: Set<WeakKey>) => JSONValue;
+//#endregion
+export { assertGeoSpecJsonValue, decodeGeoSpecCanonicalJson, encodeGeoSpecCanonicalJson, isGeoSpecJsonValue, toGeoSpecProtocolJson };

package/dist/engine/protocol.mjs

@@ -0,0 +1 @@
+const e=e=>{if(typeof e!=`object`||!e)return!1;let t=Object.getPrototypeOf(e);return t===Object.prototype||t===null},t=(n,r=new Set)=>{if(n===null||typeof n==`string`||typeof n==`boolean`)return!0;if(typeof n==`number`)return Number.isFinite(n);if(!Array.isArray(n)&&!e(n)||r.has(n))return!1;r.add(n);let i=Array.isArray(n)?n.every(e=>t(e,r)):e(n)&&Object.values(n).every(e=>t(e,r));return r.delete(n),i},n=e=>{if(!t(e))throw TypeError(`GeoSpec protocol values must contain only finite JSON data.`)},r=e=>Array.isArray(e)?e.map(e=>r(e)):typeof e==`object`&&e?Object.fromEntries(Object.entries(e).sort(([e],[t])=>e.localeCompare(t)).map(([e,t])=>[e,r(t)])):e,i=e=>(n(e),new TextEncoder().encode(JSON.stringify(r(e)))),a=e=>{let t=JSON.parse(new TextDecoder().decode(e));return n(t),t},o=(t,n=new Set)=>{if(t==null)return null;if(typeof t==`string`||typeof t==`boolean`)return t;if(typeof t==`number`){if(!Number.isFinite(t))throw TypeError(`GeoSpec claims cannot contain non-finite numbers.`);return t}if(t instanceof RegExp)return{type:`regexp`,pattern:t.source,flags:t.flags};if(typeof t!=`object`||n.has(t))throw TypeError(`GeoSpec claims cannot contain functions, symbols, bigint values, or cycles.`);let r=Reflect.get(t,`subjectId`);if(typeof r==`string`)return{type:`subject-reference`,subjectId:r};if(n.add(t),Array.isArray(t)){let e=t.map(e=>o(e,n));return n.delete(t),e}if(!e(t))throw TypeError(`GeoSpec claims cannot contain class instances.`);let i={};for(let[e,r]of Object.entries(t))r!==void 0&&(i[e]=o(r,n));return n.delete(t),i};export{n as assertGeoSpecJsonValue,a as decodeGeoSpecCanonicalJson,i as encodeGeoSpecCanonicalJson,t as isGeoSpecJsonValue,o as toGeoSpecProtocolJson};

package/dist/geometry-unit.d.mts

@@ -0,0 +1,12 @@
+//#region src/geometry-unit.d.ts
+/**
+ * Geometry units accepted at GeoSpec evidence-loading boundaries.
+ *
+ * Loaded subjects normalize coordinates into canonical millimetres; this type
+ * describes source and provenance units, not a project-wide configuration.
+ *
+ * @public
+ */
+type GeoSpecUnit = 'mm' | 'cm' | 'm' | 'in' | 'ft' | (string & {});
+//#endregion
+export { GeoSpecUnit };

package/dist/index.d.mts

@@ -0,0 +1,6 @@
+import { GeoSpecUnit } from "./geometry-unit.mjs";
+import { BrepEvidence, GeometryCapability, GeometryDiagnostic, GeometryFileFormat, GeometryProvenance, GeometrySource, GeometrySubject, GeometrySubjectMeshEvidence, MeshEvidence, MeshFileFormat, MeshQualityStats, MeshTriangle, StepEvidence, Vec3 } from "./mesh/types.mjs";
+import { GeoSpecSubject } from "./model/subject.mjs";
+import { GeoSpecAssemblyOccurrenceExpectation, GeoSpecAssemblyOccurrencesExpectation, GeoSpecAssertion, GeoSpecAxisExpectation, GeoSpecBoundingBoxExpectation, GeoSpecCenterOfMassExpectation, GeoSpecChamferFeatureExpectation, GeoSpecCircularHoleExpectation, GeoSpecCircularHolePatternExpectation, GeoSpecComponentInterferenceAllowance, GeoSpecComponentInterferenceExpectation, GeoSpecComponentInterferencePairExpectation, GeoSpecConnectedComponentsExpectation, GeoSpecCylindricalFaceExpectation, GeoSpecExpectOptions, GeoSpecFilletFeatureExpectation, GeoSpecGeometrySelector, GeoSpecMassExpectation, GeoSpecMatcher, GeoSpecMeshIntegrityExpectation, GeoSpecMinimumWallThicknessExpectation, GeoSpecNoDiagnosticsExpectation, GeoSpecNumericExpectation, GeoSpecPlanarFaceExpectation, GeoSpecPointExpectation, GeoSpecProductStructureExpectation, GeoSpecSpatialRelationshipExpectation, GeoSpecSpatialRelationshipsExpectation, GeoSpecStepUnitsExpectation, GeoSpecSurfaceAreaExpectation, GeoSpecTopologyCountsExpectation, GeoSpecValidBrepExpectation, GeoSpecVoidContinuityExpectation, GeoSpecVoidWaypoint, GeoSpecVolumeExpectation } from "./runner/types.mjs";
+import { describe, expectGeo, geoSpecMatcherNames, it, test } from "./create-geospec.mjs";
+export { type BrepEvidence, type GeoSpecAssemblyOccurrenceExpectation, type GeoSpecAssemblyOccurrencesExpectation, type GeoSpecAssertion, type GeoSpecAxisExpectation, type GeoSpecBoundingBoxExpectation, type GeoSpecCenterOfMassExpectation, type GeoSpecChamferFeatureExpectation, type GeoSpecCircularHoleExpectation, type GeoSpecCircularHolePatternExpectation, type GeoSpecComponentInterferenceAllowance, type GeoSpecComponentInterferenceExpectation, type GeoSpecComponentInterferencePairExpectation, type GeoSpecConnectedComponentsExpectation, type GeoSpecCylindricalFaceExpectation, type GeoSpecExpectOptions, type GeoSpecFilletFeatureExpectation, type GeoSpecGeometrySelector, type GeoSpecMassExpectation, type GeoSpecMatcher, type GeoSpecMeshIntegrityExpectation, type GeoSpecMinimumWallThicknessExpectation, type GeoSpecNoDiagnosticsExpectation, type GeoSpecNumericExpectation, type GeoSpecPlanarFaceExpectation, type GeoSpecPointExpectation, type GeoSpecProductStructureExpectation, type GeoSpecSpatialRelationshipExpectation, type GeoSpecSpatialRelationshipsExpectation, type GeoSpecStepUnitsExpectation, type GeoSpecSubject, type GeoSpecSurfaceAreaExpectation, type GeoSpecTopologyCountsExpectation, type GeoSpecUnit, type GeoSpecValidBrepExpectation, type Vec3 as GeoSpecVec3, type GeoSpecVoidContinuityExpectation, type GeoSpecVoidWaypoint, type GeoSpecVolumeExpectation, type GeometryCapability, type GeometryDiagnostic, type GeometryFileFormat, type GeometryProvenance, type GeometrySource, type GeometrySubject, type GeometrySubjectMeshEvidence, type MeshEvidence, type MeshFileFormat, type MeshQualityStats, type MeshTriangle, type StepEvidence, type Vec3, describe, expectGeo, geoSpecMatcherNames, it, test };

package/dist/index.mjs

@@ -0,0 +1 @@
+import{describe as e,expectGeo as t,geoSpecMatcherNames as n,it as r,test as i}from"./create-geospec.mjs";export{e as describe,t as expectGeo,n as geoSpecMatcherNames,r as it,i as test};

package/dist/mesh/index.d.mts

@@ -0,0 +1,4 @@
+import { GeoSpecUnit } from "../geometry-unit.mjs";
+import { AabbMeters, BoundingBoxAxisExtremum, BoundingBoxAxisFailure, BoundingBoxFailure, BoundingBoxStats, BrepEvidence, CheckResult, ClusterGap, ClusterReport, ConnectedComponentsFailure, ConnectedComponentsResult, GeometryCapability, GeometryDiagnostic, GeometryEvidenceDiagnostic, GeometryFileFormat, GeometryProvenance, GeometrySource, GeometryStats, GeometrySubject, GeometrySubjectMeshEvidence, MeshEvidence, MeshFileFormat, MeshQualityStats, MeshTriangle, PrimitiveRecord, StepEvidence, Vec3, WatertightFailure, WatertightIrregularEdgeCluster, WatertightIrregularEdgeKind, WatertightIrregularEdgeSample, WatertightPrimitiveBreakdown, WatertightResult } from "./types.mjs";
+import { MeshBufferSource, MeshSource } from "../model/types.mjs";
+export type { AabbMeters, BoundingBoxAxisExtremum, BoundingBoxAxisFailure, BoundingBoxFailure, BoundingBoxStats, BrepEvidence, CheckResult, ClusterGap, ClusterReport, ConnectedComponentsFailure, ConnectedComponentsResult, GeoSpecUnit, GeometryCapability, GeometryDiagnostic, GeometryEvidenceDiagnostic, GeometryFileFormat, GeometryProvenance, GeometrySource, GeometryStats, GeometrySubject, GeometrySubjectMeshEvidence, MeshBufferSource, MeshEvidence, MeshFileFormat, MeshQualityStats, MeshSource, MeshTriangle, PrimitiveRecord, StepEvidence, Vec3, WatertightFailure, WatertightIrregularEdgeCluster, WatertightIrregularEdgeKind, WatertightIrregularEdgeSample, WatertightPrimitiveBreakdown, WatertightResult };

package/dist/mesh/index.mjs

@@ -0,0 +1 @@
+export{};