@lostgradient/weft 0.2.1 → 0.4.0

package/dist/server/operations/start-workflow.js

@@ -1,20 +1,18 @@
 import { z } from "zod";
 import {
+  IdempotencyKeyPurgedError,
   WorkflowAlreadyExistsError,
   WorkflowNotRegisteredError
 } from "../../core/engine/errors.js";
 import { runtimeWorkflowEngine } from "../../core/runtime-workflow-engine.js";
-import { validateAttributeType } from "../../core/search-attributes.js";
-import {
-  assertExclusiveStartWorkflowOptions,
-  coerceStartWorkflowDuration,
-  coerceStartWorkflowId,
-  coerceStartWorkflowTags,
-  coerceStartWorkflowTimestamp,
-  StartWorkflowValidationError
-} from "../../core/start-workflow-validation.js";
+import { StartWorkflowValidationError } from "../../core/start-workflow-validation.js";
 import { defineOperation } from "../operation-registry.js";
 import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { buildSharedStartWorkflowOptions } from "./start-workflow-options.js";
+import {
+  extractSharedStartWorkflowRestFields,
+  parseStartWorkflowRequestRecord
+} from "./start-workflow-rest-input.js";
 const startWorkflowInput = z.object({
   type: z.unknown().describe("Workflow type name. Runtime validation requires a non-empty string."),
   input: z.unknown().optional(),
@@ -34,7 +32,7 @@ function validateStartWorkflowInput(input, lookupSearchAttributeSchema) {
   const type = input.type;
   let options;
   try {
-    options = buildStartWorkflowOptions(input, lookupSearchAttributeSchema(type));
+    options = buildSharedStartWorkflowOptions(input, lookupSearchAttributeSchema(type));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw invalidParamsFault(message);
@@ -44,12 +42,12 @@ function validateStartWorkflowInput(input, lookupSearchAttributeSchema) {
 function resolveStartWorkflowAccess(error) {
   const message = error instanceof Error ? error.message : String(error);
   if (error instanceof WorkflowNotRegisteredError)
-    throw invalidParamsFault(message);
-  if (error instanceof WorkflowAlreadyExistsError)
+    throw invalidParamsFault(message, error.code);
+  if (error instanceof WorkflowAlreadyExistsError || error instanceof IdempotencyKeyPurgedError)
     throw {
       code: "Conflict",
       message,
-      data: { reason: message }
+      data: { reason: message, weftCode: error.code }
     };
   if (error instanceof StartWorkflowValidationError)
     throw invalidParamsFault(message);
@@ -63,7 +61,7 @@ export const startWorkflowOperation = defineOperation({
   name: "weft.workflows.start",
   mcpExposable: !1,
   summary: "Start a new workflow",
-  description: "Start a new workflow execution of a registered type. Requires `type` (the registered workflow type name) and accepts an optional `input` payload plus start options: `id` (client-supplied workflow id), `executionTimeout`, `startAt`/`startAfter` (mutually exclusive scheduling), `tags`, and `searchAttributes`. Returns the workflow `id`. Faults with InvalidParams for an unregistered type or malformed options, and Conflict when a workflow with the same id already exists.",
+  description: "Start a new workflow execution of a registered type. Requires `type` (the registered workflow type name) and accepts an optional `input` payload plus start options: `id` (client-supplied workflow id), `executionTimeout`, `startAt`/`startAfter` (mutually exclusive scheduling), `tags`, `idempotencyKey` (at-most-once dedup: a repeated key returns the existing run instead of starting a second), and `searchAttributes`. Returns the workflow `id`. Faults with InvalidParams for an unregistered type or malformed options, and Conflict when a workflow with the same id already exists or the supplied `idempotencyKey` has been spent (its run was purged or swept by retention).",
   destructive: !1,
   tags: ["Workflows"],
   inputSchema: startWorkflowInput,
@@ -82,63 +80,7 @@ export const startWorkflowOperation = defineOperation({
       resolveStartWorkflowAccess(error);
     }
   }
-});
-function buildStartWorkflowOptions(input, searchAttributeSchema) {
-  const options = {};
-  if (input.id !== void 0)
-    options.id = coerceStartWorkflowId(input.id, 'Field "id"');
-  if (input.executionTimeout !== void 0)
-    options.executionTimeout = coerceStartWorkflowDuration(input.executionTimeout, 'Field "executionTimeout"');
-  if (input.startAt !== void 0)
-    options.startAt = coerceStartWorkflowTimestamp(input.startAt, 'Field "startAt"');
-  if (input.startAfter !== void 0)
-    options.startAfter = coerceStartWorkflowDuration(input.startAfter, 'Field "startAfter"');
-  if (input.tags !== void 0)
-    options.tags = coerceStartWorkflowTags(input.tags, 'Field "tags"');
-  if (input.idempotencyKey !== void 0)
-    throw new StartWorkflowValidationError("idempotencyKey is not supported over HttpClient because the start workflow HTTP protocol does not implement start idempotency");
-  if (input.searchAttributes !== void 0)
-    options.searchAttributes = coerceStartWorkflowSearchAttributes(input.searchAttributes, 'Field "searchAttributes"', searchAttributeSchema);
-  assertExclusiveStartWorkflowOptions(options.startAt, options.startAfter);
-  return options;
-}
-function coerceStartWorkflowSearchAttributes(value, fieldName, schema) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    throw new StartWorkflowValidationError(`${fieldName} must be an object`);
-  const attributes = Object.create(null);
-  for (const [key, attributeValue] of Object.entries(value)) {
-    const coercedValue = coerceStartWorkflowSearchAttributeValue(key, attributeValue, fieldName, schema);
-    attributes[key] = coercedValue;
-  }
-  return attributes;
-}
-function coerceStartWorkflowSearchAttributeValue(key, value, fieldName, schema) {
-  if (!isSearchAttributeValue(value))
-    throw new StartWorkflowValidationError(`${fieldName}.${key} must be a string, number, boolean, Date, or string array`);
-  if (schema === void 0)
-    return value;
-  const definition = schema[key];
-  if (definition === void 0)
-    throw new StartWorkflowValidationError(`Unknown search attribute "${key}". Registered attributes: ${Object.keys(schema).join(", ")}`);
-  const normalizedValue = definition.type === "string" && definition.format === "date-time" && typeof value === "string" ? coerceDateTimeSearchAttribute(key, value, fieldName) : value;
-  try {
-    validateAttributeType(key, normalizedValue, definition);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new StartWorkflowValidationError(message);
-  }
-  return normalizedValue;
-}
-function coerceDateTimeSearchAttribute(key, value, fieldName) {
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime()))
-    throw new StartWorkflowValidationError(`${fieldName}.${key} must be a valid date-time string`);
-  return date;
-}
-function isSearchAttributeValue(value) {
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || value instanceof Date || Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-export const startWorkflowRestBinding = {
+}), startWorkflowRestBinding = {
   method: "POST",
   path: "/v1/workflows",
   pathParamNames: [],
@@ -154,27 +96,8 @@ export const startWorkflowRestBinding = {
     idempotencyKey: { kind: "body-field", bodyField: "idempotencyKey" },
     searchAttributes: { kind: "body-field", bodyField: "searchAttributes" }
   },
-  extractInput: async (request) => {
-    let body;
-    try {
-      body = await request.json();
-    } catch {
-      throw invalidParamsFault("Invalid JSON body");
-    }
-    if (typeof body !== "object" || body === null)
-      throw invalidParamsFault("Request body must be a JSON object");
-    const record = body;
-    return {
-      type: record.type,
-      input: record.input,
-      id: record.id,
-      executionTimeout: record.executionTimeout,
-      startAt: record.startAt,
-      startAfter: record.startAfter,
-      tags: record.tags,
-      idempotencyKey: record.idempotencyKey,
-      searchAttributes: record.searchAttributes
-    };
+  extractInput: async (request, _pathParams, context) => {
+    return extractSharedStartWorkflowRestFields(await parseStartWorkflowRequestRecord(request, context));
   },
   success: { kind: "json", status: 201 },
   shapeFault: shapeRestFault

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

@@ -60,14 +60,14 @@ export type StorageConditionalBatchInput = z.infer<typeof storageConditionalBatc
 export type StorageConditionalBatchOutput = z.infer<typeof storageConditionalBatchOutput>;
 export declare const storageGetOperation: import("../operation-catalog.ts").OperationDefinition<{
     key: string;
-}, Uint8Array<ArrayBufferLike> | null>;
+}, Uint8Array<ArrayBufferLike> | null, unknown>;
 export declare const storagePutOperation: import("../operation-catalog.ts").OperationDefinition<{
     key: string;
     value: Uint8Array<ArrayBuffer>;
-}, null>;
+}, null, unknown>;
 export declare const storageDeleteOperation: import("../operation-catalog.ts").OperationDefinition<{
     key: string;
-}, null>;
+}, null, unknown>;
 export declare const storageScanOperation: import("../operation-catalog.ts").OperationDefinition<{
     prefix: string;
     limit?: number | undefined;
@@ -76,7 +76,7 @@ export declare const storageScanOperation: import("../operation-catalog.ts").Ope
     gte?: string | undefined;
     lt?: string | undefined;
     lte?: string | undefined;
-}, StorageScanOutput>;
+}, StorageScanOutput, unknown>;
 export declare const storageBatchOperation: import("../operation-catalog.ts").OperationDefinition<{
     operations: ({
         type: "put";
@@ -86,7 +86,7 @@ export declare const storageBatchOperation: import("../operation-catalog.ts").Op
         type: "delete";
         key: string;
     })[];
-}, null>;
+}, null, unknown>;
 export declare const storageConditionalBatchOperation: import("../operation-catalog.ts").OperationDefinition<{
     conditions: {
         key: string;
@@ -102,7 +102,7 @@ export declare const storageConditionalBatchOperation: import("../operation-cata
     })[];
 }, {
     applied: boolean;
-}>;
+}, unknown>;
 export declare const storageGetRestBinding: UnknownRestBinding;
 export declare const storagePutRestBinding: UnknownRestBinding;
 export declare const storageDeleteRestBinding: UnknownRestBinding;

