@wow-two-beta/ui-vue 0.0.2

package/dist/foundation/workers/RunInWorker.d.ts

@@ -0,0 +1,41 @@
+/** The outcome of a {@link runInWorker} attempt. */
+export type RunInWorkerResult<TValue> = {
+    /** The function ran on the worker thread and returned. */
+    readonly status: 'ok';
+    /** The value it returned, structured-cloned back. */
+    readonly value: TValue;
+} | {
+    /** No `Worker`, `Blob`, or `URL.createObjectURL` here — SSR, or a CSP blocking `blob:` workers. Nothing ran. */
+    readonly status: 'unsupported';
+} | {
+    /** The function threw, the worker failed to start, or the deadline elapsed. */
+    readonly status: 'failed';
+    /** The normalized failure — the worker's own error where one crossed the boundary. */
+    readonly error: Error;
+};
+/** Tunes a {@link runInWorker} call. */
+export interface RunInWorkerOptions {
+    /** The deadline in milliseconds. On lapse the worker is terminated and the result is `failed` with a `TimeoutError`. Omit for none. */
+    readonly timeoutMs?: number;
+    /**
+     * The objects to transfer into the worker instead of cloning. Each is NEUTERED in the caller: an
+     * `ArrayBuffer` passed here has `byteLength === 0` once the call returns.
+     */
+    readonly transfer?: readonly Transferable[];
+}
+/**
+ * Runs `fn` on a throwaway worker thread and resolves with its result.
+ *
+ * ```ts
+ * const result = await runInWorker((rows: number[]) => rows.reduce((a, b) => a + b, 0), [bigArray]);
+ * if (result.status === 'ok') console.log(result.value);
+ * ```
+ *
+ * `fn` MUST be self-contained — it is stringified, so it captures nothing from the scope it was written
+ * in, and it may not be a method shorthand. Every input arrives through `args`, and both `args` and the
+ * return value must survive structured clone. See the module header for the full rationale.
+ *
+ * Never throws: an unsupported runtime, a failed start, a thrown function, and a lapsed deadline all
+ * resolve to a {@link RunInWorkerResult}. The worker is terminated and the blob URL revoked on every path.
+ */
+export declare function runInWorker<TArgs extends readonly unknown[], TValue>(fn: (...args: TArgs) => TValue | Promise<TValue>, args: TArgs, options?: RunInWorkerOptions): Promise<RunInWorkerResult<TValue>>;

package/dist/foundation/workers/UseWorker.d.ts

@@ -0,0 +1,28 @@
+import { ShallowRef } from 'vue';
+import { WorkerApiOf, WorkerClient, WorkerClientOptions } from './WorkerClient';
+/** What {@link useWorker} returns. */
+export interface UseWorkerResult<TApi extends WorkerApiOf<TApi>> {
+    /**
+     * The typed client, or `null` before mount and in any runtime without `Worker`.
+     *
+     * Guard on it (`client.value?.call(...)`) rather than asserting: the `null` window is real until mount, so
+     * an effect or event handler firing before the worker exists must have a defined answer.
+     */
+    readonly client: Readonly<ShallowRef<WorkerClient<TApi> | null>>;
+    /**
+     * Whether this runtime can spawn a worker, as determined after mount. `false` during SSR and until mount —
+     * before then it is not yet knowable, and claiming otherwise at setup time would desync hydration.
+     */
+    readonly supported: Readonly<ShallowRef<boolean>>;
+}
+/**
+ * Owns a worker for the lifetime of the calling scope: created on mount, terminated on disposal.
+ *
+ * ```ts
+ * const { client } = useWorker<MathApi>(() => new Worker(new URL('./math.worker.ts', import.meta.url), { type: 'module' }));
+ * const sum = await client.value?.call('add', 2, 3);
+ * ```
+ *
+ * The factory is invoked once per mount, so an inline arrow is the expected call shape.
+ */
+export declare function useWorker<TApi extends WorkerApiOf<TApi>>(factory: () => Worker, options?: WorkerClientOptions): UseWorkerResult<TApi>;

