@faicad/faijs 0.13.0

package/dist/define-op.d.ts

@@ -0,0 +1,163 @@
+/**
+ * define-op — dual-path implementation decorator for geometry functions
+ * (D-face contract: mesh mandatory as the default path, BREP optional).
+ *
+ *
+ * `defineOp({ mesh?, brep?, ... })` declares the implementation set of a
+ * geometry function (a function whose signature returns `SolidShape`). The
+ * wrapper:
+ * - auto-collects geometry inputs via `args.filter(isGeometryInput)` — a shape
+ *   that is identity-registered (`isShape`) or a structural mesh shape
+ *   (`isMeshShape`, positions + indices — e.g. bare ManifoldMeshData handed in
+ *   by a host via `geoToManifoldMesh`). The old per-function form passed the
+ *   actual geometry args (`dispatchPath([input], ...)`), so a bare mesh input
+ *   dispatched to the mesh path (`hasBrep=false`); the re-collection must keep
+ *   that compatibility. No `inputs` field — decided at runtime by the args
+ *   themselves, not the author.
+ * - calls the engine's `dispatchPath` to select brep/mesh by mode (static,
+ *   no runtime fallback);
+ * - wraps raw products: mesh path → `solid()`, brep path → `fromHandle()` /
+ *   `fromBrep()` (D3/D4: products must come from constructors, brep products
+ *   must carry a BREP slot).
+ *
+ * Zero heavy runtime dependencies: imports only runtime-state / shape /
+ * handle-bridge / backend-dispatch / mesh/types (a zero-import module holding
+ * the Shape type and the structural `isMeshShape` guard) — the dist/sdk.js
+ * static-import guard keeps passing.
+ */
+import { type BrepCapabilityName } from './cad-runtime/backend-dispatch.js';
+import { type SlotMap } from './api/internal/dual-form-args.js';
+import type { Shape } from './mesh/types.js';
+import type { BrepHandle } from './brep/engine/types.js';
+/** Raw mesh data (structurally identical to Shape; mesh impls return it). */
+export type MeshData = {
+    positions: Float32Array;
+    indices: Uint32Array;
+};
+/**
+ * Geometry-input recognition for dispatch auto-collection.
+ *
+ * Compat rule: the old per-function form passed the *actual* geometry args to
+ * `dispatchPath` (`[input]` / `shapes`), so a bare ManifoldMeshData object
+ * (e.g. `geoToManifoldMesh` output passed straight by a host) had no BREP slot
+ * → `hasBrep=false` → mesh path. defineOp must keep that: an input counts as
+ * geometry when it is identity-registered (`isShape`, constructor product) OR
+ * structurally a mesh shape (`positions` + `indices`). Params objects and other
+ * scalar args are not geometry inputs.
+ *
+ * @param v - the candidate argument.
+ * @returns true when the argument is a geometry input (registered shape or bare mesh data).
+ */
+export declare function isGeometryInput(v: unknown): v is Shape;
+/** Product of a mesh implementation: raw mesh data, a wrapped Shape, or (with `outputs`) a record of named products. */
+export type MeshProduct = MeshData | Shape | Record<string, MeshData | Shape>;
+/** Mesh implementation: sync or async (stdlib mesh paths are often async); returns a mesh product. */
+export type MeshImpl<A extends unknown[]> = (...args: A) => MeshProduct | Promise<MeshProduct>;
+/** BREP implementation result: a raw handle, or a handle plus face evolution. */
+export interface BrepResult {
+    solid: BrepHandle;
+    faceEvolution?: Map<number, number[]>;
+}
+/** Product of a BREP implementation: a raw handle, { solid, faceEvolution }, a wrapped Shape, or (with `outputs`) a record of named products. */
+export type BrepProduct = BrepHandle | BrepResult | Shape | Record<string, BrepHandle | BrepResult | Shape>;
+/** BREP implementation: sync or async; returns a brep product. */
+export type BrepImpl<A extends unknown[]> = (...args: A) => BrepProduct | Promise<BrepProduct>;
+/** Optional declaration: capabilities (D5) and named multi-products (split, scheme C). */
+export interface DualOpOptions {
+    /** Op name (error messages); falls back to an anonymous prefix when absent. */
+    name?: string;
+    capabilities?: BrepCapabilityName[];
+    outputs?: string[];
+    /** L3 schema per named parameter (G1 codegen + UI panel, plain string form). */
+    schema?: Record<string, string>;
+    /**
+     * D11 slot-map declaration (§4.2): the positional→object boxing table
+     * (SlotMap) mapping a brepjs-style positional call onto this op's native
+     * object form. Ops without it accept only the form their implementation
+     * natively takes.
+     */
+    slotMap?: SlotMap;
+}
+/** Implementation set (at least one of mesh/brep is required, D1/D1b); options are siblings of the implementations. */
+export type DualOpImpls<A extends unknown[]> = (DualOpOptions & {
+    mesh: MeshImpl<A>;
+    brep?: BrepImpl<A>;
+}) | (DualOpOptions & {
+    mesh?: never;
+    brep: BrepImpl<A>;
+});
+/** Metadata hung on the wrapped function object (K5: function info is data). */
+export interface DualOpMeta {
+    kind: 'dual-op';
+    mesh?: unknown;
+    brep?: unknown;
+    /** Op name (error messages). */
+    name?: string;
+    capabilities?: BrepCapabilityName[];
+    outputs?: string[];
+    schema?: Record<string, string>;
+    /** D11 slot-map declaration (positional → object boxing table, §9 naming). */
+    slotMap?: SlotMap;
+}
+/** Property key carrying DualOpMeta on wrapped functions. */
+export declare const DUAL_OP_META = "__faijs__dualOp";
+type MetaCarrier = {
+    [DUAL_OP_META]?: DualOpMeta;
+};
+/**
+ * Declare a geometry function's dual-path implementation set.
+ *
+ * At least one implementation (mesh or brep) is required — enforced at
+ * compile time by the union type and at construction time by a runtime check.
+ * Geometry inputs are auto-collected by identity-or-structure
+ * (`args.filter(isGeometryInput)` = `isShape` ∨ `isMeshShape`); raw mesh
+ * products are wrapped by `solid()`, raw brep products by
+ * `fromHandle()` / `fromBrep()`. `mode` selects the engine path via the
+ * engine's static `dispatchPath` — the author never writes an `if (path)`
+ * branch.
+ *
+ * @param decl - the declaration object: implementations `{ mesh }` (mesh-only),
+ * `{ brep }` (brep-only, D1b), or `{ mesh, brep }` (dual-path), plus optional
+ * `capabilities` (D5: missing capability degrades in auto, errors in brep mode)
+ * and `outputs` (named multi-products, e.g. split) as siblings.
+ * @returns the wrapped geometry function with dual-op metadata attached.
+ */
+export declare function defineOp<A extends unknown[]>(decl: DualOpImpls<A> & {
+    outputs: string[];
+}): ((...args: A) => Promise<Record<string, Shape>>) & MetaCarrier;
+/**
+ * Overload without `outputs`: single-product functions resolve to a `Promise<Shape>`.
+ * @param decl - the declaration object: implementations `{ mesh }`, `{ brep }`, or `{ mesh, brep }`.
+ * @returns the wrapped geometry function with dual-op metadata attached.
+ */
+export declare function defineOp<A extends unknown[]>(decl: DualOpImpls<A>): ((...args: A) => Promise<Shape>) & MetaCarrier;
+/**
+ * Assembly-time validation (③, strict mode, D-4): a library that exports any
+ * dual-op function must carry a matching `contractVersion`, and every exported
+ * dual-op must be structurally valid (mesh a function, brep a function or
+ * undefined, capabilities/outputs well-formed). Called by `registerLib`.
+ *
+ * Functions without dual-op metadata are left untouched (declarative
+ * enforcement boundary — K5 forbids name-based classification).
+ *
+ * @param lib - the library namespace object being registered.
+ */
+/**
+ * Detect whether a library namespace exports any dual-op function (carries
+ * `DUAL_OP_META`). Used by `registerLib`'s inferred `autoLift` default: a
+ * library that already declares dual-ops does not need bare-function lifting.
+ *
+ * @param ns - the library namespace object.
+ * @returns `true` if at least one exported value is a dual-op function.
+ */
+export declare function hasDualOp(ns: Record<string, unknown>): boolean;
+/**
+ * Assert that a library conforms to the dual-op contract: if it exports any
+ * dual-op function, it must also export `contractVersion` matching the engine's.
+ *
+ * @param lib - the library namespace object being registered.
+ * @throws {Error} when dual-op functions are present without a matching contract version.
+ */
+export declare function assertLibConforms(lib: Record<string, unknown>): void;
+export {};
+//# sourceMappingURL=define-op.d.ts.map

