@lostgradient/weft 0.12.0 → 0.13.0

package/dist/server/handler/route-dispatch.js

@@ -94,19 +94,19 @@ export const DIRECT_ROUTE_EXECUTORS = {
     return jsonResponse(generateMcpDiscovery({ origin: originResolution.origin }));
   },
   openApiDocument: async ({ options }) => jsonResponse(generateOpenApiDocument({
-    registry: options?.operationRegistry ?? defaultOperationRegistry(),
+    registry: options?.operationRegistry ?? defaultOperationRegistry(options),
     ...options?.restBindings !== void 0 ? { restBindings: options.restBindings } : {},
     ...options?.supportedAuthenticationSchemes !== void 0 ? { supportedSchemes: options.supportedAuthenticationSchemes } : {},
     ...options?.discoveryInfo !== void 0 ? { discoveryInfo: options.discoveryInfo } : {}
   })),
   openRpcDocument: async ({ engine, options }) => jsonResponse(generateOpenRpcDocument({
-    registry: options?.operationRegistry ?? defaultOperationRegistry(),
+    registry: options?.operationRegistry ?? defaultOperationRegistry(options),
     transports: ["http", "websocket"],
     mcpTools: listMcpTools(engine),
     ...options?.discoveryInfo !== void 0 ? { discoveryInfo: options.discoveryInfo } : {}
   })),
   asyncApiDocument: async ({ options }) => jsonResponse(generateAsyncApiDocument({
-    registry: options?.operationRegistry ?? defaultOperationRegistry(),
+    registry: options?.operationRegistry ?? defaultOperationRegistry(options),
     ...options?.restBindings !== void 0 ? { restBindings: options.restBindings } : {},
     ...options?.discoveryInfo !== void 0 ? { discoveryInfo: options.discoveryInfo } : {}
   }))
@@ -173,7 +173,22 @@ export function isOperationFaultLike(value) {
   return typeof fields.code === "string" && Object.hasOwn(FAULT_CODE_TO_HTTP_STATUS, fields.code) && typeof fields.message === "string" && typeof fields.data === "object" && fields.data !== null && !Array.isArray(fields.data);
 }
 let defaultOperationRegistryCache;