package/dist/foundation/workers/WorkerClient.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Constrains an RPC contract to methods only — used as `TApi extends WorkerApiOf<TApi>`.
+ *
+ * The self-reference is not decoration, it is the only form a plain `interface` satisfies. The obvious
+ * spelling, `TApi extends Record<string, Fn>`, silently rejects every `interface`: TypeScript grants an
+ * implicit index signature to type ALIASES and inferred object literals but never to an interface, so
+ * `interface MathApi { add(a: number, b: number): number }` — the shape this slice's own documentation
+ * recommends, and the one a consumer sharing a contract between two files will reach for — fails the
+ * constraint with a message about a missing index signature that says nothing about what to do. Mapping
+ * over `keyof TApi` asks the same question (is every member callable?) without ever requiring one.
+ *
+ * `never[]` in the parameter position is the standard "any function is assignable here" trick: parameters
+ * are contravariant, so it accepts every signature while `Parameters<TApi[TMethod]>` still reads a
+ * concrete contract's own argument types exactly.
+ */
+export type WorkerApiOf<TApi> = {
+    [TMethod in keyof TApi]: (...args: never[]) => unknown;
+};
+/** Tunes a single call. */
+export interface WorkerCallOptions {
+    /**
+     * The deadline in milliseconds. Rejects with an `Error` named `TimeoutError` — the same name
+     * `AbortSignal.timeout()` uses, so `isTimeoutError` from `foundation/errors` recognizes it. Overrides
+     * the client-level default; omit (or pass a non-positive value) for no deadline.
+     */
+    readonly timeoutMs?: number;
+    /**
+     * The objects to transfer rather than clone — an `ArrayBuffer`, `MessagePort`, `ImageBitmap`, or
+     * `OffscreenCanvas` reachable from `args`.
+     *
+     * A transferred object is NEUTERED in the sender: after the call, the caller's own `ArrayBuffer` has
+     * `byteLength === 0` and reading it throws. This is the single most surprising thing about the API and
+     * is the price of the move — see the `withTransfer` docs for the full note.
+     */
+    readonly transfer?: readonly Transferable[];
+}
+/** Tunes a client. */
+export interface WorkerClientOptions {
+    /** The default deadline in milliseconds applied to every call that does not set its own. Omit for none. */
+    readonly timeoutMs?: number;
+    /**
+     * Called with the normalized error when the WORKER ITSELF fails — an `ErrorEvent` or a `messageerror`,
+     * neither of which names a call. The seam for logging a broken worker; a per-call failure never reaches
+     * it, since that rejects the call instead. A throw from this callback is swallowed.
+     */
+    readonly onError?: (error: Error) => void;
+}
+/** The typed handle over one worker. */
+export interface WorkerClient<TApi extends WorkerApiOf<TApi>> {
+    /**
+     * Calls `method` on the worker and resolves with its reply. Rejects if the handler throws, the deadline
+     * elapses, the worker dies, or {@link WorkerClient.terminate} is called while this is in flight.
+     */
+    call<TMethod extends keyof TApi & string>(method: TMethod, ...args: Parameters<TApi[TMethod]>): Promise<Awaited<ReturnType<TApi[TMethod]>>>;
+    /** Calls `method` with per-call options — a deadline, a transfer list, or both. Otherwise identical to {@link WorkerClient.call}. */
+    callWith<TMethod extends keyof TApi & string>(options: WorkerCallOptions, method: TMethod, ...args: Parameters<TApi[TMethod]>): Promise<Awaited<ReturnType<TApi[TMethod]>>>;
+    /** The number of calls awaiting a reply — the observable that proves an exit path cleaned up after itself. */
+    readonly pendingCount: number;
+    /** Whether {@link WorkerClient.terminate} has run. A terminated client rejects every further call rather than hanging. */
+    readonly terminated: boolean;
+    /**
+     * Kills the worker and rejects every in-flight call. Idempotent.
+     *
+     * The rejection is the point: a terminated worker will never reply, so leaving those promises pending
+     * would hang each awaiting caller forever with no error to catch.
+     */
+    terminate(): void;
+}
+/**
+ * Wraps a `Worker` in a typed request/response client.
+ *
+ * The worker must run {@link exposeWorkerApi} (or speak the same envelope). `TApi` is the shared contract:
+ * declare it once, use it here and to type the handler map on the worker side.
+ *
+ * ```ts
+ * interface MathApi { add(a: number, b: number): number }
+ * const client = createWorkerClient<MathApi>(new Worker(new URL('./math.worker.ts', import.meta.url), { type: 'module' }));
+ * await client.call('add', 2, 3); // 5
+ * ```
+ *
+ * Takes an already-constructed `Worker` rather than a factory so it stays usable with any worker the
+ * consumer's bundler produced, and so nothing in this module ever touches the `Worker` constructor — which
+ * is what keeps it importable under SSR.
+ */
+export declare function createWorkerClient<TApi extends WorkerApiOf<TApi>>(worker: Worker, options?: WorkerClientOptions): WorkerClient<TApi>;

