@lostgradient/weft 0.3.0 → 0.5.0

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

@@ -10,10 +10,10 @@ export declare const purgeWorkflowsOperation: import("../operation-catalog.ts").
     attributes?: {
         key: string;
         value?: import("../../index.ts").SearchAttributeValue | undefined;
-        gt?: import("../../index.ts").SearchAttributeValue | undefined;
-        lt?: import("../../index.ts").SearchAttributeValue | undefined;
-        gte?: import("../../index.ts").SearchAttributeValue | undefined;
-        lte?: import("../../index.ts").SearchAttributeValue | undefined;
+        gt?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
+        lt?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
+        gte?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
+        lte?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
     }[] | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
@@ -37,5 +37,5 @@ export declare const purgeWorkflowsOperation: import("../operation-catalog.ts").
         lte?: number | undefined;
         lt?: number | undefined;
     } | undefined;
-}, PurgeResult>;
+}, PurgeResult, unknown>;
 export declare const purgeWorkflowsRestBinding: UnknownRestBinding;

package/dist/server/operations/purge-workflows.js

@@ -43,8 +43,8 @@ export const purgeWorkflowsOperation = defineOperation({
   pathParamNames: [],
   operationName: "weft.workflows.purge",
   inputSources: {},
-  extractInput: async (request) => {
-    const raw = await readOptionalJsonBody(request);
+  extractInput: async (request, _pathParams, context) => {
+    const raw = await readOptionalJsonBody(request, context);
     try {
       return { ...parseBulkListFilterFromBody(raw) };
     } catch (error) {

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

@@ -13,7 +13,7 @@ export declare const queryWorkflowOperation: import("../operation-catalog.ts").O
     workflowId: string;
     queryName: string;
     input?: unknown;
-}, QueryWorkflowOutput>;
+}, QueryWorkflowOutput, unknown>;
 export declare const queryWorkflowRestBinding: UnknownRestBinding;
 export declare const queryWorkflowWithInputRestBinding: UnknownRestBinding;
 export {};

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

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
+import { readRestTextBody } from "../rest-body.js";
 import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
 const queryWorkflowInput = z.object({
   workflowId: z.string().min(1),
@@ -71,8 +72,8 @@ export const queryWorkflowRestBinding = {
     queryName: { kind: "path", pathParam: "name" },
     input: { kind: "body-field", bodyField: "input" }
   },
-  extractInput: async (request, pathParams) => {
-    const rawBody = await request.text();
+  extractInput: async (request, pathParams, context) => {
+    const rawBody = await readRestTextBody(request, context);
     if (rawBody.trim().length === 0)
       return {
         workflowId: pathParams.id ?? "",

package/dist/server/operations/recover-all.d.ts

@@ -8,6 +8,6 @@ export type RecoverAllInput = z.infer<typeof recoverAllInput>;
 export type RecoverAllOutput = z.infer<typeof recoverAllOutput>;
 export declare const recoverAllOperation: import("../operation-catalog.ts").OperationDefinition<Record<string, never>, {
     recovered: string[];
-}>;
+}, unknown>;
 export declare const recoverAllRestBinding: UnknownRestBinding;
 export {};

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

@@ -23,6 +23,6 @@ export type ReplayWorkflowOutput = WorkflowReplay;
 export declare const replayWorkflowOperation: import("../operation-catalog.ts").OperationDefinition<{
     workflowId: string;
     step: string | number;
-}, WorkflowReplay>;
+}, WorkflowReplay, unknown>;
 export declare const replayWorkflowRestBinding: UnknownRestBinding;
 export {};

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

@@ -8,6 +8,6 @@ export type ResumeScheduleInput = z.infer<typeof resumeScheduleInput>;
 export type ResumeScheduleOutput = z.infer<typeof resumeScheduleOutput>;
 export declare const resumeScheduleOperation: import("../operation-catalog.ts").OperationDefinition<{
     scheduleId: string;
-}, undefined>;
+}, undefined, unknown>;
 export declare const resumeScheduleRestBinding: UnknownRestBinding;
 export {};

package/dist/server/operations/set-workflow-attributes.d.ts

@@ -14,6 +14,6 @@ export declare const setWorkflowAttributesOperation: import("../operation-catalo
     attributes?: unknown;
 }, {
     ok: true;
-}>;
+}, unknown>;
 export declare const setWorkflowAttributesRestBinding: UnknownRestBinding;
 export {};

package/dist/server/operations/set-workflow-attributes.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 setWorkflowAttributesInput = z.object({
   workflowId: z.string().min(1),
   attributes: z.unknown().optional()
@@ -50,8 +51,10 @@ export const setWorkflowAttributesRestBinding = {
     workflowId: { kind: "path", pathParam: "id" },
     attributes: { kind: "body-field", bodyField: "attributes" }
   },
-  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");
     });
     if (body === null)

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

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { isSignalIdWithinByteLimit } from "../../core/signal-id.js";
-import { shapeRestFault } from "./operation-helpers.js";
+import { readRestJsonBody } from "../rest-body.js";
+import { isOperationFault, shapeRestFault } from "./operation-helpers.js";
 import {
   createSingleWorkflowControlOperation,
   extractWorkflowIdFromPath
@@ -43,8 +44,12 @@ export const signalWorkflowRestBinding = {
     signalName: { kind: "path", pathParam: "name" },
     payload: { kind: "body-field", bodyField: "payload" }
   },
-  extractInput: async (request, pathParams) => {
-    const body = await request.json().catch(() => null), payload = typeof body === "object" && body !== null ? body.payload : void 0, signalId = typeof body === "object" && body !== null ? body.signalId : void 0;
+  extractInput: async (request, pathParams, context) => {
+    const body = await readRestJsonBody(request, context).catch((error) => {
+      if (isOperationFault(error))
+        throw error;
+      return null;
+    }), payload = typeof body === "object" && body !== null ? body.payload : void 0, signalId = typeof body === "object" && body !== null ? body.signalId : void 0;
     return {
       ...extractWorkflowIdFromPath(pathParams),
       signalName: pathParams.name ?? "",

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

@@ -1,10 +1,12 @@
 import { z } from "zod";
+import { WorkflowNotFoundError } from "../../core/engine/errors.js";
 import {
   coerceStartWorkflowTags,
   StartWorkflowValidationError
 } from "../../core/start-workflow-validation.js";
 import { defineOperation } from "../operation-registry.js";
-import { jsonErrorResponse, shapeRestFault } from "./operation-helpers.js";
+import { readRestJsonBody } from "../rest-body.js";
+import { isOperationFault, jsonErrorResponse, shapeRestFault } from "./operation-helpers.js";
 const singleWorkflowTagMutationInput = z.object({
   workflowId: z.string().min(1),
   tags: z.unknown().optional()
@@ -50,8 +52,10 @@ export function createSingleWorkflowTagMutationRestBinding(configuration) {
       workflowId: { kind: "path", pathParam: "id" },
       tags: { kind: "body-field", bodyField: "tags" }
     },
-    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");
       });
       if (!isJsonObject(body))
@@ -79,6 +83,12 @@ function shapeSingleWorkflowTagMutationFault(fault) {
 }
 function mapTagMutationErrorToFault(error, workflowId) {
   const message = faultMessage(error);
+  if (error instanceof WorkflowNotFoundError)
+    return {
+      code: "NotFound",
+      message,
+      data: { resource: "workflow", identifier: workflowId, weftCode: error.code }
+    };
   if (message.includes("not found"))
     return {
       code: "NotFound",

package/dist/server/operations/start-or-signal-workflow.d.ts

@@ -16,6 +16,10 @@ declare const startOrSignalWorkflowInput: z.ZodObject<{
 }, z.core.$strip>;
 declare const startOrSignalWorkflowOutput: z.ZodObject<{
     id: z.ZodString;
+    outcome: z.ZodEnum<{
+        started: "started";
+        signalled: "signalled";
+    }>;
 }, z.core.$strip>;
 export type StartOrSignalWorkflowInput = z.infer<typeof startOrSignalWorkflowInput>;
 export type StartOrSignalWorkflowOutput = z.infer<typeof startOrSignalWorkflowOutput>;
@@ -34,6 +38,7 @@ export declare const startOrSignalWorkflowOperation: import("../operation-catalo
     searchAttributes?: unknown;
 }, {
     id: string;
-}>;
+    outcome: "started" | "signalled";
+}, unknown>;
 export declare const startOrSignalWorkflowRestBinding: UnknownRestBinding;
 export {};

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

@@ -10,6 +10,10 @@ import { StartWorkflowValidationError } from "../../core/start-workflow-validati
 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 startOrSignalWorkflowInput = z.object({
   type: z.unknown().describe("Workflow type name. Runtime validation requires a non-empty string."),
   input: z.unknown().optional(),
@@ -24,7 +28,8 @@ const startOrSignalWorkflowInput = z.object({
   idempotencyKey: z.unknown().optional(),
   searchAttributes: z.unknown().optional()
 }), startOrSignalWorkflowOutput = z.object({
-  id: z.string()
+  id: z.string(),
+  outcome: z.enum(["started", "signalled"])
 });
 function validateStartOrSignalWorkflowInput(input, lookupSearchAttributeSchema) {
   if (typeof input.type !== "string" || input.type.length === 0)
@@ -53,12 +58,12 @@ function assertConvergenceTokenProvided(signalId, idempotencyKey) {
 function resolveStartOrSignalWorkflowFault(error) {
   const message = error instanceof Error ? error.message : String(error);
   if (error instanceof WorkflowNotRegisteredError)
-    throw invalidParamsFault(message);
+    throw invalidParamsFault(message, error.code);
   if (error instanceof StartOrSignalConflictError || error instanceof IdempotencyKeyPurgedError)
     throw {
       code: "Conflict",
       message,
-      data: { reason: message }
+      data: { reason: message, weftCode: error.code }
     };
   if (error instanceof StartWorkflowValidationError)
     throw invalidParamsFault(message);
@@ -86,7 +91,8 @@ export const startOrSignalWorkflowOperation = defineOperation({
       return typedEngine.getWorkflowDefinition(validType)?.searchAttributes;
     });
     try {
-      return { id: (await typedEngine.startOrSignal(type, input.input, signal, options)).id };
+      const { handle, outcome } = await typedEngine.startOrSignal(type, input.input, signal, options);
+      return { id: handle.id, outcome };
     } catch (error) {
       resolveStartOrSignalWorkflowFault(error);
     }
@@ -110,29 +116,13 @@ export const startOrSignalWorkflowOperation = defineOperation({
     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;
+  extractInput: async (request, _pathParams, context) => {
+    const record = await parseStartWorkflowRequestRecord(request, context);
     return {
-      type: record.type,
-      input: record.input,
+      ...extractSharedStartWorkflowRestFields(record),
       signalName: record.signalName,
       signalPayload: record.signalPayload,
-      signalId: record.signalId,
-      id: record.id,
-      executionTimeout: record.executionTimeout,
-      startAt: record.startAt,
-      startAfter: record.startAfter,
-      tags: record.tags,
-      idempotencyKey: record.idempotencyKey,
-      searchAttributes: record.searchAttributes
+      signalId: record.signalId
     };
   },
   success: { kind: "json", status: 201 },

package/dist/server/operations/start-workflow-options.d.ts

@@ -20,6 +20,12 @@ export type SharedStartWorkflowOptionInput = {
  * `executionTimeout`, `startAt`/`startAfter`, `tags`, `idempotencyKey`, and
  * `searchAttributes` (a new field added here covers both surfaces at once). Throws
  * {@link StartWorkflowValidationError} on any malformed field.
+ *
+ * `onTerminalConflict` is intentionally NOT part of this shared path: it is an
+ * in-process `engine.start`-only policy (its purge-and-restart would make the
+ * transport `weft.workflows.start` operation conditionally destructive and would
+ * violate `startOrSignal`'s at-most-once identity), so it is not exposed over
+ * REST/JSON-RPC. See follow-up issue #489.
  */
 export declare function buildSharedStartWorkflowOptions(input: SharedStartWorkflowOptionInput, searchAttributeSchema: SearchAttributeSchema | undefined): StartOptions;
 /**

package/dist/server/operations/start-workflow-rest-input.d.ts

@@ -0,0 +1,14 @@
+import type { RestInputContext } from '../rest-binding.ts';
+export type SharedStartWorkflowRestFields = {
+    readonly type: unknown;
+    readonly input: unknown;
+    readonly id: unknown;
+    readonly executionTimeout: unknown;
+    readonly startAt: unknown;
+    readonly startAfter: unknown;
+    readonly tags: unknown;
+    readonly idempotencyKey: unknown;
+    readonly searchAttributes: unknown;
+};
+export declare function parseStartWorkflowRequestRecord(request: Request, context?: RestInputContext): Promise<Record<string, unknown>>;
+export declare function extractSharedStartWorkflowRestFields(record: Record<string, unknown>): SharedStartWorkflowRestFields;

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

@@ -0,0 +1,31 @@
+import { readRestJsonBody } from "../rest-body.js";
+import { invalidParamsFault, isOperationFault } from "./operation-helpers.js";
+function isJsonObjectLikeRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+export async function parseStartWorkflowRequestRecord(request, context) {
+  let body;
+  try {
+    body = await readRestJsonBody(request, context);
+  } catch (error) {
+    if (isOperationFault(error))
+      throw error;
+    throw invalidParamsFault("Invalid JSON body");
+  }
+  if (body === null || typeof body !== "object")
+    throw invalidParamsFault("Request body must be a JSON object");
+  return isJsonObjectLikeRecord(body) ? body : {};
+}
+export function extractSharedStartWorkflowRestFields(record) {
+  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
+  };
+}

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

@@ -28,6 +28,6 @@ export declare const startWorkflowOperation: import("../operation-catalog.ts").O
     searchAttributes?: unknown;
 }, {
     id: string;
-}>;
+}, unknown>;
 export declare const startWorkflowRestBinding: UnknownRestBinding;
 export {};

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

@@ -9,6 +9,10 @@ import { StartWorkflowValidationError } from "../../core/start-workflow-validati
 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(),
@@ -38,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);
+    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);
@@ -92,27 +96,8 @@ export const startWorkflowOperation = defineOperation({
     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/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)