@agent-native/core 0.211.0 → 0.212.0-nightly-20261021010049

package/dist/client/use-chat-threads.js

@@ -3,8 +3,10 @@ import { AGENT_CHAT_THREAD_ABSENCE_HEADER } from "../shared/agent-chat.js";
 import { agentNativePath } from "./api-path.js";
 import { getBrowserTabId } from "./browser-tab-id.js";
 const ACTIVE_THREAD_KEY = "agent-chat-active-thread";
-const THREADS_UPDATED_EVENT = "agent-chat:threads-updated";
+export const CHAT_THREADS_UPDATED_EVENT = "agent-chat:threads-updated";
 const THREADS_PAGE_SIZE = 50;
+/** The server caps one page here; larger requests are silently shortened. */
+export const CHAT_THREADS_MAX_PAGE_SIZE = 200;
 const CLIENT_DRAFT_THREAD_PREFIX = "agent-chat-client-draft-thread:";
 const MAX_THREAD_SAVE_RETRIES = 3;
 const MAX_THREAD_CONFIRMATION_RETRIES = 2;
@@ -50,20 +52,126 @@ function clearClientDraftThreadMarker(id) {
 function isUnconfirmedClientDraftThread(id, newlyCreated) {
     return newlyCreated.has(id) || hasClientDraftThreadMarker(id);
 }
-async function fetchThreadListPage(apiUrl, offset, includeExternal, scope) {
+/** The thread list endpoint answered with a failure status or a malformed body. */
+export class ChatThreadListError extends Error {
+    status;
+    constructor(message, status = null) {
+        super(message);
+        this.name = "ChatThreadListError";
+        this.status = status;
+    }
+}
+const CHAT_THREAD_ACCESS_BASES = [
+    "owner",
+    "direct",
+    "organization",
+];
+const CHAT_THREAD_VISIBILITIES = [
+    "private",
+    "org",
+    "public",
+];
+function parseChatThreadListRow(row, ownership) {
+    const candidate = row;
+    if (!candidate ||
+        typeof candidate !== "object" ||
+        typeof candidate.id !== "string" ||
+        typeof candidate.ownerEmail !== "string" ||
+        !candidate.ownerEmail ||
+        !CHAT_THREAD_ACCESS_BASES.includes(candidate.accessBasis) ||
+        !CHAT_THREAD_VISIBILITIES.includes(candidate.visibility)) {
+        throw new ChatThreadListError("Chat history response included a thread without ownership metadata.");
+    }
+    // A row on the wrong side of the filter means the server and client
+    // disagree about what the list is; showing it would label someone else's
+    // chat as the caller's own, or the reverse.
+    const owned = candidate.accessBasis === "owner";
+    if ((ownership === "mine" && !owned) || (ownership === "shared" && owned)) {
+        throw new ChatThreadListError(`Chat history response included a thread outside the ${ownership} list.`);
+    }
+    return candidate;
+}
+async function requestChatThreadListPage(request) {
+    // Zero offsets keep their canonical URL omission, but invalid arguments
+    // must fail before serialization can turn them into a default page.
+    for (const [parameter, minimum] of [
+        ["limit", 1],
+        ["offset", 0],
+    ]) {
+        const value = request[parameter];
+        if (value === undefined)
+            continue;
+        if (!Number.isSafeInteger(value) || value < minimum) {
+            throw new TypeError(`Chat history ${parameter} must be a safe integer of at least ${minimum}.`);
+        }
+    }
+    const apiUrl = request.apiUrl ?? agentNativePath("/_agent-native/agent-chat");
     const params = new URLSearchParams();
-    if (offset > 0)
-        params.set("offset", String(offset));
-    if (includeExternal)
+    const query = request.query?.trim();
+    if (query)
+        params.set("q", query);
+    if (request.limit)
+        params.set("limit", String(request.limit));
+    if (request.offset && request.offset > 0) {
+        params.set("offset", String(request.offset));
+    }
+    if (request.ownership && request.ownership !== "all") {
+        params.set("ownership", request.ownership);
+    }
+    if (request.includeExternal)
         params.set("includeExternal", "1");
-    appendChatThreadScopeParams(params, scope);
-    const query = params.toString();
-    return fetch(`${apiUrl}/threads${query ? `?${query}` : ""}`).then(async (res) => {
-        if (!res.ok)
+    appendChatThreadScopeParams(params, request.scope);
+    const search = params.toString();
+    const res = await fetch(`${apiUrl}/threads${search ? `?${search}` : ""}`);
+    if (!res.ok) {
+        throw new ChatThreadListError(`Could not load chat history (HTTP ${res.status}).`, res.status);
+    }
+    const data = (await res.json());
+    if (!data || !Array.isArray(data.threads)) {
+        throw new ChatThreadListError("Chat history response did not include a thread list.", res.status);
+    }
+    return {
+        threads: data.threads,
+        hasMore: typeof data.hasMore === "boolean" ? data.hasMore : undefined,
+    };
+}
+/**
+ * One page of the thread list or search, for the ownership-aware lists. Throws
+ * `ChatThreadListError` for a non-2xx response, a body that is not a thread
+ * list, or a row missing `ownerEmail` / `accessBasis` / `visibility` or sitting
+ * on the wrong side of `ownership`, so callers cannot mistake a failed page
+ * for an empty one. Invalid explicit pagination arguments reject with
+ * `TypeError` before a request is sent.
+ *
+ * The server caps each page at 200 rows. Advance offsets by the actual number
+ * of returned rows and use `hasMore`, rather than the requested limit.
+ */
+export async function fetchChatThreadListPage(request = {}) {
+    const page = await requestChatThreadListPage(request);
+    return {
+        threads: page.threads.map((row) => parseChatThreadListRow(row, request.ownership)),
+        hasMore: page.hasMore,
+    };
+}
+async function fetchThreadListPage(apiUrl, offset, includeExternal, scope, ownership) {
+    // The lifecycle list keeps optimistic local drafts beside server rows, so it
+    // tolerates summaries without ownership metadata; the ownership-aware lists
+    // go through `fetchChatThreadListPage`, which requires it.
+    try {
+        const page = await requestChatThreadListPage({
+            apiUrl,
+            offset,
+            includeExternal,
+            scope,
+            ownership,
+        });
+        return page.threads;
+    }
+    catch (error) {
+        if (error instanceof ChatThreadListError)
             return undefined;
-        const data = await res.json();
-        return (data.threads ?? []);
-    });
+        throw error;
+    }
 }
 async function fetchThreadById(apiUrl, id, scope) {
     try {
@@ -152,10 +260,15 @@ function withChatThreadScope(url, scope) {
         return url;
     return `${url}${url.includes("?") ? "&" : "?"}${query}`;
 }
-function emitThreadsUpdated() {
+/**
+ * Tell every mounted chat history list the thread set or its sharing changed,
+ * so they refetch. Anything that mutates a thread outside `useChatThreads`
+ * (a share grant, a visibility change) must call this.
+ */
+export function notifyChatThreadsUpdated() {
     if (typeof window === "undefined")
         return;
-    window.dispatchEvent(new CustomEvent(THREADS_UPDATED_EVENT));
+    window.dispatchEvent(new CustomEvent(CHAT_THREADS_UPDATED_EVENT));
 }
 function sortThreadSummaries(threads) {
     return [...threads].sort((a, b) => {
@@ -240,6 +353,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
     const autoCreate = options?.autoCreate !== false;
     const restoreActiveThread = options?.restoreActiveThread !== false;
     const includeExternal = options?.includeExternal === true;
+    const ownership = options?.ownership;
     const isolateHistoryByScope = options?.isolateHistoryByScope === true;
     const browserTabId = options?.browserTabId ??
         (typeof window === "undefined" ? undefined : getBrowserTabId());
@@ -658,7 +772,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         let loadedThreads;
         try {
             const offset = options?.append ? nextThreadsOffsetRef.current : 0;
-            const loaded = await fetchThreadListPage(apiUrl, offset, includeExternal, historyScope);
+            const loaded = await fetchThreadListPage(apiUrl, offset, includeExternal, historyScope, ownership);
             if (requestId !== latestFetchRequestRef.current)
                 return undefined;
             if (!loaded) {
@@ -843,6 +957,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         historyScopeKey,
         includeExternal,
         isolateHistory,
+        ownership,
         routeControlsActiveThread,
         routeThreadId,
         completeInitialThreadRestore,
@@ -1060,7 +1175,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             else {
                 setThreads((prev) => prev.map((t) => (t.id === threadId ? { ...t, scope: null } : t)));
             }
-            emitThreadsUpdated();
+            notifyChatThreadsUpdated();
         }
         catch {
             await fetchThreads().catch(() => { });
@@ -1106,7 +1221,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             if (pendingPinnedAtRef.current.get(threadId) === pinnedAt) {
                 pendingPinnedAtRef.current.delete(threadId);
             }
-            emitThreadsUpdated();
+            notifyChatThreadsUpdated();
             return true;
         }
         catch {
@@ -1155,7 +1270,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             if (threadId === activeThreadIdRef.current) {
                 setActiveThreadId(null);
             }
-            emitThreadsUpdated();
+            notifyChatThreadsUpdated();
             return true;
         }
         catch {
@@ -1191,7 +1306,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                 await fetchThreads();
                 return false;
             }
-            emitThreadsUpdated();
+            notifyChatThreadsUpdated();
             return true;
         }
         catch {
@@ -1269,7 +1384,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(id)}`, historyScope), {
                 method: "DELETE",
             });
-            emitThreadsUpdated();
+            notifyChatThreadsUpdated();
         }
         catch { }
         clearUserRenamedThread(id);
@@ -1354,7 +1469,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             if (data.threadData !== "") {
                 confirmThreadSnapshotPersisted(id);
             }
-            emitThreadsUpdated();
+            notifyChatThreadsUpdated();
             setThreads((prev) => {
                 const exists = prev.some((t) => t.id === id);
                 if (exists) {
@@ -1512,7 +1627,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
                 },
                 ...prev,
             ]);
-            emitThreadsUpdated();
+            notifyChatThreadsUpdated();
             return t.id;
         }
         catch (err) {
@@ -1525,6 +1640,9 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
             const params = new URLSearchParams({ q: query });
             if (includeExternal)
                 params.set("includeExternal", "1");
+            if (ownership && ownership !== "all") {
+                params.set("ownership", ownership);
+            }
             appendChatThreadScopeParams(params, historyScope);
             const res = await fetch(`${apiUrl}/threads?${params.toString()}`);
             if (!res.ok)
@@ -1536,7 +1654,7 @@ export function useChatThreads(apiUrl = agentNativePath("/_agent-native/agent-ch
         catch {
             return [];
         }
-    }, [apiUrl, historyScope, includeExternal, isolateHistory]);
+    }, [apiUrl, historyScope, includeExternal, isolateHistory, ownership]);
     const getThreadShareState = useCallback(async (threadId) => {
         try {
             const res = await fetch(withChatThreadScope(`${apiUrl}/threads/${encodeURIComponent(threadId)}/share`, historyScope));

package/dist/client/use-db-sync.d.ts

@@ -21,6 +21,7 @@ export declare function registerCollabActivityResource(resource: {
     resourceType: string;
     resourceId: string;
 }): () => void;
+export declare function registerOwnCollabSource(source: string): void;
 type CollabActivityEvent = {
     source?: string;
     resourceType?: string;

package/dist/client/use-db-sync.js

@@ -39,6 +39,12 @@ let collabBoostActivityAt = 0;
 // proves someone is editing the resource right now, so it boosts on its own.
 const collabActivityUntilByResource = new Map();
 const openCollabResources = new Map();
+// The request sources this tab's collab connections have posted updates under.
+// Apps choose their own (Content's `chat-…` tab id is not getBrowserTabId()),
+// and a lone editor's every update comes back in its polls under that source.
+// Never forget one when its connection closes: echoes of its last updates can
+// arrive minutes later, while another doc on the resource is still open.
+const ownCollabSources = new Set();
 function collabResourceKey(resourceType, resourceId) {
     return `${resourceType}\0${resourceId}`;
 }
@@ -60,6 +66,9 @@ export function registerCollabActivityResource(resource) {
         notifyCollabBoostChange();
     };
 }
+export function registerOwnCollabSource(source) {
+    ownCollabSources.add(source);
+}
 function collabBoostWanted() {
     const now = Date.now();
     let hasRecentResourceActivity = false;
@@ -91,7 +100,9 @@ function noteCollaboratorActivity(events) {
             typeof event.resourceType !== "string" ||
             event.resourceType === "" ||
             typeof event.resourceId !== "string" ||
-            event.requestSource === ownSource) {
+            event.requestSource === ownSource ||
+            (event.requestSource !== undefined &&
+                ownCollabSources.has(event.requestSource))) {
             continue;
         }
         const key = collabResourceKey(event.resourceType, event.resourceId);
@@ -1144,6 +1155,7 @@ export function _resetSyncTransportRegistryForTests() {
     collabBoostActivityAt = 0;
     collabActivityUntilByResource.clear();
     openCollabResources.clear();
+    ownCollabSources.clear();
 }
 export function subscribeSyncEvents(options) {
     const pollUrl = agentNativePath(options.pollUrl ?? "/_agent-native/poll");

package/dist/collab/__fixtures__/live-copy-tasks.d.ts

@@ -0,0 +1 @@
+export declare const tasks: Record<string, (input: never) => Promise<import("../live-copy-tasks.js").LiveCopyTaskResult>>;

package/dist/collab/__fixtures__/live-copy-tasks.js

@@ -0,0 +1,92 @@
+import * as Y from "yjs";
+import { defineLiveCopyTasks } from "../live-copy-tasks.js";
+// A tiny live-copy task module for the live-copy spec: a body is a list of
+// paragraphs, and anything else is refused rather than dropped. Paragraphs
+// and seed sources starting with "!" drive the failure cases.
+function paragraph(text) {
+    const element = new Y.XmlElement("paragraph");
+    const content = new Y.XmlText();
+    content.insert(0, text);
+    element.insert(0, [content]);
+    return element;
+}
+/** An update whose base this document never had. */
+function orphanUpdate() {
+    const elsewhere = new Y.Doc();
+    elsewhere.getXmlFragment("default").insert(0, [paragraph("unknown base")]);
+    const before = Y.encodeStateVector(elsewhere);
+    const fragment = elsewhere.getXmlFragment("default");
+    fragment.insert(1, [paragraph("orphan")]);
+    return Y.encodeStateAsUpdate(elsewhere, before);
+}
+export const tasks = defineLiveCopyTasks({
+    derive(doc, field) {
+        const lines = [];
+        for (const node of doc.getXmlFragment(field).toArray()) {
+            if (!(node instanceof Y.XmlElement) || node.nodeName !== "paragraph") {
+                return {
+                    kind: "refused",
+                    reason: "unsupported_node",
+                    detail: node instanceof Y.XmlElement ? node.nodeName : "text",
+                };
+            }
+            const text = node
+                .toArray()
+                .map((child) => child.toString())
+                .join("");
+            if (text === "!spin") {
+                for (;;) {
+                    // never returns
+                }
+            }
+            if (text === "!html")
+                return { kind: "html" };
+            if (text === "!edit")
+                doc.getXmlFragment(field).insert(0, [paragraph("")]);
+            if (text === "!park")
+                Y.applyUpdate(doc, orphanUpdate());
+            lines.push(text);
+        }
+        return lines.join("\n");
+    },
+    seed(doc, field, source) {
+        if (source === "!refuse")
+            return { kind: "refused", reason: "too_complex" };
+        if (source === "!empty")
+            return;
+        if (source === "!junk")
+            return { kind: "update" };
+        if (source === "!stray")
+            doc.getText("other").insert(0, "hidden");
+        doc.getXmlFragment(field).insert(0, source.split("\n").map(paragraph));
+    },
+    edits: {
+        append(doc, field, input) {
+            const fragment = doc.getXmlFragment(field);
+            const text = input?.text ?? "";
+            fragment.insert(fragment.length, [paragraph(text)]);
+        },
+        clear(doc, field) {
+            const fragment = doc.getXmlFragment(field);
+            fragment.delete(0, fragment.length);
+        },
+        stray(doc) {
+            doc.getText("other").insert(0, "hidden");
+        },
+        unchanged() { },
+        refuse() {
+            return { kind: "refused", reason: "too_complex" };
+        },
+        junk() {
+            return { kind: "update" };
+        },
+        dependent(doc) {
+            Y.applyUpdate(doc, orphanUpdate());
+        },
+        dependentAndValid(doc, field) {
+            Y.applyUpdate(doc, orphanUpdate());
+            const fragment = doc.getXmlFragment(field);
+            fragment.insert(fragment.length, [paragraph("valid")]);
+        },
+    },
+});

package/dist/collab/awareness.d.ts

@@ -38,19 +38,19 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

package/dist/collab/bounded-task-bundle.d.ts

@@ -0,0 +1,17 @@
+import { type BoundedTaskSource } from "./bounded-task-source.js";
+export interface BundleBoundedTaskSourceOptions {
+    /** Shown in errors and runner names. Defaults to the entry file's name. */
+    name?: string;
+    /** Extra esbuild `conditions` for package resolution. */
+    conditions?: string[];
+}
+export interface BundledBoundedTaskSource extends BoundedTaskSource {
+    /** Every file esbuild read, for watch-mode rebuilds. */
+    readonly inputs: readonly string[];
+}
+/**
+ * Bundles a task module and everything it imports into one script a worker
+ * can evaluate. The module must export `tasks`: an object of functions that
+ * take plain data and return plain data (or a Promise of it).
+ */
+export declare function bundleBoundedTaskSource(entry: string | URL, options?: BundleBoundedTaskSourceOptions): Promise<BundledBoundedTaskSource>;

package/dist/collab/bounded-task-bundle.js

@@ -0,0 +1,39 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { BOUNDED_TASK_GLOBAL, } from "./bounded-task-source.js";
+/**
+ * Bundles a task module and everything it imports into one script a worker
+ * can evaluate. The module must export `tasks`: an object of functions that
+ * take plain data and return plain data (or a Promise of it).
+ */
+export async function bundleBoundedTaskSource(entry, options = {}) {
+    const entryPath = entry instanceof URL || entry.startsWith("file:")
+        ? fileURLToPath(entry)
+        : path.resolve(entry);
+    const esbuild = await import("esbuild");
+    const result = await esbuild.build({
+        entryPoints: [entryPath],
+        bundle: true,
+        write: false,
+        format: "iife",
+        globalName: BOUNDED_TASK_GLOBAL,
+        platform: "node",
+        target: "node20",
+        metafile: true,
+        sourcemap: false,
+        legalComments: "none",
+        logLevel: "silent",
+        ...(options.conditions ? { conditions: options.conditions } : {}),
+    });
+    const output = result.outputFiles?.[0];
+    if (!output) {
+        throw new Error(`esbuild produced no output for bounded task ${entryPath}`);
+    }
+    const cwd = process.cwd();
+    return {
+        kind: "bounded-task-source",
+        name: options.name ?? path.basename(entryPath).replace(/\.[^.]+$/, ""),
+        code: output.text,
+        inputs: Object.keys(result.metafile?.inputs ?? {}).map((input) => path.resolve(cwd, input)),
+    };
+}

package/dist/collab/bounded-task-source.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Identifier the bundled task module is assigned to. `bundleBoundedTaskSource`
+ * emits an IIFE with this global name; the worker host reads it back.
+ */
+export declare const BOUNDED_TASK_GLOBAL = "__agentNativeBoundedTasks";
+/**
+ * A self-contained task module, bundled to one script. Produce it with
+ * `bundleBoundedTaskSource` (Node, esbuild); never hand-write `code`.
+ */
+export interface BoundedTaskSource {
+    readonly kind: "bounded-task-source";
+    readonly name: string;
+    readonly code: string;
+}

package/dist/collab/bounded-task-source.js

@@ -0,0 +1,8 @@
+// The bundler and the vitest base config import this, not bounded-tasks.ts:
+// packages that typecheck @agent-native/core/vitest-config from source load
+// several @types/node versions, and node:worker_threads does not type there.
+/**
+ * Identifier the bundled task module is assigned to. `bundleBoundedTaskSource`
+ * emits an IIFE with this global name; the worker host reads it back.
+ */
+export const BOUNDED_TASK_GLOBAL = "__agentNativeBoundedTasks";

package/dist/collab/bounded-tasks.d.ts

@@ -0,0 +1,67 @@
+import { BOUNDED_TASK_GLOBAL, type BoundedTaskSource } from "./bounded-task-source.js";
+export { BOUNDED_TASK_GLOBAL, type BoundedTaskSource };
+export type BoundedTaskErrorCode = "unavailable" | "closed" | "queue_full" | "queue_timeout" | "invalid_input" | "input_too_large" | "startup_failed" | "task_unknown" | "task_threw" | "deadline_exceeded" | "memory_exceeded" | "invalid_output" | "output_too_large" | "worker_crashed";
+export declare class BoundedTaskError extends Error {
+    readonly code: BoundedTaskErrorCode;
+    readonly task: string;
+    /** `name` of the error the task threw, for `task_threw`. */
+    readonly taskErrorName?: string;
+    constructor(code: BoundedTaskErrorCode, task: string, message: string, options?: {
+        cause?: unknown;
+        taskErrorName?: string;
+    });
+}
+export interface BoundedTaskRunnerOptions {
+    source: BoundedTaskSource;
+    /** Wall-clock budget for one task once a worker has it. Default 2000 ms. */
+    deadlineMs?: number;
+    /** Budget for a fresh worker to evaluate the bundle. Default 10000 ms. */
+    startupTimeoutMs?: number;
+    /** Workers alive at once; also the number of tasks running at once. Default 1. */
+    maxWorkers?: number;
+    /** Tasks allowed to wait for a worker. Beyond this, `queue_full`. Default 8. */
+    maxQueue?: number;
+    /**
+     * Longest a task may wait for a busy or terminating worker. A task waiting
+     * only for a worker to start is bounded by `startupTimeoutMs` instead.
+     * Default `deadlineMs`.
+     */
+    queueTimeoutMs?: number;
+    /** Strings count two bytes per UTF-16 unit. Default 8 MiB. */
+    maxInputBytes?: number;
+    /** Checked inside the worker before the result is copied out. Default 16 MiB. */
+    maxOutputBytes?: number;
+    /** Worker old-generation heap. Default 128 MiB. */
+    memoryLimitMb?: number;
+    /** Default 4 MiB. */
+    stackSizeMb?: number;
+    /** An idle worker is stopped after this long. Default 30000 ms. */
+    idleTimeoutMs?: number;
+}
+export interface BoundedTaskRunnerStats {
+    workers: number;
+    running: number;
+    queued: number;
+}
+export interface BoundedTaskRunner {
+    readonly name: string;
+    run<Output = unknown>(task: string, input: unknown): Promise<Output>;
+    stats(): BoundedTaskRunnerStats;
+    close(): Promise<void>;
+}
+/**
+ * Size of a structured-clone payload in bytes, or -1 when it holds anything
+ * but plain data (or more than 200,000 values). Stops counting once
+ * `limit` is passed. The worker host evaluates this function's source, so it
+ * must not reference anything outside its own body.
+ */
+export declare function measureBoundedPayload(value: unknown, limit: number): number;
+/**
+ * Runs functions from one bundled module in worker threads, each under a
+ * terminable deadline and a heap limit, with a fixed number of workers and a
+ * bounded wait queue. A task that overruns is stopped by terminating its
+ * worker, so synchronous work in the task never blocks the caller's event
+ * loop. Where worker threads do not exist (Cloudflare Workers), every run
+ * fails with `unavailable`; it never falls back to running inline.
+ */
+export declare function createBoundedTaskRunner(options: BoundedTaskRunnerOptions): BoundedTaskRunner;