package/dist/foundation/workers/WorkerHost.d.ts

@@ -0,0 +1,80 @@
+import { WorkerApiOf } from './WorkerClient';
+/**
+ * Describes the parts of a worker's global scope this module uses. Structural so it typechecks without the
+ * `webworker` lib, and so a test can pass a stand-in.
+ */
+export interface WorkerScope {
+    /** Subscribes to inbound messages. */
+    addEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+    /** Unsubscribes a previously registered listener. */
+    removeEventListener(type: 'message', listener: (event: MessageEvent) => void): void;
+    /** Posts a reply back to the main thread, optionally transferring ownership of objects reachable from it. */
+    postMessage(message: unknown, transfer?: Transferable[]): void;
+}
+/** Constrains a handler map: method name → implementation, sync or async. */
+export type WorkerHandlerMap = Record<string, (...args: never[]) => unknown>;
+/**
+ * Projects a client-side contract into the handler map that satisfies it — the optional annotation for a
+ * consumer who wants the compiler to hold both halves of the RPC to one interface.
+ *
+ * ```ts
+ * const handlers: WorkerHandlersOf<MathApi> = { add: (a, b) => a + b };
+ * exposeWorkerApi(handlers);
+ * ```
+ *
+ * Each handler may return the value, a promise of it, or that value wrapped by {@link withTransfer} — all
+ * three arrive at the client as the plain value.
+ */
+export type WorkerHandlersOf<TApi extends WorkerApiOf<TApi>> = {
+    readonly [TMethod in keyof TApi]: (...args: Parameters<TApi[TMethod]>) => Awaited<ReturnType<TApi[TMethod]>> | Promise<Awaited<ReturnType<TApi[TMethod]>>> | WorkerTransfer<Awaited<ReturnType<TApi[TMethod]>>> | Promise<WorkerTransfer<Awaited<ReturnType<TApi[TMethod]>>>>;
+};
+/**
+ * Brands a {@link WorkerTransfer} wrapper. Exported only because the declaration emit needs the symbol to
+ * be nameable; it is an implementation detail, not something to reference. The wrapper is unwrapped before
+ * the reply is posted, so this symbol never crosses a thread boundary.
+ */
+export declare const WorkerTransferMarker: unique symbol;
+/** Wraps a handler's return value together with the objects to move rather than copy. Built by {@link withTransfer}. */
+export interface WorkerTransfer<TValue> {
+    /** The brand. */
+    readonly [WorkerTransferMarker]: true;
+    /** The value the client will receive — the wrapper itself is stripped before posting. */
+    readonly value: TValue;
+    /** The objects whose ownership moves to the main thread. */
+    readonly transfer: readonly Transferable[];
+}
+/**
+ * Marks a handler's result for transfer instead of a structured-clone copy — the return-path counterpart
+ * of `WorkerCallOptions.transfer`.
+ *
+ * ```ts
+ * const handlers = {
+ *   render: (size: number) => {
+ *     const pixels = new ArrayBuffer(size);
+ *     return withTransfer(pixels, [pixels]); // moved, not copied
+ *   },
+ * };
+ * ```
+ *
+ * THE TRANSFERRED OBJECT IS NEUTERED IN THE SENDER. This is the single most surprising thing about the
+ * whole API and it is not a bug: transfer is a MOVE. Once posted, the worker's own `pixels` has
+ * `byteLength === 0` and any read of it throws — the memory now belongs to the receiving thread. So
+ * transfer only a buffer you are done with, and never one you also returned a view over or kept in a
+ * cache. The payoff is that a 100 MB buffer costs a pointer hand-off instead of a 100 MB copy, which for
+ * a large payload is the difference between a frame and a stall.
+ *
+ * The same neutering hits the CALLER when transferring into the worker via `callWith({ transfer })`: after
+ * that call the caller's `ArrayBuffer` is the empty one.
+ */
+export declare function withTransfer<TValue>(value: TValue, transfer: readonly Transferable[]): WorkerTransfer<TValue>;
+/**
+ * Registers `handlers` as the worker's RPC surface and returns a disposer that unregisters them.
+ *
+ * Dispatch is by method name; an unknown method rejects that one call rather than killing the worker. A
+ * handler may be sync or async — the result is awaited either way — and may wrap its return value in
+ * {@link withTransfer} to move a large buffer instead of copying it.
+ *
+ * Never throws, including when there is no worker scope (main thread, SSR), where it registers nothing and
+ * the returned disposer is a no-op.
+ */
+export declare function exposeWorkerApi<THandlers extends WorkerHandlerMap>(handlers: THandlers, scope?: WorkerScope | null): () => void;

