@evolu/common 7.4.0 → 8.0.0-next.0

package/dist/src/WebSocket.js

@@ -1,131 +1,223 @@
-import { err, ok } from "./Result.js";
-import { retry } from "./Task.js";
-import { maxPositiveInt } from "./Type.js";
 /**
- * Create a new {@link WebSocket}.
- *
- * The default behavior is that WebSocket tries to reconnect repeatedly in case
- * the application is offline, because online events (both web and native) are
- * not reliable. Once it connects and the connection is closed, it tries to
- * reconnect again. Retrying the connection can be controlled using the
- * retryOptions retryable predicate.
- *
- * ### How Binary Messages Work in WebSockets
- *
- * The Server Chooses the Message Type:
- *
- * - Text (0x1) → Sent as UTF-8 encoded text (always received as a string in the
- *   browser).
- * - Binary (0x2) → Sent as raw binary data (received as a Blob or ArrayBuffer,
- *   depending on binaryType).
- *
- * The Client's binaryType Controls How Binary Data is Processed:
- *
- * - If the server sends a text frame (0x1), the browser always delivers
- *   event.data as a string, regardless of binaryType.
- * - If the server sends a binary frame (0x2), the browser delivers event.data as:
- *
- *   - A Blob (default: "blob")
- *   - An ArrayBuffer ("arraybuffer")
+ * WebSocket with auto-reconnect.
  *
- * ### Example
- *
- * TODO:
+ * @module
  */
