@lostgradient/weft 0.3.0 → 0.4.0

package/dist/server/runtime/event-broadcasting.d.ts

@@ -1,4 +1,5 @@
 import type { Engine } from '../../core/engine.ts';
+import type { FleetEventFeed } from '../fleet-event-feed.ts';
 import type { ServerContext } from './context.ts';
 /**
  * Result of wiring up engine-to-WebSocket event broadcasting.
@@ -46,6 +47,9 @@ export declare function registerWorkflowEventLifecycle(engine: Engine, context:
  *   token messages, enabling per-workflow stream sockets to be used in
  *   place of the default pub/sub channel. Leave unset unless you manage stream
  *   sockets separately (as `serve()` does internally).
+ * @param options.publishWatchMessage - Optional override for watch-event delivery.
+ *   When provided, this callback is called instead of `server.publish()` for
+ *   watch messages, enabling per-socket replay buffering during catch-up.
  *
  * @example
  * ```ts
@@ -68,4 +72,6 @@ export declare function registerWorkflowEventLifecycle(engine: Engine, context:
  */
 export declare function wireEventBroadcasting(engine: Engine, server: ReturnType<typeof Bun.serve>, options?: {
     publishTokenMessage?: (workflowId: string, sequence: number, message: string) => void;
+    publishWatchMessage?: (workflowId: string, sequence: number, message: string) => void;
+    fleetEventFeed?: FleetEventFeed;
 }): EventBroadcastingHandle;

package/dist/server/runtime/event-broadcasting.js

@@ -1,24 +1,19 @@
 import { encode } from "../../core/codec.js";
 import {
-  ActivityCompletedEvent,
-  ActivityFailedEvent,
-  ActivityStartedEvent,
-  AttributesChangedEvent,
-  SignalDeliveredEvent,
-  SignalReceivedEvent,
-  UpdateCompletedEvent,
-  UpdateReceivedEvent,
+  encodeStoredStreamTailSequence,
+  loadStoredStreamTailSequence
+} from "../../core/engine/stream-chunk-loading.js";
+import {
   WorkflowCancelledEvent,
   WorkflowCompletedEvent,
   WorkflowFailedEvent,
-  WorkflowStartedEvent,
   WorkflowTimedOutEvent
 } from "../../core/events.js";
 import { KEYS } from "../../storage/interface.js";
 import { claimNextSequence } from "../runtime-helpers.js";
+import { CLIENT_VISIBLE_EVENT_TYPES, TOKEN_EVENT_TYPE } from "./client-visible-events.js";
 import { cancelTask } from "./task-dispatch.js";
 import { withRetry } from "./websocket-worker.js";
-const TOKEN_EVENT_TYPE = "stream:token";
 function workflowChannelPath(workflowId, connectionType) {
   return `/v1/workflows/${encodeURIComponent(workflowId)}/${connectionType}`;
 }