package/dist/foundation/workers/WorkerProtocol.d.ts

@@ -0,0 +1,78 @@
+import { SerializedError } from '../errors';
+/**
+ * Tags every message belonging to this protocol. A namespaced literal rather than a `Symbol`, because a
+ * `Symbol` does not survive structured clone and would arrive as `undefined` on the far thread.
+ */
+export declare const WorkerMessageChannel = "@wow-two-beta/worker-rpc";
+/** Names the channel tag's type — used to type the envelopes without restating the literal. */
+export type WorkerMessageChannel = typeof WorkerMessageChannel;
+/** Describes a call travelling from the client to the worker. */
+export interface WorkerRequestMessage {
+    /** The protocol tag — always {@link WorkerMessageChannel}. */
+    readonly channel: WorkerMessageChannel;
+    /** The envelope discriminant, distinguishing a request from a reply on the same pipe. */
+    readonly kind: 'request';
+    /** The correlation id the reply must echo back. Unique per client, monotonic. */
+    readonly id: number;
+    /** The handler name to dispatch to on the worker side. */
+    readonly method: string;
+    /** The positional arguments, structured-cloned (or transferred) to the worker. */
+    readonly args: readonly unknown[];
+}
+/** Describes a reply carrying a handler's resolved value. */
+export interface WorkerSuccessMessage {
+    /** The protocol tag — always {@link WorkerMessageChannel}. */
+    readonly channel: WorkerMessageChannel;
+    /** The envelope discriminant. */
+    readonly kind: 'response';
+    /** The correlation id echoed from the request this answers. */
+    readonly id: number;
+    /** The success discriminant. */
+    readonly ok: true;
+    /** The handler's resolved value. Legitimately `undefined` for a `void` method. */
+    readonly result: unknown;
+}
+/** Describes a reply carrying a handler's failure. */
+export interface WorkerFailureMessage {
+    /** The protocol tag — always {@link WorkerMessageChannel}. */
+    readonly channel: WorkerMessageChannel;
+    /** The envelope discriminant. */
+    readonly kind: 'response';
+    /** The correlation id echoed from the request this answers. */
+    readonly id: number;
+    /** The failure discriminant. */
+    readonly ok: false;
+    /** The JSON-safe projection of the thrown value, rehydrated by `toError` on the client. */
+    readonly error: SerializedError;
+}
+/** Describes either half of a reply — the union the client switches on. */
+export type WorkerResponseMessage = WorkerSuccessMessage | WorkerFailureMessage;
+/**
+ * Recognizes a request envelope arriving on the worker side.
+ *
+ * Deliberately total and silent: a message failing this check is ignored by the host, because the pipe is
+ * shared and a foreign message must not be answered with a protocol error addressed to nobody.
+ */
+export declare function isWorkerRequestMessage(value: unknown): value is WorkerRequestMessage;
+/**
+ * Recognizes a reply envelope arriving on the client side.
+ *
+ * Note it does NOT require a `result` member on the success branch — absent and `undefined` are the same
+ * thing after a clone, and a `void` handler must still resolve its call.
+ */
+export declare function isWorkerResponseMessage(value: unknown): value is WorkerResponseMessage;
+/** Builds a request envelope. */
+export declare function createRequestMessage(id: number, method: string, args: readonly unknown[]): WorkerRequestMessage;
+/** Builds a success reply. */
+export declare function createSuccessMessage(id: number, result: unknown): WorkerSuccessMessage;
+/** Builds a failure reply. */
+export declare function createFailureMessage(id: number, error: SerializedError): WorkerFailureMessage;
+/**
+ * Creates a per-client monotonic id source, starting at `1` so a falsy `0` never identifies a real call.
+ *
+ * Per-client rather than module-global on purpose: two clients over two workers each keep their own
+ * sequence, so ids stay small and readable in a log, and one client's traffic can never be confused with
+ * another's. No wrap handling — exhausting `Number.MAX_SAFE_INTEGER` at a million calls a second would
+ * take roughly 285 years, so a counter reset is dead code that could only ever hide a bug.
+ */
+export declare function createRequestIdAllocator(): () => number;

