@lostgradient/weft 0.12.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/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/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

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

@@ -29,9 +29,8 @@ import type { TaskQueue } from './task-queue.ts';
 export type UnknownRestBinding = RestBinding<any, any>;
 /**
  * Static REST bindings for all operations that do not need per-server
- * configuration. The `weft.system.metrics` binding is excluded here
- * because it is constructed per-server via `createGetSystemMetricsRestBinding`
- * (to receive the metrics collector without module-level singletons).
+ * configuration. The `weft.system.metrics` binding is excluded because its
+ * factory receives the per-server metrics collector.
  * Use `createLiveRestBindings()` to get the full set for a given server.
  */
 export declare const REST_BINDINGS: ReadonlyArray<UnknownRestBinding>;
@@ -43,16 +42,6 @@ export declare const REST_BINDINGS: ReadonlyArray<UnknownRestBinding>;
  * are wired into the operations through {@link createLiveOperationRegistry}.
  */
 export declare function createLiveRestBindings(): ReadonlyArray<UnknownRestBinding>;
-/**
- * Live operation registry — populated with every operation that has a
- * `RestBinding`, a JSON-RPC mount, or an stdio mount. Exposed via a
- * factory so tests can spin up a fresh registry without inheriting
- * the live one's state.
- *
- * Concrete `OperationDefinition<Input, Output>` values are directly
- * assignable to `RegistrableOperation` by the variance design in
- * `operation-catalog.ts` — no `as ErasedOperation` cast is needed.
- */
 /**
  * Create the live operation registry for a server instance.
  *

package/dist/server/rest-bindings.js

@@ -7,12 +7,7 @@ import {
   aggregateWorkflowsOperation,
   aggregateWorkflowsRestBinding
 } from "./operations/aggregate-workflows.js";
-import {
-  completeAsyncActivityOperation,
-  completeAsyncActivityRestBinding,
-  failAsyncActivityOperation,
-  failAsyncActivityRestBinding
-} from "./operations/async-activity.js";
+import * as asyncActivity from "./operations/async-activity.js";
 import {
   bulkCancelWorkflowsOperation,
   bulkCancelWorkflowsRestBinding
@@ -66,6 +61,10 @@ import {
   getStreamChunksOperation,
   getStreamChunksRestBinding
 } from "./operations/get-stream-chunks.js";
+import {
+  getSystemLeaseOperation,
+  getSystemLeaseRestBinding
+} from "./operations/get-system-lease.js";
 import {
   createGetSystemMetricsOperation,
   createGetSystemMetricsRestBinding
@@ -89,6 +88,7 @@ import {
   getWorkflowEventsOperation,
   getWorkflowEventsRestBinding
 } from "./operations/get-workflow-events.js";
+import * as workflowObservability from "./operations/get-workflow-observability.js";
 import {
   getWorkflowResultOperation,
   getWorkflowResultRestBinding
@@ -155,6 +155,7 @@ import {
   startOrSignalWorkflowRestBinding
 } from "./operations/start-or-signal-workflow.js";
 import { startWorkflowOperation, startWorkflowRestBinding } from "./operations/start-workflow.js";
+import * as storageCapabilities from "./operations/storage-capabilities.js";
 import {
   storageBatchOperation,
   storageBatchRestBinding,
@@ -228,11 +229,13 @@ export const REST_BINDINGS = [
   cancelWorkflowRestBinding,
   getWorkflowResultRestBinding,
   getWorkflowAttributesRestBinding,
+  ...workflowObservability.workflowObservabilityRestBindings,
   getWorkflowEventsRestBinding,
   setWorkflowAttributesRestBinding,
   signalWorkflowRestBinding,
-  completeAsyncActivityRestBinding,
-  failAsyncActivityRestBinding,
+  asyncActivity.listPendingAsyncActivitiesRestBinding,
+  asyncActivity.completeAsyncActivityRestBinding,
+  asyncActivity.failAsyncActivityRestBinding,
   queryWorkflowRestBinding,
   queryWorkflowWithInputRestBinding,
   resumeWorkflowRestBinding,
@@ -243,6 +246,7 @@ export const REST_BINDINGS = [
   createScheduleRestBinding,
   updateScheduleRestBinding,
   getRegistryRestBinding,
+  getSystemLeaseRestBinding,
   getRetentionOverviewRestBinding,
   getUpdateResultRestBinding,
   listReviewsRestBinding,
@@ -265,6 +269,7 @@ export const REST_BINDINGS = [
   listSchedulesRestBinding,
   getScheduleRestBinding,
   replayWorkflowRestBinding,
+  storageCapabilities.storageCapabilitiesRestBinding,
   storageGetRestBinding,
   storagePutRestBinding,
   storageDeleteRestBinding,
@@ -357,11 +362,13 @@ export function createLiveOperationRegistry(options) {
     cancelWorkflowOperation,
     getWorkflowResultOperation,
     getWorkflowAttributesOperation,
+    ...workflowObservability.workflowObservabilityOperations,
     getWorkflowEventsOperation,
     setWorkflowAttributesOperation,
     signalWorkflowOperation,
-    completeAsyncActivityOperation,
-    failAsyncActivityOperation,
+    asyncActivity.listPendingAsyncActivitiesOperation,
+    asyncActivity.completeAsyncActivityOperation,
+    asyncActivity.failAsyncActivityOperation,
     queryWorkflowOperation,
     resumeWorkflowOperation,
     suspendWorkflowOperation,
@@ -371,6 +378,7 @@ export function createLiveOperationRegistry(options) {
     createScheduleOperation,
     updateScheduleOperation,
     getRegistryOperation,
+    getSystemLeaseOperation,
     getRetentionOverviewOperation,
     getUpdateResultOperation,
     listReviewsOperation,
@@ -395,6 +403,7 @@ export function createLiveOperationRegistry(options) {
     listSchedulesOperation,
     getScheduleOperation,
     replayWorkflowOperation,
+    storageCapabilities.storageCapabilitiesOperation,
     storageGetOperation,
     storagePutOperation,
     storageDeleteOperation,

package/dist/server/task-queue.d.ts

@@ -14,21 +14,23 @@ export declare function resetLifoStarvationWarningForTesting(): void;
  * until a task arrives or the timeout expires.
  *
  * `serve()` owns the live instance and exposes it as
- * {@link WeftServer.taskQueue} for inspection. Prefer the `WeftServer` methods
- * (`dispatchTask`, `shutdownWorker`, etc.) over mutating the queue directly —
- * the type is re-exported so callers can name `server.taskQueue`, not as a
- * stable mutation surface.
+ * {@link WeftServer.taskQueue} for inspection. Direct `handleRequest()` hosts
+ * can construct an instance alongside a `WorkerRegistry` and inject both via
+ * `HandlerOptions`. Prefer the `WeftServer` methods (`dispatchTask`,
+ * `shutdownWorker`, etc.) over mutating a server-owned queue directly.
  *
  * @example
  * ```ts
- * import { serve, type TaskQueue } from '@lostgradient/weft/server';
+ * import { serve, TaskQueue } from '@lostgradient/weft/server';
  * import { Engine, MemoryStorage } from '@lostgradient/weft';
  *
  * await using engine = new Engine({ storage: new MemoryStorage() });
  * await using server = serve({ engine });
  *
  * const taskQueue: TaskQueue = server.taskQueue;
+ * const standaloneTaskQueue = new TaskQueue();
  * void taskQueue;
+ * standaloneTaskQueue[Symbol.dispose]();
  * ```
  */
 export declare class TaskQueue implements Disposable {

package/dist/storage/capabilities.d.ts

@@ -72,7 +72,7 @@ export type StorageCapabilities = {
      * - `remote`: data is owned by a remote service or synchronized storage area
      *   whose durability and freshness depend on that service.
      */
-    persistence?: 'ephemeral' | 'local' | 'remote';
+    persistence: 'ephemeral' | 'local' | 'remote';
     /**
      * Visibility of a completed write to a later read, scoped to one `Storage`
      * instance.

package/dist/storage/cloudflare-value-codec.d.ts

@@ -41,9 +41,11 @@ export type CloudflareValueEncoding = 'base64' | 'blob';
  * throws immediately, instead of silently misinterpreting the bytes.
  *
  * This is the cross-mode contract for
- * {@link CloudflareDurableObjectSQLiteStorageOptions.valueEncoding}: a table
- * must use a single `valueEncoding` for its lifetime. There is no dual-read
- * fallback and no migration path between encodings — pick one per table.
+ * {@link CloudflareDurableObjectSQLiteStorageOptions.valueEncoding}:
+ * `valueEncoding` is a per-table storage-format decision, and every row in a
+ * table must use the same encoding. Each codec accepts only values written in
+ * its storage class, so cross-mode reads fail fast. Configure a distinct table
+ * name when one Durable Object needs both encodings.
  */
 type CloudflareValueCodec = {
     readonly sqlColumnType: 'TEXT' | 'BLOB';