@rybosome/tspice 0.0.7 → 0.0.8

package/dist/transport/caching/withCachingSync.js

@@ -0,0 +1,161 @@
+import { createCachePolicy } from "./policy.js";
+import { defaultSpiceCacheKey, } from "./withCaching.js";
+const cachingTransportBrand = new WeakSet();
+const defaultOnWarning = (message) => {
+    if (typeof console !== "undefined" && typeof console.warn === "function") {
+        console.warn(message);
+    }
+};
+/**
+ * Type guard for narrowing a transport returned by `withCachingSync()`.
+ */
+export function isCachingTransportSync(t) {
+    if (typeof t !== "object" || t === null)
+        return false;
+    if (!cachingTransportBrand.has(t))
+        return false;
+    const v = t;
+    return (typeof v.request === "function" &&
+        typeof v.clear === "function" &&
+        typeof v.dispose === "function");
+}
+function tryUnrefTimer(timer) {
+    let unref;
+    try {
+        unref = timer.unref;
+    }
+    catch {
+        return;
+    }
+    if (typeof unref !== "function")
+        return;
+    try {
+        unref.call(timer);
+    }
+    catch {
+        // Ignore. Some runtimes / shims may throw for `unref` even when present.
+    }
+}
+/** Wrap a sync transport with an in-memory response cache (LRU-ish + optional TTL). */
+export function withCachingSync(base, opts) {
+    // Note: cached values are returned by reference. If a caller mutates the
+    // returned object/array, subsequent cache hits will observe that mutation.
+    // Treat results as immutable (or clone them yourself) when caching is enabled.
+    const rawMaxEntries = opts?.maxEntries;
+    const maxEntries = rawMaxEntries ?? 1000;
+    const maxEntriesLimit = maxEntries === Infinity
+        ? undefined
+        : Number.isFinite(maxEntries)
+            ? maxEntries
+            : 0;
+    const rawTtlMs = opts?.ttlMs;
+    const ttlMs = rawTtlMs == null ? undefined : rawTtlMs;
+    const cachingEnabled = (ttlMs === undefined || ttlMs > 0) &&
+        (maxEntriesLimit === undefined || maxEntriesLimit > 0);
+    // True no-op mode: preserve the input object identity and avoid allocating
+    // any wrapper state when caching is disabled.
+    if (!cachingEnabled)
+        return base;
+    // Only pick defaults after the no-op early return so disabled caching pays
+    // ~0 overhead.
+    const now = opts?.now ?? Date.now;
+    const onWarning = opts?.onWarning ?? defaultOnWarning;
+    const keyFn = opts?.key ?? defaultSpiceCacheKey;
+    const policyByOp = opts?.policy;
+    const allowUnsafePolicyOverrides = opts?.allowUnsafePolicyOverrides === true;
+    const allowBroadNoStorePrefixes = opts?.allowBroadNoStorePrefixes === true;
+    const getPolicy = createCachePolicy({
+        wrapperName: "withCachingSync()",
+        onWarning,
+        policyByOp,
+        noStorePrefixes: opts?.noStorePrefixes,
+        allowBroadNoStorePrefixes,
+        allowUnsafePolicyOverrides,
+    });
+    const cache = new Map();
+    let sweepTimer;
+    const isExpired = (entry, now) => entry.expiresAt !== undefined && entry.expiresAt <= now;
+    const cleanupExpired = (now) => {
+        // TTL eviction is optional. When ttlMs is undefined, the cache is “forever”
+        // (still LRU-bounded by maxEntries).
+        if (ttlMs === undefined || ttlMs <= 0)
+            return;
+        for (const [k, entry] of cache) {
+            if (isExpired(entry, now))
+                cache.delete(k);
+        }
+    };
+    if (cachingEnabled && ttlMs !== undefined && ttlMs > 0) {
+        const sweepIntervalMs = opts?.sweepIntervalMs;
+        if (sweepIntervalMs !== undefined && sweepIntervalMs > 0) {
+            sweepTimer = setInterval(() => cleanupExpired(now()), sweepIntervalMs);
+            // In Node, interval timers keep the event loop alive by default. `unref()`
+            // prevents this from pinning test runners / CLIs. Browsers return a
+            // numeric id (no-op).
+            tryUnrefTimer(sweepTimer);
+        }
+    }
+    const clear = () => {
+        cache.clear();
+    };
+    const dispose = () => {
+        if (sweepTimer !== undefined) {
+            clearInterval(sweepTimer);
+            sweepTimer = undefined;
+        }
+        cache.clear();
+    };
+    const touch = (k, entry) => {
+        cache.delete(k);
+        cache.set(k, entry);
+    };
+    const enforceMaxEntries = () => {
+        if (maxEntriesLimit === undefined)
+            return;
+        while (cache.size > maxEntriesLimit) {
+            const oldestKey = cache.keys().next().value;
+            if (oldestKey === undefined)
+                return;
+            cache.delete(oldestKey);
+        }
+    };
+    const request = (op, args) => {
+        // Per-method cache policy. When bypassing, skip *all* cache work (no key
+        // computation, no reads/writes, no TTL sweeps).
+        if (getPolicy(op) === "no-store")
+            return base.request(op, args);
+        const k = keyFn(op, args);
+        if (k == null)
+            return base.request(op, args);
+        const nowMs = now();
+        cleanupExpired(nowMs);
+        const existing = cache.get(k);
+        if (existing && !isExpired(existing, nowMs)) {
+            // LRU touch on access. TTL remains absolute (does not refresh on access).
+            touch(k, existing);
+            return existing.value;
+        }
+        if (existing)
+            cache.delete(k);
+        // Only cache successful responses.
+        let value;
+        try {
+            value = base.request(op, args);
+        }
+        catch (err) {
+            cache.delete(k);
+            throw err;
+        }
+        const entry = { value };
+        if (ttlMs !== undefined && ttlMs > 0) {
+            entry.expiresAt = now() + ttlMs;
+        }
+        cache.set(k, entry);
+        enforceMaxEntries();
+        return value;
+    };
+    const transport = { request, clear, dispose };
+    cachingTransportBrand.add(transport);
+    return transport;
+}
+//# sourceMappingURL=withCachingSync.js.map