package/dist/foundation/workers/WorkerSupport.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Reports whether the current runtime can construct a `Worker`.
+ *
+ * `false` under SSR and in Node's test environment. Call it before anything that would construct one —
+ * every entry point in this slice already does, so this is for a consumer branching its own UI.
+ */
+export declare function isWorkerSupported(): boolean;
+/**
+ * Reports whether the runtime can build a worker from a `Blob` URL — the strictly stronger requirement
+ * behind {@link runInWorker}, which needs `Blob` and `URL.createObjectURL` on top of `Worker`.
+ *
+ * Separate from {@link isWorkerSupported} because the two can genuinely diverge: a locked-down CSP with
+ * no `worker-src blob:` leaves `Worker` fully functional while making the blob route unusable.
+ */
+export declare function isBlobWorkerSupported(): boolean;

package/dist/foundation/workers/index.d.ts

@@ -0,0 +1,6 @@
+export { isWorkerSupported, isBlobWorkerSupported } from './WorkerSupport';
+export { WorkerMessageChannel, isWorkerRequestMessage, isWorkerResponseMessage, createRequestMessage, createSuccessMessage, createFailureMessage, createRequestIdAllocator, type WorkerRequestMessage, type WorkerSuccessMessage, type WorkerFailureMessage, type WorkerResponseMessage, } from './WorkerProtocol';
+export { createWorkerClient, type WorkerApiOf, type WorkerClient, type WorkerCallOptions, type WorkerClientOptions, } from './WorkerClient';
+export { exposeWorkerApi, withTransfer, WorkerTransferMarker, type WorkerScope, type WorkerHandlerMap, type WorkerHandlersOf, type WorkerTransfer, } from './WorkerHost';
+export { useWorker, type UseWorkerResult } from './UseWorker';
+export { runInWorker, type RunInWorkerResult, type RunInWorkerOptions } from './RunInWorker';

package/dist/foundation/workers/index.js