-export function defaultOperationRegistry() {
+const missingWorkerRegistryCacheKey = {}, missingTaskQueueCacheKey = {}, liveOperationRegistryCache = new WeakMap;
+export function defaultOperationRegistry(options) {
+  if (options?.workerRegistry !== void 0 || options?.taskQueue !== void 0) {
+    const workerRegistryCacheKey = options.workerRegistry ?? missingWorkerRegistryCacheKey, taskQueueCacheKey = options.taskQueue ?? missingTaskQueueCacheKey;
+    let registriesByTaskQueue = liveOperationRegistryCache.get(workerRegistryCacheKey);
+    if (registriesByTaskQueue === void 0) {
+      registriesByTaskQueue = new WeakMap;
+      liveOperationRegistryCache.set(workerRegistryCacheKey, registriesByTaskQueue);
+    }
+    let registry = registriesByTaskQueue.get(taskQueueCacheKey);
+    if (registry === void 0) {
+      registry = createLiveOperationRegistry(options);
+      registriesByTaskQueue.set(taskQueueCacheKey, registry);
+    }
+    return registry;
+  }
   if (defaultOperationRegistryCache === void 0)
     defaultOperationRegistryCache = createLiveOperationRegistry();
   return defaultOperationRegistryCache;

package/dist/server/index.d.ts

@@ -23,7 +23,7 @@ export { WorkerRegistry } from '../worker/registry.ts';
 export type { RoutingPolicy } from '../worker/registry.ts';
 export type { DiscoveryInfo } from './discovery-info.ts';
 export type { SchedulingPolicy } from './task-queue-types.ts';
-export type { TaskQueue } from './task-queue.ts';
+export { TaskQueue } from './task-queue.ts';
 /**
  * Static route patterns at which an externally supplied dashboard shell is
  * served. Weft no longer bundles a dashboard, but `serve({ dashboard })`

package/dist/server/index.js

@@ -33,6 +33,7 @@ export {
   validateRateLimitConfig
 } from "./authentication.js";
 export { WorkerRegistry } from "../worker/registry.js";
+export { TaskQueue } from "./task-queue.js";
 export const DASHBOARD_PAGE_ROUTES = [
   "/",
   "/workflows",

package/dist/server/interactive-operations.js

@@ -1,6 +1,8 @@
 export const INTERACTIVE_OPERATION_NAMES = [
   "weft.workflows.start",
   "weft.workflows.get",
+  "weft.workflows.scheduleprovenance.get",
+  "weft.workflows.finalizer.get",
   "weft.workflows.list",
   "weft.workflows.signal",
   "weft.workflows.query",

package/dist/server/openapi-error-responses.js

@@ -2,11 +2,62 @@ import { UNIVERSAL_FAULT_DEFAULTS } from "./operation-catalog/raise-fault.js";
 import { FAULT_CODE_TO_HTTP_STATUS } from "./operation-fault.js";
 export const ERROR_SCHEMA = {
   type: "object",
-  required: ["code", "message"],
+  required: ["error"],
+  additionalProperties: !1,
   properties: {
-    code: { type: "string", description: "Machine-readable error code" },
-    message: { type: "string", description: "Human-readable error description" },
-    data: { description: "Additional fault-specific context" }
+    error: { type: "string", description: "Human-readable error description" },
+    weftCode: {
+      type: "string",
+      description: "Fine-grained public Weft error code when one is available"
+    },
+    missingTypes: {
+      type: "array",
+      items: { type: "string" },
+      description: "Established recovery-conflict field; also present under data"
+    },
+    missingWorkflowCount: {
+      type: "integer",
+      minimum: 0,
+      description: "Established recovery-conflict field; also present under data"
+    },
+    samplesTruncated: {
+      type: "boolean",
+      description: "Established recovery-conflict field; also present under data"
+    },
+    data: {
+      type: "object",
+      description: "Audited fault-specific context; omitted when no fields are safe to expose",
+      additionalProperties: !1,
+      properties: {
+        resource: { type: "string" },
+        identifier: { type: "string" },
+        missingTypes: { type: "array", items: { type: "string" } },
+        missingWorkflowCount: { type: "integer", minimum: 0 },
+        samplesTruncated: { type: "boolean" },
+        maxBytes: { type: "integer", minimum: 0 },
+        operationName: { type: "string" },
+        transport: { type: "string" },
+        supported: { type: "array", items: { type: "string" } },
+        droppedCount: { type: "integer", minimum: 0 },
+        issues: {
+          type: "array",
+          items: {
+            type: "object",
+            required: ["path", "message", "code"],
+            additionalProperties: !1,
+            properties: {
+              path: {
+                type: "array",
+                items: { oneOf: [{ type: "string" }, { type: "number" }] }
+              },
+              message: { type: "string" },
+              code: { type: "string" }
+            }
+          }
+        },
+        method: { type: "string" }
+      }
+    }
   }
 };
 export function buildErrorResponses(operation) {

package/dist/server/openapi.d.ts

@@ -4,7 +4,9 @@
  *
  * Produces a JSON-serializable OpenAPI document for the REST-ish HTTP
  * surface. Both `handleRequest()` and `serve()` expose this at
- * `GET /openapi.json`.
+ * `GET /openapi.json`. Every operation-catalog binding carries the canonical
+ * `x-weft-access` metadata and, when applicable,
+ * `x-weft-parameterizedAccess`; direct infrastructure routes do not.
  *
  * @module server/openapi
  */

package/dist/server/openapi.js

@@ -1,5 +1,6 @@
 import { definitionSchemaToJsonSchema } from "../core/types/definition-schema-to-json.js";
 import { VERSION } from "../version.js";
+import { serializeAccessPolicy, serializeParameterizedAccess } from "./access-policy-metadata.js";
 import { isDiscoverable } from "./discovery-filter.js";
 import { applyDiscoveryInfo } from "./discovery-info.js";
 import { asPlainObject, compareStrings } from "./json-schema-utilities.js";
@@ -184,11 +185,14 @@ function buildBindingEntry(binding, operation, schemaHelper) {
     summary: operation.summary,
     operationId: operation.name,
     tags: operation.tags,
+    "x-weft-access": serializeAccessPolicy(operation.access),
     responses: {
       ...successResponse,
       ...buildErrorResponses(operation)
     }
   };
+  if (operation.parameterizedAccess !== void 0)
+    entry["x-weft-parameterizedAccess"] = serializeParameterizedAccess(operation.parameterizedAccess);
   if (operation.description !== void 0)
     entry.description = operation.description;
   if (parameters.length > 0)

package/dist/server/openrpc-document-schema.d.ts

@@ -31,6 +31,38 @@ export declare const OpenRpcMethodSchema: z.ZodObject<{
         $ref: z.ZodString;
     }, z.core.$strict>>>;
     'x-weft-paramsSchema': z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    'x-weft-access': z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"public">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"authenticated">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"scoped">;
+        scopes: z.ZodObject<{
+            kind: z.ZodEnum<{
+                anyOf: "anyOf";
+                allOf: "allOf";
+            }>;
+            scopes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"optionalAuth">;
+        authenticatedScopes: z.ZodObject<{
+            kind: z.ZodEnum<{
+                anyOf: "anyOf";
+                allOf: "allOf";
+            }>;
+            scopes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"scopedAlternatives">;
+        alternatives: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                anyOf: "anyOf";
+                allOf: "allOf";
+            }>;
+            scopes: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">;
     'x-weft-mcp': z.ZodOptional<z.ZodObject<{
         workflowType: z.ZodString;
         toolName: z.ZodString;
@@ -121,6 +153,38 @@ export declare const OpenRpcDocumentSchema: z.ZodObject<{
             $ref: z.ZodString;
         }, z.core.$strict>>>;
         'x-weft-paramsSchema': z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        'x-weft-access': z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"public">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"authenticated">;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"scoped">;
+            scopes: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    anyOf: "anyOf";
+                    allOf: "allOf";
+                }>;
+                scopes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"optionalAuth">;
+            authenticatedScopes: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    anyOf: "anyOf";
+                    allOf: "allOf";
+                }>;
+                scopes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"scopedAlternatives">;
+            alternatives: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    anyOf: "anyOf";
+                    allOf: "allOf";
+                }>;
+                scopes: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "kind">;
         'x-weft-mcp': z.ZodOptional<z.ZodObject<{
             workflowType: z.ZodString;
             toolName: z.ZodString;

package/dist/server/openrpc-document-schema.js

@@ -1,4 +1,8 @@
 import { z } from "zod";
+import {
+  AccessPolicyMetadataSchema,
+  ParameterizedAccessMetadataSchema
+} from "./access-policy-metadata.js";
 import { MCP_DISCOVERY_PATH, MCP_TOOLS_LIST_METHOD } from "./mcp-discovery.js";
 export const ContentDescriptorSchema = z.strictObject({
   name: z.string(),
@@ -12,31 +16,6 @@ const OpenRpcMcpMethodMetadataSchema = z.strictObject({
     method: z.literal(MCP_TOOLS_LIST_METHOD),
     source: z.literal("live")
   })
-}), OpenRpcScopeRequirementSchema = z.strictObject({
-  kind: z.enum(["anyOf", "allOf"]),
-  scopes: z.array(z.string())
-}), OpenRpcAccessPolicySchema = z.discriminatedUnion("kind", [
-  z.strictObject({ kind: z.literal("public") }),
-  z.strictObject({ kind: z.literal("authenticated") }),
-  z.strictObject({
-    kind: z.literal("scoped"),
-    scopes: OpenRpcScopeRequirementSchema
-  }),
-  z.strictObject({
-    kind: z.literal("optionalAuth"),
-    authenticatedScopes: OpenRpcScopeRequirementSchema
-  }),
-  z.strictObject({
-    kind: z.literal("scopedAlternatives"),
-    alternatives: z.array(OpenRpcScopeRequirementSchema)
-  })
-]), OpenRpcParameterizedAccessSchema = z.strictObject({
-  discriminator: z.string(),
-  defaultValue: z.string().optional(),
-  variants: z.array(z.strictObject({
-    value: z.string(),
-    access: OpenRpcAccessPolicySchema
-  }))
 });
 export const OpenRpcMethodSchema = z.strictObject({
   name: z.string(),
@@ -48,8 +27,9 @@ export const OpenRpcMethodSchema = z.strictObject({
   result: ContentDescriptorSchema,
   errors: z.array(z.strictObject({ $ref: z.string() })).optional(),
   "x-weft-paramsSchema": z.record(z.string(), z.unknown()),
+  "x-weft-access": AccessPolicyMetadataSchema,
   "x-weft-mcp": OpenRpcMcpMethodMetadataSchema.optional(),
-  "x-weft-parameterizedAccess": OpenRpcParameterizedAccessSchema.optional()
+  "x-weft-parameterizedAccess": ParameterizedAccessMetadataSchema.optional()
 });
 const OpenRpcMcpMetadataSchema = z.strictObject({
   discoveryPath: z.literal(MCP_DISCOVERY_PATH),

package/dist/server/openrpc.d.ts

@@ -16,6 +16,10 @@
  *     authoritative top-level object schema used by runtime enforcement
  *     and generator tooling; the per-field descriptors cannot drift
  *     from it by the "names match" invariant enforced in tests.
+ *   - Every operation-catalog method carries the canonical `x-weft-access`
+ *     metadata and, when applicable, `x-weft-parameterizedAccess`. The
+ *     synthetic `rpc.discover` method is not an operation-catalog entry,
+ *     but advertises its dispatcher-enforced public access posture explicitly.
  *   - `rpc.discover` is itself emitted as a method so clients can
  *     locate the document via JSON-RPC.
  *

package/dist/server/openrpc.js

@@ -1,6 +1,10 @@
 import { z } from "zod";
 import { definitionSchemaToJsonSchema } from "../core/types/definition-schema-to-json.js";
 import { VERSION } from "../version.js";
+import {
+  serializeAccessPolicy,
+  serializeParameterizedAccess
+} from "./access-policy-metadata.js";
 import { isDiscoverable } from "./discovery-filter.js";
 import { applyDiscoveryInfo } from "./discovery-info.js";
 import { asPlainObject, compareStrings } from "./json-schema-utilities.js";
@@ -109,7 +113,8 @@ function buildMethod(operation) {
     paramStructure: "by-name",
     params: descriptors,
     result: { name: "result", schema: resultSchema, required: !0 },
-    "x-weft-paramsSchema": paramsSchema
+    "x-weft-paramsSchema": paramsSchema,
+    "x-weft-access": serializeAccessPolicy(operation.access)
   };
   if (operation.summary)
     method.summary = operation.summary;
@@ -118,40 +123,10 @@ function buildMethod(operation) {
   if (operation.tags.length > 0)
     method.tags = [...operation.tags].toSorted(compareStrings).map((name) => ({ name }));
   if (operation.parameterizedAccess !== void 0)
-    method["x-weft-parameterizedAccess"] = {
-      discriminator: operation.parameterizedAccess.discriminator,
-      ...operation.parameterizedAccess.defaultValue === void 0 ? {} : { defaultValue: operation.parameterizedAccess.defaultValue },
-      variants: operation.parameterizedAccess.variants.map((variant) => ({
-        value: variant.value,
-        access: accessPolicyExtension(variant.access)
-      }))
-    };
+    method["x-weft-parameterizedAccess"] = serializeParameterizedAccess(operation.parameterizedAccess);
   method.errors = buildMethodErrorReferences(operation);
   return method;
 }
-function accessPolicyExtension(access) {
-  if (access.kind === "public")
-    return { kind: "public" };
-  if (access.kind === "authenticated")
-    return { kind: "authenticated" };
-  if (access.kind === "scoped")
-    return { kind: "scoped", scopes: scopeRequirementExtension(access.scopes) };
-  if (access.kind === "optionalAuth")
-    return {
-      kind: "optionalAuth",
-      authenticatedScopes: scopeRequirementExtension(access.authenticatedScopes)
-    };
-  return {
-    kind: "scopedAlternatives",
-    alternatives: access.alternatives.map(scopeRequirementExtension)
-  };
-}
-function scopeRequirementExtension(requirement) {
-  return {
-    kind: requirement.kind,
-    scopes: [...requirement.scopes].toSorted(compareStrings)
-  };
-}
 function buildDiscoverMethod() {
   return {
     name: "rpc.discover",
@@ -169,7 +144,8 @@ function buildDiscoverMethod() {
       properties: {},
       required: [],
       additionalProperties: !1
-    }
+    },
+    "x-weft-access": { kind: "public" }
   };
 }
 const UNIVERSAL_FAULT_CODES = [...UNIVERSAL_FAULT_DEFAULTS];

package/dist/server/operation-fault.d.ts

@@ -35,7 +35,7 @@
  * serialized consistently across REST and JSON-RPC transports.
  */
 import type { FaultCode } from '../core/fault-code.ts';
-import type { WeftErrorCode } from '../core/weft-error.ts';
+import { type WeftErrorCode } from '../core/weft-error.ts';
 export type { FaultCode };
 /** Transport identifiers as seen by `executeOperation`. */
 export type TransportKind = 'http-rest' | 'jsonRpcHttp' | 'jsonRpcWebSocket' | 'jsonRpcStdio';
@@ -149,14 +149,31 @@ export declare const FAULT_CODE_TO_HTTP_STATUS: Readonly<Record<FaultCode, numbe
 export declare function formatInvalidParamsMessage(fault: Extract<OperationFault, {
     code: 'InvalidParams';
 }>): string;
+export type RestFaultResponseOptions = {
+    /** REST-only status override for a binding with an established non-canonical status. */
+    readonly status?: number;
+    /** REST-only public message override for a binding with an established response message. */
+    readonly message?: string;
+};
+export type RestFaultBody = {
+    readonly error: string;
+    readonly weftCode?: WeftErrorCode;
+    readonly data?: Readonly<Record<string, unknown>>;
+};
 /**
- * Map an `OperationFault` to a JSON `Response` with an `{ error }` body.
- * Treats `InvalidParams` as 400 with a flattened issues message, masks
- * `EngineFailure` as `Internal server error` at 500, and uses
- * {@link FAULT_CODE_TO_HTTP_STATUS} for every other code. Used by REST
- * bindings that serve a single resource and want a uniform error shape.
+ * Map an `OperationFault` to the canonical additive REST body:
+ * `{ error, weftCode?, data? }`. The existing string `error` and optional
+ * fine-grained `weftCode` remain unchanged; `data` contains only fields from
+ * the audited allowlist above. JSON-RPC uses its own broader projection.
+ *
+ * `EngineFailure` is a hard exception: its exact body remains
+ * `{ "error": "Internal server error" }`, regardless of response overrides.
  */
-export declare function shapeOperationFaultAsJson(fault: OperationFault): Response;
+export declare function shapeOperationFaultAsJson(fault: OperationFault, options?: RestFaultResponseOptions): Response;
+/** Canonical flat REST response used by bindings and route-dispatch fallback. */
+export declare function shapeRestFaultAsJson(fault: OperationFault, options?: RestFaultResponseOptions): Response;
+/** Build the audited body for bespoke REST shapers that retain extra legacy fields. */
+export declare function shapeRestFaultBody(fault: OperationFault, message?: string): RestFaultBody;
 /**
  * JSON-RPC error code for each fault. Reserved codes (-32700..-32603) keep
  * the spec meanings (`InvalidParams`, `MethodNotFound`); Weft domain codes

package/dist/server/operation-fault.js

@@ -1,3 +1,4 @@
+import { isWeftErrorCode } from "../core/weft-error.js";
 export const FAULT_CODE_TO_HTTP_STATUS = Object.freeze({
   Unauthorized: 401,
   Forbidden: 403,
@@ -19,22 +20,73 @@ export function formatInvalidParamsMessage(fault) {
     return path.length > 0 ? `${path}: ${issue.message}` : issue.message;
   }).join("; ");
 }
-export function shapeOperationFaultAsJson(fault) {
-  if (fault.code === "InvalidParams")
-    return new Response(JSON.stringify({ error: formatInvalidParamsMessage(fault) }), {
-      status: 400,
-      headers: { "Content-Type": "application/json" }
-    });
-  if (fault.code === "EngineFailure")
-    return new Response(JSON.stringify({ error: "Internal server error" }), {
-      status: 500,
-      headers: { "Content-Type": "application/json" }
-    });
-  return new Response(JSON.stringify({ error: fault.message }), {
-    status: FAULT_CODE_TO_HTTP_STATUS[fault.code],
+const NO_REST_FAULT_DATA = Object.freeze({}), REST_FAULT_DATA_EXTRACTORS = {
+  Unauthorized: () => NO_REST_FAULT_DATA,
+  Forbidden: () => NO_REST_FAULT_DATA,
+  NotFound: (data) => filterDefined({
+    resource: data.resource,
+    identifier: data.identifier === void 0 || data.identifier.length === 0 ? void 0 : data.identifier
+  }),
+  Conflict: (data) => filterDefined({
+    missingTypes: data.missingTypes === void 0 ? void 0 : [...data.missingTypes],
+    missingWorkflowCount: data.missingWorkflowCount,
+    samplesTruncated: data.samplesTruncated
+  }),
+  Unprocessable: () => NO_REST_FAULT_DATA,
+  PayloadTooLarge: (data) => ({ maxBytes: data.maxBytes }),
+  Timeout: (data) => filterDefined({ operationName: data.operationName }),
+  NotImplemented: () => NO_REST_FAULT_DATA,
+  UnsupportedTransport: (data) => ({
+    transport: data.transport,
+    supported: [...data.supported]
+  }),
+  SubscriptionOverflow: (data) => ({ droppedCount: data.droppedCount }),
+  InvalidParams: (data) => data.issues.length === 0 ? NO_REST_FAULT_DATA : {
+    issues: data.issues.map((issue) => ({
+      path: [...issue.path],
+      message: issue.message,
+      code: issue.code
+    }))
+  },
+  MethodNotFound: (data) => ({ method: data.method })
+};
+export function shapeOperationFaultAsJson(fault, options = {}) {
+  const message = options.message ?? (fault.code === "InvalidParams" ? formatInvalidParamsMessage(fault) : void 0);
+  return shapeRestFaultAsJson(fault, { ...options, ...message === void 0 ? {} : { message } });
+}
+export function shapeRestFaultAsJson(fault, options = {}) {
+  const body = shapeRestFaultBody(fault, options.message), status = fault.code === "EngineFailure" ? 500 : options.status ?? FAULT_CODE_TO_HTTP_STATUS[fault.code];
+  return new Response(JSON.stringify(body), {
+    status,
     headers: { "Content-Type": "application/json" }
   });
 }
+export function shapeRestFaultBody(fault, message) {
+  if (fault.code === "EngineFailure")
+    return { error: "Internal server error" };
+  const error = message ?? fault.message, weftCode = weftCodeFromFaultData(fault.data), data = restDataFromFault(fault), body = { error };
+  if (weftCode !== void 0)
+    body.weftCode = weftCode;
+  if (Object.keys(data).length > 0)
+    body.data = data;
+  return body;
+}
+function restDataFromFault(fault) {
+  const extractor = REST_FAULT_DATA_EXTRACTORS[fault.code];
+  return extractor(fault.data);
+}
+function weftCodeFromFaultData(data) {
+  if (typeof data !== "object" || data === null || !("weftCode" in data))
+    return;
+  return isWeftErrorCode(data.weftCode) ? data.weftCode : void 0;
+}
+function filterDefined(input) {
+  const output = {};
+  for (const [key, value] of Object.entries(input))
+    if (value !== void 0)
+      output[key] = value;
+  return output;
+}
 export const FAULT_CODE_TO_JSON_RPC_CODE = Object.freeze({
   Unauthorized: -32010,
   Forbidden: -32011,

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

@@ -13,6 +13,9 @@ declare const aggregateWorkflowsInput: z.ZodObject<{
         gte: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
         lte: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
     }, z.core.$strip>>>;
+    scheduleId: z.ZodOptional<z.ZodString>;
+    parentWorkflowId: z.ZodOptional<z.ZodString>;
+    parentWorkflowExecutionToken: z.ZodOptional<z.ZodString>;
     idPrefix: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodOptional<z.ZodObject<{
         gte: z.ZodOptional<z.ZodNumber>;
@@ -55,6 +58,9 @@ export declare const aggregateWorkflowsOperation: import("../operation-catalog.t
         gte?: unknown;
         lte?: unknown;
     }[] | undefined;
+    scheduleId?: string | undefined;
+    parentWorkflowId?: string | undefined;
+    parentWorkflowExecutionToken?: string | undefined;
     idPrefix?: string | undefined;
     createdAt?: {
         gte?: number | undefined;

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

@@ -14,7 +14,7 @@ import {
 } from "../../core/list-filter-validation.js";
 import { defineOperation } from "../operation-registry.js";
 import { extractListFilterFromQuery } from "./list-filter-query-extractor.js";
-import { jsonErrorResponse, shapeRestFault } from "./operation-helpers.js";
+import { shapeRestFault } from "./operation-helpers.js";
 const aggregateWorkflowsInput = listFilterObjectSchema.omit({ limit: !0, offset: !0 }).extend(aggregateOptionsObjectSchema.shape), aggregateWorkflowsOutput = z.object({
   total: z.number().int().min(0),
   groups: z.array(z.object({
@@ -87,7 +87,7 @@ function shapeAggregateWorkflowsSuccess(result) {
 }
 function shapeAggregateWorkflowsFault(fault) {
   if (fault.code === "Unprocessable")
-    return jsonErrorResponse(fault.message, 400);
+    return shapeRestFault(fault, { status: 400 });
   return shapeRestFault(fault);
 }
 export const aggregateWorkflowsRestBinding = {
@@ -98,6 +98,7 @@ export const aggregateWorkflowsRestBinding = {
   inputSources: {
     status: { kind: "query", queryParam: "status", repeating: !0 },
     type: { kind: "query", queryParam: "type" },
+    scheduleId: { kind: "query", queryParam: "schedule_id" },
     tags: { kind: "query", queryParam: "tag", repeating: !0 },
     idPrefix: { kind: "query", queryParam: "id_prefix" },
     limit: { kind: "query", queryParam: "limit" },

package/dist/server/operations/async-activity.d.ts

@@ -1,9 +1,15 @@
 import { z } from 'zod';
+import type { PendingAsyncActivityPage } from '../../core/types.ts';
 import type { UnknownRestBinding } from '../rest-bindings.ts';
 declare const completeAsyncActivityInput: z.ZodObject<{
     token: z.ZodString;
     result: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
+declare const listPendingAsyncActivitiesInput: z.ZodObject<{
+    workflowId: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 /**
  * The failure payload is a *serializable* error description, not a live `Error`.
  * The engine already reduces an async-activity failure to `message` + `name`
@@ -24,6 +30,13 @@ declare const okOutput: z.ZodObject<{
 export type CompleteAsyncActivityInput = z.infer<typeof completeAsyncActivityInput>;
 export type FailAsyncActivityInput = z.infer<typeof failAsyncActivityInput>;
 export type AsyncActivityOutput = z.infer<typeof okOutput>;
+export type ListPendingAsyncActivitiesInput = z.infer<typeof listPendingAsyncActivitiesInput>;
+export type ListPendingAsyncActivitiesOutput = PendingAsyncActivityPage;
+export declare const listPendingAsyncActivitiesOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId: string;
+    limit: number;
+    cursor?: string | undefined;
+}, PendingAsyncActivityPage, unknown>;
 export declare const completeAsyncActivityOperation: import("../operation-catalog.ts").OperationDefinition<{
     token: string;
     result?: unknown;
@@ -39,6 +52,7 @@ export declare const failAsyncActivityOperation: import("../operation-catalog.ts
 }, {
     ok: true;
 }, unknown>;
+export declare const listPendingAsyncActivitiesRestBinding: UnknownRestBinding;
 export declare const completeAsyncActivityRestBinding: UnknownRestBinding;
 export declare const failAsyncActivityRestBinding: UnknownRestBinding;
 export {};