@lostgradient/weft 0.11.0 → 0.13.0

package/dist/server/operations/operation-helpers.js

@@ -1,14 +1,9 @@
-import { isWeftErrorCode } from "../../core/weft-error.js";
-import { FAULT_CODE_TO_HTTP_STATUS } from "../operation-fault.js";
+import {
+  shapeRestFaultAsJson
+} from "../operation-fault.js";
 export function isOperationFault(value) {
   return typeof value === "object" && value !== null && "code" in value && "message" in value && "data" in value;
 }
-export function jsonErrorResponse(message, status) {
-  return new Response(JSON.stringify({ error: message }), {
-    status,
-    headers: { "Content-Type": "application/json" }
-  });
-}
 export function invalidParamsFault(message, weftCode) {
   return {
     code: "InvalidParams",
@@ -16,19 +11,6 @@ export function invalidParamsFault(message, weftCode) {
     data: weftCode === void 0 ? { issues: [] } : { issues: [], weftCode }
   };
 }
-export function shapeRestFault(fault) {
-  if (fault.code === "EngineFailure")
-    return jsonErrorResponse("Internal server error", 500);
-  const status = FAULT_CODE_TO_HTTP_STATUS[fault.code], weftCode = weftCodeFromFaultData(fault.data);
-  if (weftCode === void 0)
-    return jsonErrorResponse(fault.message, status);
-  return new Response(JSON.stringify({ error: fault.message, weftCode }), {
-    status,
-    headers: { "Content-Type": "application/json" }
-  });
-}
-function weftCodeFromFaultData(data) {
-  if (typeof data !== "object" || data === null || !("weftCode" in data))
-    return;
-  return isWeftErrorCode(data.weftCode) ? data.weftCode : void 0;
+export function shapeRestFault(fault, options) {
+  return shapeRestFaultAsJson(fault, options);
 }

package/dist/server/operations/purge-workflows.d.ts

@@ -6,6 +6,9 @@ export type PurgeWorkflowsOutput = PurgeResult;
 export declare const purgeWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<{
     status?: import("../../index.ts").WorkflowStatus | import("../../index.ts").WorkflowStatus[] | undefined;
     type?: string | undefined;
+    scheduleId?: string | undefined;
+    parentWorkflowId?: string | undefined;
+    parentWorkflowExecutionToken?: string | undefined;
     tags?: string[] | undefined;
     attributes?: {
         key: string;

package/dist/server/operations/recover-all.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { WorkflowTypeNotRegisteredForRecoveryError } from "../../core/engine.js";
+import { shapeRestFaultBody } from "../operation-fault.js";
 import { defineOperation } from "../operation-registry.js";
 import { shapeRestFault } from "./operation-helpers.js";
 const recoverAllInput = z.object({}), recoverAllOutput = z.object({
@@ -54,7 +55,7 @@ function shapeRecoverAllFault(fault) {
   if (fault.code !== "Conflict" || fault.data.missingTypes === void 0)
     return shapeRestFault(fault);
   return new Response(JSON.stringify({
-    error: "workflow_type_not_registered_for_recovery",
+    ...shapeRestFaultBody(fault, "workflow_type_not_registered_for_recovery"),
     missingTypes: fault.data.missingTypes,
     missingWorkflowCount: fault.data.missingWorkflowCount,
     samplesTruncated: fault.data.samplesTruncated

package/dist/server/operations/single-workflow-tag-mutation.js

@@ -6,7 +6,7 @@ import {
 } from "../../core/start-workflow-validation.js";
 import { defineOperation } from "../operation-registry.js";
 import { readRestJsonBody } from "../rest-body.js";
-import { isOperationFault, jsonErrorResponse, shapeRestFault } from "./operation-helpers.js";
+import { isOperationFault, shapeRestFault } from "./operation-helpers.js";
 const singleWorkflowTagMutationInput = z.object({
   workflowId: z.string().min(1),
   tags: z.unknown().optional()
@@ -78,7 +78,7 @@ function shapeSingleWorkflowTagMutationSuccess(output) {
 }
 function shapeSingleWorkflowTagMutationFault(fault) {
   if (fault.code === "Unprocessable")
-    return jsonErrorResponse(fault.message, 400);
+    return shapeRestFault(fault, { status: 400 });
   return shapeRestFault(fault);
 }
 function mapTagMutationErrorToFault(error, workflowId) {

package/dist/server/operations/sse-stream.js

@@ -1,10 +1,5 @@
 import { decodeCursor } from "../workflow-event-feed.js";
-import {
-  invalidParamsFault,
-  isOperationFault,
-  jsonErrorResponse,
-  shapeRestFault
-} from "./operation-helpers.js";
+import { invalidParamsFault, isOperationFault, shapeRestFault } from "./operation-helpers.js";
 const textEncoder = new TextEncoder, DEFAULT_SSE_HEARTBEAT_INTERVAL_MS = 15000;
 export const SSE_ACCEPT_REQUIRED_MESSAGE = "Accept header must include text/event-stream";
 export function acceptsServerSentEvents(acceptHeader) {
@@ -30,7 +25,7 @@ export function readServerSentEventsCursor(value) {
 }
 export function shapeServerSentEventsFault(fault) {
   if (fault.code === "InvalidParams" && fault.message === SSE_ACCEPT_REQUIRED_MESSAGE)
-    return jsonErrorResponse(fault.message, 406);
+    return shapeRestFault(fault, { status: 406 });
   return shapeRestFault(fault);
 }
 export function formatServerSentEvent(event) {

package/dist/server/operations/storage-capabilities.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const storageCapabilitiesInput: z.ZodObject<{}, z.core.$strip>;
+declare const storageCapabilitiesOutput: z.ZodObject<{
+    persistence: z.ZodEnum<{
+        ephemeral: "ephemeral";
+        local: "local";
+        remote: "remote";
+    }>;
+    readAfterWrite: z.ZodEnum<{
+        linearizable: "linearizable";
+        session: "session";
+        eventual: "eventual";
+    }>;
+    scanConsistency: z.ZodEnum<{
+        snapshot: "snapshot";
+        "best-effort": "best-effort";
+    }>;
+    atomicBatch: z.ZodBoolean;
+    conditionalBatch: z.ZodBoolean;
+    boundedRangeDelete: z.ZodBoolean;
+}, z.core.$strict>;
+export type StorageCapabilitiesInput = z.infer<typeof storageCapabilitiesInput>;
+export type StorageCapabilitiesOutput = z.infer<typeof storageCapabilitiesOutput>;
+export declare const storageCapabilitiesOperation: import("../operation-catalog.ts").OperationDefinition<Record<string, never>, {
+    persistence: "ephemeral" | "local" | "remote";
+    readAfterWrite: "linearizable" | "session" | "eventual";
+    scanConsistency: "snapshot" | "best-effort";
+    atomicBatch: boolean;
+    conditionalBatch: boolean;
+    boundedRangeDelete: boolean;
+}, unknown>;
+export declare const storageCapabilitiesRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/storage-capabilities.js

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const storageCapabilitiesInput = z.object({}), storageCapabilitiesOutput = z.object({
+  persistence: z.enum(["ephemeral", "local", "remote"]),
+  readAfterWrite: z.enum(["linearizable", "session", "eventual"]),
+  scanConsistency: z.enum(["snapshot", "best-effort"]),
+  atomicBatch: z.boolean(),
+  conditionalBatch: z.boolean(),
+  boundedRangeDelete: z.boolean()
+}).strict();
+export const storageCapabilitiesOperation = defineOperation({
+  name: "weft.storage.capabilities",
+  mcpExposable: !1,
+  summary: "Report the connected storage backend's capability profile",
+  destructive: !1,
+  tags: ["Storage"],
+  inputSchema: storageCapabilitiesInput,
+  outputSchema: storageCapabilitiesOutput,
+  access: {
+    kind: "scoped",
+    scopes: { kind: "anyOf", scopes: ["storage:read", "storage:admin"] }
+  },
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ engine }) => engine.storage.capabilities()
+}), storageCapabilitiesRestBinding = {
+  method: "GET",
+  path: "/v1/storage/-/capabilities",
+  pathParamNames: [],
+  operationName: "weft.storage.capabilities",
+  inputSources: {},
+  extractInput: async () => ({}),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => Response.json(output),
+  shapeFault: shapeRestFault
+};

package/dist/server/operations/storage.js

@@ -12,18 +12,9 @@ import { defineOperation } from "../operation-registry.js";
 import { isAuthenticated } from "../principal.js";
 import { readRestBodyBounded, readRestJsonBody } from "../rest-body.js";
 import { invalidParamsFault, isOperationFault, shapeRestFault } from "./operation-helpers.js";
-const storageReadAccess = {
+const rawStorageAccess = {
   kind: "scoped",
-  scopes: { kind: "anyOf", scopes: ["storage:read", "storage:admin"] }
-}, storageWriteAccess = {
-  kind: "scoped",
-  scopes: { kind: "anyOf", scopes: ["storage:write", "storage:admin"] }
-}, storageConditionalBatchAccess = {
-  kind: "scopedAlternatives",
-  alternatives: [
-    { kind: "anyOf", scopes: ["storage:admin"] },
-    { kind: "allOf", scopes: ["storage:read", "storage:write"] }
-  ]
+  scopes: { kind: "anyOf", scopes: ["storage:admin"] }
 }, httpOnlyStorageTransports = {
   http: !0,
   jsonRpcHttp: !1,
@@ -187,7 +178,7 @@ export const storageGetOperation = defineOperation({
   tags: ["Storage"],
   inputSchema: storageGetInput,
   outputSchema: storageGetOutput,
-  access: storageReadAccess,
+  access: rawStorageAccess,
   discoverable: !0,
   transports: httpOnlyStorageTransports,
   unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
@@ -202,7 +193,7 @@ export const storageGetOperation = defineOperation({
   tags: ["Storage"],
   inputSchema: storagePutInput,
   outputSchema: emptyOutput,
-  access: storageWriteAccess,
+  access: rawStorageAccess,
   discoverable: !0,
   transports: httpOnlyStorageTransports,
   unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
@@ -218,7 +209,7 @@ export const storageGetOperation = defineOperation({
   tags: ["Storage"],
   inputSchema: storageDeleteInput,
   outputSchema: emptyOutput,
-  access: storageWriteAccess,
+  access: rawStorageAccess,
   discoverable: !0,
   transports: httpOnlyStorageTransports,
   unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
@@ -234,7 +225,7 @@ export const storageGetOperation = defineOperation({
   tags: ["Storage"],
   inputSchema: storageScanInput,
   outputSchema: storageScanOutput,
-  access: storageReadAccess,
+  access: rawStorageAccess,
   discoverable: !0,
   transports: httpOnlyStorageTransports,
   unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
@@ -250,7 +241,7 @@ export const storageGetOperation = defineOperation({
   tags: ["Storage"],
   inputSchema: storageBatchInput,
   outputSchema: emptyOutput,
-  access: storageWriteAccess,
+  access: rawStorageAccess,
   discoverable: !0,
   transports: httpOnlyStorageTransports,
   unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
@@ -267,7 +258,7 @@ export const storageGetOperation = defineOperation({
   tags: ["Storage"],
   inputSchema: storageConditionalBatchInput,
   outputSchema: storageConditionalBatchOutput,
-  access: storageConditionalBatchAccess,
+  access: rawStorageAccess,
   discoverable: !0,
   transports: httpOnlyStorageTransports,
   producibleFaults: ["NotImplemented"],

package/dist/server/operations/stream-workflow-sse.js

@@ -1,8 +1,7 @@
 import { z } from "zod";
-import { FAULT_CODE_TO_HTTP_STATUS } from "../operation-fault.js";
 import { defineOperation } from "../operation-registry.js";
 import { parseOptionalSequenceCursor } from "../sequence-cursor.js";
-import { invalidParamsFault, jsonErrorResponse } from "./operation-helpers.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
 import { createStoredChunkSSEStream, SSE_RESPONSE_HEADERS } from "./sse-stream.js";
 const TOKENS_STREAM_KEY = "tokens", streamWorkflowSseInput = z.object({
   workflowId: z.string().min(1),
@@ -42,16 +41,11 @@ export const streamWorkflowSseOperation = defineOperation({
 });
 const ACCEPT_HEADER_MUST_INCLUDE_SSE = "Accept header must include text/event-stream";
 function shapeStreamWorkflowSseFault(fault) {
-  if (fault.code === "NotFound")
-    return jsonErrorResponse(fault.message, 404);
   if (fault.code === "InvalidParams") {
     if (fault.message === ACCEPT_HEADER_MUST_INCLUDE_SSE)
-      return jsonErrorResponse(fault.message, 406);
-    return jsonErrorResponse(fault.message, 400);
+      return shapeRestFault(fault, { status: 406 });
   }
-  if (fault.code === "EngineFailure")
-    return jsonErrorResponse("Internal server error", 500);
-  return jsonErrorResponse(fault.message, FAULT_CODE_TO_HTTP_STATUS[fault.code]);
+  return shapeRestFault(fault);
 }
 function mapTokenChunkToText(chunk) {
   if (typeof chunk.value === "string")

package/dist/server/operations/submit-review-decision.d.ts

@@ -5,6 +5,7 @@ declare const submitReviewDecisionInput: z.ZodObject<{
     decision: z.ZodOptional<z.ZodUnknown>;
     reviewer: z.ZodOptional<z.ZodUnknown>;
     feedback: z.ZodOptional<z.ZodUnknown>;
+    sectionDecisions: z.ZodOptional<z.ZodUnknown>;
     workflowId: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 declare const submitReviewDecisionOutput: z.ZodObject<{
@@ -17,6 +18,7 @@ export declare const submitReviewDecisionOperation: import("../operation-catalog
     decision?: unknown;
     reviewer?: unknown;
     feedback?: unknown;
+    sectionDecisions?: unknown;
     workflowId?: unknown;
 }, {
     ok: true;

package/dist/server/operations/submit-review-decision.js

@@ -6,15 +6,28 @@ const VALID_DECISIONS = [
   "approved",
   "rejected",
   "needs-changes"
-], submitReviewDecisionInput = z.object({
+], sectionDecisionsSchema = z.record(z.string(), z.enum(["approved", "rejected"])), submitReviewDecisionInput = z.object({
   reviewId: z.string().min(1),
   decision: z.unknown().optional(),
   reviewer: z.unknown().optional(),
   feedback: z.unknown().optional(),
+  sectionDecisions: z.unknown().optional(),
   workflowId: z.unknown().optional()
 }), submitReviewDecisionOutput = z.object({
   ok: z.literal(!0)
 });
+function parseSectionDecisions(sectionDecisions) {
+  if (sectionDecisions === void 0)
+    return;
+  const parsed = sectionDecisionsSchema.safeParse(sectionDecisions);
+  if (!parsed.success)
+    throw {
+      code: "InvalidParams",
+      message: 'Field "sectionDecisions" must be a record mapping section names to "approved" or "rejected"',
+      data: { issues: [] }
+    };
+  return parsed.data;
+}
 function validateReviewDecisionInput(input) {
   if (typeof input.decision !== "string" || typeof input.reviewer !== "string")
     throw {
@@ -34,9 +47,11 @@ function validateReviewDecisionInput(input) {
       message: 'Field "feedback" must be a string when provided',
       data: { issues: [] }
     };
-  const { decision, reviewer } = input, reviewOptions = { decision, reviewer };
+  const sectionDecisions = parseSectionDecisions(input.sectionDecisions), decision = input.decision, reviewer = input.reviewer, reviewOptions = { decision, reviewer };
   if (typeof input.feedback === "string")
     reviewOptions.feedback = input.feedback;
+  if (sectionDecisions !== void 0)
+    reviewOptions.sectionDecisions = sectionDecisions;
   if (typeof input.workflowId === "string")
     reviewOptions.workflowId = input.workflowId;
   return { decision, reviewer, reviewOptions };
@@ -94,6 +109,7 @@ export const submitReviewDecisionRestBinding = {
     decision: { kind: "body-field", bodyField: "decision" },
     reviewer: { kind: "body-field", bodyField: "reviewer" },
     feedback: { kind: "body-field", bodyField: "feedback" },
+    sectionDecisions: { kind: "body-field", bodyField: "sectionDecisions" },
     workflowId: { kind: "body-field", bodyField: "workflowId" }
   },
   extractInput: async (request, pathParams, context) => {
@@ -107,6 +123,7 @@ export const submitReviewDecisionRestBinding = {
       decision: record.decision,
       reviewer: record.reviewer,
       feedback: record.feedback,
+      sectionDecisions: record.sectionDecisions,
       workflowId: record.workflowId
     };
   },

package/dist/server/operations/update-schedule.d.ts

@@ -4,12 +4,20 @@ declare const updateScheduleInput: z.ZodObject<{
     scheduleId: z.ZodString;
     cronExpression: z.ZodOptional<z.ZodUnknown>;
     every: z.ZodOptional<z.ZodUnknown>;
+    description: z.ZodOptional<z.ZodUnknown>;
+    overlap: z.ZodOptional<z.ZodUnknown>;
+    backfill: z.ZodOptional<z.ZodUnknown>;
+    jitter: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 export type UpdateScheduleInput = z.infer<typeof updateScheduleInput>;
 export declare const updateScheduleOperation: import("../operation-catalog.ts").OperationDefinition<{
     scheduleId: string;
     cronExpression?: unknown;
     every?: unknown;
+    description?: unknown;
+    overlap?: unknown;
+    backfill?: unknown;
+    jitter?: unknown;
 }, null, unknown>;
 export declare const updateScheduleRestBinding: UnknownRestBinding;
 export {};

package/dist/server/operations/update-schedule.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { normalizeScheduleUpdateOptions } from "../../core/engine/validation/schedule.js";
 import { defineOperation } from "../operation-registry.js";
 import { readRestJsonBody } from "../rest-body.js";
 import { invalidParamsFault, isOperationFault, shapeRestFault } from "./operation-helpers.js";
@@ -6,25 +7,79 @@ import { mapScheduleErrorToFault, validateScheduleInputCadence } from "./schedul
 const updateScheduleInput = z.object({
   scheduleId: z.string().min(1),
   cronExpression: z.unknown().optional().describe("Cron expression. Supply exactly one of cronExpression or every; runtime validation requires a non-empty string."),
-  every: z.unknown().optional().describe("Interval period (duration string or milliseconds). Supply exactly one of cronExpression or every.")
+  every: z.unknown().optional().describe("Interval period (duration string or milliseconds). Supply exactly one of cronExpression or every."),
+  description: z.unknown().optional().describe("Operator-facing schedule description. Runtime validation requires a string."),
+  overlap: z.unknown().optional(),
+  backfill: z.unknown().optional(),
+  jitter: z.unknown().optional()
 });
+function isScheduleOverlapPolicy(value) {
+  return value === "skip" || value === "queue" || value === "cancel-running" || value === "allow";
+}
+function validateDescription(value) {
+  if (value === void 0)
+    return;
+  if (typeof value !== "string")
+    throw invalidParamsFault('Field "description" must be a string');
+  return value;
+}
+function validateOverlap(value) {
+  if (value === void 0)
+    return;
+  if (typeof value !== "string" || !isScheduleOverlapPolicy(value))
+    throw invalidParamsFault('Field "overlap" must be one of skip, queue, cancel-running, allow');
+  return value;
+}
+function validateBackfill(value) {
+  if (value === void 0)
+    return;
+  if (typeof value !== "boolean")
+    throw invalidParamsFault('Field "backfill" must be a boolean');
+  return value;
+}
+function formatJitterValidationMessage(message) {
+  const enginePrefix = "Invalid options.jitter: ", hasEnginePrefix = message.startsWith(enginePrefix), wireDetail = (hasEnginePrefix ? message.slice(enginePrefix.length) : message).replaceAll("options.jitter", 'Field "jitter"');
+  return hasEnginePrefix ? `Field "jitter" is invalid: ${wireDetail}` : wireDetail;
+}
+function validateJitter(value) {
+  if (value === void 0)
+    return;
+  if (typeof value !== "string" && typeof value !== "number")
+    throw invalidParamsFault('Field "jitter" must be a duration string or a number of milliseconds');
+  try {
+    normalizeScheduleUpdateOptions({ jitter: value });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw invalidParamsFault(formatJitterValidationMessage(message));
+  }
+  return value;
+}
+function validateScheduleUpdateOptions(input) {
+  const description = validateDescription(input.description), overlap = validateOverlap(input.overlap), backfill = validateBackfill(input.backfill), jitter = validateJitter(input.jitter);
+  return {
+    ...description !== void 0 ? { description } : {},
+    ...overlap !== void 0 ? { overlap } : {},
+    ...backfill !== void 0 ? { backfill } : {},
+    ...jitter !== void 0 ? { jitter } : {}
+  };
+}
 export const updateScheduleOperation = defineOperation({
   name: "weft.schedules.update",
   mcpExposable: !1,
   summary: "Update a recurring schedule",
-  description: "Update an existing recurring schedule by `id`, replacing its recurrence specification, target workflow input, or start options. Returns null on success. Faults with NotFound when no schedule with the given id exists and InvalidParams for a malformed recurrence specification.",
+  description: "Update an existing recurring schedule by `id`, replacing its recurrence specification and optionally changing description, overlap, backfill, or jitter. Omitted options retain their persisted values; schedule id, workflow type, and input remain unchanged. Returns null on success. Faults with NotFound when no schedule with the given id exists and InvalidParams for malformed fields.",
   destructive: !1,
   tags: ["Schedules"],
   inputSchema: updateScheduleInput,
   outputSchema: z.null(),
   access: { kind: "public" },
-  producibleFaults: ["NotFound", "Conflict"],
+  producibleFaults: ["NotFound", "Conflict", "InvalidParams"],
   transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
   unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
   invoke: async ({ input, engine }) => {
-    const typedEngine = engine, spec = validateScheduleInputCadence(input);
+    const typedEngine = engine, spec = validateScheduleInputCadence(input), options = validateScheduleUpdateOptions(input);
     try {
-      await typedEngine.updateSchedule(input.scheduleId, spec);
+      await typedEngine.updateSchedule(input.scheduleId, spec, options);
       return null;
     } catch (error) {
       throw mapScheduleErrorToFault(input.scheduleId, error);
@@ -38,7 +93,11 @@ export const updateScheduleOperation = defineOperation({
   inputSources: {
     scheduleId: { kind: "path", pathParam: "id" },
     cronExpression: { kind: "body-field", bodyField: "cronExpression" },
-    every: { kind: "body-field", bodyField: "every" }
+    every: { kind: "body-field", bodyField: "every" },
+    description: { kind: "body-field", bodyField: "description" },
+    overlap: { kind: "body-field", bodyField: "overlap" },
+    backfill: { kind: "body-field", bodyField: "backfill" },
+    jitter: { kind: "body-field", bodyField: "jitter" }
   },
   extractInput: async (request, pathParams, context) => {
     let body;
@@ -55,7 +114,11 @@ export const updateScheduleOperation = defineOperation({
     return {
       scheduleId: pathParams.id ?? "",
       cronExpression: Object.hasOwn(record, "cronExpression") ? record.cronExpression : void 0,
-      every: Object.hasOwn(record, "every") ? record.every : void 0
+      every: Object.hasOwn(record, "every") ? record.every : void 0,
+      description: record.description,
+      overlap: record.overlap,
+      backfill: record.backfill,
+      jitter: record.jitter
     };
   },
   success: { kind: "empty", status: 204 },

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

@@ -4,7 +4,7 @@ import { isAuthenticated } from "../principal.js";
 import {
   decodeCursor
 } from "../workflow-event-feed.js";
-import { invalidParamsFault, jsonErrorResponse } from "./operation-helpers.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
 import {
   createEventEnvelopeSSEStream,
   readServerSentEventsCursor,
@@ -163,7 +163,7 @@ function shapeWorkflowEventsSseSuccess(output, request) {
 }
 function shapeWorkflowEventsSseFault(fault) {
   if (fault.code === "InvalidParams" && fault.message === MAXIMUM_WORKFLOW_STREAMS_MESSAGE)
-    return jsonErrorResponse(fault.message, 429);
+    return shapeRestFault(fault, { status: 429 });
   return shapeServerSentEventsFault(fault);
 }
 function readSelector(request) {

package/dist/server/replay-live-feed-internals.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Private replay/live-drain algorithm shared by every `createReplayLiveFeed()`
+ * instance (`workflow-event-feed.ts`'s per-workflow feed and
+ * `fleet-event-feed.ts`'s fleet-wide feed). Split out of
+ * `workflow-event-feed.ts` purely to keep that file under the repository's
+ * implementation-file line limit — nothing here is public API.
+ *
+ * @module server/replay-live-feed-internals
+ */
+import type { ReplayLiveFeedBackend, ReplayLiveSubscribeOptions, SequencedEventEnvelope } from './workflow-event-feed.ts';
+/** Thrown when a replay window exceeds the caller's configured limit. */
+export declare class ReplayWindowExceededError extends Error {
+    readonly count: number;
+    readonly limit: number;
+    constructor(count: number, limit: number);
+}
+export declare function replayUpTo<TEnvelope extends SequencedEventEnvelope>(backend: ReplayLiveFeedBackend<TEnvelope>, afterSequence: number, snapshot: number, signal: AbortSignal | undefined, replayOptions: ReplayLiveSubscribeOptions<TEnvelope> | undefined): AsyncIterable<TEnvelope>;
+export declare function shouldDeliverEnvelope<TEnvelope extends SequencedEventEnvelope>(envelope: TEnvelope, replayOptions: ReplayLiveSubscribeOptions<TEnvelope> | undefined): boolean;
+export declare function drainLive<TEnvelope extends SequencedEventEnvelope>(buffer: TEnvelope[], snapshot: number, signal: AbortSignal | undefined, overflowed: () => boolean, installWaker: (fn: (() => void) | null) => void): AsyncIterable<TEnvelope>;

package/dist/server/replay-live-feed-internals.js

@@ -0,0 +1,76 @@
+export class ReplayWindowExceededError extends Error {
+  count;
+  limit;
+  constructor(count, limit) {
+    super(`Replay window is ${count} events; maximum is ${limit}.`);
+    this.count = count;
+    this.limit = limit;
+    this.name = "ReplayWindowExceededError";
+  }
+}
+export async function* replayUpTo(backend, afterSequence, snapshot, signal, replayOptions) {
+  let replayCount = 0;
+  for await (const envelope of backend.replay({ afterSequence })) {
+    if (envelope.sequence > snapshot)
+      break;
+    if (signal?.aborted)
+      return;
+    if (!shouldDeliverEnvelope(envelope, replayOptions))
+      continue;
+    if (shouldCountReplayEnvelope(envelope, replayOptions)) {
+      replayCount += 1;
+      const replayLimit = replayOptions?.replayLimit;
+      if (replayLimit !== void 0 && replayCount > replayLimit)
+        throw createReplayLimitError(replayOptions, replayCount, replayLimit);
+    }
+    yield envelope;
+  }
+}
+export function shouldDeliverEnvelope(envelope, replayOptions) {
+  return replayOptions?.filterEnvelope?.(envelope) ?? !0;
+}
+function shouldCountReplayEnvelope(envelope, replayOptions) {
+  return replayOptions?.countReplayEnvelope?.(envelope) ?? !0;
+}
+function createReplayLimitError(replayOptions, count, limit) {
+  return replayOptions?.createReplayLimitError?.(count, limit) ?? new ReplayWindowExceededError(count, limit);
+}
+function flushPendingBuffer(buffer, watermark) {
+  const batch = [];
+  let newWatermark = watermark, head = buffer.shift();
+  while (head !== void 0) {
+    if (head.sequence > newWatermark) {
+      batch.push(head);
+      newWatermark = head.sequence;
+    }
+    head = buffer.shift();
+  }
+  return { batch, newWatermark };
+}
+async function armAndWait(buffer, overflowed, signal, installWaker) {
+  const armed = new Promise((resolve) => {
+    installWaker(resolve);
+  });
+  if (buffer.length > 0 || overflowed() || signal?.aborted) {
+    installWaker(null);
+    return;
+  }
+  await armed;
+}
+export async function* drainLive(buffer, snapshot, signal, overflowed, installWaker) {
+  let watermark = snapshot;
+  while (!0) {
+    if (signal?.aborted || overflowed())
+      break;
+    const { batch, newWatermark } = flushPendingBuffer(buffer, watermark);
+    watermark = newWatermark;
+    for (const envelope of batch) {
+      if (signal?.aborted || overflowed())
+        return;
+      yield envelope;
+    }
+    if (batch.length > 0)
+      continue;
+    await armAndWait(buffer, overflowed, signal, installWaker);
+  }
+}

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

@@ -114,16 +114,17 @@ export type RestBinding<Input, Output> = {
     /**
      * Optional override for fault → HTTP response mapping. When absent,
      * 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.
+     * the same flat audited `{ error, weftCode?, data? }` body as
+     * `shapeRestFault`. This is distinct from the JSON-RPC fault object
+     * (`faultToJsonRpcError`), which uses `{ code, message, data }` with a numeric
+     * `code` and a broader data projection. REST and JSON-RPC deliberately differ
+     * in fault shape, so each transport owns its own projection.
      *
      * 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
+     * leaking internal detail over REST), adds audited safe context under a
+     * `data` sibling for other faults, 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