@lostgradient/weft 0.2.0

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

@@ -0,0 +1,181 @@
+import { z } from "zod";
+import {
+  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 { defineOperation } from "../operation-registry.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+const startWorkflowInput = z.object({
+  type: z.unknown().describe("Workflow type name. Runtime validation requires a non-empty string."),
+  input: z.unknown().optional(),
+  id: z.unknown().optional(),
+  executionTimeout: z.unknown().optional(),
+  startAt: z.unknown().optional(),
+  startAfter: z.unknown().optional(),
+  tags: z.unknown().optional(),
+  idempotencyKey: z.unknown().optional(),
+  searchAttributes: z.unknown().optional()
+}), startWorkflowOutput = z.object({
+  id: z.string()
+});
+function validateStartWorkflowInput(input, lookupSearchAttributeSchema) {
+  if (typeof input.type !== "string" || input.type.length === 0)
+    throw invalidParamsFault("Missing required field: type");
+  const type = input.type;
+  let options;
+  try {
+    options = buildStartWorkflowOptions(input, lookupSearchAttributeSchema(type));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw invalidParamsFault(message);
+  }
+  return { type, options };
+}
+function resolveStartWorkflowAccess(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (error instanceof WorkflowNotRegisteredError)
+    throw invalidParamsFault(message);
+  if (error instanceof WorkflowAlreadyExistsError)
+    throw {
+      code: "Conflict",
+      message,
+      data: { reason: message }
+    };
+  if (error instanceof StartWorkflowValidationError)
+    throw invalidParamsFault(message);
+  throw {
+    code: "EngineFailure",
+    message,
+    data: {}
+  };
+}
+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.",
+  destructive: !1,
+  tags: ["Workflows"],
+  inputSchema: startWorkflowInput,
+  outputSchema: startWorkflowOutput,
+  access: { kind: "public" },
+  producibleFaults: ["Conflict"],
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const typedEngine = runtimeWorkflowEngine(engine), { type, options } = validateStartWorkflowInput(input, (validType) => {
+      return typedEngine.getWorkflowDefinition(validType)?.searchAttributes;
+    });
+    try {
+      return { id: (await typedEngine.start(type, input.input, options)).id };
+    } catch (error) {
+      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 = {
+  method: "POST",
+  path: "/v1/workflows",
+  pathParamNames: [],
+  operationName: "weft.workflows.start",
+  inputSources: {
+    type: { kind: "body-field", bodyField: "type" },
+    input: { kind: "body-field", bodyField: "input" },
+    id: { kind: "body-field", bodyField: "id" },
+    executionTimeout: { kind: "body-field", bodyField: "executionTimeout" },
+    startAt: { kind: "body-field", bodyField: "startAt" },
+    startAfter: { kind: "body-field", bodyField: "startAfter" },
+    tags: { kind: "body-field", bodyField: "tags" },
+    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
+    };
+  },
+  success: { kind: "json", status: 201 },
+  shapeFault: shapeRestFault
+};

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

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const storageGetInput: z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$strip>;
+declare const storagePutInput: z.ZodObject<{
+    key: z.ZodString;
+    value: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+}, z.core.$strip>;
+declare const storageDeleteInput: z.ZodObject<{
+    key: z.ZodString;
+}, z.core.$strip>;
+declare const storageScanInput: z.ZodObject<{
+    prefix: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    reverse: z.ZodOptional<z.ZodBoolean>;
+    gt: z.ZodOptional<z.ZodString>;
+    gte: z.ZodOptional<z.ZodString>;
+    lt: z.ZodOptional<z.ZodString>;
+    lte: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const storageBatchInput: z.ZodObject<{
+    operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"put">;
+        key: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"delete">;
+        key: z.ZodString;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+declare const storageConditionalBatchInput: z.ZodObject<{
+    conditions: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        expectedValue: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    operations: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"put">;
+        key: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"delete">;
+        key: z.ZodString;
+    }, z.core.$strip>], "type">>;
+}, z.core.$strip>;
+declare const storageConditionalBatchOutput: z.ZodObject<{
+    applied: z.ZodBoolean;
+}, z.core.$strip>;
+export type StorageGetInput = z.infer<typeof storageGetInput>;
+export type StoragePutInput = z.infer<typeof storagePutInput>;
+export type StorageDeleteInput = z.infer<typeof storageDeleteInput>;
+export type StorageScanInput = z.infer<typeof storageScanInput>;
+type StorageScanEntry = {
+    readonly key: string;
+    readonly value: string;
+};
+export type StorageScanOutput = AsyncIterable<StorageScanEntry>;
+export type StorageBatchInput = z.infer<typeof storageBatchInput>;
+export type StorageConditionalBatchInput = z.infer<typeof storageConditionalBatchInput>;
+export type StorageConditionalBatchOutput = z.infer<typeof storageConditionalBatchOutput>;
+export declare const storageGetOperation: import("../operation-catalog.ts").OperationDefinition<{
+    key: string;
+}, Uint8Array<ArrayBufferLike> | null>;
+export declare const storagePutOperation: import("../operation-catalog.ts").OperationDefinition<{
+    key: string;
+    value: Uint8Array<ArrayBuffer>;
+}, null>;
+export declare const storageDeleteOperation: import("../operation-catalog.ts").OperationDefinition<{
+    key: string;
+}, null>;
+export declare const storageScanOperation: import("../operation-catalog.ts").OperationDefinition<{
+    prefix: string;
+    limit?: number | undefined;
+    reverse?: boolean | undefined;
+    gt?: string | undefined;
+    gte?: string | undefined;
+    lt?: string | undefined;
+    lte?: string | undefined;
+}, StorageScanOutput>;
+export declare const storageBatchOperation: import("../operation-catalog.ts").OperationDefinition<{
+    operations: ({
+        type: "put";
+        key: string;
+        value: string;
+    } | {
+        type: "delete";
+        key: string;
+    })[];
+}, null>;
+export declare const storageConditionalBatchOperation: import("../operation-catalog.ts").OperationDefinition<{
+    conditions: {
+        key: string;
+        expectedValue: string | null;
+    }[];
+    operations: ({
+        type: "put";
+        key: string;
+        value: string;
+    } | {
+        type: "delete";
+        key: string;
+    })[];
+}, {
+    applied: boolean;
+}>;
+export declare const storageGetRestBinding: UnknownRestBinding;
+export declare const storagePutRestBinding: UnknownRestBinding;
+export declare const storageDeleteRestBinding: UnknownRestBinding;
+export declare const storageScanRestBinding: UnknownRestBinding;
+export declare const storageBatchRestBinding: UnknownRestBinding;
+export declare const storageConditionalBatchRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/storage.js