package/dist/transport/rpc/protocol.d.ts

@@ -0,0 +1,35 @@
+export declare const tspiceRpcRequestType: "tspice:request";
+export declare const tspiceRpcResponseType: "tspice:response";
+export declare const tspiceRpcDisposeType: "tspice:dispose";
+export type RpcRequest = {
+    type: typeof tspiceRpcRequestType;
+    id: number;
+    op: string;
+    args: unknown[];
+};
+export type RpcDispose = {
+    type: typeof tspiceRpcDisposeType;
+};
+export type SerializedError = {
+    message: string;
+    name?: string;
+    stack?: string;
+};
+export type RpcResponse = {
+    type: typeof tspiceRpcResponseType;
+    id: number;
+    ok: true;
+    value: unknown;
+} | {
+    type: typeof tspiceRpcResponseType;
+    id: number;
+    ok: false;
+    error: SerializedError;
+};
+export type RpcMessageFromMain = RpcRequest | RpcDispose;
+export type RpcMessageFromWorker = RpcResponse;
+/** Serialize an unknown error into a structured, transferable shape for RPC. */
+export declare function serializeError(err: unknown): SerializedError;
+/** Deserialize an RPC-transferred error shape back into an {@link Error}. */
+export declare function deserializeError(err: unknown): Error;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/transport/rpc/protocol.js