-export const createWebSocket = (url, { protocols, binaryType, onOpen, onClose, onMessage, onError, retryOptions, WebSocketConstructor = globalThis.WebSocket, } = {}) => {
-    let isDisposed = false;
-    const reconnectController = new AbortController();
-    const defaultRetryOptions = {
-        retries: maxPositiveInt, // Practically infinite retries
-    };
-    let socket = null;
-    const disposeSocket = () => {
-        if (!socket)
-            return;
-        // Remove all listeners before closing
-        socket.onopen = null;
-        socket.onclose = null;
-        socket.onmessage = null;
-        socket.onerror = null;
-        if (socket.readyState !== socket.CLOSING &&
-            socket.readyState !== socket.CLOSED) {
-            socket.close();
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
         }
-        socket = null;
+        return next();
     };
-    // To prevent a memory leak from pending connection promise.
-    let disposePromise = null;
-    /**
-     * This promise represents continuous connection which:
-     *
-     * - Is rejected when a connection cannot be established.
-     * - Is rejected when a connection is closed.
-     * - Is resolved when WebSocket is disposed().
-     */
-    void retry({
-        ...defaultRetryOptions,
-        ...retryOptions,
-    }, () => new Promise((resolve) => {
-        disposePromise = () => {
-            resolve(ok());
-        };
-        if (isDisposed)
-            disposePromise();
-        disposeSocket();
-        socket = new WebSocketConstructor(url, protocols);
-        if (binaryType)
-            socket.binaryType = binaryType;
-        let isOpen = false;
-        socket.onopen = () => {
-            isOpen = true;
-            onOpen?.();
-        };
-        socket.onerror = (event) => {
-            const error = isOpen
-                ? { type: "WebSocketConnectionError", event }
-                : { type: "WebSocketConnectError", event };
-            onError?.(error);
-            // Trigger reconnect only on WebSocketConnectError.
-            if (error.type === "WebSocketConnectError") {
-                resolve(err(error));
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { lazyTrue } from "./Function.js";
+import { err, ok } from "./Result.js";
+import { exponential, jitter, maxDelay } from "./Schedule.js";
+import { callback, retry } from "./Task.js";
+import { String } from "./Type.js";
+import { assert } from "./Assert.js";
+/** Create a new {@link WebSocket}. */
+export const createWebSocket = (url, { protocols, binaryType, onOpen, onClose, shouldRetryOnClose = lazyTrue, onMessage, onError, schedule = jitter(1)(maxDelay("30s")(exponential("100ms"))), WebSocketConstructor = globalThis.WebSocket, } = {}) => async (run) => {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const stack = __addDisposableResource(env_1, new AsyncDisposableStack(), true);
+        let socket = null;
+        let disposed = false;
+        const closeSocket = () => {
+            if (!socket)
+                return;
+            socket.onopen = null;
+            socket.onclose = null;
+            socket.onmessage = null;
+            socket.onerror = null;
+            if (socket.readyState !== socket.CLOSING &&
+                socket.readyState !== socket.CLOSED) {
+                socket.close();
             }
+            socket = null;
         };
-        socket.onclose = (event) => {
-            onClose?.(event);
-            resolve(err({ type: "WebSocketConnectionCloseError", event }));
-        };
-        socket.onmessage = (event) => {
-            onMessage?.(event.data);
-        };
-    }))(reconnectController).then((result) => {
-        if (result.ok || result.error.type === "AbortError")
-            return;
-        onError?.(result.error);
-    });
-    return {
-        send: (data) => {
-            // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
-            if (!socket || socket.readyState === socket.CONNECTING) {
-                return err({ type: "WebSocketSendError" });
+        /**
+         * A task that connects and stays connected until the connection closes or
+         * errors. Returns error to trigger retry.
+         */
+        const connect = callback(({ err, ok }) => {
+            closeSocket();
+            socket = new WebSocketConstructor(url, String.is(protocols) ? protocols : protocols && [...protocols]);
+            if (binaryType)
+                socket.binaryType = binaryType;
+            let isOpen = false;
+            socket.onopen = () => {
+                isOpen = true;
+                onOpen?.();
+            };
+            socket.onclose = (event) => {
+                onClose?.(event);
+                if (shouldRetryOnClose(event)) {
+                    err({ type: "WebSocketConnectionCloseError", event });
+                }
+                else {
+                    ok();
+                }
+            };
+            socket.onmessage = (event) => {
+                onMessage?.(event.data);
+            };
+            socket.onerror = (event) => {
+                const error = isOpen
+                    ? { type: "WebSocketConnectionError", event }
+                    : { type: "WebSocketConnectError", event };
+                onError?.(error);
+                if (error.type === "WebSocketConnectError")
+                    err(error);
+            };
+            return closeSocket;
+        });
+        const retryFiber = stack.use(run.daemon(retry(connect, schedule)));
+        // Report RetryError (schedule exhausted) via onError callback
+        void retryFiber.then((result) => {
+            if (!result.ok && result.error.type === "RetryError") {
+                onError?.(result.error);
             }
-            socket.send(data);
-            return ok();
+        });
+        const moved = stack.move();
+        return ok({
+            send: (data) => {
+                // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send
+                if (!socket || socket.readyState === socket.CONNECTING) {
+                    return err({ type: "WebSocketSendError" });
+                }
+                socket.send(data);
+                return ok();
+            },
+            getReadyState: () => {
+                if (disposed)
+                    return "closed";
+                return socket ? nativeToStringState[socket.readyState] : "connecting";
+            },
+            isOpen: () => !disposed && socket?.readyState === globalThis.WebSocket.OPEN,
+            [Symbol.asyncDispose]: async () => {
+                disposed = true;
+                await moved.disposeAsync();
+            },
+        });
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
+};
+export const testCreateWebSocket = (options = {}) => {
+    const createdUrls = [];
+    const sentMessages = [];
+    const stateByUrl = new Map();
+    const getState = (url) => {
+        const state = stateByUrl.get(url);
+        assert(state, `Test WebSocket for ${url} does not exist.`);
+        return state;
+    };
+    const createWebSocket = (url, socketOptions) => () => {
+        if (options.throwOnCreate) {
+            throw new Error("testCreateWebSocket is configured to throw on create");
+        }
+        createdUrls.push(url);
+        stateByUrl.set(url, {
+            options: socketOptions,
+            isOpen: options.isOpen ?? true,
+            isDisposed: false,
+        });
+        return ok({
+            send: (data) => {
+                const state = getState(url);
+                if (state.isDisposed || !state.isOpen) {
+                    return err({ type: "WebSocketSendError" });
+                }
+                sentMessages.push({ url, data });
+                return ok();
+            },
+            getReadyState: () => {
+                const state = getState(url);
+                if (state.isDisposed)
+                    return "closed";
+                return state.isOpen ? "open" : "closed";
+            },
+            isOpen: () => {
+                const state = getState(url);
+                return !state.isDisposed && state.isOpen;
+            },
+            [Symbol.asyncDispose]: () => {
+                const state = getState(url);
+                state.isDisposed = true;
+                state.isOpen = false;
+                return Promise.resolve();
+            },
+        });
+    };
+    return Object.assign(createWebSocket, {
+        createdUrls,
+        sentMessages,
+        message: (url, data) => {
+            getState(url).options?.onMessage?.(data);
         },
-        getReadyState: () => socket ? nativeToStringState[socket.readyState] : "connecting",
-        isOpen: () => (socket ? socket.readyState === socket.OPEN : false),
-        [Symbol.dispose]() {
-            if (isDisposed)
-                return;
-            isDisposed = true;
-            reconnectController.abort();
-            disposeSocket();
-            disposePromise?.();
+        open: (url) => {
+            const state = getState(url);
+            state.isOpen = true;
+            state.options?.onOpen?.();
         },
-    };
+    });
 };
 const nativeToStringState = {
-    [WebSocket.CONNECTING]: "connecting",
-    [WebSocket.OPEN]: "open",
-    [WebSocket.CLOSING]: "closing",
-    [WebSocket.CLOSED]: "closed",
+    [globalThis.WebSocket.CONNECTING]: "connecting",
+    [globalThis.WebSocket.OPEN]: "open",
+    [globalThis.WebSocket.CLOSING]: "closing",
+    [globalThis.WebSocket.CLOSED]: "closed",
 };

package/dist/src/Worker.d.ts

@@ -1,67 +1,252 @@
-import { TransferableError } from "./Error.js";
-/** Cross-platform worker abstraction. */
-export interface Worker<Input, Output> {
-    /** Sends a message to the worker. */
-    readonly postMessage: (message: Input) => void;
-    /** Sets a callback for messages from the worker. */
-    readonly onMessage: (callback: (message: Output) => void) => void;
+/**
+ * Platform-agnostic Worker abstractions.
+ *
+ * @module
+ */
+import type { Brand } from "./Brand.js";
+import type { ConsoleDep, ConsoleStoreOutputEntryDep } from "./Console.js";
+/**
+ * Platform-agnostic Worker.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Worker
+ */
+export interface Worker<Input, Output = never> extends MessagePort<Input, Output> {
+}
+/**
+ * Platform-agnostic SharedWorker.
+ *
+ * A shared worker is shared across multiple clients (tabs, windows, iframes)
+ * and provides a port for bidirectional communication with each client.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/SharedWorker
+ */
+export interface SharedWorker<Input, Output = never> extends Disposable {
+    /** Port for communicating with the shared worker. */
+    readonly port: MessagePort<Input, Output>;
 }
-export interface WorkerPostMessageDep<Output> {
-    readonly postMessage: (message: Output) => void;
+/**
+ * Platform-agnostic MessagePort.
+ *
+ * Note: There is no reliable way to detect when a port is closed or
+ * disconnected. Calling `postMessage` on a disposed port does not throw — it
+ * silently fails. To detect dead ports, use a heartbeat pattern where the other
+ * end periodically sends "alive" messages and stale ports are pruned after a
+ * timeout.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MessagePort
+ */
+export interface MessagePort<Input, Output = never> extends Disposable {
+    readonly postMessage: (message: Input, transfer?: ReadonlyArray<Transferable>) => void;
+    /**
+     * Handler for incoming messages. Messages are queued until this is assigned,
+     * matching native `MessagePort` behavior where setting `onmessage` implicitly
+     * calls `start()`. This enables safe async initialization — the sender can
+     * post messages immediately while the receiver sets up.
+     */
+    onMessage: ((message: Output) => void) | null;
+    /**
+     * The native underlying port for transferring via `postMessage`.
+     *
+     * ### Example
+     *
+     * ```ts
+     * sharedWorker.port.postMessage(
+     *   { type: "InitConsole", port: consoleChannel.port1.native },
+     *   [consoleChannel.port1.native],
+     * );
+     * ```
+     */
+    readonly native: NativeMessagePort<Input, Output>;
 }
 /**
- * Error reporting wrapper that catches synchronous errors in handlers and
- * converts them to transferable error messages sent to the main thread.
- */
-export type WithErrorReporting = <A extends Array<any>>(handler: (...args: A) => void) => (...args: A) => void;
-type HasInit<Input> = Extract<Input, {
-    type: "init";
-}> extends never ? ["Input must contain a variant with { type: 'init' }"] : unknown;
-type HasWorkerErrorOutput<T> = Extract<T, {
-    type: "onError";
-}> extends infer E ? [E] extends [never] ? [
-    "Output must contain { type: 'onError'; error: TransferableError | ... }"
-] : E extends {
-    error: infer Err;
-} ? TransferableError extends Err ? unknown : ["Output.onError.error must include TransferableError"] : ["Output.onError must have an error property"] : never;
-/**
- * Creates a {@link Worker} that supports initialization with dependencies and
- * safe error handling.
- */
-export declare const createInitializedWorker: <Input extends {
-    readonly type: string;
-} & HasInit<Input>, Output extends {
-    readonly type: string;
-} & HasWorkerErrorOutput<Output>, Deps>({ init, onMessage, }: {
-    readonly init: (initMessage: Extract<Input, {
-        type: "init";
-    }>, postMessage: (msg: Output) => void, withErrorReporting: WithErrorReporting) => Promise<Deps | null>;
-    readonly onMessage: (deps: Deps) => (message: Exclude<Input, {
-        type: "init";
-    }>) => void;
-}) => Worker<Input, Output>;
-/** Type helper to extract message types from a union type */
-export type MessageHandlers<Input extends {
-    readonly type: string;
-}, Deps> = {
-    readonly [K in Input["type"]]: (deps: Deps) => (message: Extract<Input, {
-        type: K;
-    }>) => void;
+ * Objects whose ownership can be transferred between threads via `postMessage`.
+ *
+ * Intentionally scoped to types Evolu uses. The web platform defines additional
+ * transferable types (`ImageBitmap`, `OffscreenCanvas`, `ReadableStream`, etc.)
+ * that can be added here if needed.
+ */
+export type Transferable = NativeMessagePort<any, any> | ArrayBuffer;
+/**
+ * Opaque type for platform-specific native MessagePort.
+ *
+ * Exists because `postMessage` transfer requires the native object itself, not
+ * a wrapper. Ensures type-safe wiring between {@link MessagePort.native} and
+ * {@link CreateMessagePort} without exposing platform details.
+ */
+export type NativeMessagePort<Input = unknown, Output = never> = Brand<"NativeMessagePort"> & {
+    readonly [nativeMessagePortInput]?: Input;
+    readonly [nativeMessagePortOutput]?: Output;
 };
+declare const nativeMessagePortInput: unique symbol;
+declare const nativeMessagePortOutput: unique symbol;
+/** Factory function to create a {@link MessagePort} from a native port. */
+export type CreateMessagePort = <Input, Output = never>(nativePort: NativeMessagePort<Input, Output>) => MessagePort<Input, Output>;
+export interface CreateMessagePortDep {
+    readonly createMessagePort: CreateMessagePort;
+}
+/** Common dependencies for worker entry points. */
+export type WorkerDeps = ConsoleDep & ConsoleStoreOutputEntryDep & CreateMessagePortDep;
+/**
+ * Platform-agnostic MessageChannel.
+ *
+ * Creates two entangled ports: keep one and transfer the other (e.g., to a
+ * SharedWorker via `postMessage` with `transfer`). Messages sent to one port
+ * are received by the other.
+ *
+ * Messages are queued until `onMessage` is assigned, enabling safe async
+ * initialization. The sender can post messages immediately while the receiver
+ * performs async setup — no manual buffering required.
+ *
+ * For one-way communication, omit `Output` (defaults to `never`).
+ *
+ * ### Example
+ *
+ * Transfer a channel port to a SharedWorker for async initialization:
+ *
+ * ```ts
+ * // Main thread: create channel, transfer port1, use port2 immediately.
+ * const channel = createMessageChannel<EvoluRequest, EvoluResponse>();
+ *
+ * sharedWorker.port.postMessage(
+ *   { type: "CreateEvolu", port: channel.port1.native },
+ *   [channel.port1.native],
+ * );
+ *
+ * // Safe to send immediately — messages queue until worker is ready.
+ * channel.port2.postMessage({ type: "Query", query });
+ * channel.port2.onMessage = (response) => {
+ *   handleResponse(response);
+ * };
+ * ```
+ *
+ * ```ts
+ * // Worker: receive the port, do async init, then start listening.
+ * const evoluPort = createMessagePort<EvoluResponse, EvoluRequest>(
+ *   message.port,
+ * );
+ * await openDatabase(name);
+ * evoluPort.onMessage = (request) => {
+ *   handleRequest(request);
+ * };
+ * // Queued messages are now delivered in order.
+ * ```
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MessageChannel
+ */
+export interface MessageChannel<Input, Output = never> extends Disposable {
+    /** The first port of the channel. */
+    readonly port1: MessagePort<Input, Output>;
+    /** The second port of the channel. */
+    readonly port2: MessagePort<Output, Input>;
+}
+/** Factory function to create a {@link MessageChannel}. */
+export type CreateMessageChannel = <Input, Output = never>() => MessageChannel<Input, Output>;
+export interface CreateMessageChannelDep {
+    readonly createMessageChannel: CreateMessageChannel;
+}
+/**
+ * Typed `self` for code running inside a dedicated worker.
+ *
+ * This is the worker-side counterpart to {@link Worker} — a typed
+ * {@link MessagePort} that wraps `self` inside the worker.
+ */
+export interface WorkerSelf<Input, Output = never> extends MessagePort<Output, Input> {
+}
+/**
+ * Typed `self` for code running inside a shared worker.
+ *
+ * This is the worker-side counterpart to {@link SharedWorker}. It wraps `self`
+ * inside the shared worker, providing typed `onConnect` callbacks.
+ */
+export interface SharedWorkerSelf<Input, Output = never> extends Disposable {
+    onConnect: ((port: MessagePort<Output, Input>) => void) | null;
+}
 /**
- * Creates a {@link Worker} with type-safe message handlers for each message
- * type. This provides better type safety and organization compared to a single
- * onMessage handler.
- */
-export declare const createInitializedWorkerWithHandlers: <Input extends {
-    readonly type: string;
-} & HasInit<Input>, Output extends {
-    readonly type: string;
-} & HasWorkerErrorOutput<Output>, Deps>({ init, handlers, }: {
-    readonly init: (initMessage: Extract<Input, {
-        type: "init";
-    }>, postMessage: (msg: Output) => void, withErrorReporting: WithErrorReporting) => Promise<Deps | null>;
-    readonly handlers: Omit<MessageHandlers<Input, Deps>, "init">;
-}) => Worker<Input, Output>;
+ * Creates an in-memory {@link Worker}.
+ *
+ * This is a memory-only fallback for platforms without native worker support.
+ * Message delivery is asynchronous in-process.
+ */
+export declare const createWorker: <Input, Output = never>(initWorker: (self: WorkerSelf<Input, Output>) => void) => Worker<Input, Output>;
+/**
+ * Creates an in-memory {@link SharedWorker}.
+ *
+ * This is a memory-only fallback for platforms without native SharedWorker
+ * support. Connection is synchronous while message delivery is asynchronous
+ * in-process.
+ *
+ * Intended usage is one shared worker instance per process/app runtime.
+ */
+export declare const createSharedWorker: <Input, Output = never>(initWorker: (self: SharedWorkerSelf<Input, Output>) => void) => SharedWorker<Input, Output>;
+/**
+ * Creates an in-memory {@link MessageChannel}.
+ *
+ * This is a memory-only fallback for platforms without native MessageChannel
+ * support. Message delivery is asynchronous in-process.
+ */
+export declare const createMessageChannel: CreateMessageChannel;
+/**
+ * Creates an in-memory {@link MessagePort} from a native token.
+ *
+ * This is a memory-only fallback for platforms without native MessagePort
+ * support. Message delivery through returned ports is asynchronous in-process.
+ */
+export declare const createMessagePort: CreateMessagePort;
+/**
+ * Test {@link Worker} with access to its paired worker-side `self`.
+ *
+ * Use `self` to simulate messages and behavior from inside the worker.
+ */
+export interface TestWorker<Input, Output = never> extends Worker<Input, Output> {
+    /** Typed `self` counterpart for worker-side testing assertions. */
+    readonly self: WorkerSelf<Input, Output>;
+}
+/**
+ * Test {@link SharedWorker} with direct access to `self` and `connect`.
+ *
+ * Call `connect()` to simulate a client connection and trigger
+ * `self.onConnect`.
+ */
+export interface TestSharedWorker<Input, Output = never> extends SharedWorker<Input, Output> {
+    readonly self: SharedWorkerSelf<Input, Output>;
+    readonly connect: () => void;
+}
+/** {@link MessageChannel} with disposal tracking for testing. */
+export interface TestMessageChannel<Input, Output = never> extends MessageChannel<Input, Output> {
+    readonly isDisposed: () => boolean;
+}
+/**
+ * Creates a connected {@link TestWorker} for testing.
+ *
+ * The returned worker includes its typed {@link TestWorker.self} counterpart, so
+ * tests can exercise dedicated worker communication without a real thread.
+ */
+export declare const testCreateWorker: <Input, Output = never>() => TestWorker<Input, Output>;
+/**
+ * Creates a connected {@link TestSharedWorker} for testing.
+ *
+ * The returned worker includes `self` and `connect` so tests can exercise the
+ * full worker ↔ client pipeline without a real worker thread.
+ */
+export declare const testCreateSharedWorker: <Input, Output = never>() => TestSharedWorker<Input, Output>;
+/**
+ * Creates an in-memory {@link MessageChannel} for testing.
+ *
+ * Messages are queued until `onMessage` is assigned, matching the browser
+ * MessagePort behavior where the port message queue starts disabled.
+ *
+ * Both ports are registered in the native port registry so
+ * {@link testCreateMessagePort} can look them up by their native token.
+ */
+export declare const testCreateMessageChannel: <Input, Output = never>() => TestMessageChannel<Input, Output>;
+/** Creates an in-memory {@link CreateMessagePort} for testing. */
+export declare const testCreateMessagePort: CreateMessagePort;
+/**
+ * Waits long enough for multi-hop in-memory worker message delivery in tests.
+ *
+ * Some flows require several queued macrotasks across worker/message-port
+ * boundaries; this helper advances that pipeline deterministically.
+ */
+export declare const testWaitForWorkerMessage: () => Promise<void>;
 export {};
 //# sourceMappingURL=Worker.d.ts.map