geospec 0.0.0 → 0.1.0-beta.3

package/dist/runner/discovery.d.mts

@@ -0,0 +1,93 @@
+//#region src/runner/discovery.d.ts
+/**
+ * Default file globs used by GeoSpec test discovery.
+ *
+ * @public
+ */
+declare const defaultGeoSpecInclude: readonly ["**/*.geospec.{ts,js}"];
+/**
+ * Directories skipped by recursive GeoSpec discovery unless callers provide
+ * their own ignored-directory list.
+ *
+ * @public
+ */
+declare const defaultGeoSpecIgnoredDirectories: readonly [".git", "node_modules", "dist", "coverage", ".tau/cache", ".tau/artifacts", ".tau/transcripts"];
+/**
+ * File kind returned by a GeoSpec discovery filesystem.
+ *
+ * @public
+ */
+type GeoSpecDiscoveryFileKind = 'file' | 'directory';
+/**
+ * Minimal stat object required for recursive GeoSpec test discovery.
+ *
+ * @public
+ */
+type GeoSpecDiscoveryFileStat = {
+  kind: GeoSpecDiscoveryFileKind;
+};
+/**
+ * Minimal filesystem contract used by GeoSpec test discovery.
+ *
+ * Browser workers, Node CLI hosts, and embedded runners adapt their native
+ * filesystem APIs to this shape so discovery has one shared behavior.
+ *
+ * @public
+ */
+type GeoSpecDiscoveryFileSystem = {
+  readdir(path: string): Promise<readonly string[]>;
+  stat(path: string): Promise<GeoSpecDiscoveryFileStat>;
+};
+/**
+ * Options for recursive GeoSpec test discovery.
+ *
+ * `files` accepts either exact `*.geospec.ts` / `*.geospec.js` files or
+ * directory roots. When omitted, discovery starts at `projectPath`.
+ *
+ * `include` and `exclude` are Vitest-style file globs applied to
+ * project-relative GeoSpec paths after `files` roots have been expanded.
+ *
+ * @public
+ */
+type DiscoverGeoSpecFilesOptions = {
+  filesystem: GeoSpecDiscoveryFileSystem;
+  projectPath: string;
+  files?: readonly string[];
+  include?: readonly string[];
+  exclude?: readonly string[];
+  ignoredDirectories?: readonly string[];
+};
+/**
+ * Result returned by recursive GeoSpec test discovery.
+ *
+ * `files` are project-relative, sorted, and de-duplicated. `unmatchedRoots`
+ * contains requested file or directory roots that did not select any GeoSpec
+ * files.
+ *
+ * @public
+ */
+type GeoSpecDiscoveryResult = {
+  files: string[];
+  unmatchedRoots: string[];
+};
+/**
+ * Return true when a project-relative path names a GeoSpec test file.
+ *
+ * @param path - Project-relative path to inspect.
+ * @returns True when the path ends with `.geospec.ts` or `.geospec.js`.
+ * @public
+ */
+declare const isGeoSpecTestFile: (path: string) => boolean;
+/**
+ * Discover GeoSpec test files from exact files or directory roots.
+ *
+ * The returned `files` are project-relative paths suitable for
+ * `runGeoSpecModule` and runner factory APIs.
+ *
+ * @param options - Discovery options containing a filesystem adapter and project roots.
+ * @returns Sorted, de-duplicated project-relative GeoSpec files plus unmatched roots.
+ * @public
+ */
+declare const discoverGeoSpecFiles: (options: DiscoverGeoSpecFilesOptions) => Promise<GeoSpecDiscoveryResult>;
+//#endregion
+export { DiscoverGeoSpecFilesOptions, GeoSpecDiscoveryFileKind, GeoSpecDiscoveryFileStat, GeoSpecDiscoveryFileSystem, GeoSpecDiscoveryResult, defaultGeoSpecIgnoredDirectories, defaultGeoSpecInclude, discoverGeoSpecFiles, isGeoSpecTestFile };

package/dist/runner/discovery.mjs