@@ -0,0 +1,56 @@
+export const tspiceRpcRequestType = "tspice:request";
+export const tspiceRpcResponseType = "tspice:response";
+export const tspiceRpcDisposeType = "tspice:dispose";
+/** Serialize an unknown error into a structured, transferable shape for RPC. */
+export function serializeError(err) {
+    const defaultMessage = "Worker request failed";
+    const readStringProp = (obj, key) => {
+        if (!obj || typeof obj !== "object")
+            return undefined;
+        const v = obj[key];
+        return typeof v === "string" ? v : undefined;
+    };
+    if (err instanceof Error) {
+        const out = { message: err.message || defaultMessage };
+        if (typeof err.name === "string" && err.name)
+            out.name = err.name;
+        if (typeof err.stack === "string")
+            out.stack = err.stack;
+        return out;
+    }
+    if (typeof err === "string") {
+        return { message: err };
+    }
+    if (err && typeof err === "object") {
+        const message = readStringProp(err, "message") ?? defaultMessage;
+        const name = readStringProp(err, "name");
+        const stack = readStringProp(err, "stack");
+        const out = { message };
+        if (typeof name === "string" && name)
+            out.name = name;
+        if (typeof stack === "string")
+            out.stack = stack;
+        return out;
+    }
+    // Only stringify primitives (avoid calling an arbitrary `.toString()` on objects).
+    if (typeof err === "number" ||
+        typeof err === "boolean" ||
+        typeof err === "bigint") {
+        return { message: String(err) };
+    }
+    return { message: defaultMessage };
+}
+/** Deserialize an RPC-transferred error shape back into an {@link Error}. */
+export function deserializeError(err) {
+    if (err && typeof err === "object") {
+        const e = err;
+        const out = new Error(typeof e.message === "string" ? e.message : "Worker request failed");
+        if (typeof e.name === "string")
+            out.name = e.name;
+        if (typeof e.stack === "string")
+            out.stack = e.stack;
+        return out;
+    }
+    return new Error(typeof err === "string" ? err : "Worker request failed");
+}
+//# sourceMappingURL=protocol.js.map

package/dist/transport/rpc/taskScheduling.d.ts

@@ -0,0 +1,20 @@
+export type QueueMacrotaskOptions = {
+    /**
+     * When no macrotask scheduler exists (no `MessageChannel` and no `setTimeout`),
+     * there is no way to create a real task boundary.
+     *
+     * - `true` (default): invoke `fn()` synchronously as a best-effort fallback.
+     * - `false`: do not call `fn()` and return `false`.
+     */
+    allowSyncFallback?: boolean;
+};
+/**
+ * Probe whether a true macrotask scheduler is available in the current runtime
+ * (without actually scheduling a task).
+ */
+export declare function canQueueMacrotask(): boolean;
+/** Queue `fn` on the next macrotask (MessageChannel preferred; setTimeout fallback). */
+export declare function queueMacrotask(fn: () => void, opts?: QueueMacrotaskOptions): boolean;
+/** Return a promise that resolves on the next macrotask boundary (rejects if unavailable). */
+export declare function nextMacrotask(): Promise<void>;
+//# sourceMappingURL=taskScheduling.d.ts.map

package/dist/transport/rpc/taskScheduling.js

