@lostgradient/weft 0.2.1 → 0.4.0

package/dist/server/operations/workflow-events-subscription.js

@@ -1,9 +1,14 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-const INITIAL_SUBSCRIPTION_CURSOR = "-1", workflowEventsSubscriptionInput = z.object({
+import { isAuthenticated } from "../principal.js";
+import {
+  decodeCursor
+} from "../workflow-event-feed.js";
+import { invalidParamsFault } from "./operation-helpers.js";
+const INITIAL_SUBSCRIPTION_CURSOR = "-1", MAX_WORKFLOW_SUBSCRIPTION_REPLAY_EVENTS = 1000, workflowEventsSubscriptionInput = z.object({
   workflowId: z.string().min(1),
   selector: z.enum(["events", "tokens"]).optional().default("events"),
-  fromCursor: z.string().optional()
+  fromCursor: z.string().refine((cursor) => decodeCursor(cursor) !== null, { message: "Invalid cursor" }).optional()
 }), workflowEventsSubscriptionEnvelope = z.object({
   subscriptionId: z.string(),
   cursor: z.string()
@@ -13,10 +18,12 @@ export const workflowEventsSubscriptionOperation = defineOperation({
   mcpExposable: !1,
   kind: "subscription",
   summary: "Subscribe to workflow events with replay-from-cursor",
+  description: '`selector: "events"` requires `events:read`; `selector: "tokens"` requires `streams:read`. The grant is checked when the WebSocket subscription starts and remains active until unsubscribe, socket close, or feed termination.',
   destructive: !1,
   tags: ["Events"],
   inputSchema: workflowEventsSubscriptionInput,
   outputSchema: workflowEventsSubscriptionEnvelope,
+  producibleFaults: ["InvalidParams"],
   eventSchema: z.object({
     kind: z.string(),
     workflowId: z.string(),
@@ -26,20 +33,45 @@ export const workflowEventsSubscriptionOperation = defineOperation({
     emittedAtMs: z.number(),
     payload: z.unknown()
   }),
-  access: {
-    kind: "scoped",
-    scopes: { kind: "anyOf", scopes: ["workflows:read"] }
+  access: { kind: "authenticated" },
+  parameterizedAccess: {
+    discriminator: "selector",
+    defaultValue: "events",
+    variants: [
+      {
+        value: "events",
+        access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["events:read"] } }
+      },
+      {
+        value: "tokens",
+        access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["streams:read"] } }
+      }
+    ]
+  },
+  authorize: async ({ input, principal }) => {
+    const requiredScope = workflowSubscriptionScope(input.selector);
+    if (!isAuthenticated(principal))
+      return { allowed: !1, classification: "unauthorized", reason: "authentication required" };
+    if (principal.hasScope(requiredScope))
+      return { allowed: !0 };
+    return {
+      allowed: !1,
+      classification: "forbidden",
+      reason: `requires scope: ${requiredScope}`
+    };
   },
   discoverable: !0,
   transports: { http: !1, jsonRpcHttp: !1, jsonRpcWebSocket: !0, jsonRpcStdio: !1 },
   unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
   invoke: async ({ input, engine }) => {
-    const feed = engine.feed, controller = new AbortController, startingCursor = input.fromCursor ?? INITIAL_SUBSCRIPTION_CURSOR, iterable = feed.subscribe({
+    const feed = engine.feed, controller = new AbortController, startingCursor = input.fromCursor ?? INITIAL_SUBSCRIPTION_CURSOR, subscribeOptions = {
       workflowId: input.workflowId,
       selector: input.selector,
       ...input.fromCursor === void 0 ? {} : { fromCursor: input.fromCursor },
-      signal: controller.signal
-    });
+      signal: controller.signal,
+      replayLimit: MAX_WORKFLOW_SUBSCRIPTION_REPLAY_EVENTS,
+      createReplayLimitError: (count, limit) => invalidParamsFault(`Workflow event replay window is ${count} events; maximum is ${limit}. Supply a more recent fromCursor.`)
+    }, iterable = feed.subscribe(subscribeOptions);
     return {
       envelope: { subscriptionId: `sub_${crypto.randomUUID()}`, cursor: startingCursor },
       iterable,
@@ -49,3 +81,6 @@ export const workflowEventsSubscriptionOperation = defineOperation({
     };
   }
 });
+function workflowSubscriptionScope(selector) {
+  return selector === "tokens" ? "streams:read" : "events:read";
+}

package/dist/server/rest-binding.d.ts

@@ -12,6 +12,7 @@
  */
 import { WeftError } from '../core/weft-error.ts';
 import type { OperationFault } from './operation-fault.ts';
+import type { RestBodyReadOptions } from './rest-body.ts';
 import type { HttpMethod } from './route-model.ts';
 /**
  * Thrown by `bindingPathMatches` when a URL path parameter contains malformed
@@ -59,6 +60,7 @@ export type ResponseShape = {
     readonly kind: 'streaming';
     readonly mediaType: 'text/event-stream' | 'application/octet-stream' | 'application/x-ndjson';
 };
+export type RestInputContext = RestBodyReadOptions;
 /**
  * Binds a REST mount point to an `OperationDefinition`. Generic over
  * `Input` / `Output` so `extractInput` returns a value the operation's
@@ -91,7 +93,7 @@ export type RestBinding<Input, Output> = {
      * Called before `executeOperation`; the returned value is what the
      * pipeline's schema parse step sees.
      */
-    readonly extractInput: (request: Request, pathParams: Record<string, string>) => Promise<Input>;
+    readonly extractInput: (request: Request, pathParams: Record<string, string>, context: RestInputContext) => Promise<Input>;
     /** Canonical response shape — OpenAPI reads this, handler may override via `shapeSuccess`. */
     readonly success: ResponseShape;
     /**
@@ -111,14 +113,25 @@ export type RestBinding<Input, Output> = {
     readonly shapeSuccess?: (output: Output, request: Request) => Response;
     /**
      * Optional override for fault → HTTP response mapping. When absent,
-     * the transport adapter falls back to `faultToHttpResponse` (the
-     * canonical `{ error: { code, message, data? } }` shape).
+     * the transport adapter falls back to `faultToHttpResponse`, which emits
+     * the REST fault body `{ error: { code, message, data? } }`. This is
+     * distinct from the JSON-RPC fault object (`faultToJsonRpcError`): JSON-RPC
+     * uses a flat `{ code, message, data }` with a numeric `code` and the
+     * symbolic name relocated to `data.weftCode`. REST and JSON-RPC deliberately
+     * differ in fault shape, so each transport owns its own projection.
      *
-     * During Milestone 1, bindings for REST operations that already exist
-     * with a different legacy error shape MUST provide this so their
-     * parity diff test passes byte-for-byte against the legacy handler.
-     * Milestone 2 drops the per-binding override and all REST endpoints
-     * move to the canonical fault shape.
+     * REST operations provide this to shape faults the way a REST client
+     * expects: most use `shapeRestFault`, which masks an `EngineFailure` to a
+     * flat `{ error: "Internal server error" }` with status `500` (never
+     * leaking internal detail over REST) and maps the remaining fault codes to
+     * their HTTP statuses. A few operations supply a bespoke shaper to special-case
+     * a particular fault — typically to override its message or to handle one code
+     * explicitly — while delegating the rest. The status often matches what the
+     * shared map would already produce; the shaper exists for the operation-specific
+     * detail (for example, `get-workflow-result` returns the custom message
+     * `"Timeout waiting for workflow result"` on a `Timeout`, and `get-stream-chunks`
+     * handles `InvalidParams` inline). This per-operation hook is the current
+     * contract, not a transitional shim.
      */
     readonly shapeFault?: (fault: OperationFault) => Response;
 };

package/dist/server/rest-bindings.js

@@ -25,6 +25,10 @@ import {
   bulkMutateWorkflowTagsOperation,
   bulkMutateWorkflowTagsRestBinding
 } from "./operations/bulk-mutate-workflow-tags.js";
+import {
+  bulkRetryFailedWorkflowsOperation,
+  bulkRetryFailedWorkflowsRestBinding
+} from "./operations/bulk-retry-failed-workflows.js";
 import {
   bulkSignalWorkflowsOperation,
   bulkSignalWorkflowsRestBinding
@@ -41,6 +45,7 @@ import {
   createScheduleOperation,
   createScheduleRestBinding
 } from "./operations/create-schedule.js";
+import { fleetEventsSubscriptionOperation } from "./operations/fleet-events-subscription.js";
 import { forkWorkflowOperation, forkWorkflowRestBinding } from "./operations/fork-workflow.js";
 import {
   getCheckpointAtOperation,
@@ -62,6 +67,8 @@ import {
   createGetSystemMetricsRestBinding
 } from "./operations/get-system-metrics.js";
 import {
+  clearTaskDeadLetterOperation,
+  clearTaskDeadLetterRestBinding,
   createGetTaskDiagnosticsOperation,
   getTaskDiagnosticsOperation,
   getTaskDiagnosticsRestBinding
@@ -139,6 +146,10 @@ import {
   signalWorkflowOperation,
   signalWorkflowRestBinding
 } from "./operations/signal-workflow.js";
+import {
+  startOrSignalWorkflowOperation,
+  startOrSignalWorkflowRestBinding
+} from "./operations/start-or-signal-workflow.js";
 import { startWorkflowOperation, startWorkflowRestBinding } from "./operations/start-workflow.js";
 import {
   storageBatchOperation,
@@ -162,6 +173,10 @@ import {
   submitReviewDecisionOperation,
   submitReviewDecisionRestBinding
 } from "./operations/submit-review-decision.js";
+import {
+  suspendWorkflowOperation,
+  suspendWorkflowRestBinding
+} from "./operations/suspend-workflow.js";
 import {
   timeoutWorkflowOperation,
   timeoutWorkflowRestBinding
@@ -191,12 +206,14 @@ import {
 import { workflowEventsSubscriptionOperation } from "./operations/workflow-events-subscription.js";
 export const REST_BINDINGS = [
   startWorkflowRestBinding,
+  startOrSignalWorkflowRestBinding,
   recoverAllRestBinding,
   listWorkflowsRestBinding,
   aggregateWorkflowsRestBinding,
   purgeWorkflowsRestBinding,
   bulkCancelWorkflowsRestBinding,
   bulkSignalWorkflowsRestBinding,
+  bulkRetryFailedWorkflowsRestBinding,
   bulkDeleteWorkflowsRestBinding,
   bulkMutateWorkflowTagsRestBinding,
   getWorkflowRestBinding,
@@ -211,6 +228,7 @@ export const REST_BINDINGS = [
   queryWorkflowRestBinding,
   queryWorkflowWithInputRestBinding,
   resumeWorkflowRestBinding,
+  suspendWorkflowRestBinding,
   forkWorkflowRestBinding,
   timeoutWorkflowRestBinding,
   updateWorkflowRestBinding,
@@ -233,6 +251,7 @@ export const REST_BINDINGS = [
   getStreamChunksRestBinding,
   streamWorkflowSseRestBinding,
   getTaskDiagnosticsRestBinding,
+  clearTaskDeadLetterRestBinding,
   listSchedulesRestBinding,
   getScheduleRestBinding,
   replayWorkflowRestBinding,
@@ -314,12 +333,14 @@ export function createLiveOperationRegistry(options) {
   const resolved = options ?? {};
   return createOperationRegistry([
     startWorkflowOperation,
+    startOrSignalWorkflowOperation,
     recoverAllOperation,
     listWorkflowsOperation,
     aggregateWorkflowsOperation,
     purgeWorkflowsOperation,
     bulkCancelWorkflowsOperation,
     bulkSignalWorkflowsOperation,
+    bulkRetryFailedWorkflowsOperation,
     bulkDeleteWorkflowsOperation,
     bulkMutateWorkflowTagsOperation,
     getWorkflowOperation,
@@ -333,6 +354,7 @@ export function createLiveOperationRegistry(options) {
     failAsyncActivityOperation,
     queryWorkflowOperation,
     resumeWorkflowOperation,
+    suspendWorkflowOperation,
     forkWorkflowOperation,
     timeoutWorkflowOperation,
     updateWorkflowOperation,
@@ -355,7 +377,9 @@ export function createLiveOperationRegistry(options) {
     getStreamChunksOperation,
     streamWorkflowSseOperation,
     workflowEventsSubscriptionOperation,
+    fleetEventsSubscriptionOperation,
     buildTaskDiagnosticsOperationForRegistry(resolved),
+    clearTaskDeadLetterOperation,
     listSchedulesOperation,
     getScheduleOperation,
     replayWorkflowOperation,

package/dist/server/rest-body.d.ts

@@ -0,0 +1,10 @@
+import type { OperationFault } from './operation-fault.ts';
+export declare const DEFAULT_REST_MAX_BODY_BYTES: number;
+export type RestBodyReadOptions = {
+    readonly maxBodyBytes?: number;
+};
+export declare function payloadTooLargeFault(maxBytes: number): OperationFault;
+export declare function readRestBodyBounded(request: Request, options?: RestBodyReadOptions): Promise<Uint8Array>;
+export declare function readRestTextBody(request: Request, options?: RestBodyReadOptions): Promise<string>;
+export declare function readRestJsonBody(request: Request, options?: RestBodyReadOptions): Promise<unknown>;
+export declare function readOptionalRestJsonBody(request: Request, options?: RestBodyReadOptions): Promise<unknown>;

package/dist/server/rest-body.js

@@ -0,0 +1,80 @@
+export const DEFAULT_REST_MAX_BODY_BYTES = 1048576;
+const CONTENT_LENGTH_PATTERN = /^(0|[1-9]\d*)$/;
+export function payloadTooLargeFault(maxBytes) {
+  return {
+    code: "PayloadTooLarge",
+    message: "Payload Too Large",
+    data: { maxBytes }
+  };
+}
+function invalidContentLengthFault() {
+  return {
+    code: "InvalidParams",
+    message: "Invalid Content-Length header",
+    data: { issues: [] }
+  };
+}
+function resolveMaxBodyBytes(options) {
+  const maxBytes = options?.maxBodyBytes ?? DEFAULT_REST_MAX_BODY_BYTES;
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
+    throw Error("REST body size limit must be a non-negative safe integer");
+  return maxBytes;
+}
+function assertDeclaredContentLengthWithinLimit(request, maxBytes) {
+  const header = request.headers.get("content-length");
+  if (header === null)
+    return;
+  if (!CONTENT_LENGTH_PATTERN.test(header))
+    throw invalidContentLengthFault();
+  const declared = Number(header);
+  if (!Number.isSafeInteger(declared) || declared < 0)
+    throw invalidContentLengthFault();
+  if (declared > maxBytes)
+    throw payloadTooLargeFault(maxBytes);
+}
+async function cancelReaderAfterPayloadOverflow(reader) {
+  try {
+    await reader.cancel();
+  } catch {}
+}
+export async function readRestBodyBounded(request, options) {
+  const maxBytes = resolveMaxBodyBytes(options);
+  assertDeclaredContentLengthWithinLimit(request, maxBytes);
+  const body = request.body;
+  if (body === null)
+    return new Uint8Array;
+  const reader = body.getReader(), chunks = [];
+  let total = 0;
+  try {
+    while (!0) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await cancelReaderAfterPayloadOverflow(reader);
+        throw payloadTooLargeFault(maxBytes);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+export async function readRestTextBody(request, options) {
+  return new TextDecoder("utf-8").decode(await readRestBodyBounded(request, options));
+}
+export async function readRestJsonBody(request, options) {
+  return JSON.parse(await readRestTextBody(request, options));
+}
+export async function readOptionalRestJsonBody(request, options) {
+  const text = await readRestTextBody(request, options);
+  return text.trim() === "" ? void 0 : JSON.parse(text);
+}

package/dist/server/runtime/authentication-bridge.d.ts

@@ -11,6 +11,7 @@ type ServerFetchOptions = {
     discoveryInfo?: import('../discovery-info.ts').DiscoveryInfo;
     publicOrigin?: string;
     trustedHosts?: ReadonlyArray<string>;
+    maxRequestBodyBytes?: number;
 };
 export declare function deriveSupportedOpenApiSecuritySchemes(auth: AuthConfig | undefined): ReadonlySet<OpenApiSecuritySchemeName>;
 export declare function handleServerFetchRequest(server: ReturnType<typeof Bun.serve>, context: ServerContext, options: ServerFetchOptions, originalRequest: Request): Promise<Response | undefined>;

package/dist/server/runtime/authentication-bridge.js

@@ -1,4 +1,5 @@
 import { decode } from "../../core/codec.js";
+import { WorkerDisconnectedEvent } from "../../core/events.js";
 import { handleMcpHttpRequest } from "../../mcp/http.js";
 import { KEYS } from "../../storage/interface.js";
 import { authContextToPrincipal, handleRequest } from "../handler.js";
@@ -13,7 +14,15 @@ import { buildPreflightResponse, decorateResponseWithCors, isPreflightRequest }
 import { gateRequest } from "./request-gate.js";
 import { handleTaskPollRequest, handleTaskResultRequest } from "./task-polling.js";
 import { reassignOrExpireTask } from "./task-reconciliation.js";
-import { addStreamSocket, removeStreamSocket, replayTokenStream } from "./websocket-stream.js";
+import {
+  addStreamSocket,
+  addWatchSocket,
+  removeStreamSocket,
+  removeWatchSocket,
+  removeWorkflowStreamConnection,
+  replayTokenStream,
+  replayWatchEvents
+} from "./websocket-stream.js";
 import { handleWebSocketUpgrade } from "./websocket-upgrade.js";
 import { handleWorkerWebSocketMessage, isInflightRecord } from "./websocket-worker.js";
 export function deriveSupportedOpenApiSecuritySchemes(auth) {
@@ -72,7 +81,8 @@ async function dispatchServerFetchRequest(server, context, options, originalRequ
       request,
       registry: context.liveOperationRegistry,
       engine: options.engine,
-      authContext: authentication.authContext
+      authContext: authentication.authContext,
+      ...options.maxRequestBodyBytes !== void 0 ? { maxBodyBytes: options.maxRequestBodyBytes } : {}
     });
   return handleRequest(request, options.engine, buildHandlerOptions(context, options, authentication));
 }
@@ -83,6 +93,7 @@ function buildHandlerOptions(context, options, authentication) {
     ...options.discoveryInfo !== void 0 ? { discoveryInfo: options.discoveryInfo } : {},
     ...options.publicOrigin !== void 0 ? { publicOrigin: options.publicOrigin } : {},
     ...options.trustedHosts !== void 0 ? { trustedHosts: options.trustedHosts } : {},
+    ...options.maxRequestBodyBytes !== void 0 ? { maxRequestBodyBytes: options.maxRequestBodyBytes } : {},
     operationRegistry: context.liveOperationRegistry,
     restBindings: context.liveRestBindings,
     supportedAuthenticationSchemes: context.supportedAuthenticationSchemes
@@ -92,12 +103,20 @@ export function createServerWebSocketHandlers(context, options, cleanupWorkflowI
   return {
     open(ws) {
       const { pathname, connectionType, workflowId } = ws.data;
-      if (pathname && connectionType !== "stream" && connectionType !== "jsonrpc")
+      if (connectionType === "watch" && workflowId && !addWatchSocket(context, workflowId, ws))
+        return;
+      if (connectionType === "watch" && workflowId) {
+        ws.data.watchReplayInProgress = !0;
+        ws.data.pendingWatchMessages = [];
+        replayWatchEvents(context, options.engine, ws, workflowId);
+      }
+      if (pathname && connectionType !== "stream" && connectionType !== "watch" && connectionType !== "jsonrpc")
         ws.subscribe(pathname);
       if (connectionType === "stream" && workflowId) {
-        ws.data.replayInProgress = !0;
+        ws.data.streamReplayInProgress = !0;
         ws.data.pendingStreamMessages = [];
-        addStreamSocket(context, workflowId, ws);
+        if (!addStreamSocket(context, workflowId, ws))
+          return;
         replayTokenStream(context, options.engine, ws, workflowId);
       }
       if (connectionType === "jsonrpc") {
@@ -106,6 +125,7 @@ export function createServerWebSocketHandlers(context, options, cleanupWorkflowI
           registry: context.liveOperationRegistry,
           engine: options.engine,
           feed: context.workflowEventFeed,
+          fleetFeed: context.fleetEventFeed,
           activeSessions: context.activeJsonRpcSessions
         });
         return;
@@ -133,8 +153,14 @@ export function createServerWebSocketHandlers(context, options, cleanupWorkflowI
         });
         return;
       }
-      if (ws.data.connectionType === "stream")
+      if (ws.data.connectionType === "stream") {
         removeStreamSocket(context, ws);
+        removeWorkflowStreamConnection(context, ws);
+      }
+      if (ws.data.connectionType === "watch") {
+        removeWatchSocket(context, ws);
+        removeWorkflowStreamConnection(context, ws);
+      }
       const workerId = ws.data.workerId;
       if (workerId) {
         if (context.workerSockets.get(workerId) !== ws) {
@@ -167,6 +193,7 @@ function runWorkerDisconnectRequeue(context, options, workerId, _ws, cleanupWork
   }
   context.registry.unregister(workerId);
   context.workerSockets.delete(workerId);
+  options.engine.dispatchEvent(new WorkerDisconnectedEvent(workerId, inFlightTasks.length));
   for (const [workflowId, affinityWorkerId] of context.workerAffinity)
     if (affinityWorkerId === workerId)
       context.workerAffinity.delete(workflowId);

package/dist/server/runtime/client-visible-events.d.ts

@@ -0,0 +1,3 @@
+export declare const TOKEN_EVENT_TYPE = "stream:token";
+export declare const EVENTS_READ_EVENT_TYPES: readonly ["workflow:started", "workflow:completed", "workflow:failed", "workflow:cancelled", "workflow:timed-out", "workflow:resumed", "workflow:suspended", "workflow:teardown", "activity:started", "activity:completed", "activity:failed", "activity:async-pending", "task:dead-lettered", "signal:received", "signal:delivered", "attributes:changed", "update:received", "update:completed", "schedule:fired", "schedule:missed-fire", "checkpoint:size-warning", "development:warning", "cleanup:warning", "storage:size-reported", "human-review:requested", "human-review:completed", "alert:fired", "alert:resolved", "constraint:violated", "worker:connected", "worker:disconnected"];
+export declare const CLIENT_VISIBLE_EVENT_TYPES: readonly ["workflow:started", "workflow:completed", "workflow:failed", "workflow:cancelled", "workflow:timed-out", "workflow:resumed", "workflow:suspended", "workflow:teardown", "activity:started", "activity:completed", "activity:failed", "activity:async-pending", "task:dead-lettered", "signal:received", "signal:delivered", "attributes:changed", "update:received", "update:completed", "schedule:fired", "schedule:missed-fire", "checkpoint:size-warning", "development:warning", "cleanup:warning", "storage:size-reported", "human-review:requested", "human-review:completed", "alert:fired", "alert:resolved", "constraint:violated", "worker:connected", "worker:disconnected", "stream:token"];

package/dist/server/runtime/client-visible-events.js

@@ -0,0 +1,65 @@
+import {
+  ActivityAsyncPendingEvent,
+  ActivityCompletedEvent,
+  ActivityFailedEvent,
+  ActivityStartedEvent,
+  AlertFiredEvent,
+  AlertResolvedEvent,
+  AttributesChangedEvent,
+  CheckpointSizeWarningEvent,
+  CleanupWarningEvent,
+  ConstraintViolatedEvent,
+  DevelopmentWarningEvent,
+  ScheduleFiredEvent,
+  ScheduleMissedFireEvent,
+  SignalDeliveredEvent,
+  SignalReceivedEvent,
+  StorageSizeReportedEvent,
+  TaskResultDeadLetteredEvent,
+  UpdateCompletedEvent,
+  UpdateReceivedEvent,
+  WorkerConnectedEvent,
+  WorkerDisconnectedEvent,
+  WorkflowCancelledEvent,
+  WorkflowCompletedEvent,
+  WorkflowFailedEvent,
+  WorkflowResumedEvent,
+  WorkflowStartedEvent,
+  WorkflowSuspendedEvent,
+  WorkflowTeardownEvent,
+  WorkflowTimedOutEvent
+} from "../../core/events.js";
+import { ReviewCompletedEvent, ReviewRequestedEvent } from "../../core/review/events.js";
+export const TOKEN_EVENT_TYPE = "stream:token", EVENTS_READ_EVENT_TYPES = [
+  WorkflowStartedEvent.type,
+  WorkflowCompletedEvent.type,
+  WorkflowFailedEvent.type,
+  WorkflowCancelledEvent.type,
+  WorkflowTimedOutEvent.type,
+  WorkflowResumedEvent.type,
+  WorkflowSuspendedEvent.type,
+  WorkflowTeardownEvent.type,
+  ActivityStartedEvent.type,
+  ActivityCompletedEvent.type,
+  ActivityFailedEvent.type,
+  ActivityAsyncPendingEvent.type,
+  TaskResultDeadLetteredEvent.type,
+  SignalReceivedEvent.type,
+  SignalDeliveredEvent.type,
+  AttributesChangedEvent.type,
+  UpdateReceivedEvent.type,
+  UpdateCompletedEvent.type,
+  ScheduleFiredEvent.type,
+  ScheduleMissedFireEvent.type,
+  CheckpointSizeWarningEvent.type,
+  DevelopmentWarningEvent.type,
+  CleanupWarningEvent.type,
+  StorageSizeReportedEvent.type,
+  ReviewRequestedEvent.type,
+  ReviewCompletedEvent.type,
+  AlertFiredEvent.type,
+  AlertResolvedEvent.type,
+  ConstraintViolatedEvent.type,
+  WorkerConnectedEvent.type,
+  WorkerDisconnectedEvent.type
+], CLIENT_VISIBLE_EVENT_TYPES = [...EVENTS_READ_EVENT_TYPES, TOKEN_EVENT_TYPE];

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

@@ -5,6 +5,7 @@ import type { WorkerRegistry } from '../../worker/registry.ts';
 import type { Authenticator, RateLimiter } from '../authentication.ts';
 import type { DeadlineTracker } from '../deadline-tracker.ts';
 import type { createEngineEventFeedBackend } from '../engine-event-feed-backend.ts';
+import type { FleetEventFeed } from '../fleet-event-feed.ts';
 import type { WebSocketData } from '../json-rpc-websocket-runtime.ts';
 import type { JsonRpcWebSocketSession } from '../json-rpc-websocket.ts';
 import type { OpenApiSecuritySchemeName } from '../openapi.ts';
@@ -23,6 +24,9 @@ export interface ServerContext {
     readonly taskQueue: TaskQueue;
     readonly workerSockets: Map<string, ServerWebSocket<WebSocketData>>;
     readonly streamSockets: Map<string, Set<ServerWebSocket<WebSocketData>>>;
+    readonly watchSockets: Map<string, Set<ServerWebSocket<WebSocketData>>>;
+    readonly workflowStreamConnectionCounts: Map<string, number>;
+    readonly maxStreamConnectionsPerWorkflow: number;
     /** Tracks per-workflow worker affinity for sticky routing. Maps workflowId to workerId. */
     readonly workerAffinity: Map<string, string>;
     /** Reverse index: workflowId to set of operationIds currently in-flight for that workflow. */
@@ -42,6 +46,7 @@ export interface ServerContext {
     readonly metricsCollector: MetricsCollector;
     readonly eventFeedBackend: ReturnType<typeof createEngineEventFeedBackend>;
     readonly workflowEventFeed: WorkflowEventFeed;
+    readonly fleetEventFeed: FleetEventFeed;
     readonly activeJsonRpcSessions: Set<JsonRpcWebSocketSession>;
     readonly mcpSessionManager: McpSessionManager;
     readonly authenticatorPromise: Promise<Authenticator> | null;
@@ -59,6 +64,8 @@ export interface ServerContext {
      * this window cancels the pending requeue. `0` means inline requeue.
      */
     readonly workerReconnectGracePeriodMs: number;
+    /** Engine-level cap for activity results delivered by remote workers. */
+    readonly payloadSizeMaxBytes: number | null;
     /**
      * Pending requeue timers keyed by `workerId`. A successful re-register clears
      * the timer for that worker, suppressing the deferred requeue.

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;