@lostgradient/weft 0.2.0

package/dist/worker/index.js

@@ -0,0 +1,334 @@
+import { sleep } from "../runtime/portable.js";
+import { normalizeWorkerJsonValue, resolveActivityTable } from "./activity-table.js";
+import {
+  buildComposedInterceptor,
+  executeWithInterceptors
+} from "./execute-with-interceptors.js";
+import { HeartbeatManager } from "./heartbeat.js";
+import {
+  buildRegisterMessage
+} from "./options.js";
+import {
+  parseServerToWorkerMessage
+} from "./protocol.js";
+import { MAX_BUFFERED_TASK_RESULTS, TaskResultOutbox } from "./task-result-outbox.js";
+export { isOutboxFull, MAX_BUFFERED_TASK_RESULTS } from "./task-result-outbox.js";
+export { HeartbeatManager } from "./heartbeat.js";
+export { LongPollWorker } from "./long-poll.js";
+export { WorkerRegistry } from "./registry.js";
+export {
+  buildQualifiedActivityTable
+} from "./workflow-activity-binding.js";
+const DEFAULT_CONCURRENCY = 10, DEFAULT_QUEUE = "default", HEARTBEAT_INTERVAL_MS = 1e4, DEFAULT_DISCONNECT_TIMEOUT_MS = 30000;
+function createWorkerWebSocket(url, headers) {
+  if (headers === void 0)
+    return new WebSocket(url);
+  return new WebSocket(url, { headers });
+}
+
+export class RemoteWorker {
+  #options;
+  #activityTable;
+  #ws;
+  #inFlight;
+  #abortController;
+  #heartbeat;
+  #shuttingDown;
+  #taskAbortControllers;
+  #composedInterceptor;
+  #pendingRegistration;
+  #taskResultOutbox;
+  #disposed;
+  #workerId;
+  constructor(options) {
+    this.#activityTable = resolveActivityTable(options);
+    this.#workerId = options.workerId ?? crypto.randomUUID();
+    this.#options = {
+      ...options,
+      concurrency: options.concurrency ?? DEFAULT_CONCURRENCY,
+      queue: options.queue ?? DEFAULT_QUEUE,
+      workerId: this.#workerId
+    };
+    this.#ws = null;
+    this.#inFlight = 0;
+    this.#abortController = new AbortController;
+    this.#shuttingDown = !1;
+    this.#taskAbortControllers = new Map;
+    this.#composedInterceptor = buildComposedInterceptor(options.interceptors);
+    this.#pendingRegistration = null;
+    this.#taskResultOutbox = new TaskResultOutbox(options.maxBufferedResults ?? MAX_BUFFERED_TASK_RESULTS);
+    this.#disposed = !1;
+    this.#heartbeat = new HeartbeatManager(() => {
+      this.#sendMessage({ type: "heartbeat", workerId: this.#workerId });
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  async connect() {
+    if (this.#disposed)
+      throw Error("RemoteWorker has been disposed and cannot reconnect");
+    this.#shuttingDown = !1;
+    if (this.#ws !== null && this.#ws.readyState === WebSocket.OPEN && this.#pendingRegistration === null)
+      return;
+    this.#teardownActiveConnection("Superseded by a new connect() call");
+    return new Promise((resolve, reject) => {
+      const ws = createWorkerWebSocket(this.#options.serverUrl, this.#options.headers);
+      this.#ws = ws;
+      this.#pendingRegistration = { resolve, reject };
+      ws.addEventListener("open", () => {
+        this.#sendMessage(buildRegisterMessage(this.#workerId, Object.keys(this.#activityTable), this.#options));
+      }, { signal: this.#abortController.signal });
+      ws.addEventListener("message", (event) => {
+        this.#handleMessage(event);
+      }, { signal: this.#abortController.signal });
+      ws.addEventListener("error", () => {
+        this.#rejectPendingRegistration("WebSocket connection failed");
+      }, { signal: this.#abortController.signal });
+      ws.addEventListener("close", () => {
+        this.#heartbeat.stop();
+        this.#ws = null;
+        this.#rejectPendingRegistration("WebSocket closed before worker registration completed");
+      }, { signal: this.#abortController.signal });
+    });
+  }
+  async disconnect() {
+    this.#heartbeat.stop();
+    await this.#drainAndClose();
+  }
+  get inFlight() {
+    return this.#inFlight;
+  }
+  get connected() {
+    return this.#ws !== null && this.#ws.readyState === WebSocket.OPEN;
+  }
+  get shuttingDown() {
+    return this.#shuttingDown;
+  }
+  [Symbol.dispose]() {
+    this.#disposed = !0;
+    this.#taskResultOutbox.clear();
+    this.#abortAllTasks();
+    this.#rejectPendingRegistration("Worker disposed before worker registration completed");
+    this.#abortController.abort();
+    this.#abortController = new AbortController;
+    this.#heartbeat.stop();
+    if (this.#ws !== null) {
+      this.#ws.close();
+      this.#ws = null;
+    }
+  }
+  #abortAllTasks() {
+    for (const controller of this.#taskAbortControllers.values())
+      controller.abort();
+    this.#taskAbortControllers.clear();
+  }
+  async#gracefulShutdown() {
+    this.#shuttingDown = !0;
+    this.#heartbeat.stop();
+    await this.#drainAndClose();
+  }
+  async#drainAndClose() {
+    const timeout = this.#options.disconnectTimeoutMs ?? DEFAULT_DISCONNECT_TIMEOUT_MS, deadline = Date.now() + timeout;
+    while (this.#inFlight > 0) {
+      if (Date.now() >= deadline) {
+        console.warn(`[weft] RemoteWorker timed out after ${timeout}ms with ${this.#inFlight} tasks still in-flight`);
+        this.#abortAllTasks();
+        break;
+      }
+      await sleep(50);
+    }
+    this.#rejectPendingRegistration("Worker disconnected before worker registration completed");
+    const oldAbortController = this.#abortController;
+    this.#abortController = new AbortController;
+    oldAbortController.abort();
+    if (this.#ws !== null) {
+      this.#ws.close();
+      this.#ws = null;
+    }
+  }
+  #parseServerMessage(event) {
+    let rawData;
+    try {
+      rawData = JSON.parse(String(event.data));
+    } catch {
+      console.warn("[weft] Received non-JSON server message \u2014 ignoring");
+      return null;
+    }
+    const parsed = parseServerToWorkerMessage(rawData);
+    if (!parsed.ok) {
+      if (parsed.error.code === "unknown_message_type")
+        return null;
+      console.warn(`[weft] Received malformed server message: ${parsed.error.message}`);
+      return null;
+    }
+    return parsed.message;
+  }
+  #handleRegisterAck() {
+    if (this.#pendingRegistration === null)
+      return;
+    const pending = this.#pendingRegistration;
+    this.#pendingRegistration = null;
+    this.#heartbeat.start();
+    if (this.#flushTaskResultOutbox())
+      pending.resolve();
+    else
+      pending.reject(Error("reconnect required: result flush failed during registration"));
+  }
+  #handleRegisterError(message) {
+    this.#rejectPendingRegistration(message);
+    this.#heartbeat.stop();
+    if (this.#ws !== null) {
+      this.#ws.close();
+      this.#ws = null;
+    }
+  }
+  #rejectPendingRegistration(message) {
+    if (this.#pendingRegistration === null)
+      return;
+    const pending = this.#pendingRegistration;
+    this.#pendingRegistration = null;
+    pending.reject(Error(message));
+  }
+  #handleCancel(operationId) {
+    const controller = this.#taskAbortControllers.get(operationId);
+    if (controller)
+      controller.abort();
+  }
+  async#handleMessage(event) {
+    const data = this.#parseServerMessage(event);
+    if (data === null)
+      return;
+    switch (data.type) {
+      case "registerAck":
+        this.#handleRegisterAck();
+        break;
+      case "registerError":
+        this.#handleRegisterError(data.message);
+        break;
+      case "protocolError":
+        console.warn(`[weft] RemoteWorker protocol error from server: ${data.message}`);
+        break;
+      case "task":
+        if (!this.#shuttingDown)
+          await this.#executeTask(data);
+        break;
+      case "shutdown":
+        this.#gracefulShutdown();
+        break;
+      case "cancel":
+        this.#handleCancel(data.operationId);
+        break;
+    }
+  }
+  async#executeTask(task) {
+    if (this.#taskResultOutbox.full) {
+      if (this.#taskResultOutbox.shouldWarnFull())
+        console.warn(`[weft] RemoteWorker result buffer full (${this.#taskResultOutbox.size}); declining new tasks until the backlog drains`);
+      this.#failSocket();
+      return;
+    }
+    const activityFunction = this.#activityTable[task.activityName];
+    if (activityFunction === void 0) {
+      this.#sendTaskResult({
+        type: "taskResult",
+        operationId: task.operationId,
+        status: "failed",
+        error: `Unknown activity: ${task.activityName}`
+      });
+      return;
+    }
+    const taskAbortController = new AbortController;
+    this.#taskAbortControllers.set(task.operationId, taskAbortController);
+    this.#inFlight += 1;
+    try {
+      const result = await executeWithInterceptors(activityFunction, task, this.#composedInterceptor, taskAbortController.signal);
+      this.#sendTaskResult({
+        type: "taskResult",
+        operationId: task.operationId,
+        status: "completed",
+        value: normalizeWorkerJsonValue(result)
+      });
+    } catch (error) {
+      if (taskAbortController.signal.aborted)
+        this.#sendTaskResult({
+          type: "taskResult",
+          operationId: task.operationId,
+          status: "cancelled",
+          cancelled: !0,
+          error: "Task cancelled"
+        });
+      else
+        this.#sendTaskResult({
+          type: "taskResult",
+          operationId: task.operationId,
+          status: "failed",
+          error: error instanceof Error ? error.message : String(error)
+        });
+    } finally {
+      this.#taskAbortControllers.delete(task.operationId);
+      this.#inFlight -= 1;
+    }
+  }
+  #readySocket() {
+    if (this.#ws !== null && this.#ws.readyState === WebSocket.OPEN && this.#pendingRegistration === null)
+      return this.#ws;
+    return null;
+  }
+  #sendTaskResult(message) {
+    if (this.#disposed)
+      return;
+    const socket = this.#readySocket();
+    if (socket !== null)
+      try {
+        socket.send(JSON.stringify(message));
+        this.#taskResultOutbox.delete(message.operationId);
+        return;
+      } catch {
+        this.#taskResultOutbox.buffer(message);
+        this.#failSocket();
+        return;
+      }
+    this.#taskResultOutbox.buffer(message);
+  }
+  #flushTaskResultOutbox() {
+    for (const message of this.#taskResultOutbox.drainOrder()) {
+      const socket = this.#readySocket();
+      if (socket === null) {
+        this.#failSocket();
+        return !1;
+      }
+      try {
+        socket.send(JSON.stringify(message));
+        this.#taskResultOutbox.delete(message.operationId);
+      } catch {
+        this.#failSocket();
+        return !1;
+      }
+    }
+    return !0;
+  }
+  #failSocket() {
+    this.#rejectPendingRegistration("WebSocket failed before worker registration completed; reconnect required");
+    const oldAbortController = this.#abortController;
+    this.#abortController = new AbortController;
+    oldAbortController.abort();
+    this.#heartbeat.stop();
+    if (this.#ws !== null) {
+      this.#ws.close();
+      this.#ws = null;
+    }
+  }
+  #teardownActiveConnection(reason) {
+    this.#rejectPendingRegistration(reason);
+    this.#heartbeat.stop();
+    const oldAbortController = this.#abortController;
+    this.#abortController = new AbortController;
+    oldAbortController.abort();
+    if (this.#ws !== null) {
+      this.#ws.close();
+      this.#ws = null;
+    }
+  }
+  #sendMessage(message) {
+    if (this.#ws !== null && this.#ws.readyState === WebSocket.OPEN)
+      this.#ws.send(JSON.stringify(message));
+  }
+}