@@ -0,0 +1,98 @@
+/**
+ * Probe whether a true macrotask scheduler is available in the current runtime
+ * (without actually scheduling a task).
+ */
+export function canQueueMacrotask() {
+    // Prefer MessageChannel when available.
+    //
+    // Important: if MessageChannel exists but is broken (e.g. constructible but
+    // `postMessage` throws), we fall through to `setTimeout` rather than failing
+    // closed. This matches `queueMacrotask()` behavior.
+    if (typeof MessageChannel !== "undefined") {
+        try {
+            const { port1, port2 } = new MessageChannel();
+            try {
+                // Probe that `postMessage` works (some polyfills allow construction but
+                // throw on `postMessage`, which would otherwise deadlock queueing).
+                port2.postMessage(undefined);
+                return true;
+            }
+            finally {
+                // Always close ports so they don't keep the event loop alive in Node.
+                // Be defensive: some polyfills/test environments may not implement `close()`.
+                try {
+                    port1.close?.();
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    port2.close?.();
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        catch {
+            // Ignore and fall back to setTimeout.
+        }
+    }
+    return typeof setTimeout === "function";
+}
+/** Queue `fn` on the next macrotask (MessageChannel preferred; setTimeout fallback). */
+export function queueMacrotask(fn, opts) {
+    const allowSyncFallback = opts?.allowSyncFallback ?? true;
+    // Prefer MessageChannel when available. This schedules a real task boundary
+    // without relying on timers, which makes it friendlier to fake-timer test
+    // environments.
+    try {
+        if (typeof MessageChannel !== "undefined") {
+            const { port1, port2 } = new MessageChannel();
+            const port1WithOnMessage = port1;
+            port1WithOnMessage.onmessage = () => {
+                port1WithOnMessage.onmessage = null;
+                // Close ports so this doesn't keep the event loop alive in Node.
+                // Be defensive: some polyfills/test environments may not implement
+                // `close()`.
+                try {
+                    port1.close?.();
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    port2.close?.();
+                }
+                catch {
+                    // ignore
+                }
+                fn();
+            };
+            port2.postMessage(undefined);
+            return true;
+        }
+    }
+    catch {
+        // Ignore and fall back to setTimeout.
+    }
+    // Next preference: a real macrotask via setTimeout.
+    if (typeof setTimeout === "function") {
+        setTimeout(fn, 0);
+        return true;
+    }
+    // No macrotask scheduler available in this runtime.
+    if (allowSyncFallback)
+        fn();
+    return false;
+}
+/** Return a promise that resolves on the next macrotask boundary (rejects if unavailable). */
+export function nextMacrotask() {
+    return new Promise((resolve, reject) => {
+        const ok = queueMacrotask(resolve, { allowSyncFallback: false });
+        if (!ok) {
+            reject(new Error("nextMacrotask(): no macrotask scheduler available (MessageChannel/setTimeout missing)"));
+        }
+    });
+}
+//# sourceMappingURL=taskScheduling.js.map

package/dist/transport/rpc/valueCodec.d.ts

@@ -0,0 +1,5 @@
+/** Encode an arbitrary value into a structured-clone-safe shape. */
+export declare function encodeRpcValue(value: unknown): unknown;
+/** Decode a value that was encoded by {@link encodeRpcValue}. */
+export declare function decodeRpcValue(value: unknown): unknown;
+//# sourceMappingURL=valueCodec.d.ts.map

package/dist/transport/rpc/valueCodec.js

@@ -0,0 +1,106 @@
+import { Mat3 } from "../../kit/math/mat3.js";
+/**
+ * Values sent across the worker boundary must be structured-clone-safe.
+ *
+ * This codec provides a minimal, extensible tagged encoding for non-plain
+ * objects (e.g. `Mat3`) used by the tspice API.
+ */
+const tspiceRpcTagKey = "__tspiceRpcTag";
+function isRecord(value) {
+    return value !== null && typeof value === "object";
+}
+function isTaggedRecord(value) {
+    return isRecord(value) && tspiceRpcTagKey in value;
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function isMat3RowMajorData(value) {
+    return (Array.isArray(value) && value.length === 9 && value.every(isFiniteNumber));
+}
+/** Encode an arbitrary value into a structured-clone-safe shape. */
+export function encodeRpcValue(value) {
+    if (value instanceof Mat3) {
+        const data = Array.from(value.rowMajor);
+        return {
+            [tspiceRpcTagKey]: "Mat3",
+            layout: "rowMajor",
+            data,
+        };
+    }
+    if (Array.isArray(value)) {
+        return value.map(encodeRpcValue);
+    }
+    // Fast-path: ArrayBuffer + views (TypedArrays/DataView) are structured-clone-
+    // safe and should pass through unchanged. This is important for transferring
+    // kernel bytes (e.g. Uint8Array) into a worker.
+    if (value instanceof ArrayBuffer)
+        return value;
+    if (ArrayBuffer.isView(value))
+        return value;
+    // SharedArrayBuffer exists in some environments (Node, some browsers) but is
+    // gated by cross-origin isolation in browsers. Allow it when present.
+    if (typeof SharedArrayBuffer !== "undefined" &&
+        value instanceof SharedArrayBuffer) {
+        return value;
+    }
+    if (isRecord(value)) {
+        // Allow byte buffers/typed arrays to cross the worker boundary.
+        // These are structured-clone-safe and commonly used for kernel outputs.
+        if (value instanceof ArrayBuffer)
+            return value;
+        if (ArrayBuffer.isView(value))
+            return value;
+        if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) {
+            return value;
+        }
+        // Preserve Date/Map/Set/etc as-is? No: those are not guaranteed to be
+        // structured-clone-safe across all targets. For now, we only support plain
+        // object literals.
+        const proto = Object.getPrototypeOf(value);
+        if (proto !== Object.prototype && proto !== null) {
+            const ctorName = value.constructor?.name ??
+                proto.constructor?.name;
+            throw new Error("encodeRpcValue(): unsupported non-plain object for worker RPC " +
+                `(constructor=${String(ctorName)}). ` +
+                "Pass plain objects/arrays/primitives or extend the codec.");
+        }
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = encodeRpcValue(v);
+        }
+        return out;
+    }
+    return value;
+}
+/** Decode a value that was encoded by {@link encodeRpcValue}. */
+export function decodeRpcValue(value) {
+    if (isTaggedRecord(value)) {
+        const tag = value[tspiceRpcTagKey];
+        if (tag === "Mat3") {
+            const layout = value.layout;
+            const data = value.data;
+            if (layout === "rowMajor" && isMat3RowMajorData(data)) {
+                // Mat3.fromRowMajor expects a branded Mat3RowMajor type. We validated
+                // the runtime shape here, so the cast is safe.
+                return Mat3.fromRowMajor(data);
+            }
+        }
+    }
+    if (Array.isArray(value)) {
+        return value.map(decodeRpcValue);
+    }
+    if (isRecord(value)) {
+        // Preserve non-plain objects (e.g. TypedArrays) as-is.
+        const proto = Object.getPrototypeOf(value);
+        if (proto !== Object.prototype && proto !== null)
+            return value;
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = decodeRpcValue(v);
+        }
+        return out;
+    }
+    return value;
+}
+//# sourceMappingURL=valueCodec.js.map

package/dist/transport/types.d.ts

@@ -0,0 +1,7 @@
+export type SpiceTransport = {
+    request(op: string, args: unknown[]): Promise<unknown>;
+};
+export type SpiceTransportSync = {
+    request(op: string, args: unknown[]): unknown;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/transport/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.d.ts

@@ -11,11 +11,14 @@ export type Vec6 = readonly [
 ];
 /** SPICE frame name (e.g. "J2000", "IAU_EARTH"). */
 export type FrameName = string;
+/** Canonical inertial reference frame. */
+export declare const J2000: "J2000";
 /** Aberration correction string accepted by `spkezr`. */
 export type AberrationCorrection = "NONE" | "LT" | "LT+S" | "CN" | "CN+S" | "XLT" | "XLT+S" | "XCN" | "XCN+S";
-export type SpiceTime = number & {
-    readonly __tspiceBrand: "SpiceTime";
-};
+/** Seconds past J2000 (ET). */
+export type SpiceTime = number;
+/** Body identifier accepted by kit APIs (name or NAIF id). */
+export type BodyRef = string | number;
 export type StateVector = {
     /** Seconds past J2000 (ET). */
     et: SpiceTime;
@@ -33,8 +36,8 @@ export type StateVector = {
     lightTime: number;
 };
 export type GetStateArgs = {
-    target: string;
-    observer: string;
+    target: BodyRef;
+    observer: BodyRef;
     at: SpiceTime;
     frame?: FrameName;
     aberration?: AberrationCorrection;

package/dist/types.js

@@ -1,2 +1,3 @@
-export {};
+/** Canonical inertial reference frame. */
+export const J2000 = "J2000";
 //# sourceMappingURL=types.js.map

package/dist/worker/browser/createSpiceWorker.d.ts

@@ -0,0 +1,22 @@
+import type { WorkerLike } from "../transport/createWorkerTransport.js";
+export type CreateSpiceWorkerOptions = {
+    /** Override the worker entrypoint (advanced). */
+    url?: string | URL;
+    /**
+     * Override the WASM binary URL used by the default inline worker.
+     *
+     * When omitted, `createSpiceWorker()` will resolve the WASM binary URL
+     * relative to the published package layout.
+     */
+    wasmUrl?: string | URL;
+    /**
+     * Options passed through to the `Worker` constructor.
+     *
+     * Typed loosely on purpose so this package doesn't require `lib.dom` types
+     * (and so it can be consumed in non-DOM TS configs).
+     */
+    workerOptions?: Record<string, unknown>;
+};
+/** Create a Web Worker instance for the tspice worker entrypoint (inline by default). */
+export declare function createSpiceWorker(opts?: CreateSpiceWorkerOptions): WorkerLike;
+//# sourceMappingURL=createSpiceWorker.d.ts.map

package/dist/worker/browser/createSpiceWorker.js

@@ -0,0 +1,41 @@
+import { SPICE_WORKER_INLINE_SOURCE } from "./spiceWorkerInlineSource.js";
+/** Create a Web Worker instance for the tspice worker entrypoint (inline by default). */
+export function createSpiceWorker(opts = {}) {
+    const WorkerCtor = globalThis.Worker;
+    if (typeof WorkerCtor !== "function") {
+        throw new Error("createSpiceWorker() requires Web Worker support in the current runtime");
+    }
+    // Default to module workers since this package is ESM and relies on
+    // ESM-only dependencies.
+    const workerOptions = {
+        type: "module",
+        ...(opts.workerOptions ?? {}),
+    };
+    if (opts.url != null) {
+        return new WorkerCtor(opts.url, workerOptions);
+    }
+    // Inline (blob) worker by default.
+    //
+    // This avoids requiring consumers to separately bundle/host a worker JS asset
+    // URL. It also means the worker entry cannot use `import.meta.url` to locate
+    // assets, since the entrypoint URL will be `blob:`.
+    if (workerOptions.type !== "module") {
+        throw new Error('createSpiceWorker() inline worker requires a module worker (workerOptions.type="module")');
+    }
+    const wasmUrl = opts.wasmUrl?.toString() ??
+        // Published package layout (and what `build:dist-publish` produces):
+        //   dist/worker/browser/createSpiceWorker.js
+        //   backend-wasm/dist/tspice_backend_wasm.wasm
+        new URL("../../../backend-wasm/dist/tspice_backend_wasm.wasm", import.meta.url).href;
+    const workerSource = `globalThis.__TSPICE_WORKER_CONFIG__ = ${JSON.stringify({ wasmUrl })};\n` +
+        SPICE_WORKER_INLINE_SOURCE;
+    const blob = new Blob([workerSource], { type: "text/javascript" });
+    const blobUrl = URL.createObjectURL(blob);
+    try {
+        return new WorkerCtor(blobUrl, workerOptions);
+    }
+    finally {
+        URL.revokeObjectURL(blobUrl);
+    }
+}
+//# sourceMappingURL=createSpiceWorker.js.map

package/dist/worker/browser/createSpiceWorkerClient.d.ts

@@ -0,0 +1,40 @@
+import type { SpiceAsync } from "../../kit/types/spice-types.js";
+import type { SpiceTransport } from "../../transport/types.js";
+import { type WorkerLike, type WorkerTransport } from "../transport/createWorkerTransport.js";
+export type SpiceWorkerClient<TTransport extends SpiceTransport = WorkerTransport> = {
+    worker: WorkerLike;
+    /** The underlying request/response RPC transport (always a WorkerTransport). */
+    baseTransport: WorkerTransport;
+    /** The transport after applying `wrapTransport` (e.g. `withCaching`). */
+    transport: TTransport;
+    /** A `SpiceAsync` client backed by `transport`. */
+    spice: SpiceAsync;
+    /** Dispose wrapper transport (if any) and the worker transport. */
+    dispose: () => void;
+    /**
+     * Async dispose variant that awaits wrapper transport cleanup (if any) before
+     * disposing the underlying worker transport.
+     */
+    disposeAsync: () => Promise<void>;
+};
+export type CreateSpiceWorkerClientOptions<TTransport extends SpiceTransport = WorkerTransport> = {
+    /**
+     * Pass an existing Worker or a factory to create one.
+     *
+     * Defaults to `() => createSpiceWorker()`.
+     */
+    worker?: WorkerLike | (() => WorkerLike);
+    /** Default request timeout forwarded to `createWorkerTransport`. */
+    timeoutMs?: number;
+    /** Forwarded to `createWorkerTransport`. Defaults to `true` when `worker` is a factory. */
+    terminateOnDispose?: boolean;
+    /** Forwarded to `createWorkerTransport`. Defaults to `terminateOnDispose`. */
+    signalDispose?: boolean;
+    /** Optional transport wrapper (e.g. `withCaching`). */
+    wrapTransport?: (t: WorkerTransport) => TTransport;
+    /** Called if `disposeAsync()` rejects when invoked via fire-and-forget `dispose()`. */
+    onDisposeError?: (err: unknown) => void;
+};
+/** Create a {@link SpiceWorkerClient} that communicates with a tspice Web Worker via RPC. */
+export declare function createSpiceWorkerClient<TTransport extends SpiceTransport = WorkerTransport>(opts?: CreateSpiceWorkerClientOptions<TTransport>): SpiceWorkerClient<TTransport>;
+//# sourceMappingURL=createSpiceWorkerClient.d.ts.map