package/dist/server/operations/storage.js

@@ -1,12 +1,17 @@
 import { z } from "zod";
+import { copyBytesToArrayBuffer } from "../../core/byte-arrays.js";
 import { decodeBase64ToBytes, encodeBytesToBase64 } from "../../storage/byte-encoding.js";
 import {
+  MAX_BATCH_OPERATIONS,
+  MAX_SCAN_LIMIT,
+  storageBatch,
   storageConditionalBatch
 } from "../../storage/interface.js";
 import { raiseFault } from "../operation-catalog.js";
 import { defineOperation } from "../operation-registry.js";
 import { isAuthenticated } from "../principal.js";
-import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { readRestBodyBounded, readRestJsonBody } from "../rest-body.js";
+import { invalidParamsFault, isOperationFault, shapeRestFault } from "./operation-helpers.js";
 const storageReadAccess = {
   kind: "scoped",
   scopes: { kind: "anyOf", scopes: ["storage:read", "storage:admin"] }
@@ -26,7 +31,7 @@ const storageReadAccess = {
   jsonRpcWebSocket: !1
 }, binaryValueSchema = z.instanceof(Uint8Array).meta({ type: "string", format: "binary" }), storageGetInput = z.object({ key: z.string().min(1) }), storagePutInput = z.object({ key: z.string().min(1), value: binaryValueSchema }), storageDeleteInput = z.object({ key: z.string().min(1) }), storageScanInput = z.object({
   prefix: z.string(),
-  limit: z.number().int().positive().optional(),
+  limit: z.number().int().positive().max(MAX_SCAN_LIMIT).optional(),
   reverse: z.boolean().optional(),
   gt: z.string().optional(),
   gte: z.string().optional(),
@@ -38,9 +43,11 @@ const storageReadAccess = {
 ]), storageConditionInput = z.object({
   key: z.string().min(1),
   expectedValue: z.string().nullable()
-}), storageBatchInput = z.object({ operations: z.array(storageBatchOperationInput) }), storageConditionalBatchInput = z.object({
-  conditions: z.array(storageConditionInput),
-  operations: z.array(storageBatchOperationInput)
+}), storageBatchInput = z.object({
+  operations: z.array(storageBatchOperationInput).max(MAX_BATCH_OPERATIONS)
+}), storageConditionalBatchInput = z.object({
+  conditions: z.array(storageConditionInput).max(MAX_BATCH_OPERATIONS),
+  operations: z.array(storageBatchOperationInput).max(MAX_BATCH_OPERATIONS)
 }), emptyOutput = z.null(), storageGetOutput = binaryValueSchema.nullable(), storageScanOutput = z.custom((value) => typeof value === "object" && value !== null && (Symbol.asyncIterator in value) && typeof value[Symbol.asyncIterator] === "function", "Storage scan output must be an async iterable."), storageConditionalBatchOutput = z.object({ applied: z.boolean() });
 function resolveAuthorizedStorage(engine, principal, operation) {
   if (!isAuthenticated(principal))
@@ -89,10 +96,12 @@ function decodeCondition(condition) {
     expectedValue: condition.expectedValue === null ? null : decodeStorageBytes(condition.expectedValue, "Storage conditional batch expectedValue must be base64.")
   };
 }
-async function readJsonRequestBody(request) {
+async function readJsonRequestBody(request, context) {
   try {
-    return await request.json();
-  } catch {
+    return await readRestJsonBody(request, context);
+  } catch (error) {
+    if (isOperationFault(error))
+      throw error;
     throw invalidParamsFault("Request body must be valid JSON.");
   }
 }
@@ -137,7 +146,7 @@ function createNoContentResponse() {
 function createBinaryResponse(value) {
   if (value === null)
     return new Response(null, { status: 404 });
-  return new Response(value, {
+  return new Response(copyBytesToArrayBuffer(value), {
     status: 200,
     headers: { "Content-Type": "application/octet-stream" }
   });
@@ -246,7 +255,8 @@ export const storageGetOperation = defineOperation({
   transports: httpOnlyStorageTransports,
   unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
   invoke: async ({ input, engine, principal }) => {
-    await resolveAuthorizedStorage(engine, principal, storageBatchOperation).batch(input.operations.map(decodeBatchOperation));
+    const storage = resolveAuthorizedStorage(engine, principal, storageBatchOperation);
+    await storageBatch(storage, input.operations.map(decodeBatchOperation));
     return null;
   }
 }), storageConditionalBatchOperation = defineOperation({
@@ -293,9 +303,9 @@ export const storageGetOperation = defineOperation({
     key: { kind: "path", pathParam: "key" },
     value: { kind: "body", mediaType: "application/octet-stream" }
   },
-  extractInput: async (request, pathParams) => ({
+  extractInput: async (request, pathParams, context) => ({
     key: storageKeyFromPath(pathParams),
-    value: new Uint8Array(await request.arrayBuffer())
+    value: await readRestBodyBounded(request, context)
   }),
   success: { kind: "empty", status: 204 },
   shapeSuccess: createNoContentResponse,
@@ -338,7 +348,7 @@ export const storageGetOperation = defineOperation({
   inputSources: {
     operations: { kind: "body-field", bodyField: "operations" }
   },
-  extractInput: async (request) => readJsonRequestBody(request),
+  extractInput: async (request, _pathParams, context) => readJsonRequestBody(request, context),
   success: { kind: "empty", status: 204 },
   shapeSuccess: createNoContentResponse,
   shapeFault: shapeRestFault
@@ -351,7 +361,7 @@ export const storageGetOperation = defineOperation({
     conditions: { kind: "body-field", bodyField: "conditions" },
     operations: { kind: "body-field", bodyField: "operations" }
   },
-  extractInput: async (request) => readJsonRequestBody(request),
+  extractInput: async (request, _pathParams, context) => readJsonRequestBody(request, context),
   success: { kind: "json", status: 200 },
   shapeSuccess: (output) => Response.json(output),
   shapeFault: shapeRestFault

package/dist/server/operations/stream-workflow-sse.d.ts

@@ -12,6 +12,6 @@ export type StreamWorkflowSseOutput = {
 export declare const streamWorkflowSseOperation: import("../operation-catalog.ts").OperationDefinition<{
     workflowId: string;
     after?: unknown;
-}, StreamWorkflowSseOutput>;
+}, StreamWorkflowSseOutput, unknown>;
 export declare const streamWorkflowSseRestBinding: UnknownRestBinding;
 export {};

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

@@ -20,6 +20,6 @@ export declare const submitReviewDecisionOperation: import("../operation-catalog
     workflowId?: unknown;
 }, {
     ok: true;
-}>;
+}, unknown>;
 export declare const submitReviewDecisionRestBinding: UnknownRestBinding;
 export {};

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-import { shapeRestFault } from "./operation-helpers.js";
+import { readRestJsonBody } from "../rest-body.js";
+import { isOperationFault, shapeRestFault } from "./operation-helpers.js";
 const VALID_DECISIONS = [
   "approved",
   "rejected",
@@ -95,8 +96,10 @@ export const submitReviewDecisionRestBinding = {
     feedback: { kind: "body-field", bodyField: "feedback" },
     workflowId: { kind: "body-field", bodyField: "workflowId" }
   },
-  extractInput: async (request, pathParams) => {
-    const body = await request.json().catch(() => {
+  extractInput: async (request, pathParams, context) => {
+    const body = await readRestJsonBody(request, context).catch((error) => {
+      if (isOperationFault(error))
+        throw error;
       throw Error("Invalid JSON body");
     }), record = typeof body === "object" && body !== null && !Array.isArray(body) ? body : {};
     return {

package/dist/server/operations/suspend-workflow.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const suspendWorkflowInput: z.ZodObject<{
+    workflowId: z.ZodString;
+}, z.core.$strip>;
+declare const suspendWorkflowOutput: z.ZodUndefined;
+export type SuspendWorkflowInput = z.infer<typeof suspendWorkflowInput>;
+export type SuspendWorkflowOutput = z.infer<typeof suspendWorkflowOutput>;
+export declare const suspendWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+}, undefined>;
+export declare const suspendWorkflowRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/suspend-workflow.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { WorkflowSuspendNotSupportedError } from "../../core/engine/errors.js";
+import { shapeRestFault } from "./operation-helpers.js";
+import {
+  createSingleWorkflowControlOperation,
+  extractWorkflowIdFromPath
+} from "./single-workflow-control-operation.js";
+const suspendWorkflowInput = z.object({
+  workflowId: z.string().min(1)
+}), suspendWorkflowOutput = z.undefined();
+export const suspendWorkflowOperation = createSingleWorkflowControlOperation({
+  name: "weft.workflows.suspend",
+  summary: "Suspend a running workflow",
+  description: "Request suspension of a running workflow by `id` without terminating it. The workflow transitions to the non-terminal `suspended` status, keeps its durable checkpoint, and is later resumable via `resume`. Unlike cancellation, suspension does not run cancel handlers and does not settle the result. Suspending a workflow that is not running is a no-op. Faults with Unprocessable when the engine runs in worker execution mode (which cannot pause a run without cancelling it).",
+  destructive: !1,
+  tags: ["Workflows"],
+  inputSchema: suspendWorkflowInput,
+  outputSchema: suspendWorkflowOutput,
+  producibleFaults: ["Unprocessable"],
+  invoke: async ({ input, engine }) => {
+    await engine.suspend(input.workflowId);
+    return;
+  },
+  mapErrorToFault: ({ error, message }) => error instanceof WorkflowSuspendNotSupportedError ? { code: "Unprocessable", message, data: { reason: message } } : void 0
+}), suspendWorkflowRestBinding = {
+  method: "POST",
+  path: "/v1/workflows/:id/suspend",
+  pathParamNames: ["id"],
+  operationName: "weft.workflows.suspend",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" }
+  },
+  extractInput: async (_request, pathParams) => extractWorkflowIdFromPath(pathParams),
+  success: { kind: "empty", status: 204 },
+  shapeFault: shapeRestFault
+};

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

@@ -10,6 +10,6 @@ export declare const updateScheduleOperation: import("../operation-catalog.ts").
     scheduleId: string;
     cronExpression?: unknown;
     every?: unknown;
-}, null>;
+}, null, unknown>;
 export declare const updateScheduleRestBinding: UnknownRestBinding;
 export {};

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import { readRestJsonBody } from "../rest-body.js";
+import { invalidParamsFault, isOperationFault, shapeRestFault } from "./operation-helpers.js";
 import { mapScheduleErrorToFault, validateScheduleInputCadence } from "./schedule-faults.js";
 const updateScheduleInput = z.object({
   scheduleId: z.string().min(1),
@@ -39,11 +40,13 @@ export const updateScheduleOperation = defineOperation({
     cronExpression: { kind: "body-field", bodyField: "cronExpression" },
     every: { kind: "body-field", bodyField: "every" }
   },
-  extractInput: async (request, pathParams) => {
+  extractInput: async (request, pathParams, context) => {
     let body;
     try {
-      body = await request.json();
-    } catch {
+      body = await readRestJsonBody(request, context);
+    } catch (error) {
+      if (isOperationFault(error))
+        throw error;
       throw invalidParamsFault("Invalid JSON body");
     }
     if (typeof body !== "object" || body === null)

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

@@ -22,6 +22,6 @@ export declare const updateWorkflowOperation: import("../operation-catalog.ts").
 }, {
     updateId: string;
     result: unknown;
-}>;
+}, unknown>;
 export declare const updateWorkflowRestBinding: UnknownRestBinding;
 export {};

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

@@ -5,6 +5,7 @@ import {
   WorkflowTerminalError
 } from "../../core/updates.js";
 import { defineOperation } from "../operation-registry.js";
+import { readRestJsonBody } from "../rest-body.js";
 import { isOperationFault, shapeRestFault } from "./operation-helpers.js";
 const DEFAULT_UPDATE_TIMEOUT_MS = 30000, updateWorkflowInput = z.object({
   workflowId: z.string().min(1),
@@ -85,17 +86,20 @@ export const updateWorkflowOperation = defineOperation({
     timeout: { kind: "body-field", bodyField: "timeout" },
     idempotencyKey: { kind: "body-field", bodyField: "idempotencyKey" }
   },
-  extractInput: async (request, pathParams) => {
+  extractInput: async (request, pathParams, context) => {
     let payload, timeout, idempotencyKey;
     try {
-      const body = await request.json();
+      const body = await readRestJsonBody(request, context);
       if (typeof body === "object" && body !== null) {
         const record = body;
         payload = record.payload;
         timeout = record.timeout;
         idempotencyKey = record.idempotencyKey;
       }
-    } catch {}
+    } catch (error) {
+      if (isOperationFault(error))
+        throw error;
+    }
     return {
       workflowId: pathParams.id ?? "",
       updateName: pathParams.name ?? "",

package/dist/server/operations/worker-drain.d.ts

@@ -37,31 +37,31 @@ type WorkerDrainOperationOptions = {
 export declare function createDrainWorkerOperation(options?: WorkerDrainOperationOptions): import("../operation-catalog.ts").OperationDefinition<{
     workerId: string;
     reason?: string | undefined;
-}, WorkerDrainMutationResult>;
+}, WorkerDrainMutationResult, unknown>;
 export declare function createClearWorkerDrainOperation(options?: WorkerDrainOperationOptions): import("../operation-catalog.ts").OperationDefinition<{
     workerId: string;
-}, WorkerDrainMutationResult>;
+}, WorkerDrainMutationResult, unknown>;
 export declare function createDrainDeploymentOperation(options?: WorkerDrainOperationOptions): import("../operation-catalog.ts").OperationDefinition<{
     deploymentName: string;
     reason?: string | undefined;
-}, WorkerDrainMutationResult>;
+}, WorkerDrainMutationResult, unknown>;
 export declare function createClearDeploymentDrainOperation(options?: WorkerDrainOperationOptions): import("../operation-catalog.ts").OperationDefinition<{
     deploymentName: string;
-}, WorkerDrainMutationResult>;
+}, WorkerDrainMutationResult, unknown>;
 export declare const drainWorkerOperation: import("../operation-catalog.ts").OperationDefinition<{
     workerId: string;
     reason?: string | undefined;
-}, WorkerDrainMutationResult>;
+}, WorkerDrainMutationResult, unknown>;
 export declare const clearWorkerDrainOperation: import("../operation-catalog.ts").OperationDefinition<{
     workerId: string;
-}, WorkerDrainMutationResult>;
+}, WorkerDrainMutationResult, unknown>;
 export declare const drainDeploymentOperation: import("../operation-catalog.ts").OperationDefinition<{
     deploymentName: string;
     reason?: string | undefined;
-}, WorkerDrainMutationResult>;
+}, WorkerDrainMutationResult, unknown>;
 export declare const clearDeploymentDrainOperation: import("../operation-catalog.ts").OperationDefinition<{
     deploymentName: string;
-}, WorkerDrainMutationResult>;
+}, WorkerDrainMutationResult, unknown>;
 export declare function createDrainWorkerRestBinding(): UnknownRestBinding;
 export declare function createClearWorkerDrainRestBinding(): UnknownRestBinding;
 export declare function createDrainDeploymentRestBinding(): UnknownRestBinding;

package/dist/server/operations/worker-drain.js

@@ -1,7 +1,8 @@
 import { z } from "zod";
 import { shapeOperationFaultAsJson } from "../operation-fault.js";
 import { defineOperation } from "../operation-registry.js";
-import { invalidParamsFault } from "./operation-helpers.js";
+import { readRestTextBody } from "../rest-body.js";
+import { invalidParamsFault, isOperationFault } from "./operation-helpers.js";
 const drainReasonSchema = z.string().min(1).max(256).optional(), workerDrainInput = z.object({
   workerId: z.string().min(1),
   reason: drainReasonSchema
@@ -153,9 +154,9 @@ function createWorkerDrainRestBinding(method, operationName) {
       workerId: { kind: "path", pathParam: "workerId" },
       ...method === "POST" ? { reason: { kind: "body-field", bodyField: "reason" } } : {}
     },
-    extractInput: async (request, pathParams) => ({
+    extractInput: async (request, pathParams, context) => ({
       workerId: pathParams.workerId ?? "",
-      ...method === "POST" ? await readDrainBody(request) : {}
+      ...method === "POST" ? await readDrainBody(request, context) : {}
     }),
     success: { kind: "json", status: 200 },
     shapeSuccess: shapeDrainSuccess,
@@ -172,9 +173,9 @@ function createDeploymentDrainRestBinding(method, operationName) {
       deploymentName: { kind: "path", pathParam: "deploymentName" },
       ...method === "POST" ? { reason: { kind: "body-field", bodyField: "reason" } } : {}
     },
-    extractInput: async (request, pathParams) => ({
+    extractInput: async (request, pathParams, context) => ({
       deploymentName: pathParams.deploymentName ?? "",
-      ...method === "POST" ? await readDrainBody(request) : {}
+      ...method === "POST" ? await readDrainBody(request, context) : {}
     }),
     success: { kind: "json", status: 200 },
     shapeSuccess: shapeDrainSuccess,
@@ -187,14 +188,16 @@ function shapeDrainSuccess(output) {
     headers: { "Content-Type": "application/json" }
   });
 }
-async function readDrainBody(request) {
-  const text = await request.text();
+async function readDrainBody(request, context) {
+  const text = await readRestTextBody(request, context);
   if (text.trim().length === 0)
     return {};
   let parsed;
   try {
     parsed = JSON.parse(text);
-  } catch {
+  } catch (error) {
+    if (isOperationFault(error))
+      throw error;
     throw invalidParamsFault("Drain request body must be valid JSON");
   }
   if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))

package/dist/server/operations/workflow-events-subscription.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { type EventEnvelope } from '../workflow-event-feed.ts';
 declare const workflowEventsSubscriptionInput: z.ZodObject<{
     workflowId: z.ZodString;
     selector: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
@@ -28,13 +29,11 @@ export type WorkflowEventsSubscriptionEnvelope = z.infer<typeof workflowEventsSu
  * subscriptions. This is documented as a known v1 constraint; per-event
  * filtering is a planned future refinement.
  *
- * Access is `scoped: { workflows:read }` (NOT optionalAuth, NOT public).
- * Anonymous callers and authenticated callers without `workflows:read` are
- * both denied. The earlier policies allowed unauthenticated clients to
- * subscribe to arbitrary workflow event streams — a real exposure the
- * security committee flagged. Operators running `serve({ engine })`
- * without auth must add an authentication layer before exposing this
- * endpoint to untrusted networks.
+ * Access is selector-specific: event envelopes require `events:read`, while
+ * token-stream envelopes require `streams:read`. Anonymous callers and
+ * authenticated callers without the matching scope are denied. Operators
+ * running `serve({ engine })` without auth must add an authentication layer
+ * before exposing this endpoint to untrusted networks.
  */
 export declare const workflowEventsSubscriptionOperation: import("../operation-catalog.ts").OperationDefinition<{
     workflowId: string;
@@ -43,5 +42,5 @@ export declare const workflowEventsSubscriptionOperation: import("../operation-c
 }, {
     subscriptionId: string;
     cursor: string;
-}>;
+}, EventEnvelope>;
 export {};