package/dist/define-op.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-op.d.ts","sourceRoot":"","sources":["../src/define-op.ts"],"names":[],"mappings":"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"}

package/dist/define-op.js

@@ -0,0 +1,268 @@
+/**
+ * define-op — dual-path implementation decorator for geometry functions
+ * (D-face contract: mesh mandatory as the default path, BREP optional).
+ *
+ *
+ * `defineOp({ mesh?, brep?, ... })` declares the implementation set of a
+ * geometry function (a function whose signature returns `SolidShape`). The
+ * wrapper:
+ * - auto-collects geometry inputs via `args.filter(isGeometryInput)` — a shape
+ *   that is identity-registered (`isShape`) or a structural mesh shape
+ *   (`isMeshShape`, positions + indices — e.g. bare ManifoldMeshData handed in
+ *   by a host via `geoToManifoldMesh`). The old per-function form passed the
+ *   actual geometry args (`dispatchPath([input], ...)`), so a bare mesh input
+ *   dispatched to the mesh path (`hasBrep=false`); the re-collection must keep
+ *   that compatibility. No `inputs` field — decided at runtime by the args
+ *   themselves, not the author.
+ * - calls the engine's `dispatchPath` to select brep/mesh by mode (static,
+ *   no runtime fallback);
+ * - wraps raw products: mesh path → `solid()`, brep path → `fromHandle()` /
+ *   `fromBrep()` (D3/D4: products must come from constructors, brep products
+ *   must carry a BREP slot).
+ *
+ * Zero heavy runtime dependencies: imports only runtime-state / shape /
+ * handle-bridge / backend-dispatch / mesh/types (a zero-import module holding
+ * the Shape type and the structural `isMeshShape` guard) — the dist/sdk.js
+ * static-import guard keeps passing.
+ */
+import { dispatchPath } from './cad-runtime/backend-dispatch.js';
+import { getBackends, CONTRACT_VERSION, BrepUnsupportedError, MeshUnsupportedError, } from './runtime-state.js';
+import { isShape, solid, fromBrep } from './shape.js';
+import { isMeshShape } from './mesh/types.js';
+import { fromHandle, meshHandle, isOcctHandle } from './brep/handle-bridge.js';
+import { positionalToObject } from './api/internal/dual-form-args.js';
+import { toOpFailure, unwrapResult, OpError } from './api/internal/result-unwrap.js';
+/**
+ * Geometry-input recognition for dispatch auto-collection.
+ *
+ * Compat rule: the old per-function form passed the *actual* geometry args to
+ * `dispatchPath` (`[input]` / `shapes`), so a bare ManifoldMeshData object
+ * (e.g. `geoToManifoldMesh` output passed straight by a host) had no BREP slot
+ * → `hasBrep=false` → mesh path. defineOp must keep that: an input counts as
+ * geometry when it is identity-registered (`isShape`, constructor product) OR
+ * structurally a mesh shape (`positions` + `indices`). Params objects and other
+ * scalar args are not geometry inputs.
+ *
+ * @param v - the candidate argument.
+ * @returns true when the argument is a geometry input (registered shape or bare mesh data).
+ */
+export function isGeometryInput(v) {
+    return isShape(v) || isMeshShape(v);
+}
+/** Property key carrying DualOpMeta on wrapped functions. */
+export const DUAL_OP_META = '__faijs__dualOp';
+function wrapMeshOne(v) {
+    if (isShape(v))
+        return v;
+    return solid(v);
+}
+function wrapBrepOne(v) {
+    if (isShape(v))
+        return v;
+    if (v !== null && typeof v === 'object' && 'faceEvolution' in v) {
+        const res = v;
+        return fromBrep(meshHandle(res.solid), res);
+    }
+    // A plain object that is not a Shape and not an OCCT handle is a data
+    // product (e.g. a compat fn returning a sheetmetal-style record), not a
+    // geometry handle — pass it through so it lands in the engine's value
+    // store instead of being tessellated as if it were a bare handle. Native
+    // OCCT handles from an implementation are hand-computed shape numbers
+    // (from a branded number return) or objects; only the number path reaches
+    // fromHandle. The handle/data distinction must go through the shared
+    // isOcctHandle leaf (handle-bridge) — never a hardcoded '__occtWasm' in v.
+    if (v !== null && typeof v === 'object' && !isOcctHandle(v)) {
+        return v;
+    }
+    return fromHandle(v);
+}
+function wrapByKeys(r, keys, wrapOne) {
+    const src = (r ?? {});
+    const out = {};
+    for (const k of keys) {
+        const v = src[k];
+        // An output may be an array (e.g. the compat adapter adopts each element of
+        // an array-valued `outputs` field); wrap element-wise so arrays stay arrays.
+        out[k] = Array.isArray(v) ? v.map(wrapOne) : wrapOne(v);
+    }
+    return out;
+}
+/** Human-readable op label for error messages (falls back when unnamed). */
+function opLabel(meta) {
+    return meta.name ?? '<anon>';
+}
+/**
+ * Run one implementation through the unified Result boundary (§5.2, D1).
+ *
+ * Transition contract: an implementation may
+ *   ① return a `Result`  → unwrapped here (`err` becomes a throw);
+ *   ② throw              → normalized into an op-labelled error;
+ *   ③ return a plain product → passed through untouched.
+ *
+ * The two engine-level routing errors keep their class: `runtime.ts` matches
+ * `BrepUnsupportedError` / `MeshUnsupportedError` by `instanceof` to turn them
+ * into `ExecutionResult.failedAt`, so they must not be re-wrapped.
+ *
+ * @param meta - the op's metadata (name).
+ * @param impl - the implementation to run.
+ * @param args - the normalized argument list.
+ * @returns the (unwrapped) implementation product.
+ */
+async function runImpl(meta, impl, args) {
+    const label = opLabel(meta);
+    let product;
+    try {
+        product = await impl(...args);
+    }
+    catch (e) {
+        if (e instanceof BrepUnsupportedError || e instanceof MeshUnsupportedError)
+            throw e;
+        // An OpError is already the engine-recognizable statement failure (thrown
+        // by the compat adapter's Result unwrap, or by impls returning a Result);
+        // re-wrapping it into a plain Error would make CadRuntime treat it as an
+        // uncaught bug instead of a statement failure.
+        if (e instanceof OpError)
+            throw e;
+        throw toOpFailure(label, e);
+    }
+    return unwrapResult(product, label);
+}
+/** Implementation signature (not visible to callers); matches the union of both overloads. */
+export function defineOp(decl) {
+    // Construction-time check (②): implementations must be functions, then at
+    // least one implementation must be present.
+    if (decl.mesh !== undefined && typeof decl.mesh !== 'function') {
+        throw new Error('[faijs/defineOp] mesh must be a function');
+    }
+    if (decl.brep !== undefined && typeof decl.brep !== 'function') {
+        throw new Error('[faijs/defineOp] brep must be a function');
+    }
+    if (typeof decl.mesh !== 'function' && typeof decl.brep !== 'function') {
+        throw new Error('[faijs/defineOp] at least one implementation (mesh or brep) is required');
+    }
+    const meta = {
+        kind: 'dual-op',
+        mesh: decl.mesh,
+        brep: decl.brep,
+        name: decl.name,
+        capabilities: decl.capabilities,
+        outputs: decl.outputs,
+        schema: decl.schema,
+        slotMap: decl.slotMap,
+    };
+    // Async wrapper: implementations may be sync or async (stdlib mesh paths are
+    // often async, e.g. drill/engrave/boolean). The compiled .fai.js product always
+    // awaits the call, so returning a Promise is transparent.
+    const wrapped = async (...args) => {
+        // D11 (§4.2): faijs-native ops declare an object-form implementation, so a
+        // brepjs-style positional call is boxed into the object form here — before
+        // dispatch, so geometry inputs are collected from the normalized arg list.
+        const callArgs = (meta.slotMap ? positionalToObject(args, meta.slotMap, opLabel(meta)) : args);
+        // Geometry inputs: identity-or-structure auto collection (execution-time
+        // read, same nature as hasBrep — decided before the implementation runs).
+        // Compat: bare ManifoldMeshData args (host geoToManifoldMesh output) are
+        // geometry inputs too — old form passed [input] so they reached the mesh path.
+        const inputs = callArgs.filter(isGeometryInput);
+        // D5 capability routing: feed the first missing capability to dispatchPath
+        // (auto degrades to mesh, brep mode errors).
+        const missing = meta.capabilities?.find((cap) => !getBackends().config.brepCapabilities?.[cap]);
+        const path = dispatchPath(inputs, meta, missing);
+        if (path === 'brep') {
+            const r = await runImpl(meta, decl.brep, callArgs);
+            return meta.outputs ? wrapByKeys(r, meta.outputs, wrapBrepOne) : wrapBrepOne(r);
+        }
+        const m = await runImpl(meta, decl.mesh, callArgs);
+        return meta.outputs ? wrapByKeys(m, meta.outputs, wrapMeshOne) : wrapMeshOne(m);
+    };
+    Object.defineProperty(wrapped, DUAL_OP_META, { value: meta, enumerable: false });
+    return wrapped;
+}
+/**
+ * Assembly-time validation (③, strict mode, D-4): a library that exports any
+ * dual-op function must carry a matching `contractVersion`, and every exported
+ * dual-op must be structurally valid (mesh a function, brep a function or
+ * undefined, capabilities/outputs well-formed). Called by `registerLib`.
+ *
+ * Functions without dual-op metadata are left untouched (declarative
+ * enforcement boundary — K5 forbids name-based classification).
+ *
+ * @param lib - the library namespace object being registered.
+ */
+/**
+ * Detect whether a library namespace exports any dual-op function (carries
+ * `DUAL_OP_META`). Used by `registerLib`'s inferred `autoLift` default: a
+ * library that already declares dual-ops does not need bare-function lifting.
+ *
+ * @param ns - the library namespace object.
+ * @returns `true` if at least one exported value is a dual-op function.
+ */
+export function hasDualOp(ns) {
+    const values = Object.values(ns);
+    return values.some((v) => typeof v === 'function' && v[DUAL_OP_META]);
+}
+/**
+ * Assert that a library conforms to the dual-op contract: if it exports any
+ * dual-op function, it must also export `contractVersion` matching the engine's.
+ *
+ * @param lib - the library namespace object being registered.
+ * @throws {Error} when dual-op functions are present without a matching contract version.
+ */
+export function assertLibConforms(lib) {
+    if (hasDualOp(lib) && lib.contractVersion !== CONTRACT_VERSION) {
+        throw new Error(`[faijs] library with dual-op functions must export contractVersion = ${CONTRACT_VERSION} (got ${String(lib.contractVersion)})`);
+    }
+    for (const [name, value] of Object.entries(lib)) {
+        if (typeof value !== 'function')
+            continue;
+        const meta = value[DUAL_OP_META];
+        if (!meta || meta.kind !== 'dual-op')
+            continue;
+        if (typeof meta.mesh !== 'function' && typeof meta.brep !== 'function') {
+            throw new Error(`[faijs] lib function '${name}' declares dual-op without any implementation`);
+        }
+        if (meta.mesh !== undefined && typeof meta.mesh !== 'function') {
+            throw new Error(`[faijs] lib function '${name}' declares dual-op with a non-function mesh implementation`);
+        }
+        if (meta.brep !== undefined && typeof meta.brep !== 'function') {
+            throw new Error(`[faijs] lib function '${name}' declares dual-op with a non-function brep implementation`);
+        }
+        if (meta.capabilities !== undefined && !Array.isArray(meta.capabilities)) {
+            throw new Error(`[faijs] lib function '${name}' declares invalid capabilities (expected string[])`);
+        }
+        if (meta.outputs !== undefined
+            && (!Array.isArray(meta.outputs) || meta.outputs.some((k) => typeof k !== 'string'))) {
+            throw new Error(`[faijs] lib function '${name}' declares invalid outputs (expected string[])`);
+        }
+        if (meta.schema !== undefined && !isValidSchema(meta.schema)) {
+            throw new Error(`[faijs] lib function '${name}' declares invalid schema (expected Record<string, string>)`);
+        }
+        if (meta.name !== undefined && typeof meta.name !== 'string') {
+            throw new Error(`[faijs] lib function '${name}' declares invalid name (expected string)`);
+        }
+        if (meta.slotMap !== undefined && !isValidSlotMap(meta.slotMap)) {
+            throw new Error(`[faijs] lib function '${name}' declares invalid slotMap (expected { keys: string[]; vec3Keys?: string[]; shapeArity?: number })`);
+        }
+    }
+}
+/** True when the D11 slot-map declaration has a non-empty string `keys` list. */
+function isValidSlotMap(form) {
+    if (form === null || typeof form !== 'object')
+        return false;
+    const keys = form.keys;
+    if (!Array.isArray(keys) || keys.some((k) => typeof k !== 'string'))
+        return false;
+    const vec3 = form.vec3Keys;
+    if (vec3 !== undefined && (!Array.isArray(vec3) || vec3.some((k) => typeof k !== 'string')))
+        return false;
+    const arity = form.shapeArity;
+    if (arity !== undefined && (typeof arity !== 'number' || !Number.isInteger(arity) || arity < 0))
+        return false;
+    return true;
+}
+/** True when every schema value is a non-empty string. */
+function isValidSchema(schema) {
+    if (schema === null || typeof schema !== 'object' || Array.isArray(schema))
+        return false;
+    return Object.values(schema).every((v) => typeof v === 'string' && v.length > 0);
+}
+//# sourceMappingURL=define-op.js.map