@@ -106,6 +101,11 @@ export function wireEventBroadcasting(engine, server, options) {
     if (existing)
       return existing;
     const promise = (async () => {
+      const storedTailSequence = await loadStoredStreamTailSequence(engine.storage, workflowId, "tokens");
+      if (storedTailSequence !== null) {
+        tokenSequenceCounters.set(workflowId, storedTailSequence + 1);
+        return;
+      }
       const prefix = KEYS.streamChunkPrefix(workflowId, "tokens");
       let highestSequence = -1;
       for await (const [key] of engine.storage.scan(prefix, { reverse: !0, limit: 1 })) {
@@ -122,11 +122,7 @@ export function wireEventBroadcasting(engine, server, options) {
     return promise;
   }
   async function persistAndPublishEvent(workflowId, eventType, message) {
-    await ensureSequenceInitialized(workflowId);
-    const parsed = JSON.parse(message), sequence = claimNextSequence(sequenceCounters, workflowId), storageKey = KEYS.event(workflowId, sequence), encoded = encode(parsed);
-    await withRetry(async () => engine.storage.put(storageKey, encoded), `persist event "${eventType}" for workflow "${workflowId}"`);
-    const watchChannel = workflowChannelPath(workflowId, "watch");
-    server.publish(watchChannel, message);
+    const parsed = JSON.parse(message);
     if (eventType === TOKEN_EVENT_TYPE) {
       const tokenPayload = {
         workflowId: typeof parsed.data.workflowId === "string" ? parsed.data.workflowId : workflowId,
@@ -135,10 +131,23 @@ export function wireEventBroadcasting(engine, server, options) {
       };
       await ensureTokenSequenceInitialized(workflowId);
       const tokenSequence = claimNextSequence(tokenSequenceCounters, workflowId);
-      await withRetry(async () => engine.storage.put(KEYS.streamChunk(workflowId, "tokens", tokenSequence), encode(tokenPayload)), `persist token stream chunk for workflow "${workflowId}"`);
+      await withRetry(async () => engine.storage.batch([
+        {
+          type: "put",
+          key: KEYS.streamChunk(workflowId, "tokens", tokenSequence),
+          value: encode(tokenPayload)
+        },
+        {
+          type: "put",
+          key: KEYS.streamTail(workflowId, "tokens"),
+          value: encodeStoredStreamTailSequence(tokenSequence)
+        }
+      ]), `persist token stream chunk for workflow "${workflowId}"`);
       const streamMessage = JSON.stringify({
-        ...parsed,
+        type: parsed.type,
+        timestamp: parsed.timestamp,
         sequence: tokenSequence,
+        cursor: String(tokenSequence),
         data: tokenPayload
       });
       if (options?.publishTokenMessage)
@@ -147,32 +156,34 @@ export function wireEventBroadcasting(engine, server, options) {
         const streamChannel = workflowChannelPath(workflowId, "stream");
         server.publish(streamChannel, streamMessage);
       }
+      return;
+    }
+    await ensureSequenceInitialized(workflowId);
+    const sequence = claimNextSequence(sequenceCounters, workflowId), watchMessage = JSON.stringify({
+      type: parsed.type,
+      timestamp: parsed.timestamp,
+      data: parsed.data,
+      sequence,
+      cursor: String(sequence)
+    }), storageKey = KEYS.event(workflowId, sequence), encoded = encode(JSON.parse(watchMessage));
+    await withRetry(async () => engine.storage.put(storageKey, encoded), `persist event "${eventType}" for workflow "${workflowId}"`);
+    await appendFleetEvent(options?.fleetEventFeed, eventType, workflowId, message);
+    if (options?.publishWatchMessage)
+      options.publishWatchMessage(workflowId, sequence, watchMessage);
+    else {
+      const watchChannel = workflowChannelPath(workflowId, "watch");
+      server.publish(watchChannel, watchMessage);
     }
   }
-  const eventTypes = [
-    WorkflowStartedEvent.type,
-    WorkflowCompletedEvent.type,
-    WorkflowFailedEvent.type,
-    WorkflowCancelledEvent.type,
-    WorkflowTimedOutEvent.type,
-    ActivityStartedEvent.type,
-    ActivityCompletedEvent.type,
-    ActivityFailedEvent.type,
-    TOKEN_EVENT_TYPE,
-    SignalReceivedEvent.type,
-    SignalDeliveredEvent.type,
-    AttributesChangedEvent.type,
-    UpdateReceivedEvent.type,
-    UpdateCompletedEvent.type
-  ];
-  for (const eventType of eventTypes)
+  for (const eventType of CLIENT_VISIBLE_EVENT_TYPES)
     engine.addEventListener(eventType, (event) => {
-      const workflowId = getWorkflowIdFromEvent(event);
-      if (workflowId === void 0)
-        return;
-      const message = serializeEvent(event);
+      const workflowId = getWorkflowIdFromEvent(event), message = serializeEvent(event);
       if (message === null)
         return;
+      if (workflowId === void 0) {
+        appendFleetEvent(options?.fleetEventFeed, eventType, void 0, message);
+        return;
+      }
       const nextChain = (sequenceChains.get(workflowId) ?? Promise.resolve()).then(() => persistAndPublishEvent(workflowId, eventType, message)).catch((error) => {
         console.error(`[weft] Failed to persist event "${eventType}" for workflow "${workflowId}":`, error);
       });
@@ -203,3 +214,26 @@ export function wireEventBroadcasting(engine, server, options) {
     cleanupWorkflow
   };
 }
+async function appendFleetEvent(fleetEventFeed, eventType, workflowId, message) {
+  if (eventType === TOKEN_EVENT_TYPE)
+    return;
+  if (fleetEventFeed === void 0)
+    return;
+  try {
+    const parsed = JSON.parse(message), event = {
+      kind: eventType,
+      emittedAtMs: parsed.timestamp,
+      payload: parsed.data
+    };
+    if (workflowId === void 0) {
+      await fleetEventFeed.append(event);
+      return;
+    }
+    await fleetEventFeed.appendWorkflowEventIfPresent({
+      ...event,
+      workflowId
+    });
+  } catch (error) {
+    console.error(`[weft] Failed to append fleet event "${eventType}":`, error);
+  }
+}

package/dist/server/runtime/retry.d.ts

@@ -0,0 +1 @@
+export declare function withRetry<T>(operation: () => Promise<T>, label: string, maxAttempts?: number): Promise<T>;

package/dist/server/runtime/retry.js

@@ -0,0 +1,14 @@
+export async function withRetry(operation, label, maxAttempts = 2) {
+  let lastError;
+  for (let attempt = 1;attempt <= maxAttempts; attempt++)
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxAttempts) {
+        console.warn(`[weft] Retrying "${label}" (attempt ${attempt + 1}/${maxAttempts})`);
+        await Bun.sleep(100 * attempt);
+      }
+    }
+  throw lastError;
+}

package/dist/server/runtime/shutdown.d.ts

@@ -1,10 +1,11 @@
 import type { ServerContext } from './context.ts';
 export declare const DEFAULT_SHUTDOWN_TIMEOUT_MS = 30000;
+type WorkerShutdownOptions = {
+    timeoutMs?: number | undefined;
+    stopWaitingWhenIdle?: boolean | undefined;
+};
 /** Send a shutdown message to a specific worker and wait for it to disconnect. */
-export declare function shutdownWorker(context: ServerContext, workerId: string, shutdownOptions?: {
-    timeoutMs?: number;
-}): Promise<boolean>;
+export declare function shutdownWorker(context: ServerContext, workerId: string, shutdownOptions?: WorkerShutdownOptions): Promise<boolean>;
 /** Send a shutdown message to all connected workers and wait for them to disconnect. */
-export declare function shutdownAllWorkers(context: ServerContext, shutdownOptions?: {
-    timeoutMs?: number;
-}): Promise<void>;
+export declare function shutdownAllWorkers(context: ServerContext, shutdownOptions?: WorkerShutdownOptions): Promise<void>;
+export {};

package/dist/server/runtime/shutdown.js

@@ -1,11 +1,16 @@
 export const DEFAULT_SHUTDOWN_TIMEOUT_MS = 30000;
+function workerShutdownFinished(context, workerId, options) {
+  if (!context.workerSockets.has(workerId))
+    return !0;
+  return options?.stopWaitingWhenIdle === !0 && context.registry.getWorkerTasks(workerId).length === 0;
+}
 export async function shutdownWorker(context, workerId, shutdownOptions) {
   const ws = context.workerSockets.get(workerId);
   if (!ws)
     return !1;
   ws.send(JSON.stringify({ type: "shutdown" }));
   const timeout = shutdownOptions?.timeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS, deadline = Date.now() + timeout;
-  while (context.workerSockets.has(workerId)) {
+  while (!workerShutdownFinished(context, workerId, shutdownOptions)) {
     if (Date.now() >= deadline)
       return !0;
     await Bun.sleep(50);

package/dist/server/runtime/task-polling.js

@@ -1,22 +1,24 @@
 import { isAuthenticated } from "../principal.js";
+import { readRestJsonBody } from "../rest-body.js";
+import { readInflightRecord, transitionQueuedToInflight } from "../task-state.js";
+import { recordTaskBacklogMetric, recordTaskQueueLatencyMetric } from "./task-metrics.js";
 import {
-  readInflightRecord,
-  transitionInflightToResolved,
-  transitionQueuedToInflight
-} from "../task-state.js";
-import {
-  recordTaskBacklogMetric,
-  recordTaskExecutionLatencyMetric,
-  recordTaskQueueLatencyMetric
-} from "./task-metrics.js";
+  taskResultPayloadSizeError,
+  transitionTaskResultToResolvedWithRetry
+} from "./task-result-resolution.js";
 const TASK_POLL_RE = /^\/v1\/tasks\/([\w-]+)$/, TASK_RESULT_RE = /^\/v1\/tasks\/([\w-]+)\/result$/, TASK_DIAGNOSTICS_PATH = "/v1/tasks/diagnostics", MAX_POLL_TIMEOUT = 60000, DEFAULT_POLL_TIMEOUT = 30000, DEFAULT_VISIBILITY_TIMEOUT = 30000;
-async function parseTaskResultBody(request) {
+async function parseTaskResultBody(request, options) {
   try {
-    return await request.json();
-  } catch {
+    return await readRestJsonBody(request, options);
+  } catch (error) {
+    if (isPayloadTooLargeFault(error))
+      return Response.json({ error: error.message }, { status: 413 });
     return null;
   }
 }
+function isPayloadTooLargeFault(value) {
+  return typeof value === "object" && value !== null && value.code === "PayloadTooLarge" && typeof value.message === "string";
+}
 function authorizeWorkerPrincipal(principal) {
   if (principal === void 0)
     return null;
@@ -47,19 +49,42 @@ async function applyTaskResult(context, options, result, inflightRecord) {
   try {
     context.taskQueue.complete({ operationId, status, value, error });
     context.deadlineTracker.remove(operationId);
-    const resolvedAt = Date.now();
-    await transitionInflightToResolved(options.engine.storage, operationId, resolvedStatus, {
-      ...inflightRecord === null ? {} : { record: inflightRecord },
-      resolvedAt,
+    await transitionTaskResultToResolvedWithRetry(context, options, {
+      operationId,
+      status: resolvedStatus,
       resolutionReason: resolvedStatus,
+      inflightRecord,
       ...status === "completed" ? { value } : { error }
     });
-    if (inflightRecord !== null)
-      recordTaskExecutionLatencyMetric(context.metricsCollector, inflightRecord, resolvedAt);
   } catch (storageError) {
     console.error(`[weft] Failed to transition task "${operationId}" to resolved \u2014 inflight record may leak:`, storageError);
   }
 }
+async function applyPayloadRejectedTaskResult(context, options, result, inflightRecord, error) {
+  context.taskQueue.complete({
+    operationId: result.operationId,
+    status: "failed",
+    error: error.message
+  });
+  context.deadlineTracker.remove(result.operationId);
+  await transitionTaskResultToResolvedWithRetry(context, options, {
+    operationId: result.operationId,
+    status: "failed",
+    resolutionReason: "failed",
+    inflightRecord,
+    error: error.message,
+    skipPayloadSizeCheck: !0
+  });
+}
+function payloadSizeExceededResponse(error) {
+  return Response.json({
+    error: error.message,
+    code: error.code,
+    maxBytes: error.maxBytes,
+    serializedBytes: error.serializedBytes,
+    payloadKind: error.payloadKind
+  }, { status: 413 });
+}
 export function createLongPollInflightRecord(queue, task) {
   const now = Date.now(), visibilityTimeout = task.visibilityTimeout ?? DEFAULT_VISIBILITY_TIMEOUT, deadline = now + visibilityTimeout;
   return {
@@ -126,7 +151,9 @@ export async function handleTaskResultRequest(context, options, request, url, pr
   const authorizationResponse = authorizeWorkerPrincipal(principal);
   if (authorizationResponse !== null)
     return authorizationResponse;
-  const body = await parseTaskResultBody(request);
+  const body = await parseTaskResultBody(request, options.maxRequestBodyBytes !== void 0 ? { maxBodyBytes: options.maxRequestBodyBytes } : {});
+  if (body instanceof Response)
+    return body;
   if (body === null)
     return Response.json({ error: "Invalid JSON body" }, { status: 400 });
   const validated = validateTaskResultBody(body);
@@ -135,13 +162,27 @@ export async function handleTaskResultRequest(context, options, request, url, pr
   const inflightRecord = await readInflightRecord(options.engine.storage, validated.operationId);
   if (inflightRecord !== null && !isLongPollCompletionAuthorized(inflightRecord, validated))
     return Response.json({ error: "Forbidden" }, { status: 403 });
+  const payloadError = taskResultPayloadSizeError({
+    operationId: validated.operationId,
+    status: validated.status,
+    resolutionReason: validated.status,
+    ...validated.status === "completed" ? { value: validated.value } : { error: validated.error }
+  }, context.payloadSizeMaxBytes);
+  if (payloadError !== null) {
+    try {
+      await applyPayloadRejectedTaskResult(context, options, validated, inflightRecord, payloadError);
+    } catch (error) {
+      console.error(`[weft] Failed to persist oversized task result rejection for task "${validated.operationId}":`, error);
+    }
+    return payloadSizeExceededResponse(payloadError);
+  }
   await applyTaskResult(context, options, validated, inflightRecord);
   return Response.json({ ok: !0 });
 }
 function isLongPollCompletionAuthorized(inflightRecord, validated) {
   if (validated.workerId === void 0 || inflightRecord.workerId !== validated.workerId)
     return !1;
-  if (inflightRecord.attemptToken !== void 0 && validated.attemptToken !== void 0 && validated.attemptToken !== inflightRecord.attemptToken)
+  if (inflightRecord.attemptToken !== void 0 && validated.attemptToken !== inflightRecord.attemptToken)
     return !1;
   return !0;
 }

package/dist/server/runtime/task-reconciliation.js

@@ -3,7 +3,11 @@ import { ActivityFailedEvent } from "../../core/events.js";
 import { calculateBackoff } from "../../core/scheduler.js";
 import { KEYS } from "../../storage/interface.js";
 import { restoreExtendedDeadlineIfStillActive } from "../runtime-helpers.js";
-import { transitionInflightToQueued, transitionInflightToResolved } from "../task-state.js";
+import {
+  isTaskDeadLettered,
+  transitionInflightToQueued,
+  transitionInflightToResolved
+} from "../task-state.js";
 import { dispatchTaskImpl, scheduleDelayedDispatch } from "./task-dispatch.js";
 import {
   isTaskHeartbeatStaleForMetrics,
@@ -98,6 +102,8 @@ export async function scanExpiredTasks(context, options, cleanupWorkflowIndex) {
           console.error(`[weft] Corrupt inflight record for task "${operationId}" \u2014 skipping`);
           continue;
         }
+        if (await isTaskDeadLettered(options.engine.storage, operationId))
+          continue;
         if (restoreExtendedDeadlineIfStillActive(context.deadlineTracker, operationId, decoded.deadline, now))
           continue;
         context.registry.completeTask(decoded.operationId);
@@ -130,6 +136,8 @@ export async function reconcileOrphanedRecords(context, options, cleanupWorkflow
           continue;
         if (isTaskHeartbeatStaleForMetrics(decoded, now))
           staleHeartbeatCount += 1;
+        if (await isTaskDeadLettered(options.engine.storage, decoded.operationId))
+          continue;
         if (decoded.deadline > now) {
           if (context.processingOperations.has(decoded.operationId))
             continue;

package/dist/server/runtime/task-result-resolution.d.ts

@@ -0,0 +1,15 @@
+import { PayloadSizeExceededError } from '../../core/payload-size.ts';
+import type { ServeOptions } from '../index.ts';
+import { type InflightRecord, type TaskResolutionReason } from '../task-state.ts';
+import type { ServerContext } from './context.ts';
+export type TaskResultResolutionInput = {
+    readonly operationId: string;
+    readonly status: 'completed' | 'failed';
+    readonly resolutionReason: TaskResolutionReason;
+    readonly value?: unknown;
+    readonly error?: string | undefined;
+    readonly inflightRecord?: InflightRecord | null | undefined;
+    readonly skipPayloadSizeCheck?: boolean | undefined;
+};
+export declare function taskResultPayloadSizeError(input: TaskResultResolutionInput, maxBytes: number | null): PayloadSizeExceededError | null;
+export declare function transitionTaskResultToResolvedWithRetry(context: ServerContext, options: ServeOptions, input: TaskResultResolutionInput): Promise<void>;

package/dist/server/runtime/task-result-resolution.js

@@ -0,0 +1,81 @@
+import { TaskResultDeadLetteredEvent } from "../../core/events.js";
+import { PayloadSizeExceededError, assertPayloadWithinLimit } from "../../core/payload-size.js";
+import {
+  readInflightRecord,
+  transitionInflightToResolved,
+  writeDeadLetteredTaskRecord
+} from "../task-state.js";
+import { withRetry } from "./retry.js";
+import { recordTaskExecutionLatencyMetric } from "./task-metrics.js";
+const TASK_RESULT_RESOLUTION_RETRY_ATTEMPTS = 2;
+function taskResultPayloadForSizeCheck(input) {
+  return input.status === "completed" ? input.value : input.error ?? "";
+}
+export function taskResultPayloadSizeError(input, maxBytes) {
+  try {
+    assertPayloadWithinLimit(taskResultPayloadForSizeCheck(input), maxBytes, "activity result");
+    return null;
+  } catch (error) {
+    if (error instanceof PayloadSizeExceededError)
+      return error;
+    throw error;
+  }
+}
+export async function transitionTaskResultToResolvedWithRetry(context, options, input) {
+  if (input.skipPayloadSizeCheck !== !0) {
+    const payloadError = taskResultPayloadSizeError(input, context.payloadSizeMaxBytes);
+    if (payloadError !== null)
+      throw payloadError;
+  }
+  const storage = options.engine.storage, resolvedAt = Date.now();
+  let latestInflightRecord = input.inflightRecord;
+  try {
+    await withRetry(async () => {
+      if (latestInflightRecord === void 0)
+        latestInflightRecord = await readInflightRecord(storage, input.operationId);
+      await transitionInflightToResolved(storage, input.operationId, input.status, {
+        ...latestInflightRecord === null ? {} : { record: latestInflightRecord },
+        resolvedAt,
+        resolutionReason: input.resolutionReason,
+        ...input.status === "completed" ? { value: input.value } : { error: input.error }
+      });
+    }, `transition task "${input.operationId}" to resolved`, TASK_RESULT_RESOLUTION_RETRY_ATTEMPTS);
+  } catch (error) {
+    const fallbackInflightRecord = latestInflightRecord ?? await readInflightRecord(storage, input.operationId).catch(() => null);
+    await withRetry(async () => {
+      await writeTaskResultDeadLetter(options, input, fallbackInflightRecord);
+    }, `dead-letter task "${input.operationId}" after result-resolution retries`, TASK_RESULT_RESOLUTION_RETRY_ATTEMPTS);
+    console.error(`[weft] Failed to transition task "${input.operationId}" to resolved after retries \u2014 dead-lettered:`, error);
+    return;
+  }
+  if (latestInflightRecord !== null && latestInflightRecord !== void 0)
+    recordTaskExecutionLatencyMetric(context.metricsCollector, latestInflightRecord, resolvedAt);
+}
+async function writeTaskResultDeadLetter(options, input, inflightRecord) {
+  const storageErrorCode = "result-resolution-storage-exhausted", record = {
+    operationId: input.operationId,
+    reason: storageErrorCode,
+    deadLetteredAt: Date.now(),
+    errorMessage: storageErrorCode,
+    retryAttempts: TASK_RESULT_RESOLUTION_RETRY_ATTEMPTS,
+    status: input.status,
+    ...inflightRecord?.activityName === void 0 ? {} : { activityName: inflightRecord.activityName },
+    ...inflightRecord?.queue === void 0 ? {} : { queue: inflightRecord.queue },
+    ...inflightRecord?.workerId === void 0 ? {} : { workerId: inflightRecord.workerId },
+    ...inflightRecord?.attempt === void 0 ? {} : { attempt: inflightRecord.attempt },
+    ...inflightRecord?.visibilityTimeout === void 0 ? {} : { visibilityTimeout: inflightRecord.visibilityTimeout },
+    ...inflightRecord?.workflowId === void 0 ? {} : { workflowId: inflightRecord.workflowId },
+    ...inflightRecord?.retryCount === void 0 ? {} : { retryCount: inflightRecord.retryCount },
+    ...inflightRecord?.requeueCount === void 0 ? {} : { requeueCount: inflightRecord.requeueCount },
+    ...inflightRecord?.lastRequeueReason === void 0 ? {} : { lastRequeueReason: inflightRecord.lastRequeueReason }
+  };
+  await writeDeadLetteredTaskRecord(options.engine.storage, record);
+  options.engine.dispatchEvent(new TaskResultDeadLetteredEvent({
+    operationId: record.operationId,
+    workflowId: record.workflowId,
+    activityName: record.activityName,
+    queue: record.queue,
+    workerId: record.workerId,
+    errorMessage: record.errorMessage
+  }));
+}

package/dist/server/runtime/websocket-stream.d.ts

@@ -2,14 +2,33 @@ import type { ServerWebSocket } from 'bun';
 import type { Engine } from '../../core/engine.ts';
 import type { WebSocketData } from '../json-rpc-websocket-runtime.ts';
 import type { ServerContext } from './context.ts';
+/**
+ * Default per-workflow cap for one-way workflow WebSocket connections
+ * (`/stream` and `/watch`). Mirrors the JSON-RPC subscription default so one
+ * workflow cannot consume unbounded server sockets.
+ */
+export declare const DEFAULT_MAX_STREAM_CONNECTIONS_PER_WORKFLOW = 100;
 export declare function sendStreamMessage(ws: ServerWebSocket<WebSocketData>, sequence: number, message: string): void;
+export declare function sendWatchMessage(ws: ServerWebSocket<WebSocketData>, sequence: number, message: string): void;
 export declare function getHighestStoredStreamSequence(engine: Engine, workflowId: string, key: string): Promise<number>;
-export declare function addStreamSocket(context: ServerContext, workflowId: string, ws: ServerWebSocket<WebSocketData>): void;
+export declare function getHighestStoredWatchSequence(engine: Engine, workflowId: string): Promise<number>;
+export declare function addStreamSocket(context: ServerContext, workflowId: string, ws: ServerWebSocket<WebSocketData>): boolean;
+export declare function addWatchSocket(context: ServerContext, workflowId: string, ws: ServerWebSocket<WebSocketData>): boolean;
 export declare function removeStreamSocket(context: ServerContext, ws: ServerWebSocket<WebSocketData>): void;
+export declare function removeWatchSocket(context: ServerContext, ws: ServerWebSocket<WebSocketData>): void;
+export declare function removeWorkflowStreamConnection(context: ServerContext, ws: ServerWebSocket<WebSocketData>): void;
 export declare function flushPendingStreamMessages(_context: ServerContext, ws: ServerWebSocket<WebSocketData>): void;
+export declare function flushPendingWatchMessages(_context: ServerContext, ws: ServerWebSocket<WebSocketData>): void;
 export declare function publishTokenMessage(context: ServerContext, workflowId: string, sequence: number, message: string): void;
+export declare function publishWatchMessage(context: ServerContext, workflowId: string, sequence: number, message: string): void;
 /**
  * Send existing token chunks from storage to a newly connected stream client,
  * so it can catch up on tokens emitted before the connection was established.
  */
 export declare function replayTokenStream(context: ServerContext, engine: Engine, ws: ServerWebSocket<WebSocketData>, workflowId: string): Promise<void>;
+/**
+ * Send stored raw watch events to a newly connected watch client. The raw
+ * watch transport keeps its historical frame shape but now honors the same
+ * `resumeFrom` cursor query parameter used by token streams.
+ */
+export declare function replayWatchEvents(context: ServerContext, engine: Engine, ws: ServerWebSocket<WebSocketData>, workflowId: string): Promise<void>;