@@ -0,0 +1,358 @@
+import { z } from "zod";
+import { decodeBase64ToBytes, encodeBytesToBase64 } from "../../storage/byte-encoding.js";
+import {
+  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";
+const storageReadAccess = {
+  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"] }
+  ]
+}, httpOnlyStorageTransports = {
+  http: !0,
+  jsonRpcHttp: !1,
+  jsonRpcStdio: !1,
+  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(),
+  reverse: z.boolean().optional(),
+  gt: z.string().optional(),
+  gte: z.string().optional(),
+  lt: z.string().optional(),
+  lte: z.string().optional()
+}), storageBatchOperationInput = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("put"), key: z.string().min(1), value: z.string() }),
+  z.object({ type: z.literal("delete"), key: z.string().min(1) })
+]), 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)
+}), 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))
+    raiseFault(operation, {
+      code: "Unauthorized",
+      message: "authentication required",
+      data: { reason: "authentication required" }
+    });
+  if (principal.hasScope("storage:admin"))
+    return engine.storage;
+  raiseFault(operation, {
+    code: "Forbidden",
+    message: "Raw storage access requires storage:admin.",
+    data: { reason: "Raw storage access requires storage:admin." }
+  });
+}
+function scanOptions(input) {
+  return {
+    ...input.limit === void 0 ? {} : { limit: input.limit },
+    ...input.reverse === void 0 ? {} : { reverse: input.reverse },
+    ...input.gt === void 0 ? {} : { gt: input.gt },
+    ...input.gte === void 0 ? {} : { gte: input.gte },
+    ...input.lt === void 0 ? {} : { lt: input.lt },
+    ...input.lte === void 0 ? {} : { lte: input.lte }
+  };
+}
+function decodeBatchOperation(operation) {
+  if (operation.type === "put")
+    return {
+      type: "put",
+      key: operation.key,
+      value: decodeStorageBytes(operation.value, "Storage batch operation value must be base64.")
+    };
+  return { type: "delete", key: operation.key };
+}
+function decodeStorageBytes(value, message) {
+  try {
+    return decodeBase64ToBytes(value);
+  } catch {
+    throw invalidParamsFault(message);
+  }
+}
+function decodeCondition(condition) {
+  return {
+    key: condition.key,
+    expectedValue: condition.expectedValue === null ? null : decodeStorageBytes(condition.expectedValue, "Storage conditional batch expectedValue must be base64.")
+  };
+}
+async function readJsonRequestBody(request) {
+  try {
+    return await request.json();
+  } catch {
+    throw invalidParamsFault("Request body must be valid JSON.");
+  }
+}
+function parseBooleanQuery(value) {
+  if (value === null)
+    return;
+  if (value === "true")
+    return !0;
+  if (value === "false")
+    return !1;
+  throw invalidParamsFault('Query parameter "reverse" must be "true" or "false".');
+}
+function parseLimitQuery(value) {
+  if (value === null)
+    return;
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit <= 0)
+    throw invalidParamsFault('Query parameter "limit" must be a positive integer.');
+  return limit;
+}
+function extractStorageScanInput(request) {
+  const url = new URL(request.url), input = {
+    prefix: url.searchParams.get("prefix") ?? ""
+  }, limit = parseLimitQuery(url.searchParams.get("limit")), reverse = parseBooleanQuery(url.searchParams.get("reverse"));
+  if (limit !== void 0)
+    input.limit = limit;
+  if (reverse !== void 0)
+    input.reverse = reverse;
+  for (const field of ["gt", "gte", "lt", "lte"]) {
+    const value = url.searchParams.get(field);
+    if (value !== null)
+      input[field] = value;
+  }
+  return input;
+}
+function storageKeyFromPath(pathParams) {
+  return pathParams.key ?? "";
+}
+function createNoContentResponse() {
+  return new Response(null, { status: 204 });
+}
+function createBinaryResponse(value) {
+  if (value === null)
+    return new Response(null, { status: 404 });
+  return new Response(value, {
+    status: 200,
+    headers: { "Content-Type": "application/octet-stream" }
+  });
+}
+function createNdjsonResponse(entries) {
+  const encoder = new TextEncoder, iterator = entries[Symbol.asyncIterator](), body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const entry = await iterator.next();
+        if (entry.done === !0) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(encoder.encode(`${JSON.stringify(entry.value)}
+`));
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel() {
+      await iterator.return?.();
+    }
+  }, { highWaterMark: 0 });
+  return new Response(body, {
+    status: 200,
+    headers: { "Content-Type": "application/x-ndjson" }
+  });
+}
+async function* scanStorage(storage, prefix, options) {
+  for await (const [key, value] of storage.scan(prefix, options))
+    yield { key, value: encodeBytesToBase64(value) };
+}
+export const storageGetOperation = defineOperation({
+  name: "weft.storage.get",
+  mcpExposable: !1,
+  summary: "Get a raw storage value",
+  destructive: !1,
+  tags: ["Storage"],
+  inputSchema: storageGetInput,
+  outputSchema: storageGetOutput,
+  access: storageReadAccess,
+  discoverable: !0,
+  transports: httpOnlyStorageTransports,
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine, principal }) => {
+    return resolveAuthorizedStorage(engine, principal, storageGetOperation).get(input.key);
+  }
+}), storagePutOperation = defineOperation({
+  name: "weft.storage.put",
+  mcpExposable: !1,
+  summary: "Put a raw storage value",
+  destructive: !0,
+  tags: ["Storage"],
+  inputSchema: storagePutInput,
+  outputSchema: emptyOutput,
+  access: storageWriteAccess,
+  discoverable: !0,
+  transports: httpOnlyStorageTransports,
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine, principal }) => {
+    await resolveAuthorizedStorage(engine, principal, storagePutOperation).put(input.key, input.value);
+    return null;
+  }
+}), storageDeleteOperation = defineOperation({
+  name: "weft.storage.delete",
+  mcpExposable: !1,
+  summary: "Delete a raw storage value",
+  destructive: !0,
+  tags: ["Storage"],
+  inputSchema: storageDeleteInput,
+  outputSchema: emptyOutput,
+  access: storageWriteAccess,
+  discoverable: !0,
+  transports: httpOnlyStorageTransports,
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine, principal }) => {
+    await resolveAuthorizedStorage(engine, principal, storageDeleteOperation).delete(input.key);
+    return null;
+  }
+}), storageScanOperation = defineOperation({
+  name: "weft.storage.scan",
+  mcpExposable: !1,
+  summary: "Scan raw storage values",
+  destructive: !1,
+  tags: ["Storage"],
+  inputSchema: storageScanInput,
+  outputSchema: storageScanOutput,
+  access: storageReadAccess,
+  discoverable: !0,
+  transports: httpOnlyStorageTransports,
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine, principal }) => {
+    const storage = resolveAuthorizedStorage(engine, principal, storageScanOperation);
+    return scanStorage(storage, input.prefix, scanOptions(input));
+  }
+}), storageBatchOperation = defineOperation({
+  name: "weft.storage.batch",
+  mcpExposable: !1,
+  summary: "Apply a raw storage batch",
+  destructive: !0,
+  tags: ["Storage"],
+  inputSchema: storageBatchInput,
+  outputSchema: emptyOutput,
+  access: storageWriteAccess,
+  discoverable: !0,
+  transports: httpOnlyStorageTransports,
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine, principal }) => {
+    await resolveAuthorizedStorage(engine, principal, storageBatchOperation).batch(input.operations.map(decodeBatchOperation));
+    return null;
+  }
+}), storageConditionalBatchOperation = defineOperation({
+  name: "weft.storage.conditionalbatch",
+  mcpExposable: !1,
+  summary: "Apply a raw storage conditional batch",
+  destructive: !0,
+  tags: ["Storage"],
+  inputSchema: storageConditionalBatchInput,
+  outputSchema: storageConditionalBatchOutput,
+  access: storageConditionalBatchAccess,
+  discoverable: !0,
+  transports: httpOnlyStorageTransports,
+  producibleFaults: ["NotImplemented"],
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine, principal }) => {
+    const storage = resolveAuthorizedStorage(engine, principal, storageConditionalBatchOperation);
+    if (!storage.capabilities().conditionalBatch)
+      raiseFault(storageConditionalBatchOperation, {
+        code: "NotImplemented",
+        message: "This storage backend reports capabilities().conditionalBatch: false.",
+        data: {}
+      });
+    return { applied: await storageConditionalBatch(storage, input.conditions.map(decodeCondition), input.operations.map(decodeBatchOperation)) };
+  }
+}), storageGetRestBinding = {
+  method: "GET",
+  path: "/v1/storage/:key",
+  pathParamNames: ["key"],
+  operationName: "weft.storage.get",
+  inputSources: {
+    key: { kind: "path", pathParam: "key" }
+  },
+  extractInput: async (_request, pathParams) => ({ key: storageKeyFromPath(pathParams) }),
+  success: { kind: "streaming", mediaType: "application/octet-stream" },
+  shapeSuccess: (output) => createBinaryResponse(output),
+  shapeFault: shapeRestFault
+}, storagePutRestBinding = {
+  method: "PUT",
+  path: "/v1/storage/:key",
+  pathParamNames: ["key"],
+  operationName: "weft.storage.put",
+  inputSources: {
+    key: { kind: "path", pathParam: "key" },
+    value: { kind: "body", mediaType: "application/octet-stream" }
+  },
+  extractInput: async (request, pathParams) => ({
+    key: storageKeyFromPath(pathParams),
+    value: new Uint8Array(await request.arrayBuffer())
+  }),
+  success: { kind: "empty", status: 204 },
+  shapeSuccess: createNoContentResponse,
+  shapeFault: shapeRestFault
+}, storageDeleteRestBinding = {
+  method: "DELETE",
+  path: "/v1/storage/:key",
+  pathParamNames: ["key"],
+  operationName: "weft.storage.delete",
+  inputSources: {
+    key: { kind: "path", pathParam: "key" }
+  },
+  extractInput: async (_request, pathParams) => ({ key: storageKeyFromPath(pathParams) }),
+  success: { kind: "empty", status: 204 },
+  shapeSuccess: createNoContentResponse,
+  shapeFault: shapeRestFault
+}, storageScanRestBinding = {
+  method: "GET",
+  path: "/v1/storage",
+  pathParamNames: [],
+  operationName: "weft.storage.scan",
+  inputSources: {
+    prefix: { kind: "query", queryParam: "prefix" },
+    limit: { kind: "query", queryParam: "limit" },
+    reverse: { kind: "query", queryParam: "reverse" },
+    gt: { kind: "query", queryParam: "gt" },
+    gte: { kind: "query", queryParam: "gte" },
+    lt: { kind: "query", queryParam: "lt" },
+    lte: { kind: "query", queryParam: "lte" }
+  },
+  extractInput: async (request) => extractStorageScanInput(request),
+  success: { kind: "streaming", mediaType: "application/x-ndjson" },
+  shapeSuccess: (output) => createNdjsonResponse(output),
+  shapeFault: shapeRestFault
+}, storageBatchRestBinding = {
+  method: "POST",
+  path: "/v1/storage/-/batch",
+  pathParamNames: [],
+  operationName: "weft.storage.batch",
+  inputSources: {
+    operations: { kind: "body-field", bodyField: "operations" }
+  },
+  extractInput: async (request) => readJsonRequestBody(request),
+  success: { kind: "empty", status: 204 },
+  shapeSuccess: createNoContentResponse,
+  shapeFault: shapeRestFault
+}, storageConditionalBatchRestBinding = {
+  method: "POST",
+  path: "/v1/storage/-/conditional-batch",
+  pathParamNames: [],
+  operationName: "weft.storage.conditionalbatch",
+  inputSources: {
+    conditions: { kind: "body-field", bodyField: "conditions" },
+    operations: { kind: "body-field", bodyField: "operations" }
+  },
+  extractInput: async (request) => readJsonRequestBody(request),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => Response.json(output),
+  shapeFault: shapeRestFault
+};

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import type { StoredStreamChunk } from '../../core/context.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const streamWorkflowSseInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    after: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type StreamWorkflowSseInput = z.infer<typeof streamWorkflowSseInput>;
+export type StreamWorkflowSseOutput = {
+    chunks: StoredStreamChunk[];
+};
+export declare const streamWorkflowSseOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    after?: unknown;
+}, StreamWorkflowSseOutput>;
+export declare const streamWorkflowSseRestBinding: UnknownRestBinding;
+export {};