package/dist/define-op.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-op.js","sourceRoot":"","sources":["../src/define-op.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * define-op — dual-path implementation decorator for geometry functions\n * (D-face contract: mesh mandatory as the default path, BREP optional).\n *\n *\n * `defineOp({ mesh?, brep?, ... })` declares the implementation set of a\n * geometry function (a function whose signature returns `SolidShape`). The\n * wrapper:\n * - auto-collects geometry inputs via `args.filter(isGeometryInput)` — a shape\n *   that is identity-registered (`isShape`) or a structural mesh shape\n *   (`isMeshShape`, positions + indices — e.g. bare ManifoldMeshData handed in\n *   by a host via `geoToManifoldMesh`). The old per-function form passed the\n *   actual geometry args (`dispatchPath([input], ...)`), so a bare mesh input\n *   dispatched to the mesh path (`hasBrep=false`); the re-collection must keep\n *   that compatibility. No `inputs` field — decided at runtime by the args\n *   themselves, not the author.\n * - calls the engine's `dispatchPath` to select brep/mesh by mode (static,\n *   no runtime fallback);\n * - wraps raw products: mesh path → `solid()`, brep path → `fromHandle()` /\n *   `fromBrep()` (D3/D4: products must come from constructors, brep products\n *   must carry a BREP slot).\n *\n * Zero heavy runtime dependencies: imports only runtime-state / shape /\n * handle-bridge / backend-dispatch / mesh/types (a zero-import module holding\n * the Shape type and the structural `isMeshShape` guard) — the dist/sdk.js\n * static-import guard keeps passing.\n */\n\nimport { dispatchPath, type BrepCapabilityName } from './cad-runtime/backend-dispatch'\nimport {\n  getBackends,\n  CONTRACT_VERSION,\n  BrepUnsupportedError,\n  MeshUnsupportedError,\n} from './runtime-state'\nimport { isShape, solid, fromBrep } from './shape'\nimport { isMeshShape } from './mesh/types'\nimport { fromHandle, meshHandle, isOcctHandle } from './brep/handle-bridge'\nimport { positionalToObject, type SlotMap } from './api/internal/dual-form-args'\nimport { toOpFailure, unwrapResult, OpError } from './api/internal/result-unwrap'\nimport type { Shape } from './mesh/types'\nimport type { BrepHandle } from './brep/engine/types'\n\n/** Raw mesh data (structurally identical to Shape; mesh impls return it). */\nexport type MeshData = { positions: Float32Array; indices: Uint32Array }\n\n/**\n * Geometry-input recognition for dispatch auto-collection.\n *\n * Compat rule: the old per-function form passed the *actual* geometry args to\n * `dispatchPath` (`[input]` / `shapes`), so a bare ManifoldMeshData object\n * (e.g. `geoToManifoldMesh` output passed straight by a host) had no BREP slot\n * → `hasBrep=false` → mesh path. defineOp must keep that: an input counts as\n * geometry when it is identity-registered (`isShape`, constructor product) OR\n * structurally a mesh shape (`positions` + `indices`). Params objects and other\n * scalar args are not geometry inputs.\n *\n * @param v - the candidate argument.\n * @returns true when the argument is a geometry input (registered shape or bare mesh data).\n */\nexport function isGeometryInput(v: unknown): v is Shape {\n  return isShape(v) || isMeshShape(v)\n}\n\n/** Product of a mesh implementation: raw mesh data, a wrapped Shape, or (with `outputs`) a record of named products. */\nexport type MeshProduct = MeshData | Shape | Record<string, MeshData | Shape>\n\n/** Mesh implementation: sync or async (stdlib mesh paths are often async); returns a mesh product. */\nexport type MeshImpl<A extends unknown[]> = (...args: A) => MeshProduct | Promise<MeshProduct>\n\n/** BREP implementation result: a raw handle, or a handle plus face evolution. */\nexport interface BrepResult {\n  solid: BrepHandle\n  faceEvolution?: Map<number, number[]>\n}\n\n/** Product of a BREP implementation: a raw handle, { solid, faceEvolution }, a wrapped Shape, or (with `outputs`) a record of named products. */\nexport type BrepProduct = BrepHandle | BrepResult | Shape | Record<string, BrepHandle | BrepResult | Shape>\n\n/** BREP implementation: sync or async; returns a brep product. */\nexport type BrepImpl<A extends unknown[]> = (...args: A) => BrepProduct | Promise<BrepProduct>\n\n/** Optional declaration: capabilities (D5) and named multi-products (split, scheme C). */\nexport interface DualOpOptions {\n  /** Op name (error messages); falls back to an anonymous prefix when absent. */\n  name?: string\n  capabilities?: BrepCapabilityName[]\n  outputs?: string[]\n  /** L3 schema per named parameter (G1 codegen + UI panel, plain string form). */\n  schema?: Record<string, string>\n  /**\n   * D11 slot-map declaration (§4.2): the positional→object boxing table\n   * (SlotMap) mapping a brepjs-style positional call onto this op's native\n   * object form. Ops without it accept only the form their implementation\n   * natively takes.\n   */\n  slotMap?: SlotMap\n}\n\n/** Implementation set (at least one of mesh/brep is required, D1/D1b); options are siblings of the implementations. */\nexport type DualOpImpls<A extends unknown[]> =\n  | (DualOpOptions & { mesh: MeshImpl<A>; brep?: BrepImpl<A> })\n  | (DualOpOptions & { mesh?: never; brep: BrepImpl<A> })\n\n/** Metadata hung on the wrapped function object (K5: function info is data). */\nexport interface DualOpMeta {\n  kind: 'dual-op'\n  mesh?: unknown\n  brep?: unknown\n  /** Op name (error messages). */\n  name?: string\n  capabilities?: BrepCapabilityName[]\n  outputs?: string[]\n  schema?: Record<string, string>\n  /** D11 slot-map declaration (positional → object boxing table, §9 naming). */\n  slotMap?: SlotMap\n}\n\n/** Property key carrying DualOpMeta on wrapped functions. */\nexport const DUAL_OP_META = '__faijs__dualOp'\n\ntype MetaCarrier = { [DUAL_OP_META]?: DualOpMeta }\n\nfunction wrapMeshOne(v: unknown): Shape {\n  if (isShape(v)) return v\n  return solid(v as MeshData)\n}\n\nfunction wrapBrepOne(v: unknown): Shape {\n  if (isShape(v)) return v\n  if (v !== null && typeof v === 'object' && 'faceEvolution' in v) {\n    const res = v as BrepResult\n    return fromBrep(meshHandle(res.solid), res)\n  }\n  // A plain object that is not a Shape and not an OCCT handle is a data\n  // product (e.g. a compat fn returning a sheetmetal-style record), not a\n  // geometry handle — pass it through so it lands in the engine's value\n  // store instead of being tessellated as if it were a bare handle. Native\n  // OCCT handles from an implementation are hand-computed shape numbers\n  // (from a branded number return) or objects; only the number path reaches\n  // fromHandle. The handle/data distinction must go through the shared\n  // isOcctHandle leaf (handle-bridge) — never a hardcoded '__occtWasm' in v.\n  if (v !== null && typeof v === 'object' && !isOcctHandle(v)) {\n    return v as unknown as Shape\n  }\n  return fromHandle(v)\n}\n\nfunction wrapByKeys(r: unknown, keys: string[], wrapOne: (v: unknown) => Shape): Record<string, Shape> {\n  const src = (r ?? {}) as Record<string, unknown>\n  const out: Record<string, Shape> = {}\n  for (const k of keys) {\n    const v = src[k]\n    // An output may be an array (e.g. the compat adapter adopts each element of\n    // an array-valued `outputs` field); wrap element-wise so arrays stay arrays.\n    out[k] = Array.isArray(v) ? (v.map(wrapOne) as unknown as Shape) : wrapOne(v)\n  }\n  return out\n}\n\n/** Human-readable op label for error messages (falls back when unnamed). */\nfunction opLabel(meta: DualOpMeta): string {\n  return meta.name ?? '<anon>'\n}\n\n/**\n * Run one implementation through the unified Result boundary (§5.2, D1).\n *\n * Transition contract: an implementation may\n *   ① return a `Result`  → unwrapped here (`err` becomes a throw);\n *   ② throw              → normalized into an op-labelled error;\n *   ③ return a plain product → passed through untouched.\n *\n * The two engine-level routing errors keep their class: `runtime.ts` matches\n * `BrepUnsupportedError` / `MeshUnsupportedError` by `instanceof` to turn them\n * into `ExecutionResult.failedAt`, so they must not be re-wrapped.\n *\n * @param meta - the op's metadata (name).\n * @param impl - the implementation to run.\n * @param args - the normalized argument list.\n * @returns the (unwrapped) implementation product.\n */\nasync function runImpl(\n  meta: DualOpMeta,\n  impl: ((...a: unknown[]) => unknown) | undefined,\n  args: unknown[],\n): Promise<unknown> {\n  const label = opLabel(meta)\n  let product: unknown\n  try {\n    product = await (impl as (...a: unknown[]) => unknown)(...args)\n  } catch (e) {\n    if (e instanceof BrepUnsupportedError || e instanceof MeshUnsupportedError) throw e\n    // An OpError is already the engine-recognizable statement failure (thrown\n    // by the compat adapter's Result unwrap, or by impls returning a Result);\n    // re-wrapping it into a plain Error would make CadRuntime treat it as an\n    // uncaught bug instead of a statement failure.\n    if (e instanceof OpError) throw e\n    throw toOpFailure(label, e)\n  }\n  return unwrapResult(product, label)\n}\n\n/**\n * Declare a geometry function's dual-path implementation set.\n *\n * At least one implementation (mesh or brep) is required — enforced at\n * compile time by the union type and at construction time by a runtime check.\n * Geometry inputs are auto-collected by identity-or-structure\n * (`args.filter(isGeometryInput)` = `isShape` ∨ `isMeshShape`); raw mesh\n * products are wrapped by `solid()`, raw brep products by\n * `fromHandle()` / `fromBrep()`. `mode` selects the engine path via the\n * engine's static `dispatchPath` — the author never writes an `if (path)`\n * branch.\n *\n * @param decl - the declaration object: implementations `{ mesh }` (mesh-only),\n * `{ brep }` (brep-only, D1b), or `{ mesh, brep }` (dual-path), plus optional\n * `capabilities` (D5: missing capability degrades in auto, errors in brep mode)\n * and `outputs` (named multi-products, e.g. split) as siblings.\n * @returns the wrapped geometry function with dual-op metadata attached.\n */\nexport function defineOp<A extends unknown[]>(\n  decl: DualOpImpls<A> & { outputs: string[] },\n): ((...args: A) => Promise<Record<string, Shape>>) & MetaCarrier\n/**\n * Overload without `outputs`: single-product functions resolve to a `Promise<Shape>`.\n * @param decl - the declaration object: implementations `{ mesh }`, `{ brep }`, or `{ mesh, brep }`.\n * @returns the wrapped geometry function with dual-op metadata attached.\n */\nexport function defineOp<A extends unknown[]>(\n  decl: DualOpImpls<A>,\n): ((...args: A) => Promise<Shape>) & MetaCarrier\n/** Implementation signature (not visible to callers); matches the union of both overloads. */\nexport function defineOp<A extends unknown[]>(\n  decl: DualOpImpls<A>,\n): ((...args: A) => Promise<Shape | Record<string, Shape>>) & MetaCarrier {\n  // Construction-time check (②): implementations must be functions, then at\n  // least one implementation must be present.\n  if (decl.mesh !== undefined && typeof decl.mesh !== 'function') {\n    throw new Error('[faijs/defineOp] mesh must be a function')\n  }\n  if (decl.brep !== undefined && typeof decl.brep !== 'function') {\n    throw new Error('[faijs/defineOp] brep must be a function')\n  }\n  if (typeof decl.mesh !== 'function' && typeof decl.brep !== 'function') {\n    throw new Error('[faijs/defineOp] at least one implementation (mesh or brep) is required')\n  }\n\n  const meta: DualOpMeta = {\n    kind: 'dual-op',\n    mesh: decl.mesh,\n    brep: decl.brep,\n    name: decl.name,\n    capabilities: decl.capabilities,\n    outputs: decl.outputs,\n    schema: decl.schema,\n    slotMap: decl.slotMap,\n  }\n\n  // Async wrapper: implementations may be sync or async (stdlib mesh paths are\n  // often async, e.g. drill/engrave/boolean). The compiled .fai.js product always\n  // awaits the call, so returning a Promise is transparent.\n  const wrapped = async (...args: A): Promise<Shape | Record<string, Shape>> => {\n    // D11 (§4.2): faijs-native ops declare an object-form implementation, so a\n    // brepjs-style positional call is boxed into the object form here — before\n    // dispatch, so geometry inputs are collected from the normalized arg list.\n    const callArgs = (\n      meta.slotMap ? positionalToObject(args as unknown[], meta.slotMap, opLabel(meta)) : args\n    ) as A\n    // Geometry inputs: identity-or-structure auto collection (execution-time\n    // read, same nature as hasBrep — decided before the implementation runs).\n    // Compat: bare ManifoldMeshData args (host geoToManifoldMesh output) are\n    // geometry inputs too — old form passed [input] so they reached the mesh path.\n    const inputs = (callArgs as unknown[]).filter(isGeometryInput) as Shape[]\n    // D5 capability routing: feed the first missing capability to dispatchPath\n    // (auto degrades to mesh, brep mode errors).\n    const missing = meta.capabilities?.find((cap) => !getBackends().config.brepCapabilities?.[cap])\n    const path = dispatchPath(inputs, meta, missing)\n    if (path === 'brep') {\n      const r = await runImpl(meta, decl.brep as unknown as ((...a: unknown[]) => unknown) | undefined, callArgs)\n      return meta.outputs ? wrapByKeys(r, meta.outputs, wrapBrepOne) : wrapBrepOne(r)\n    }\n    const m = await runImpl(meta, decl.mesh as unknown as ((...a: unknown[]) => unknown) | undefined, callArgs)\n    return meta.outputs ? wrapByKeys(m, meta.outputs, wrapMeshOne) : wrapMeshOne(m)\n  }\n\n  Object.defineProperty(wrapped, DUAL_OP_META, { value: meta, enumerable: false })\n  return wrapped as ((...args: A) => Promise<Shape | Record<string, Shape>>) & MetaCarrier\n}\n\n/**\n * Assembly-time validation (③, strict mode, D-4): a library that exports any\n * dual-op function must carry a matching `contractVersion`, and every exported\n * dual-op must be structurally valid (mesh a function, brep a function or\n * undefined, capabilities/outputs well-formed). Called by `registerLib`.\n *\n * Functions without dual-op metadata are left untouched (declarative\n * enforcement boundary — K5 forbids name-based classification).\n *\n * @param lib - the library namespace object being registered.\n */\n/**\n * Detect whether a library namespace exports any dual-op function (carries\n * `DUAL_OP_META`). Used by `registerLib`'s inferred `autoLift` default: a\n * library that already declares dual-ops does not need bare-function lifting.\n *\n * @param ns - the library namespace object.\n * @returns `true` if at least one exported value is a dual-op function.\n */\nexport function hasDualOp(ns: Record<string, unknown>): boolean {\n  const values = Object.values(ns)\n  return values.some((v) => typeof v === 'function' && (v as MetaCarrier)[DUAL_OP_META])\n}\n\n/**\n * Assert that a library conforms to the dual-op contract: if it exports any\n * dual-op function, it must also export `contractVersion` matching the engine's.\n *\n * @param lib - the library namespace object being registered.\n * @throws {Error} when dual-op functions are present without a matching contract version.\n */\nexport function assertLibConforms(lib: Record<string, unknown>): void {\n  if (hasDualOp(lib) && lib.contractVersion !== CONTRACT_VERSION) {\n    throw new Error(\n      `[faijs] library with dual-op functions must export contractVersion = ${CONTRACT_VERSION} (got ${String(lib.contractVersion)})`,\n    )\n  }\n\n  for (const [name, value] of Object.entries(lib)) {\n    if (typeof value !== 'function') continue\n    const meta = (value as MetaCarrier)[DUAL_OP_META]\n    if (!meta || meta.kind !== 'dual-op') continue\n    if (typeof meta.mesh !== 'function' && typeof meta.brep !== 'function') {\n      throw new Error(`[faijs] lib function '${name}' declares dual-op without any implementation`)\n    }\n    if (meta.mesh !== undefined && typeof meta.mesh !== 'function') {\n      throw new Error(`[faijs] lib function '${name}' declares dual-op with a non-function mesh implementation`)\n    }\n    if (meta.brep !== undefined && typeof meta.brep !== 'function') {\n      throw new Error(`[faijs] lib function '${name}' declares dual-op with a non-function brep implementation`)\n    }\n    if (meta.capabilities !== undefined && !Array.isArray(meta.capabilities)) {\n      throw new Error(`[faijs] lib function '${name}' declares invalid capabilities (expected string[])`)\n    }\n    if (\n      meta.outputs !== undefined\n      && (!Array.isArray(meta.outputs) || meta.outputs.some((k) => typeof k !== 'string'))\n    ) {\n      throw new Error(`[faijs] lib function '${name}' declares invalid outputs (expected string[])`)\n    }\n    if (meta.schema !== undefined && !isValidSchema(meta.schema)) {\n      throw new Error(`[faijs] lib function '${name}' declares invalid schema (expected Record<string, string>)`)\n    }\n    if (meta.name !== undefined && typeof meta.name !== 'string') {\n      throw new Error(`[faijs] lib function '${name}' declares invalid name (expected string)`)\n    }\n    if (meta.slotMap !== undefined && !isValidSlotMap(meta.slotMap)) {\n      throw new Error(\n        `[faijs] lib function '${name}' declares invalid slotMap (expected { keys: string[]; vec3Keys?: string[]; shapeArity?: number })`,\n      )\n    }\n  }\n}\n\n/** True when the D11 slot-map declaration has a non-empty string `keys` list. */\nfunction isValidSlotMap(form: unknown): form is SlotMap {\n  if (form === null || typeof form !== 'object') return false\n  const keys = (form as { keys?: unknown }).keys\n  if (!Array.isArray(keys) || keys.some((k) => typeof k !== 'string')) return false\n  const vec3 = (form as { vec3Keys?: unknown }).vec3Keys\n  if (vec3 !== undefined && (!Array.isArray(vec3) || vec3.some((k) => typeof k !== 'string'))) return false\n  const arity = (form as { shapeArity?: unknown }).shapeArity\n  if (arity !== undefined && (typeof arity !== 'number' || !Number.isInteger(arity) || arity < 0)) return false\n  return true\n}\n\n/** True when every schema value is a non-empty string. */\nfunction isValidSchema(schema: unknown): schema is Record<string, string> {\n  if (schema === null || typeof schema !== 'object' || Array.isArray(schema)) return false\n  return Object.values(schema).every((v) => typeof v === 'string' && v.length > 0)\n}\n"]}

package/dist/faqts/browser.d.ts

@@ -0,0 +1,16 @@
+/**
+ * faits — 浏览器入口：@faicad/faijs/faqts/browser
+ *
+ * 绑定 Blob 执行器（Blob URL → import）。不含任何 Node 专属依赖。
+ */
+export { transformFaqts } from './transform.js';
+export type { FaqtsTransformOptions, FaqtsTransformResult } from './transform.js';
+export { findImports, rewriteImports } from './imports.js';
+export type { FaqtsImportSpan, FaqtsRewriteFn } from './imports.js';
+export { runFaqts } from './run.js';
+export type { FaqtsRunOptions, FaqtsRunResult } from './run.js';
+export { executeFaqtsModuleInBrowser } from './exec-blob.js';
+import type { FaqtsModuleExecutor } from './run.js';
+/** The browser-bound module executor: executes compiled module code via a Blob URL import. */
+export declare const faqtsBrowserExecutor: FaqtsModuleExecutor;
+//# sourceMappingURL=browser.d.ts.map

package/dist/faqts/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/faqts/browser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAC5C,YAAY,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAC9E,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AACvD,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAChC,YAAY,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAC5D,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAEzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,OAAO,CAAA;AAEhD,8FAA8F;AAC9F,eAAO,MAAM,oBAAoB,EAAE,mBAAiD,CAAA"}

package/dist/faqts/browser.js

@@ -0,0 +1,13 @@
+/**
+ * faits — 浏览器入口：@faicad/faijs/faqts/browser
+ *
+ * 绑定 Blob 执行器（Blob URL → import）。不含任何 Node 专属依赖。
+ */
+export { transformFaqts } from './transform.js';
+export { findImports, rewriteImports } from './imports.js';
+export { runFaqts } from './run.js';
+export { executeFaqtsModuleInBrowser } from './exec-blob.js';
+import { executeFaqtsModuleInBrowser } from './exec-blob.js';
+/** The browser-bound module executor: executes compiled module code via a Blob URL import. */
+export const faqtsBrowserExecutor = executeFaqtsModuleInBrowser;
+//# sourceMappingURL=browser.js.map

package/dist/faqts/browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.js","sourceRoot":"","sources":["../../src/faqts/browser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAE5C,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAEvD,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAEhC,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AACzD,OAAO,EAAE,2BAA2B,EAAE,MAAM,aAAa,CAAA;AAGzD,8FAA8F;AAC9F,MAAM,CAAC,MAAM,oBAAoB,GAAwB,2BAA2B,CAAA","sourcesContent":["/**\n * faits — 浏览器入口：@faicad/faijs/faqts/browser\n *\n * 绑定 Blob 执行器（Blob URL → import）。不含任何 Node 专属依赖。\n */\n\nexport { transformFaqts } from './transform'\nexport type { FaqtsTransformOptions, FaqtsTransformResult } from './transform'\nexport { findImports, rewriteImports } from './imports'\nexport type { FaqtsImportSpan, FaqtsRewriteFn } from './imports'\nexport { runFaqts } from './run'\nexport type { FaqtsRunOptions, FaqtsRunResult } from './run'\nexport { executeFaqtsModuleInBrowser } from './exec-blob'\nimport { executeFaqtsModuleInBrowser } from './exec-blob'\nimport type { FaqtsModuleExecutor } from './run'\n\n/** The browser-bound module executor: executes compiled module code via a Blob URL import. */\nexport const faqtsBrowserExecutor: FaqtsModuleExecutor = executeFaqtsModuleInBrowser"]}

package/dist/faqts/exec-blob.d.ts

@@ -0,0 +1,14 @@
+/**
+ * faits — 浏览器执行器：Blob URL → import() 整段一次执行
+ *
+ * 浏览器侧被执行的模块若有裸说明符（`@faicad/faq/sdk` 等），由宿主页面的
+ * importmap 解析（B 通道 ① 语义）；重写钩子负责把它改到宿主资源。
+ */
+/**
+ * Execute module code once by importing it through a Blob URL, returning the
+ * ES module namespace snapshot.
+ * @param jsCode - the compiled, de-typed JavaScript module source to execute.
+ * @returns the ES module namespace snapshot of the imported module.
+ */
+export declare function executeFaqtsModuleInBrowser(jsCode: string): Promise<Record<string, unknown>>;
+//# sourceMappingURL=exec-blob.d.ts.map

package/dist/faqts/exec-blob.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-blob.d.ts","sourceRoot":"","sources":["../../src/faqts/exec-blob.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAOlG"}

package/dist/faqts/exec-blob.js

@@ -0,0 +1,22 @@
+/**
+ * faits — 浏览器执行器：Blob URL → import() 整段一次执行
+ *
+ * 浏览器侧被执行的模块若有裸说明符（`@faicad/faq/sdk` 等），由宿主页面的
+ * importmap 解析（B 通道 ① 语义）；重写钩子负责把它改到宿主资源。
+ */
+/**
+ * Execute module code once by importing it through a Blob URL, returning the
+ * ES module namespace snapshot.
+ * @param jsCode - the compiled, de-typed JavaScript module source to execute.
+ * @returns the ES module namespace snapshot of the imported module.
+ */
+export async function executeFaqtsModuleInBrowser(jsCode) {
+    const url = URL.createObjectURL(new Blob([jsCode], { type: 'text/javascript' }));
+    try {
+        return (await import(/* @vite-ignore */ url));
+    }
+    finally {
+        URL.revokeObjectURL(url);
+    }
+}
+//# sourceMappingURL=exec-blob.js.map

package/dist/faqts/exec-blob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-blob.js","sourceRoot":"","sources":["../../src/faqts/exec-blob.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,2BAA2B,CAAC,MAAc;IAC9D,MAAM,GAAG,GAAG,GAAG,CAAC,eAAe,CAAC,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC,CAAA;IAChF,IAAI,CAAC;QACH,OAAO,CAAC,MAAM,MAAM,CAAC,kBAAkB,CAAC,GAAG,CAAC,CAA4B,CAAA;IAC1E,CAAC;YAAS,CAAC;QACT,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,CAAA;IAC1B,CAAC;AACH,CAAC","sourcesContent":["/**\n * faits — 浏览器执行器：Blob URL → import() 整段一次执行\n *\n * 浏览器侧被执行的模块若有裸说明符（`@faicad/faq/sdk` 等），由宿主页面的\n * importmap 解析（B 通道 ① 语义）；重写钩子负责把它改到宿主资源。\n */\n\n/**\n * Execute module code once by importing it through a Blob URL, returning the\n * ES module namespace snapshot.\n * @param jsCode - the compiled, de-typed JavaScript module source to execute.\n * @returns the ES module namespace snapshot of the imported module.\n */\nexport async function executeFaqtsModuleInBrowser(jsCode: string): Promise<Record<string, unknown>> {\n  const url = URL.createObjectURL(new Blob([jsCode], { type: 'text/javascript' }))\n  try {\n    return (await import(/* @vite-ignore */ url)) as Record<string, unknown>\n  } finally {\n    URL.revokeObjectURL(url)\n  }\n}"]}

package/dist/faqts/exec-node.d.ts

@@ -0,0 +1,15 @@
+/**
+ * faits — Node 执行器（整段 import() 一次执行）
+ *
+ * Node 侧 import() 从 data:/blob: URL 开始无法解析其中的相对说明符
+ * （vitest/实验已验证），因此落到唯一临时 `.mjs` 文件，经 file: URL
+ * import 一次。文件位于系统 tmp，执行后立即清理。
+ */
+/**
+ * Write module code to a unique temporary .mjs file and import it once,
+ * returning the ES module namespace snapshot.
+ * @param jsCode - the compiled, de-typed JavaScript module source to execute.
+ * @returns the ES module namespace snapshot of the imported module.
+ */
+export declare function executeFaqtsModuleInNode(jsCode: string): Promise<Record<string, unknown>>;
+//# sourceMappingURL=exec-node.d.ts.map

package/dist/faqts/exec-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-node.d.ts","sourceRoot":"","sources":["../../src/faqts/exec-node.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAOH;;;;;GAKG;AACH,wBAAsB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAS/F"}

package/dist/faqts/exec-node.js

@@ -0,0 +1,29 @@
+/**
+ * faits — Node 执行器（整段 import() 一次执行）
+ *
+ * Node 侧 import() 从 data:/blob: URL 开始无法解析其中的相对说明符
+ * （vitest/实验已验证），因此落到唯一临时 `.mjs` 文件，经 file: URL
+ * import 一次。文件位于系统 tmp，执行后立即清理。
+ */
+import { writeFileSync, mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { pathToFileURL } from 'node:url';
+/**
+ * Write module code to a unique temporary .mjs file and import it once,
+ * returning the ES module namespace snapshot.
+ * @param jsCode - the compiled, de-typed JavaScript module source to execute.
+ * @returns the ES module namespace snapshot of the imported module.
+ */
+export async function executeFaqtsModuleInNode(jsCode) {
+    const dir = mkdtempSync(join(tmpdir(), 'faqts-'));
+    const file = join(dir, 'mod.mjs');
+    writeFileSync(file, jsCode, 'utf-8');
+    try {
+        return (await import(/* @vite-ignore */ pathToFileURL(file).href));
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=exec-node.js.map