@@ -0,0 +1 @@
+import{assertRootedPath as e}from"@taucad/runtime/kernel";const t=[`**/*.geospec.{ts,js}`],n=[`.git`,`node_modules`,`dist`,`coverage`,`.tau/cache`,`.tau/artifacts`,`.tau/transcripts`],r=/\.geospec\.(?:ts|js)$/u,i=e=>e.replaceAll(`\\`,`/`).replaceAll(/\/+/gu,`/`).replace(/^\.\//u,``),a=e=>{let t=i(e);return!t||t===`.`?``:t===`/`?t:t.replace(/\/$/u,``)},o=(t,n)=>{let r=e(t);return r===``?n:n===``?r:`${n.replace(/\/$/u,``)}/${r}`},s=(e,t)=>{let n=i(e).replace(/\/$/u,``);if(t===``)return n;let r=t.endsWith(`/`)?t:`${t}/`;return n===t?``:n.startsWith(r)?n.slice(r.length):n},c=e=>e.replaceAll(/[|\\{}()[\]^$+?.]/gu,String.raw`\$&`),l=e=>{let t=i(e),n=`^`;for(let e=0;e<t.length;){let r=t[e];if(r===void 0)break;let i=t[e+1];if(r===`*`&&i===`*`){t[e+2]===`/`?(n+=String.raw`(?:.*\/)?`,e+=3):(n+=`.*`,e+=2);continue}if(r===`*`){n+=`[^/]*`,e+=1;continue}if(r===`?`){n+=`[^/]`,e+=1;continue}if(r===`{`){let r=t.indexOf(`}`,e+1);if(r!==-1){let i=t.slice(e+1,r).split(`,`).map(e=>c(e));n+=`(?:${i.join(`|`)})`,e=r+1;continue}}n+=r===`/`?String.raw`\/`:c(r),e+=1}return RegExp(`${n}$`,`u`)},u=(e,t)=>l(t).test(i(e)),d=(e,t)=>t.some(t=>u(e,t)),f=(e,t)=>{let n=i(e).replace(/\/$/u,``),r=n.split(`/`).at(-1)??n;return t.has(n)||t.has(r)},p=e=>{if(typeof e!=`object`||!e)return!1;let t=`code`in e?e.code:void 0,n=`name`in e?e.name:void 0,r=e instanceof Error?e.message:``;return t===`ENOENT`||t===`ENOTDIR`||n===`NotFoundError`||r.startsWith(`ENOENT:`)||r.startsWith(`ENOTDIR:`)},m=e=>r.test(i(e)),h=async e=>{let t=await e.filesystem.readdir(e.directoryPath),n=[];for(let r of t){let t=e.directoryPath===``?r:`${e.directoryPath}/${r}`,i=s(t,e.projectPath);if((await e.filesystem.stat(t)).kind===`directory`){f(i,e.ignoredDirectories)||n.push(t);continue}m(i)&&e.selectedFiles.add(i)}n.sort((e,t)=>e.localeCompare(t));for(let t of n)await h({...e,directoryPath:t})},g=async e=>{let t=new Set,n=o(e.root,e.projectPath),r;try{r=await e.filesystem.stat(n)}catch(e){if(p(e))return[];throw e}if(r.kind===`file`){let r=s(n,e.projectPath);return m(r)&&t.add(r),[...t]}let i=s(n,e.projectPath);return i&&f(i,e.ignoredDirectories)?[]:(await h({filesystem:e.filesystem,directoryPath:n,projectPath:e.projectPath,ignoredDirectories:e.ignoredDirectories,selectedFiles:t}),[...t])},_=async e=>{let r=a(e.projectPath),o=e.include&&e.include.length>0?e.include:t,s=e.exclude??[],c=new Set(e.ignoredDirectories??n),l=e.files&&e.files.length>0?e.files:[``],u=new Set,f=[];for(let t of l){let n=await g({filesystem:e.filesystem,projectPath:r,root:t,ignoredDirectories:c});if(n.length===0){f.push(i(t)||`.`);continue}for(let e of n)u.add(e)}return{files:[...u].filter(e=>d(e,o)&&!d(e,s)).sort((e,t)=>e.localeCompare(t)),unmatchedRoots:f}};export{n as defaultGeoSpecIgnoredDirectories,t as defaultGeoSpecInclude,_ as discoverGeoSpecFiles,m as isGeoSpecTestFile};

package/dist/runner/filter.d.mts

@@ -0,0 +1,50 @@
+import { GeoSpecTestCase } from "./types.mjs";
+import { VmIssue } from "@taucad/esbuild/vm";
+//#region src/runner/filter.d.ts
+/**
+ * Compiled Vitest-style test-name pattern used by a GeoSpec run.
+ *
+ * @public
+ */
+type GeoSpecTestNamePattern = RegExp;
+/**
+ * Compile a Vitest-style test-name pattern once for a GeoSpec run.
+ *
+ * String inputs are JavaScript regular expression sources matched against the
+ * full `suite > test` name. `RegExp` inputs are used as-is.
+ *
+ * @param testNamePattern - Optional regex source or precompiled expression.
+ * @returns A compiled pattern or a structured issue when the source is invalid.
+ *
+ * @public
+ */
+declare const compileGeoSpecTestNamePattern: (testNamePattern: string | RegExp | undefined) => {
+  success: true;
+  pattern?: GeoSpecTestNamePattern;
+} | {
+  success: false;
+  issue: VmIssue;
+};
+/**
+ * Return true when a collected GeoSpec test matches the supplied compiled
+ * Vitest-style test-name pattern.
+ *
+ * @public
+ *
+ * @param test - collected test metadata.
+ * @param testNamePattern - optional compiled regex.
+ * @returns whether the test should be included.
+ */
+declare const matchesGeoSpecTestName: (test: Pick<GeoSpecTestCase, "suite" | "name">, testNamePattern: GeoSpecTestNamePattern | undefined) => boolean;
+/**
+ * Filter collected GeoSpec tests by compiled test-name pattern.
+ *
+ * @public
+ *
+ * @param tests - collected tests.
+ * @param testNamePattern - optional compiled regex.
+ * @returns tests that match the filter.
+ */
+declare const filterGeoSpecTests: (tests: readonly GeoSpecTestCase[], testNamePattern: GeoSpecTestNamePattern | undefined) => GeoSpecTestCase[];
+//#endregion
+export { GeoSpecTestNamePattern, compileGeoSpecTestNamePattern, filterGeoSpecTests, matchesGeoSpecTestName };

package/dist/runner/filter.mjs

@@ -0,0 +1 @@
+const e=e=>[...e.suite,e.name].join(` > `),t=e=>{if(e===void 0||typeof e==`string`&&e.trim()===``)return{success:!0};if(e instanceof RegExp)return{success:!0,pattern:e};try{return{success:!0,pattern:new RegExp(e,`u`)}}catch(t){return{success:!1,issue:{code:`INVALID_GEOSPEC_TEST_NAME_PATTERN`,message:`testNamePattern is not a valid JavaScript regular expression.`,severity:`error`,type:`runtime`,details:{testNamePattern:e,reason:t instanceof Error?t.message:String(t)}}}}},n=(t,n)=>!n||(n.lastIndex=0,n.test(e(t))),r=(e,t)=>e.filter(e=>n(e,t));export{t as compileGeoSpecTestNamePattern,r as filterGeoSpecTests,n as matchesGeoSpecTestName};

package/dist/runner/index.d.mts

@@ -0,0 +1,7 @@
+import { GeoSpecAssemblyOccurrenceExpectation, GeoSpecAssemblyOccurrencesExpectation, GeoSpecAssertion, GeoSpecAxisExpectation, GeoSpecBoundingBoxExpectation, GeoSpecCenterOfMassExpectation, GeoSpecChamferFeatureExpectation, GeoSpecCircularHoleExpectation, GeoSpecCircularHolePatternExpectation, GeoSpecComponentInterferenceAllowance, GeoSpecComponentInterferenceExpectation, GeoSpecComponentInterferencePairExpectation, GeoSpecConnectedComponentsExpectation, GeoSpecCylindricalFaceExpectation, GeoSpecFilletFeatureExpectation, GeoSpecGeometrySelector, GeoSpecMassExpectation, GeoSpecMatcher, GeoSpecMeshIntegrityExpectation, GeoSpecMinimumWallThicknessExpectation, GeoSpecModuleBundleCache, GeoSpecNumericExpectation, GeoSpecPlanarFaceExpectation, GeoSpecPointExpectation, GeoSpecProductStructureExpectation, GeoSpecRunFailure, GeoSpecRunResult, GeoSpecRunSuccess, GeoSpecSpatialRelationshipExpectation, GeoSpecSpatialRelationshipsExpectation, GeoSpecStepUnitsExpectation, GeoSpecSurfaceAreaExpectation, GeoSpecTestCase, GeoSpecTestEvent, GeoSpecTestStatus, GeoSpecTopologyCountsExpectation, GeoSpecValidBrepExpectation, GeoSpecVolumeExpectation, RunGeoSpecModuleOptions } from "./types.mjs";
+import { GeoSpecTestNamePattern, compileGeoSpecTestNamePattern, filterGeoSpecTests, matchesGeoSpecTestName } from "./filter.mjs";
+import { GeoSpecAssertionError, GeoSpecCollector, GeoSpecCollectorOptions, clearCollectorGlobals, createCollector, installCollector } from "./collector.mjs";
+import { DiscoverGeoSpecFilesOptions, GeoSpecDiscoveryFileKind, GeoSpecDiscoveryFileStat, GeoSpecDiscoveryFileSystem, GeoSpecDiscoveryResult, defaultGeoSpecIgnoredDirectories, defaultGeoSpecInclude, discoverGeoSpecFiles, isGeoSpecTestFile } from "./discovery.mjs";
+import { runGeoSpecModule } from "./run-geospec-module.mjs";
+import { GeoSpecTimeoutCode, geoSpecTimeoutCode, isGeoSpecTimeoutCode } from "./timeout-codes.mjs";
+export { type DiscoverGeoSpecFilesOptions, type GeoSpecAssemblyOccurrenceExpectation, type GeoSpecAssemblyOccurrencesExpectation, type GeoSpecAssertion, GeoSpecAssertionError, type GeoSpecAxisExpectation, type GeoSpecBoundingBoxExpectation, type GeoSpecCenterOfMassExpectation, type GeoSpecChamferFeatureExpectation, type GeoSpecCircularHoleExpectation, type GeoSpecCircularHolePatternExpectation, type GeoSpecCollector, type GeoSpecCollectorOptions, type GeoSpecComponentInterferenceAllowance, type GeoSpecComponentInterferenceExpectation, type GeoSpecComponentInterferencePairExpectation, type GeoSpecConnectedComponentsExpectation, type GeoSpecCylindricalFaceExpectation, type GeoSpecDiscoveryFileKind, type GeoSpecDiscoveryFileStat, type GeoSpecDiscoveryFileSystem, type GeoSpecDiscoveryResult, type GeoSpecFilletFeatureExpectation, type GeoSpecGeometrySelector, type GeoSpecMassExpectation, type GeoSpecMatcher, type GeoSpecMeshIntegrityExpectation, type GeoSpecMinimumWallThicknessExpectation, type GeoSpecModuleBundleCache, type GeoSpecNumericExpectation, type GeoSpecPlanarFaceExpectation, type GeoSpecPointExpectation, type GeoSpecProductStructureExpectation, type GeoSpecRunFailure, type GeoSpecRunResult, type GeoSpecRunSuccess, type GeoSpecSpatialRelationshipExpectation, type GeoSpecSpatialRelationshipsExpectation, type GeoSpecStepUnitsExpectation, type GeoSpecSurfaceAreaExpectation, type GeoSpecTestCase, type GeoSpecTestEvent, type GeoSpecTestNamePattern, type GeoSpecTestStatus, type GeoSpecTimeoutCode, type GeoSpecTopologyCountsExpectation, type GeoSpecValidBrepExpectation, type GeoSpecVolumeExpectation, type RunGeoSpecModuleOptions, clearCollectorGlobals, compileGeoSpecTestNamePattern, createCollector, defaultGeoSpecIgnoredDirectories, defaultGeoSpecInclude, discoverGeoSpecFiles, filterGeoSpecTests, geoSpecTimeoutCode, installCollector, isGeoSpecTestFile, isGeoSpecTimeoutCode, matchesGeoSpecTestName, runGeoSpecModule };

package/dist/runner/index.mjs

@@ -0,0 +1 @@
+import{compileGeoSpecTestNamePattern as e,filterGeoSpecTests as t,matchesGeoSpecTestName as n}from"./filter.mjs";import{geoSpecTimeoutCode as r,isGeoSpecTimeoutCode as i}from"./timeout-codes.mjs";import{GeoSpecAssertionError as a,clearCollectorGlobals as o,createCollector as s,installCollector as c}from"./collector.mjs";import{defaultGeoSpecIgnoredDirectories as l,defaultGeoSpecInclude as u,discoverGeoSpecFiles as d,isGeoSpecTestFile as f}from"./discovery.mjs";import{runGeoSpecModule as p}from"./run-geospec-module.mjs";export{a as GeoSpecAssertionError,o as clearCollectorGlobals,e as compileGeoSpecTestNamePattern,s as createCollector,l as defaultGeoSpecIgnoredDirectories,u as defaultGeoSpecInclude,d as discoverGeoSpecFiles,t as filterGeoSpecTests,r as geoSpecTimeoutCode,c as installCollector,f as isGeoSpecTestFile,i as isGeoSpecTimeoutCode,n as matchesGeoSpecTestName,p as runGeoSpecModule};

package/dist/runner/native/index.d.mts

@@ -0,0 +1,4 @@
+import { CreateGeoSpecNativeModelLoaderOptions, GeoSpecNativeLoadModelOptions, GeoSpecNativeModelEngine, GeoSpecNativeModelLoader, GeoSpecNativeModelResource, GeoSpecNativeModelSubject, GeoSpecNativeSourceReader, ManagedGeoSpecNativeModelLoader, createGeoSpecNativeModelLoader } from "../../model/native-model-loader.mjs";
+import { GeoSpecNativeRunnerAssertions, GeoSpecNativeRunnerOptions, createNativeGeoSpecRunner } from "./native-serial-runner.mjs";
+import { allocateNativePoolGrants } from "./native-pool-grants.mjs";
+export { type CreateGeoSpecNativeModelLoaderOptions, type GeoSpecNativeLoadModelOptions, type GeoSpecNativeModelEngine, type GeoSpecNativeModelLoader, type GeoSpecNativeModelResource, type GeoSpecNativeModelSubject, type GeoSpecNativeRunnerAssertions, type GeoSpecNativeRunnerOptions, type GeoSpecNativeSourceReader, type ManagedGeoSpecNativeModelLoader, allocateNativePoolGrants, createGeoSpecNativeModelLoader, createNativeGeoSpecRunner };

package/dist/runner/native/index.mjs

@@ -0,0 +1 @@
+import{createGeoSpecNativeModelLoader as e}from"../../model/native-model-loader.mjs";import{createNativeGeoSpecRunner as t}from"./native-serial-runner.mjs";import{allocateNativePoolGrants as n}from"./native-pool-grants.mjs";export{n as allocateNativePoolGrants,e as createGeoSpecNativeModelLoader,t as createNativeGeoSpecRunner};

package/dist/runner/native/native-pool-grants.d.mts

@@ -0,0 +1,21 @@
+//#region src/runner/native/native-pool-grants.d.ts
+/** Deterministic caller-inclusive permits for the host-composed compiled worker pool. @module */
+/**
+ * Assign a bounded CPU budget across already-selected worker isolates.
+ * The omitted budget is one permit per worker. A native pool must pass each
+ * returned grant to the engine it constructs inside the corresponding worker.
+ * A grant above one is admissible only for an engine with its own OCCT
+ * library instance: native workers that are threads of one process share one,
+ * so such a pool must use one worker or one permit per worker.
+ *
+ * @param options - Worker count, optional total budget, and host CPU cap.
+ * @returns Grants in worker creation order.
+ * @public
+ */
+declare const allocateNativePoolGrants: (options: {
+  workers: number;
+  budget?: number;
+  hostCap: number;
+}) => readonly number[];
+//#endregion
+export { allocateNativePoolGrants };

package/dist/runner/native/native-pool-grants.mjs

@@ -0,0 +1 @@
+const e=e=>{let{workers:t,hostCap:n}=e,r=e.budget??t;if(!Number.isSafeInteger(t)||!Number.isSafeInteger(r)||!Number.isSafeInteger(n)||t<1||r<t||r>n)throw RangeError(`Native pool requires positive workers and a caller-inclusive budget between workers and the host cap.`);let i=Math.floor(r/t),a=r%t;return Array.from({length:t},(e,t)=>i+ +(t<a))};export{e as allocateNativePoolGrants};

package/dist/runner/native/native-serial-runner.d.mts

@@ -0,0 +1,29 @@
+import { CreateGeoSpecNativeModelLoaderOptions, GeoSpecNativeModelEngine, ManagedGeoSpecNativeModelLoader } from "../../model/native-model-loader.mjs";
+import { GeoSpecAssertionClientOptions } from "../../assertion-client/client.mjs";
+import "../../assertion-client/index.mjs";
+import { GeoSpecRunner, GeoSpecRunnerOptions } from "../worker/runner-types.mjs";
+import "../worker/index.mjs";
+//#region src/runner/native/native-serial-runner.d.ts
+/** Native assertion options whose engine can also admit and release subjects. @public */
+type GeoSpecNativeRunnerAssertions = Omit<GeoSpecAssertionClientOptions, 'engine'> & {
+  readonly engine: GeoSpecNativeModelEngine;
+};
+/** Options for the native serial runner. @public */
+type GeoSpecNativeRunnerOptions = Omit<GeoSpecRunnerOptions, 'nativeAssertions' | 'nativeModelLoader'> & {
+  /** Actual protocol-3 engine used by authored assertions. */
+  readonly nativeAssertions: GeoSpecNativeRunnerAssertions;
+  /** Optional managed loader; the runner releases its subjects after every run. */
+  readonly nativeModelLoader?: ManagedGeoSpecNativeModelLoader;
+  /** Defaults used when the runner constructs its own native loader. */
+  readonly model?: Omit<CreateGeoSpecNativeModelLoaderOptions, 'engine'>;
+};
+/**
+ * Compose compiled assertion and model bindings with the SDK's serial lifecycle.
+ *
+ * @param options - VM filesystem, native engine/client options and model defaults.
+ * @returns The ordinary GeoSpec runner lifecycle and event contract.
+ * @public
+ */
+declare const createNativeGeoSpecRunner: (options: GeoSpecNativeRunnerOptions) => GeoSpecRunner;
+//#endregion
+export { GeoSpecNativeRunnerAssertions, GeoSpecNativeRunnerOptions, createNativeGeoSpecRunner };

package/dist/runner/native/native-serial-runner.mjs

@@ -0,0 +1 @@
+import{createGeoSpecNativeModelLoader as e}from"../../model/native-model-loader.mjs";import{createSerialGeoSpecRunner as t}from"../worker/serial-runner.mjs";const n=new TextDecoder(`utf-8`,{fatal:!0}),r=(e,t)=>{let r=JSON.parse(n.decode(e));if(typeof r!=`object`||!r||!(`plan`in r))throw TypeError(`Native GeoSpec assertion requires a plan with admitted subjects.`);let{plan:i}=r;if(typeof i!=`object`||!i||!(`subjects`in i)||!Array.isArray(i.subjects)||i.subjects.length===0)throw TypeError(`Native GeoSpec assertion requires admitted subjects.`);for(let e of i.subjects){if(typeof e!=`object`||!e)throw TypeError(`Native GeoSpec assertion requires admitted subjects.`);let n=`subjectHash`in e;if(n===`contentHash`in e)throw TypeError(`Native GeoSpec assertion requires one admitted subject identity.`);let r=n?e.subjectHash:`contentHash`in e?e.contentHash:void 0;if(typeof r!=`string`||!t.has(r))throw TypeError(`Native GeoSpec subject was not admitted by this run.`)}},i=i=>{let a=i.nativeModelLoader??e({...i.model,engine:i.nativeAssertions.engine,...i.nativeAssertions.maximumWorkUnitLimit===void 0?{}:{maximumWorkUnitLimit:i.nativeAssertions.maximumWorkUnitLimit}}),o=new Set,s=Object.assign(async e=>{let t=await a(e);return o.add(t.subjectHash),t},{async releaseAll(){try{await a.releaseAll()}finally{o.clear()}}}),c=i.nativeAssertions.engine,l={evaluateClaim(e){return r(e,o),c.evaluateClaim(e)},processRequest(e){let t=JSON.parse(n.decode(e));return typeof t==`object`&&t&&`method`in t&&t.method===`submitClaims`&&r(e,o),c.processRequest(e)},ingestSubject:(e,t,n)=>c.ingestSubject(e,t,n),subjectHandle:e=>c.subjectHandle(e),releaseSubject:e=>c.releaseSubject(e)},u=t({filesystem:i.filesystem,nativeAssertions:{...i.nativeAssertions,engine:l},nativeModelLoader:s,...i.builtinModules===void 0?{}:{builtinModules:i.builtinModules}});return{...u,async close(){try{await u.close()}finally{o.clear()}}}};export{i as createNativeGeoSpecRunner};

package/dist/runner/pool/pool-messages.d.mts

@@ -0,0 +1,94 @@
+import { GeoSpecRunResult } from "../types.mjs";
+//#region src/runner/pool/pool-messages.d.ts
+/** One schedulable work unit.
+ *
+ * @public
+ */
+type GeoSpecPoolShard = {
+  /** Stable shard id, unique within one pool run. */
+  id: number;
+  /** GeoSpec file this shard executes. */
+  file: string;
+  /** Exact-test pattern for split shards (R3: `(file, testNamePattern)` work units). */
+  testNamePattern?: string;
+};
+/** Host → worker messages. */
+/** @public */
+type GeoSpecPoolHostMessage = {
+  type: 'initialize';
+} | {
+  type: 'run-shard';
+  shard: GeoSpecPoolShard;
+  testNamePattern?: string;
+  testTimeout?: number;
+  matcherWallBackstop?: number;
+  forensic?: boolean;
+} | {
+  /** List-only collection pass: register tests, run no bodies (R3 splitting). */
+  type: 'list-tests';
+  shardId: number;
+  file: string;
+  testTimeout?: number;
+  matcherWallBackstop?: number;
+  forensic?: boolean;
+} | {
+  type: 'shutdown';
+};
+/** Worker → host messages. */
+/** @public */
+type GeoSpecPoolWorkerMessage = {
+  type: 'ready';
+} | {
+  type: 'initialized';
+} | {
+  type: 'initialization-error';
+  message: string;
+} | {
+  type: 'file-start';
+  shardId: number;
+  file: string;
+} | {
+  type: 'forensic';
+  shardId: number;
+  name: string;
+  value: number;
+  unit: 'milliseconds' | 'count';
+} | {
+  type: 'tests-listed';
+  shardId: number;
+  file: string;
+  names: string[];
+} | {
+  type: 'list-error';
+  shardId: number;
+  file: string;
+  message: string;
+} | {
+  type: 'shard-complete';
+  shardId: number;
+  file: string;
+  result: GeoSpecRunResult;
+  durationMs: number;
+  primaryLoadKey?: string;
+  /** Worker-isolate resident memory at completion (heap + external), bytes. */
+  workerMemoryBytes?: number;
+} | {
+  type: 'shard-error';
+  shardId: number;
+  file: string;
+  message: string;
+};
+/** Minimal worker handle the host-agnostic pool drives (Node or Web Worker). */
+/** @public */
+type GeoSpecPoolWorkerHandle = {
+  postMessage(message: GeoSpecPoolHostMessage): void;
+  onMessage(listener: (message: GeoSpecPoolWorkerMessage) => void): void;
+  onExit(listener: (details: {
+    unexpected: boolean;
+    message?: string;
+  }) => void): void;
+  /** Hard-stop the worker thread (R11 watchdog primitive). */
+  terminate(): Promise<void> | void;
+};
+//#endregion
+export { GeoSpecPoolHostMessage, GeoSpecPoolShard, GeoSpecPoolWorkerHandle, GeoSpecPoolWorkerMessage };

package/dist/runner/run-geospec-module.d.mts

@@ -0,0 +1,13 @@
+import { GeoSpecRunResult, RunGeoSpecModuleOptions } from "./types.mjs";
+//#region src/runner/run-geospec-module.d.ts
+/**
+ * Execute an ESM GeoSpec module using the shared Tau VM substrate.
+ *
+ * @param options - filesystem and test entry path.
+ * @returns collected test cases or structured VM issues.
+ *
+ * @public
+ */
+declare function runGeoSpecModule(options: RunGeoSpecModuleOptions): Promise<GeoSpecRunResult>;
+//#endregion
+export { runGeoSpecModule };

package/dist/runner/run-geospec-module.mjs

@@ -0,0 +1,47 @@
+import{bindGeoSpecSubject as e,rawSubjectResidency as t,resolveGeoSpecSubject as n}from"../model/subject.mjs";import{createGeoSpecAssertionClient as r}from"../assertion-client/client.mjs";import{GeoSpecModelLoadError as i}from"../model/errors.mjs";import{compileGeoSpecTestNamePattern as a,filterGeoSpecTests as o}from"./filter.mjs";import{createCollector as s}from"./collector.mjs";import{sha256Bytes as c}from"@taucad/runtime/kernel";import{createEsbuildModuleVm as l}from"@taucad/esbuild/vm";const u=`__GEOSPEC_RUN_BINDINGS__`,d=globalThis,f=()=>`geospec-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`,p=e=>JSON.stringify(Object.entries(e.builtinModules??{}).sort(([e],[t])=>e.localeCompare(t)).map(([e,t])=>[e,t.version,t.globalName,t.code])),m=(e,t)=>e.byteLength===t.byteLength&&e.every((e,n)=>e===t[n]),h=(e,t)=>e instanceof Uint8Array&&t instanceof Uint8Array?m(e,t):e===t,g=async(e,{question:t,path:n})=>t===`exists`?e.exists(n):t===`utf8`?e.readFile(n,`utf8`):e.readFile(n),_=async(e,t)=>(await Promise.all(t.map(async t=>{try{return h(await g(e,t),t.answer)}catch{return!1}}))).every(Boolean),v=e=>{let t=new Map,n=!0,r=async(e,r,i)=>{try{let a=await i,o=t.get(`${e}:${r}`);return o===void 0?t.set(`${e}:${r}`,{question:e,path:r,answer:a instanceof Uint8Array?Uint8Array.from(a):a}):n&&=h(o.answer,a),a}catch(e){throw n=!1,e}};return{filesystem:{exists:async t=>r(`exists`,t,e.exists(t)),readFile:(async(t,n)=>n===`utf8`?r(`utf8`,t,e.readFile(t,`utf8`)):r(`bytes`,t,e.readFile(t))),writeFile:async(t,n)=>e.writeFile(t,n),ensureDir:async t=>e.ensureDir(t)},reads:()=>n?[...t.values()]:void 0,observed:()=>[...t.values()]}},y=async e=>{let t=e.bundleCache?.get(e.entryPath);if(!(t===void 0||t.builtinIdentity!==p(e)||!await _(e.filesystem,t.bundlerReads)))return t},b=()=>{let e=d[u];if(e)return e;let t=new Map;return d[u]=t,t},x=e=>`
+const getRunBinding = () => {
+  const binding = globalThis.${u}?.get(${JSON.stringify(e)});
+  if (!binding) {
+    throw new Error('GeoSpec runner binding is not active. Run the module through runGeoSpecModule().');
+  }
+  return binding;
+};
+`,S=e=>`
+${x(e)}
+
+export const describe = (name, fn) => getRunBinding().collector.describe(name, fn);
+describe.skip = (name, fn) => getRunBinding().collector.describeSkip(name, fn);
+
+export const it = (name, fn) => getRunBinding().collector.it(name, fn);
+it.skip = (name, fn) => getRunBinding().collector.itSkip(name, fn);
+
+export const test = it;
+export const expectGeo = (subject, options) => getRunBinding().collector.expectGeo(subject, options);
+`,C=e=>`
+${x(e)}
+export const GeoSpecModelLoadError = getRunBinding().geoSpecModelLoadError;
+
+export const loadModel = async (options) => {
+  const binding = getRunBinding();
+  const loader = binding.nativeModelLoader;
+  if (typeof loader !== 'function') {
+    throw new GeoSpecModelLoadError([
+      {
+        code: 'GEOSPEC_MODEL_LOADER_UNAVAILABLE',
+        severity: 'error',
+        message: 'No GeoSpec model loader is active for this runner.',
+        suggestion: 'Run this test through the GeoSpec CLI or Tau browser test runner.',
+      },
+    ]);
+  }
+  return loader(options);
+};
+
+export const createModelLoader = (defaults = {}) => {
+  const factory = getRunBinding().createModelLoader;
+  if (typeof factory !== 'function') {
+    throw new GeoSpecModelLoadError([{ code: 'GEOSPEC_MODEL_LOADER_UNAVAILABLE', severity: 'error', message: 'No managed GeoSpec model loader is active for this runner.' }]);
+  }
+  return factory(defaults);
+};
+`;async function w(m){let h=a(m.testNamePattern);if(!h.success)return{success:!1,issues:[h.issue]};let g=v(m.filesystem),_=await l({filesystem:g.filesystem}),x=s({...m.matcherWallBackstop===void 0?{}:{matcherWallBackstop:m.matcherWallBackstop},...m.forensic===void 0?{}:{forensic:m.forensic},...m.onTestEvent===void 0?{}:{onTestEvent:m.onTestEvent},nativeAssertions:m.nativeAssertions}),w=await y(m),T=f(),E=b(),D=new Set,O=[],k=async()=>{do{let e=[...D];await Promise.allSettled(e);for(let t of e)D.delete(t)}while(D.size>0)},A=m.nativeModelLoader,j=r(m.nativeAssertions),M=!0,N=A===void 0?void 0:n=>{let r=O.length,a=`${T}:load:${r+1}`;O.push({loadId:a,status:`unavailable`});let o=(async()=>{try{let i=await A(n),{load:o,...s}=i,c=t(i),l=o===void 0?void 0:{...structuredClone(o),loadId:a};return O[r]={loadId:a,status:l?.status??`unavailable`,subject:s,...l===void 0?{}:{evidence:l}},e({engine:m.nativeAssertions.engine,client:j,identity:s,...l===void 0?{}:{load:l},isLive:()=>M,...c===void 0?{}:{ensureResident:c}})}catch(e){throw O[r]={loadId:a,status:`failed`,error:e instanceof Error?e.message:String(e),...e instanceof i?{diagnostics:e.diagnostics}:{}},e}})();return D.add(o.catch(()=>void 0)),D.add(o),o};E.set(T,{collector:x,geoSpecModelLoadError:i,...N?{nativeModelLoader:N}:{},...N?{createModelLoader:t=>{if(t.engine!==void 0||t.readSource!==void 0)throw TypeError(`Authored VM model defaults cannot replace the admitting host.`);let r=0,i=new Set,a=new Set,o,s=async i=>{let o=r,s=await N({...t,...i}),c=n(s);return c.lease!==void 0&&a.add(c.lease),e({...c,isLive:()=>c.isLive()&&r===o})},c=e=>{let t=s(e);return i.add(t),t},l=async()=>{do{let e=[...i];await Promise.allSettled(e);for(let t of e)i.delete(t)}while(i.size>0);r+=1;let e=[];for(let t of a)try{t.dispose(),a.delete(t)}catch(t){e.push(t)}if(e.length>0)throw AggregateError(e,`GeoSpec model scope disposal failed.`)};return Object.assign(c,{dispose(){return o??=l().finally(()=>{o=void 0}),o}})}}:{}}),_.registerModule(`geospec`,{version:`0.0.0-poc`,code:S(T)}),_.registerModule(`geospec/model`,{version:`0.0.0-poc`,code:C(T)});for(let[e,t]of Object.entries(m.builtinModules??{}))_.registerModule(e,t);try{let e=w?.bundle??await _.bundle(m.entryPath);if(!e.success)return{success:!1,issues:e.issues,bundle:e};let t=g.reads();m.bundleCache!==void 0&&w===void 0&&t!==void 0&&m.bundleCache.set(m.entryPath,{builtinIdentity:p(m),runToken:T,bundle:e,bundlerReads:t});let n=await _.execute(w===void 0?e.code:e.code.replaceAll(w.runToken,T)),r=async()=>{let t={},n=g.reads()!==void 0;for(let e of w?.bundlerReads??g.observed()){if(e.question===`exists`||typeof e.answer==`boolean`)continue;let r=await c(typeof e.answer==`string`?new TextEncoder().encode(e.answer):e.answer);n&&=t[e.path]===void 0||t[e.path]===`sha256:${r}`,t[e.path]=`sha256:${r}`}let r=new Map(Object.entries(t));for(let e of O){let{evidence:t}=e;for(let e of t?.exportOptions===void 0?t?.artifacts??[]:[])if(e.sourcePath!==void 0){let t=`sha256:${e.sha256}`;n&&=!r.has(e.sourcePath)||r.get(e.sourcePath)===t,r.set(e.sourcePath,t)}if(t?.sourcePath!==void 0&&t.exportOptions===void 0){let e=t.artifacts[0];if(e!==void 0){let i=`sha256:${e.sha256}`;n&&=!r.has(t.sourcePath)||r.get(t.sourcePath)===i,r.set(t.sourcePath,i)}}for(let[t,i]of Object.entries(e.evidence?.sourceRevision?.files??{}))n&&=!r.has(t)||r.get(t)===i,r.set(t,i)}return{status:n?O.some(e=>e.status!==`complete`)?`unavailable`:`complete`:`mixed`,modules:[{entryPath:m.entryPath,bundleSha256:await c(new TextEncoder().encode(w===void 0?e.code:e.code.replaceAll(w.runToken,T))),files:t,consistent:n}],loads:O}},i=e=>({discovered:x.tests.length,selected:e,completed:x.tests.filter(e=>e.status!==`not-run`&&e.status!==`skipped`).length,passed:x.tests.filter(e=>e.status===`passed`).length,failed:x.tests.filter(e=>e.status===`failed`).length,unsupported:x.tests.filter(e=>e.status===`unsupported`).length,inconclusive:x.tests.filter(e=>e.status===`inconclusive`).length,skipped:x.tests.filter(e=>e.status===`skipped`).length,notRun:x.tests.filter(e=>e.status===`not-run`).length});if(!n.success)return await k(),{success:!1,issues:n.issues,bundle:e,tests:x.tests,accounting:i(0),lineage:await r()};if(m.collectOnly===!0)return await x.waitForCompletion(m.testTimeout,/(?!)/u),await k(),{success:!0,passed:!1,tests:x.tests,bundle:e,accounting:i(0),lineage:await r()};await x.waitForCompletion(m.testTimeout,h.pattern),await k();let a=o(x.tests,h.pattern),s=await r();return{success:!0,passed:s.status===`complete`&&a.every(e=>e.status===`passed`||e.status===`skipped`),tests:a,bundle:e,accounting:i(a.length),lineage:s}}finally{await k(),M=!1,E.delete(T),E.size===0&&Reflect.deleteProperty(d,u),_.dispose()}}export{w as runGeoSpecModule};

package/dist/runner/timeout-codes.d.mts

@@ -0,0 +1,45 @@
+//#region src/runner/timeout-codes.d.ts
+/**
+ * One timeout vocabulary for every GeoSpec host.
+ *
+ * GeoSpec has three wall-clock bounds, and each host reports the ones it
+ * applies with the same code, so a spec that times out reads the same whether
+ * it ran in the browser worker, the Node pool or the CLI:
+ *
+ * | Code                    | Bound                                         | Set by                                        | Hosts                 |
+ * | ----------------------- | --------------------------------------------- | --------------------------------------------- | --------------------- |
+ * | `GEOSPEC_TEST_TIMEOUT`  | One test's async body                         | `test_model.testTimeout`, CLI `--test-timeout` | Every host            |
+ * | `GEOSPEC_SHARD_TIMEOUT` | One pool shard; its worker is terminated      | CLI `--shard-timeout`, pool `shardTimeout`     | Node pool             |
+ * | `GEOSPEC_RUN_TIMEOUT`   | One whole run; completed requirements survive | The host's run budget                          | Browser worker runner |
+ *
+ * None of them is a geometry verdict: a timed-out requirement is never a pass,
+ * and the deterministic work-unit budget inside the engine (`MATCHER_TIMEOUT`)
+ * is a separate, non-wall-clock refusal.
+ *
+ * @module
+ */
+/**
+ * Codes for GeoSpec wall-clock timeouts, one per bound.
+ *
+ * @public
+ */
+declare const geoSpecTimeoutCode: {
+  /** A test's async body outlived `testTimeout` / `--test-timeout`. */
+  readonly test: "GEOSPEC_TEST_TIMEOUT";
+  /** A pool shard outlived the non-verdict `--shard-timeout` watchdog. */
+  readonly shard: "GEOSPEC_SHARD_TIMEOUT";
+  /** A whole run outlived its host run budget. */
+  readonly run: "GEOSPEC_RUN_TIMEOUT";
+};
+/** One GeoSpec timeout code. @public */
+type GeoSpecTimeoutCode = (typeof geoSpecTimeoutCode)[keyof typeof geoSpecTimeoutCode];
+/**
+ * Whether a diagnostic or issue code belongs to the GeoSpec timeout family.
+ *
+ * @param code - Any diagnostic or issue code.
+ * @returns True for {@link geoSpecTimeoutCode} values.
+ * @public
+ */
+declare const isGeoSpecTimeoutCode: (code: string) => code is GeoSpecTimeoutCode;
+//#endregion
+export { GeoSpecTimeoutCode, geoSpecTimeoutCode, isGeoSpecTimeoutCode };

package/dist/runner/timeout-codes.mjs

@@ -0,0 +1 @@
+const e={test:`GEOSPEC_TEST_TIMEOUT`,shard:`GEOSPEC_SHARD_TIMEOUT`,run:`GEOSPEC_RUN_TIMEOUT`},t=new Set(Object.values(e)),n=e=>t.has(e);export{e as geoSpecTimeoutCode,n as isGeoSpecTimeoutCode};