package/dist/worker/long-poll.d.ts

@@ -0,0 +1,54 @@
+import type { ActivityInterceptor } from '../core/interceptor.ts';
+export interface LongPollWorkerOptions {
+    serverUrl: string;
+    activities: Record<string, (input: unknown) => Promise<unknown>>;
+    concurrency?: number;
+    queue?: string;
+    pollTimeout?: number;
+    /**
+     * HTTP headers sent with poll and result requests, such as `Authorization`.
+     * When the server enforces authentication, supply credentials with the
+     * `workers:write` scope here. `Content-Type` is reserved on result requests
+     * and is always set to `application/json`, overriding any value passed here.
+     */
+    headers?: Record<string, string>;
+    /** Activity interceptors to run around each activity execution on this worker. */
+    interceptors?: ActivityInterceptor[];
+}
+/**
+ * HTTP long-poll fallback worker for environments where WebSocket connections
+ * are unavailable (e.g. certain serverless runtimes or proxied environments).
+ *
+ * Continuously polls the server for pending tasks using HTTP long-polling and
+ * executes them locally.  Supports the same activity and interceptor model as
+ * {@link RemoteWorker} but with slightly higher per-task latency due to the
+ * poll round-trip.
+ *
+ * @example
+ * ```ts
+ * import { LongPollWorker } from '@lostgradient/weft';
+ *
+ * using worker = new LongPollWorker({
+ *   serverUrl: 'http://localhost:3000',
+ *   activities: {
+ *     resize: async (input: unknown) => {
+ *       return `resized:${JSON.stringify(input)}`;
+ *     },
+ *   },
+ *   concurrency: 3,
+ *   queue: 'images',
+ * });
+ * worker.start();
+ * ```
+ */
+export declare class LongPollWorker implements Disposable {
+    #private;
+    constructor(options: LongPollWorkerOptions);
+    /** Start polling for tasks. */
+    start(): void;
+    /** Stop polling and wait for in-flight to finish. */
+    stop(): Promise<void>;
+    get inFlight(): number;
+    get running(): boolean;
+    [Symbol.dispose](): void;
+}