@@ -0,0 +1,292 @@
+import { t as toError } from "../../chunks/ToError-CyTBsmLO.js";
+import { s as serializeError } from "../../chunks/SerializeError-CclP2jCW.js";
+import { shallowRef, onMounted, onScopeDispose } from "vue";
+function isWorkerSupported() {
+  return typeof Worker === "function";
+}
+function isBlobWorkerSupported() {
+  return isWorkerSupported() && typeof Blob === "function" && typeof URL !== "undefined" && typeof URL.createObjectURL === "function" && typeof URL.revokeObjectURL === "function";
+}
+const WorkerMessageChannel = "@wow-two-beta/worker-rpc";
+function isRecord$1(value) {
+  return typeof value === "object" && value !== null;
+}
+function isWorkerRequestMessage(value) {
+  if (!isRecord$1(value)) return false;
+  return value["channel"] === WorkerMessageChannel && value["kind"] === "request" && typeof value["id"] === "number" && typeof value["method"] === "string" && Array.isArray(value["args"]);
+}
+function isWorkerResponseMessage(value) {
+  if (!isRecord$1(value)) return false;
+  if (value["channel"] !== WorkerMessageChannel || value["kind"] !== "response") return false;
+  if (typeof value["id"] !== "number") return false;
+  const ok = value["ok"];
+  if (ok === true) return true;
+  return ok === false && isRecord$1(value["error"]);
+}
+function createRequestMessage(id, method, args) {
+  return { channel: WorkerMessageChannel, kind: "request", id, method, args };
+}
+function createSuccessMessage(id, result) {
+  return { channel: WorkerMessageChannel, kind: "response", id, ok: true, result };
+}
+function createFailureMessage(id, error) {
+  return { channel: WorkerMessageChannel, kind: "response", id, ok: false, error };
+}
+function createRequestIdAllocator() {
+  let previous = 0;
+  return () => {
+    previous += 1;
+    return previous;
+  };
+}
+function createTimeoutError(method, timeoutMs) {
+  const error = new Error(`Worker call \`${method}\` timed out after ${timeoutMs}ms`);
+  error.name = "TimeoutError";
+  return error;
+}
+function createWorkerClient(worker, options) {
+  const pendingCalls = /* @__PURE__ */ new Map();
+  const nextRequestId = createRequestIdAllocator();
+  let terminated = false;
+  function settle(id) {
+    const pending = pendingCalls.get(id);
+    if (pending === void 0) return void 0;
+    if (pending.timer !== void 0) clearTimeout(pending.timer);
+    pendingCalls.delete(id);
+    return pending;
+  }
+  function rejectAll(toFailure) {
+    for (const id of [...pendingCalls.keys()]) {
+      const pending = settle(id);
+      if (pending !== void 0) pending.reject(toFailure(pending));
+    }
+  }
+  function report(error) {
+    if (options?.onError === void 0) return;
+    try {
+      options.onError(error);
+    } catch {
+    }
+  }
+  function handleMessage(event) {
+    const message = event.data;
+    if (!isWorkerResponseMessage(message)) return;
+    const pending = settle(message.id);
+    if (pending === void 0) return;
+    const reply = message;
+    if (reply.ok) pending.resolve(reply.result);
+    else pending.reject(toError(reply.error));
+  }
+  function handleError(event) {
+    const failure = toError(event.error ?? event.message ?? "Worker error");
+    rejectAll(() => failure);
+    report(failure);
+  }
+  function handleMessageError() {
+    const failure = new Error("Worker sent a message that could not be deserialized");
+    rejectAll(() => failure);
+    report(failure);
+  }
+  worker.addEventListener("message", handleMessage);
+  worker.addEventListener("error", handleError);
+  worker.addEventListener("messageerror", handleMessageError);
+  function invoke(callOptions, method, args) {
+    if (terminated) {
+      return Promise.reject(new Error(`Worker call \`${method}\` rejected: the client is terminated`));
+    }
+    const id = nextRequestId();
+    return new Promise((resolve, reject) => {
+      const pending = { method, resolve, reject };
+      pendingCalls.set(id, pending);
+      const timeoutMs = callOptions.timeoutMs ?? options?.timeoutMs;
+      if (timeoutMs !== void 0 && timeoutMs > 0 && Number.isFinite(timeoutMs)) {
+        pending.timer = setTimeout(() => {
+          if (settle(id) !== void 0) reject(createTimeoutError(method, timeoutMs));
+        }, timeoutMs);
+      }
+      try {
+        const request = createRequestMessage(id, method, args);
+        const transfer = callOptions.transfer;
+        if (transfer !== void 0 && transfer.length > 0) worker.postMessage(request, [...transfer]);
+        else worker.postMessage(request);
+      } catch (error) {
+        if (settle(id) !== void 0) reject(toError(error));
+      }
+    });
+  }
+  function terminate() {
+    if (terminated) return;
+    terminated = true;
+    rejectAll((pending) => new Error(`Worker call \`${pending.method}\` rejected: the worker was terminated`));
+    worker.removeEventListener("message", handleMessage);
+    worker.removeEventListener("error", handleError);
+    worker.removeEventListener("messageerror", handleMessageError);
+    worker.terminate();
+  }
+  return {
+    call(method, ...args) {
+      return invoke({}, method, args);
+    },
+    callWith(callOptions, method, ...args) {
+      return invoke(callOptions, method, args);
+    },
+    get pendingCount() {
+      return pendingCalls.size;
+    },
+    get terminated() {
+      return terminated;
+    },
+    terminate
+  };
+}
+const WorkerTransferMarker = Symbol("@wow-two-beta/worker-transfer");
+function withTransfer(value, transfer) {
+  return { [WorkerTransferMarker]: true, value, transfer };
+}
+function isWorkerTransfer(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return value[WorkerTransferMarker] === true;
+}
+function resolveDefaultScope() {
+  const candidate = globalThis;
+  return typeof candidate.addEventListener === "function" && typeof candidate.removeEventListener === "function" && typeof candidate.postMessage === "function" ? candidate : null;
+}
+function exposeWorkerApi(handlers, scope = resolveDefaultScope()) {
+  if (scope === null) return () => void 0;
+  const target = scope;
+  async function dispatch(event) {
+    const request = event.data;
+    if (!isWorkerRequestMessage(request)) return;
+    try {
+      const handler = Object.prototype.hasOwnProperty.call(handlers, request.method) ? handlers[request.method] : void 0;
+      if (typeof handler !== "function") throw new Error(`Unknown worker method \`${request.method}\``);
+      const invoke = handler;
+      const outcome = await invoke(...request.args);
+      const value = isWorkerTransfer(outcome) ? outcome.value : outcome;
+      const transfer = isWorkerTransfer(outcome) ? [...outcome.transfer] : void 0;
+      target.postMessage(createSuccessMessage(request.id, value), transfer);
+    } catch (error) {
+      target.postMessage(createFailureMessage(request.id, serializeError(error)));
+    }
+  }
+  function listener(event) {
+    void dispatch(event);
+  }
+  target.addEventListener("message", listener);
+  return () => {
+    target.removeEventListener("message", listener);
+  };
+}
+function useWorker(factory, options) {
+  const client = shallowRef(null);
+  const supported = shallowRef(false);
+  onMounted(() => {
+    if (!isWorkerSupported()) {
+      client.value = null;
+      supported.value = false;
+      return;
+    }
+    client.value = createWorkerClient(factory(), options);
+    supported.value = true;
+  });
+  onScopeDispose(() => {
+    client.value?.terminate();
+    client.value = null;
+    supported.value = false;
+  });
+  return { client, supported };
+}
+function buildWorkerSource(functionSource) {
+  return `self.onmessage = function (event) {
+  Promise.resolve()
+    .then(function () {
+      var fn = (${functionSource});
+      return fn.apply(null, event.data);
+    })
+    .then(function (value) {
+      self.postMessage({ ok: true, value: value });
+    })
+    .catch(function (error) {
+      var shape = { name: 'Error', message: 'Worker function failed' };
+      if (error && typeof error === 'object') {
+        if (typeof error.name === 'string') shape.name = error.name;
+        if (typeof error.message === 'string') shape.message = error.message;
+        if (typeof error.stack === 'string') shape.stack = error.stack;
+      } else if (typeof error === 'string') {
+        shape.message = error;
+      }
+      self.postMessage({ ok: false, error: shape });
+    });
+};`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+async function runInWorker(fn, args, options) {
+  if (!isBlobWorkerSupported()) return { status: "unsupported" };
+  let url;
+  let worker;
+  try {
+    url = URL.createObjectURL(new Blob([buildWorkerSource(fn.toString())], { type: "text/javascript" }));
+    const instance = new Worker(url);
+    worker = instance;
+    const value = await new Promise((resolve, reject) => {
+      let timer;
+      const done = () => {
+        if (timer !== void 0) clearTimeout(timer);
+      };
+      const { timeoutMs } = options ?? {};
+      if (timeoutMs !== void 0 && timeoutMs > 0 && Number.isFinite(timeoutMs)) {
+        timer = setTimeout(() => {
+          const error = new Error(`Worker function timed out after ${timeoutMs}ms`);
+          error.name = "TimeoutError";
+          reject(error);
+        }, timeoutMs);
+      }
+      instance.addEventListener("message", (event) => {
+        done();
+        const reply = event.data;
+        if (!isRecord(reply)) {
+          reject(new Error("Worker sent an unrecognized reply"));
+          return;
+        }
+        if (reply["ok"] === true) {
+          resolve(reply["value"]);
+          return;
+        }
+        reject(toError(reply["error"]));
+      });
+      instance.addEventListener("error", (event) => {
+        done();
+        reject(toError(event.error ?? event.message ?? "Worker failed to start"));
+      });
+      const transfer = options?.transfer;
+      if (transfer !== void 0 && transfer.length > 0) instance.postMessage(args, [...transfer]);
+      else instance.postMessage(args);
+    });
+    return { status: "ok", value };
+  } catch (error) {
+    return { status: "failed", error: toError(error) };
+  } finally {
+    worker?.terminate();
+    if (url !== void 0) URL.revokeObjectURL(url);
+  }
+}
+export {
+  WorkerMessageChannel,
+  WorkerTransferMarker,
+  createFailureMessage,
+  createRequestIdAllocator,
+  createRequestMessage,
+  createSuccessMessage,
+  createWorkerClient,
+  exposeWorkerApi,
+  isBlobWorkerSupported,
+  isWorkerRequestMessage,
+  isWorkerResponseMessage,
+  isWorkerSupported,
+  runInWorker,
+  useWorker,
+  withTransfer
+};
+//# sourceMappingURL=index.js.map