package/dist/worker/long-poll.js

@@ -0,0 +1,134 @@
+import { sleep } from "../runtime/portable.js";
+import {
+  buildComposedInterceptor,
+  executeWithInterceptors
+} from "./execute-with-interceptors.js";
+const DEFAULT_CONCURRENCY = 10, DEFAULT_QUEUE = "default", DEFAULT_POLL_TIMEOUT = 30000;
+
+export class LongPollWorker {
+  #options;
+  #running;
+  #inFlight;
+  #abortController;
+  #composedInterceptor;
+  constructor(options) {
+    this.#options = {
+      ...options,
+      concurrency: options.concurrency ?? DEFAULT_CONCURRENCY,
+      queue: options.queue ?? DEFAULT_QUEUE,
+      pollTimeout: options.pollTimeout ?? DEFAULT_POLL_TIMEOUT
+    };
+    this.#running = !1;
+    this.#inFlight = 0;
+    this.#abortController = new AbortController;
+    this.#composedInterceptor = buildComposedInterceptor(options.interceptors);
+  }
+  start() {
+    if (this.#running)
+      return;
+    this.#running = !0;
+    this.#abortController = new AbortController;
+    this.#pollLoop();
+  }
+  async stop() {
+    this.#abortController.abort();
+    this.#running = !1;
+    while (this.#inFlight > 0)
+      await sleep(50);
+  }
+  get inFlight() {
+    return this.#inFlight;
+  }
+  get running() {
+    return this.#running;
+  }
+  [Symbol.dispose]() {
+    this.#running = !1;
+    this.#abortController.abort();
+  }
+  #buildPollUrl() {
+    const queue = this.#options.queue ?? DEFAULT_QUEUE, params = new URLSearchParams;
+    params.set("timeout", String(this.#options.pollTimeout ?? DEFAULT_POLL_TIMEOUT));
+    for (const activity of Object.keys(this.#options.activities))
+      params.append("activity", activity);
+    return `${this.#options.serverUrl}/api/v1/tasks/${encodeURIComponent(queue)}?${params.toString()}`;
+  }
+  #buildResultUrl() {
+    const queue = this.#options.queue ?? DEFAULT_QUEUE;
+    return `${this.#options.serverUrl}/api/v1/tasks/${encodeURIComponent(queue)}/result`;
+  }
+  async#pollLoop() {
+    const pollUrl = this.#buildPollUrl(), resultUrl = this.#buildResultUrl();
+    while (this.#running && !this.#abortController.signal.aborted) {
+      if (this.#inFlight >= (this.#options.concurrency ?? DEFAULT_CONCURRENCY)) {
+        await sleep(100);
+        continue;
+      }
+      try {
+        const response = await fetch(pollUrl, {
+          ...this.#options.headers === void 0 ? {} : { headers: this.#options.headers },
+          signal: this.#abortController.signal
+        });
+        if (response.status === 204)
+          continue;
+        if (!response.ok) {
+          await sleep(1000);
+          continue;
+        }
+        const task = await response.json();
+        this.#executeTask(task, resultUrl);
+      } catch {
+        if (this.#running)
+          await sleep(1000);
+      }
+    }
+  }
+  async#executeTask(task, resultUrl) {
+    this.#inFlight += 1;
+    try {
+      const activityFunction = this.#options.activities[task.activityName];
+      if (activityFunction === void 0) {
+        await fetch(resultUrl, {
+          method: "POST",
+          headers: { ...this.#options.headers, "Content-Type": "application/json" },
+          body: JSON.stringify({
+            operationId: task.operationId,
+            workerId: task.workerId,
+            status: "failed",
+            error: `Unknown activity: ${task.activityName}`
+          }),
+          signal: this.#abortController.signal
+        });
+        return;
+      }
+      const result = await executeWithInterceptors(activityFunction, task, this.#composedInterceptor);
+      await fetch(resultUrl, {
+        method: "POST",
+        headers: { ...this.#options.headers, "Content-Type": "application/json" },
+        body: JSON.stringify({
+          operationId: task.operationId,
+          workerId: task.workerId,
+          status: "completed",
+          value: result
+        }),
+        signal: this.#abortController.signal
+      });
+    } catch (error) {
+      try {
+        await fetch(resultUrl, {
+          method: "POST",
+          headers: { ...this.#options.headers, "Content-Type": "application/json" },
+          body: JSON.stringify({
+            operationId: task.operationId,
+            workerId: task.workerId,
+            status: "failed",
+            error: error instanceof Error ? error.message : String(error)
+          }),
+          signal: this.#abortController.signal
+        });
+      } catch {}
+    } finally {
+      this.#inFlight -= 1;
+    }
+  }
+}

package/dist/worker/options.d.ts

@@ -0,0 +1,66 @@
+import type { ActivityInterceptor } from '../core/interceptor.ts';
+import { type RegisterMessage, type RemoteWorkerCapabilities } from './protocol.ts';
+import type { RemoteWorkerWorkflowDefinition } from './workflow-activity-binding.ts';
+/**
+ * Options accepted by `new RemoteWorker(...)`.
+ *
+ * A worker advertises its activities through `workflows`: a map of
+ * `workflowType → { name, activities }`. The SDK builds the qualified
+ * `${workflowType}.${activityName}` table that the protocol expects and
+ * validates that each outer key matches the inner `workflow.name`. This is the
+ * API the engine-side builder produces, and it is required.
+ */
+export interface RemoteWorkerOptions {
+    serverUrl: string;
+    workerId?: string;
+    /**
+     * Map of workflow type → workflow definition. The SDK produces qualified
+     * activity names from this map and validates name grammar + key/name match.
+     * This is the single, required activity-advertisement input.
+     */
+    workflows: Record<string, RemoteWorkerWorkflowDefinition>;
+    concurrency?: number;
+    queue?: string;
+    disconnectTimeoutMs?: number;
+    deploymentName?: string;
+    buildId?: string;
+    runtimeVersion?: string;
+    gitSha?: string;
+    startedAt?: number;
+    capabilities?: RemoteWorkerCapabilities;
+    /**
+     * Headers sent with the WebSocket upgrade request, such as `Authorization`.
+     * When the server enforces authentication, registration requires credentials
+     * with the `workers:write` scope; supply them here. This relies on Bun's
+     * WebSocket constructor header extension and does not apply in browsers.
+     */
+    headers?: Record<string, string>;
+    /** Activity interceptors to run around each activity execution on this worker. */
+    interceptors?: ActivityInterceptor[];
+}
+/**
+ * Construction options including internal knobs that are deliberately kept off
+ * the public {@link RemoteWorkerOptions} surface. The `RemoteWorker` constructor
+ * accepts this wider type; only `RemoteWorkerOptions` is exported from the
+ * package, so consumers never see these fields.
+ */
+export interface InternalRemoteWorkerOptions extends RemoteWorkerOptions {
+    /**
+     * Test-only override for the unsent-task-result buffer ceiling. Defaults to
+     * `MAX_BUFFERED_TASK_RESULTS`. Lets a test exercise the backpressure decline
+     * branch with a small cap instead of fabricating a thousand buffered results.
+     */
+    maxBufferedResults?: number;
+}
+/** A `connect()` promise's resolve/reject pair, awaiting `registerAck`. */
+export type PendingRegistration = {
+    resolve: () => void;
+    reject: (error: Error) => void;
+};
+/**
+ * Build the `register` frame from the worker's resolved options and advertised
+ * activity names. Optional identity/capability fields are omitted entirely when
+ * undefined so the wire frame stays minimal. `workerId`, `concurrency`, and
+ * `queue` are resolved to defaults by the constructor before this runs.
+ */
+export declare function buildRegisterMessage(workerId: string, activities: readonly string[], options: RemoteWorkerOptions): RegisterMessage;

package/dist/worker/options.js

@@ -0,0 +1,19 @@
+import {
+  REMOTE_WORKER_PROTOCOL_VERSION
+} from "./protocol.js";
+export function buildRegisterMessage(workerId, activities, options) {
+  return {
+    type: "register",
+    protocolVersion: REMOTE_WORKER_PROTOCOL_VERSION,
+    workerId,
+    activities: [...activities],
+    ...options.concurrency !== void 0 ? { concurrency: options.concurrency } : {},
+    ...options.queue !== void 0 ? { queue: options.queue } : {},
+    ...options.deploymentName !== void 0 ? { deploymentName: options.deploymentName } : {},
+    ...options.buildId !== void 0 ? { buildId: options.buildId } : {},
+    ...options.runtimeVersion !== void 0 ? { runtimeVersion: options.runtimeVersion } : {},
+    ...options.gitSha !== void 0 ? { gitSha: options.gitSha } : {},
+    ...options.startedAt !== void 0 ? { startedAt: options.startedAt } : {},
+    ...options.capabilities !== void 0 ? { capabilities: options.capabilities } : {}
+  };
+}

package/dist/worker/protocol-internals.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Internal helpers used by `./protocol.ts` to enforce the RemoteWorker
+ * protocol contract at the trust boundary.
+ *
+ * Nothing in this module is part of the public `@lostgradient/weft/worker-protocol` surface
+ * (other than `isRemoteWorkerJsonValue`, which `protocol.ts` re-exports).
+ * Splitting these helpers out of `protocol.ts` keeps the canonical parser
+ * module focused on the schema-to-guard mapping a reviewer audits.
+ *
+ * @module worker/protocol-internals
+ */
+import type { ProtocolErrorMessage, RegisterErrorMessage, RemoteWorkerCapabilities, RemoteWorkerJsonValue } from './protocol-messages.ts';
+/**
+ * Protocol parse failure with a machine-readable code.
+ *
+ * @example
+ * ```ts
+ * import type { RemoteWorkerProtocolFailure } from '@lostgradient/weft/worker-protocol';
+ *
+ * const failure: RemoteWorkerProtocolFailure = {
+ *   code: 'invalid_message',
+ *   message: 'Protocol message must be an object',
+ * };
+ * ```
+ */
+export type RemoteWorkerProtocolFailure = {
+    readonly code: ProtocolErrorMessage['code'] | RegisterErrorMessage['code'];
+    readonly message: string;
+    readonly requestedProtocolVersion?: number;
+};
+/**
+ * Result returned by protocol parser helpers.
+ *
+ * @example
+ * ```ts
+ * import type { RemoteWorkerProtocolParseResult, RegisterMessage } from '@lostgradient/weft/worker-protocol';
+ *
+ * const result: RemoteWorkerProtocolParseResult<RegisterMessage> = {
+ *   ok: false,
+ *   error: { code: 'invalid_registration', message: 'workerId is required' },
+ * };
+ * ```
+ */
+export type RemoteWorkerProtocolParseResult<T> = {
+    readonly ok: true;
+    readonly message: T;
+} | {
+    readonly ok: false;
+    readonly error: RemoteWorkerProtocolFailure;
+};
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * Return true when a value can be represented by JSON on the worker protocol.
+ *
+ * @example
+ * ```ts
+ * import { isRemoteWorkerJsonValue } from '@lostgradient/weft/worker-protocol';
+ *
+ * const canSend = isRemoteWorkerJsonValue({ nested: ['ok'] });
+ * ```
+ */
+export declare function isRemoteWorkerJsonValue(value: unknown): value is RemoteWorkerJsonValue;
+export declare function isNonEmptyString(value: unknown): value is string;
+export declare function isStringArray(value: unknown): value is string[];
+export declare function isStringRecord(value: unknown): value is Record<string, string>;
+export declare function isRemoteWorkerCapabilities(value: unknown): value is RemoteWorkerCapabilities;
+export declare function isFiniteNumber(value: unknown): value is number;
+export declare function protocolFailure(code: RemoteWorkerProtocolFailure['code'], message: string, requestedProtocolVersion?: number): RemoteWorkerProtocolParseResult<never>;
+export type FieldSpec = readonly [
+    sourceKey: string,
+    isRequired: boolean,
+    predicate: (v: unknown) => boolean,
+    errorMessage: string
+];
+export type CollectFieldsResult = {
+    readonly ok: true;
+    readonly values: Record<string, unknown>;
+} | {
+    readonly ok: false;
+    readonly error: RemoteWorkerProtocolParseResult<never>;
+};
+export declare function collectFields(code: RemoteWorkerProtocolFailure['code'], record: Record<string, unknown>, specs: readonly FieldSpec[]): CollectFieldsResult;