@lostgradient/weft 0.2.1 → 0.4.0

package/dist/server/operation-catalog/pipeline-stages.js

@@ -51,12 +51,19 @@ export async function checkAuthorization(operation, input, context) {
   }
   if (!isAuthorizationDecision(decision))
     return failure({ code: "EngineFailure", message: "internal error", data: {} });
-  if (!decision.allowed)
+  if (!decision.allowed) {
+    if (decision.classification === "unauthorized")
+      return failure({
+        code: "Unauthorized",
+        message: decision.reason,
+        data: { reason: decision.reason }
+      });
     return failure({
       code: "Forbidden",
       message: decision.reason,
       data: { reason: decision.reason }
     });
+  }
   return null;
 }
 export function parseAndApplyUnknownKeyPolicy(operation, rawInput, policyKey, pipelineTrace) {
@@ -166,23 +173,30 @@ function safeParseInput(inputSchema, input) {
 function isAuthorizationDecision(value) {
   if (typeof value !== "object" || value === null)
     return !1;
-  let allowed;
-  try {
-    allowed = value.allowed;
-  } catch {
+  const allowed = readObjectProperty(value, "allowed");
+  if (!allowed.ok)
     return !1;
-  }
-  if (allowed === !0)
+  if (allowed.value === !0)
     return !0;
-  if (allowed !== !1)
+  if (allowed.value !== !1)
+    return !1;
+  const reason = readObjectProperty(value, "reason");
+  if (!reason.ok || typeof reason.value !== "string")
     return !1;
-  let reason;
+  const classification = readObjectProperty(value, "classification");
+  if (!classification.ok)
+    return !1;
+  return isAuthorizationFailureClassification(classification.value);
+}
+function readObjectProperty(value, property) {
   try {
-    reason = value.reason;
+    return { ok: !0, value: value[property] };
   } catch {
-    return !1;
+    return { ok: !1 };
   }
-  return typeof reason === "string";
+}
+function isAuthorizationFailureClassification(value) {
+  return value === void 0 || value === "unauthorized" || value === "forbidden";
 }
 function failure(fault) {
   return { ok: !1, fault };

package/dist/server/operation-catalog/pipeline.js

@@ -10,7 +10,14 @@ export async function executeOperation(operationName, rawInput, context) {
   const lookup = lookupOperation(operationName, context);
   if (!lookup.ok)
     return lookup;
-  const operation = lookup.value, prepared = await prepareAuthorizedInput(operation, rawInput, context);
+  const operation = lookup.value, operationKind = operation.kind ?? "unary";
+  if (operationKind === "subscription" || operationKind === "stream" && context.transport !== "http-rest")
+    return dispatchFailure({
+      code: "Unprocessable",
+      message: `operation "${operation.name}" is not unary`,
+      data: { reason: `operation kind is "${operationKind}"` }
+    });
+  const prepared = await prepareAuthorizedInput(operation, rawInput, context);
   if (!prepared.ok)
     return prepared;
   let output;

package/dist/server/operation-catalog/registry.js

@@ -28,6 +28,18 @@ function freezeScopeRequirement(requirement) {
     scopes
   });
 }
+function freezeParameterizedAccessHint(hint) {
+  if (hint === void 0)
+    return;
+  return Object.freeze({
+    discriminator: hint.discriminator,
+    ...hint.defaultValue === void 0 ? {} : { defaultValue: hint.defaultValue },
+    variants: Object.freeze(hint.variants.map((variant) => Object.freeze({
+      value: variant.value,
+      access: freezeAccessPolicy(variant.access)
+    })))
+  });
+}
 function objectInputSchema(operation) {
   if (!(operation.inputSchema instanceof z.ZodObject))
     throw Error(`operation "${operation.name}" inputSchema must be a z.ZodObject (got ${operation.inputSchema.constructor.name}); wrappers like .optional() / transforms hide the top-level shape from the unknown-key policy check`);
@@ -64,6 +76,7 @@ function freezeOperation(operation) {
     tags: Object.freeze([...operation.tags]),
     ...operation.producibleFaults === void 0 ? {} : { producibleFaults: Object.freeze([...operation.producibleFaults]) },
     access: freezeAccessPolicy(operation.access),
+    ...operation.parameterizedAccess === void 0 ? {} : { parameterizedAccess: freezeParameterizedAccessHint(operation.parameterizedAccess) },
     ...operation.mcpTool === void 0 ? {} : { mcpTool: Object.freeze({ workflowType: operation.mcpTool.workflowType }) },
     transports: Object.freeze({ ...operation.transports }),
     unknownKeyPolicy: Object.freeze({ ...operation.unknownKeyPolicy })

package/dist/server/operation-catalog/types.d.ts

@@ -44,7 +44,7 @@ export type SubscriptionOperationInvocation<Element, Envelope> = {
     readonly iterable: AsyncIterable<Element>;
     readonly close: () => Promise<void>;
 };
-export type OperationInvocationResult<Output> = Output | StreamOperationInvocation<unknown> | SubscriptionOperationInvocation<unknown, Output>;
+export type OperationInvocationResult<Output, Element = unknown> = Output | StreamOperationInvocation<Element> | SubscriptionOperationInvocation<Element, Output>;
 /**
  * Metadata that connects an operation-catalog entry to a live MCP tool.
  *
@@ -65,8 +65,17 @@ export type AuthorizationDecision = {
     allowed: true;
 } | {
     allowed: false;
+    classification?: 'unauthorized' | 'forbidden';
     reason: string;
 };
+export type ParameterizedAccessHint = {
+    readonly discriminator: string;
+    readonly defaultValue?: string;
+    readonly variants: ReadonlyArray<{
+        readonly value: string;
+        readonly access: AccessPolicy;
+    }>;
+};
 /**
  * Stable audit markers emitted after each successful operation pipeline stage.
  */
@@ -89,7 +98,7 @@ export type OperationContext<Input> = {
  * Common operation fields shared by unary, stream, and subscription kinds.
  * The discriminated union below adds `kind` and `eventSchema` per kind.
  */
-type OperationDefinitionBase<Input, Output> = {
+type OperationDefinitionBase<Input, Output, Element = unknown> = {
     readonly name: string;
     readonly mcpExposable: boolean;
     readonly mcpTool?: McpToolMetadata;
@@ -127,6 +136,7 @@ type OperationDefinitionBase<Input, Output> = {
      */
     readonly outputSchema: z.ZodType<Output>;
     readonly access: AccessPolicy;
+    readonly parameterizedAccess?: ParameterizedAccessHint;
     /** Fault codes this operation can raise in addition to universal pipeline defaults. */
     readonly producibleFaults?: ReadonlyArray<FaultCode>;
     /** Whether non-public operations should appear in generated discovery documents. */
@@ -134,7 +144,7 @@ type OperationDefinitionBase<Input, Output> = {
     readonly transports: TransportAvailability;
     readonly unknownKeyPolicy: UnknownKeyPolicy;
     readonly authorize?: (context: OperationContext<Input>) => Promise<AuthorizationDecision>;
-    readonly invoke: (context: OperationContext<Input>) => Promise<OperationInvocationResult<Output>>;
+    readonly invoke: (context: OperationContext<Input>) => Promise<OperationInvocationResult<Output, Element>>;
 };
 /**
  * Unary (request/response) operation. `kind` may be omitted (defaults to
@@ -143,7 +153,7 @@ type OperationDefinitionBase<Input, Output> = {
  * enforces this at the type level: passing `eventSchema` to a unary
  * operation is a TypeScript error, not a silent runtime mismatch.
  */
-type UnaryOperationDefinition<Input, Output> = OperationDefinitionBase<Input, Output> & {
+type UnaryOperationDefinition<Input, Output, Element = unknown> = OperationDefinitionBase<Input, Output, Element> & {
     readonly kind?: 'unary';
     readonly eventSchema?: never;
 };
@@ -154,9 +164,9 @@ type UnaryOperationDefinition<Input, Output> = OperationDefinitionBase<Input, Ou
  * have no contract to validate per-element output against, which would
  * silently leak un-validated data to consumers.
  */
-type StreamOperationDefinition<Input, Output> = OperationDefinitionBase<Input, Output> & {
+type StreamOperationDefinition<Input, Output, Element> = OperationDefinitionBase<Input, Output, Element> & {
     readonly kind: 'stream';
-    readonly eventSchema: z.ZodType;
+    readonly eventSchema: z.ZodType<Element>;
 };
 /**
  * WebSocket subscription operation. `kind: 'subscription'` is required and
@@ -164,9 +174,9 @@ type StreamOperationDefinition<Input, Output> = OperationDefinitionBase<Input, O
  * rationale as `StreamOperationDefinition` — the type forbids declaring a
  * subscription without its element schema.
  */
-type SubscriptionOperationDefinition<Input, Output> = OperationDefinitionBase<Input, Output> & {
+type SubscriptionOperationDefinition<Input, Output, Element> = OperationDefinitionBase<Input, Output, Element> & {
     readonly kind: 'subscription';
-    readonly eventSchema: z.ZodType;
+    readonly eventSchema: z.ZodType<Element>;
 };
 /**
  * Discriminated union over the three operation kinds. The discriminator
@@ -176,7 +186,7 @@ type SubscriptionOperationDefinition<Input, Output> = OperationDefinitionBase<In
  * rather than a runtime EngineFailure; unary operations cannot
  * accidentally carry an `eventSchema` that the pipeline would never read.
  */
-export type OperationDefinition<Input, Output> = UnaryOperationDefinition<Input, Output> | StreamOperationDefinition<Input, Output> | SubscriptionOperationDefinition<Input, Output>;
+export type OperationDefinition<Input, Output, Element = unknown> = UnaryOperationDefinition<Input, Output, Element> | StreamOperationDefinition<Input, Output, Element> | SubscriptionOperationDefinition<Input, Output, Element>;
 /**
  * An operation with its Input/Output type parameters erased. The dispatcher
  * only feeds values that have been validated by the operation's own schema.
@@ -207,6 +217,7 @@ type RegistrableOperationBase = {
     readonly inputSchema: z.ZodType;
     readonly outputSchema: z.ZodType;
     readonly access: AccessPolicy;
+    readonly parameterizedAccess?: ParameterizedAccessHint;
     /** Fault codes this operation can raise in addition to universal pipeline defaults. */
     readonly producibleFaults?: ReadonlyArray<FaultCode>;
     /** Whether non-public operations should appear in generated discovery documents. */

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

@@ -33,6 +33,7 @@
  * See Track 8 design decision 4.
  */
 import type { FaultCode } from '../core/fault-code.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';
@@ -65,12 +66,14 @@ export type OperationFault = {
     data: {
         resource: string;
         identifier?: string | undefined;
+        weftCode?: WeftErrorCode;
     };
 } | {
     code: 'Conflict';
     message: string;
     data: {
         reason: string;
+        weftCode?: WeftErrorCode;
         missingTypes?: readonly string[] | undefined;
         missingWorkflowCount?: number | undefined;
         samplesTruncated?: boolean | undefined;
@@ -81,6 +84,12 @@ export type OperationFault = {
     data: {
         reason: string;
     };
+} | {
+    code: 'PayloadTooLarge';
+    message: string;
+    data: {
+        maxBytes: number;
+    };
 } | {
     code: 'Timeout';
     message: string;
@@ -110,6 +119,7 @@ export type OperationFault = {
     message: string;
     data: {
         issues: ReadonlyArray<FlattenedZodIssue>;
+        weftCode?: WeftErrorCode;
     };
 } | {
     code: 'MethodNotFound';

package/dist/server/operation-fault.js

@@ -5,6 +5,7 @@ export const FAULT_CODE_TO_HTTP_STATUS = Object.freeze({
   Conflict: 409,
   Unprocessable: 422,
   Timeout: 408,
+  PayloadTooLarge: 413,
   NotImplemented: 501,
   UnsupportedTransport: 501,
   SubscriptionOverflow: 500,
@@ -41,6 +42,7 @@ export const FAULT_CODE_TO_JSON_RPC_CODE = Object.freeze({
   Conflict: -32021,
   Unprocessable: -32022,
   Timeout: -32023,
+  PayloadTooLarge: -32024,
   NotImplemented: -32025,
   UnsupportedTransport: -32030,
   SubscriptionOverflow: -32031,

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

@@ -18,7 +18,7 @@
  */
 import type { z } from 'zod';
 import type { AccessPolicy } from './authorization.ts';
-import { type OperationDefinition, type TransportAvailability, type UnknownKeyPolicy } from './operation-catalog.ts';
+import type { AuthorizationDecision, McpToolMetadata, OperationContext, OperationDefinition, OperationInvocationResult, ParameterizedAccessHint, TransportAvailability, UnknownKeyPolicy } from './operation-catalog/types.ts';
 import type { FaultCode } from './operation-fault.ts';
 export { isValidOperationName, validateOperationName } from './operation-catalog.ts';
 /**
@@ -31,10 +31,10 @@ export { isValidOperationName, validateOperationName } from './operation-catalog
  * passes. When present, BOTH `access` AND `authorize` must permit the
  * call: the policy runs first, then the parameter-aware hook.
  */
-type OperationDefinitionInputBase<Input, Output> = {
+type OperationDefinitionInputBase<Input, Output, Element = unknown> = {
     readonly name: string;
     readonly mcpExposable: boolean;
-    readonly mcpTool?: OperationDefinition<Input, Output>['mcpTool'];
+    readonly mcpTool?: McpToolMetadata;
     readonly summary: string;
     /**
      * Optional longer-form prose. See {@link OperationDefinition} for the
@@ -53,12 +53,13 @@ type OperationDefinitionInputBase<Input, Output> = {
     readonly inputSchema: z.ZodType<Input>;
     readonly outputSchema: z.ZodType<Output>;
     readonly access: AccessPolicy;
+    readonly parameterizedAccess?: ParameterizedAccessHint;
     readonly producibleFaults?: ReadonlyArray<FaultCode>;
     readonly discoverable?: boolean;
     readonly transports: TransportAvailability;
     readonly unknownKeyPolicy: UnknownKeyPolicy;
-    readonly authorize?: OperationDefinition<Input, Output>['authorize'];
-    readonly invoke: OperationDefinition<Input, Output>['invoke'];
+    readonly authorize?: (context: OperationContext<Input>) => Promise<AuthorizationDecision>;
+    readonly invoke: (context: OperationContext<Input>) => Promise<OperationInvocationResult<Output, Element>>;
 };
 /**
  * Discriminated input for `defineOperation`, mirroring the discriminated
@@ -68,15 +69,15 @@ type OperationDefinitionInputBase<Input, Output> = {
  * that would otherwise fire when a streaming operation tries to validate
  * elements without a schema.
  */
-export type OperationDefinitionInput<Input, Output> = (OperationDefinitionInputBase<Input, Output> & {
+export type OperationDefinitionInput<Input, Output, Element = unknown> = (OperationDefinitionInputBase<Input, Output, Element> & {
     readonly kind?: 'unary';
     readonly eventSchema?: never;
-}) | (OperationDefinitionInputBase<Input, Output> & {
+}) | (OperationDefinitionInputBase<Input, Output, Element> & {
     readonly kind: 'stream';
-    readonly eventSchema: z.ZodType;
-}) | (OperationDefinitionInputBase<Input, Output> & {
+    readonly eventSchema: z.ZodType<Element>;
+}) | (OperationDefinitionInputBase<Input, Output, Element> & {
     readonly kind: 'subscription';
-    readonly eventSchema: z.ZodType;
+    readonly eventSchema: z.ZodType<Element>;
 });
 /**
  * Typed builder for a single operation. Validates the name at construction
@@ -97,4 +98,4 @@ export type OperationDefinitionInput<Input, Output> = (OperationDefinitionInputB
  * the assembly check is the trust boundary that OpenRPC discovery and
  * JSON-RPC dispatch rely on.
  */
-export declare function defineOperation<Input, Output>(input: OperationDefinitionInput<Input, Output>): OperationDefinition<Input, Output>;
+export declare function defineOperation<Input, Output, Element = unknown>(input: OperationDefinitionInput<Input, Output, Element>): OperationDefinition<Input, Output, Element>;

package/dist/server/operation-registry.js

@@ -1,6 +1,4 @@
-import {
-  validateOperationName
-} from "./operation-catalog.js";
+import { validateOperationName } from "./operation-catalog.js";
 export { isValidOperationName, validateOperationName } from "./operation-catalog.js";
 export function defineOperation(input) {
   validateOperationName(input.name);
@@ -14,6 +12,7 @@ export function defineOperation(input) {
     destructive: input.destructive,
     inputSchema: input.inputSchema,
     outputSchema: input.outputSchema,
+    ...input.parameterizedAccess === void 0 ? {} : { parameterizedAccess: copyParameterizedAccessHint(input.parameterizedAccess) },
     ...input.producibleFaults === void 0 ? {} : { producibleFaults: [...input.producibleFaults] },
     ...input.discoverable === void 0 ? {} : { discoverable: input.discoverable },
     access: copyAccessPolicy(input.access),
@@ -30,6 +29,16 @@ export function defineOperation(input) {
     ...baseFields
   };
 }
+function copyParameterizedAccessHint(hint) {
+  return {
+    discriminator: hint.discriminator,
+    ...hint.defaultValue === void 0 ? {} : { defaultValue: hint.defaultValue },
+    variants: hint.variants.map((variant) => ({
+      value: variant.value,
+      access: copyAccessPolicy(variant.access)
+    }))
+  };
+}
 function copyAccessPolicy(policy) {
   if (policy.kind === "scoped")
     return {

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

@@ -5,13 +5,6 @@ declare const aggregateWorkflowsInput: z.ZodObject<{
     status: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<import("../../index.ts").WorkflowStatus, unknown, z.core.$ZodTypeInternals<import("../../index.ts").WorkflowStatus, unknown>>, z.ZodArray<z.ZodType<import("../../index.ts").WorkflowStatus, unknown, z.core.$ZodTypeInternals<import("../../index.ts").WorkflowStatus, unknown>>>]>>;
     type: z.ZodOptional<z.ZodString>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    idPrefix: z.ZodOptional<z.ZodString>;
-    createdAt: z.ZodOptional<z.ZodObject<{
-        gte: z.ZodOptional<z.ZodNumber>;
-        lte: z.ZodOptional<z.ZodNumber>;
-        gt: z.ZodOptional<z.ZodNumber>;
-        lt: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>>;
     attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
         key: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
         value: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
@@ -20,6 +13,13 @@ 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>>>;
+    idPrefix: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
     updatedAt: z.ZodOptional<z.ZodObject<{
         gte: z.ZodOptional<z.ZodNumber>;
         lte: z.ZodOptional<z.ZodNumber>;
@@ -47,13 +47,6 @@ export declare const aggregateWorkflowsOperation: import("../operation-catalog.t
     status?: import("../../index.ts").WorkflowStatus | import("../../index.ts").WorkflowStatus[] | undefined;
     type?: string | undefined;
     tags?: string[] | undefined;
-    idPrefix?: string | undefined;
-    createdAt?: {
-        gte?: number | undefined;
-        lte?: number | undefined;
-        gt?: number | undefined;
-        lt?: number | undefined;
-    } | undefined;
     attributes?: {
         key: any;
         value?: unknown;
@@ -62,6 +55,13 @@ export declare const aggregateWorkflowsOperation: import("../operation-catalog.t
         gte?: unknown;
         lte?: unknown;
     }[] | undefined;
+    idPrefix?: string | undefined;
+    createdAt?: {
+        gte?: number | undefined;
+        lte?: number | undefined;
+        gt?: number | undefined;
+        lt?: number | undefined;
+    } | undefined;
     updatedAt?: {
         gte?: number | undefined;
         lte?: number | undefined;
@@ -76,6 +76,6 @@ export declare const aggregateWorkflowsOperation: import("../operation-catalog.t
     } | undefined;
     failureCategory?: import("../../index.ts").FailureCategory | import("../../index.ts").FailureCategory[] | undefined;
     limit?: number | undefined;
-}, AggregateResult>;
+}, AggregateResult, unknown>;
 export declare const aggregateWorkflowsRestBinding: UnknownRestBinding;
 export {};

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

@@ -29,7 +29,7 @@ export declare const completeAsyncActivityOperation: import("../operation-catalo
     result?: unknown;
 }, {
     ok: true;
-}>;
+}, unknown>;
 export declare const failAsyncActivityOperation: import("../operation-catalog.ts").OperationDefinition<{
     token: string;
     error: {
@@ -38,7 +38,7 @@ export declare const failAsyncActivityOperation: import("../operation-catalog.ts
     };
 }, {
     ok: true;
-}>;
+}, unknown>;
 export declare const completeAsyncActivityRestBinding: UnknownRestBinding;
 export declare const failAsyncActivityRestBinding: UnknownRestBinding;
 export {};

package/dist/server/operations/async-activity.js

@@ -3,7 +3,8 @@ import { AsyncActivityTokenNotFoundError } from "../../core/engine.js";
 import { PayloadSizeExceededError } from "../../core/payload-size.js";
 import { raiseFault } from "../operation-catalog.js";
 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";
 const asyncActivityAccess = { kind: "public" }, httpAndJsonRpcTransports = {
   http: !0,
   jsonRpcHttp: !0,
@@ -87,8 +88,12 @@ function shapeAsyncActivitySuccess(output) {
     headers: { "Content-Type": "application/json" }
   });
 }
-async function readJsonObjectBody(request) {
-  const body = await request.json().catch(() => null);
+async function readJsonObjectBody(request, context) {
+  const body = await readRestJsonBody(request, context).catch((error) => {
+    if (isOperationFault(error))
+      throw error;
+    return null;
+  });
   if (typeof body !== "object" || body === null || Array.isArray(body))
     throw invalidParamsFault("Request body must be a JSON object.");
   return body;
@@ -102,8 +107,8 @@ export const completeAsyncActivityRestBinding = {
     token: { kind: "body-field", bodyField: "token" },
     result: { kind: "body-field", bodyField: "result" }
   },
-  extractInput: async (request) => {
-    const body = await readJsonObjectBody(request);
+  extractInput: async (request, _pathParams, context) => {
+    const body = await readJsonObjectBody(request, context);
     return {
       token: body.token,
       ..."result" in body ? { result: body.result } : {}
@@ -121,8 +126,8 @@ export const completeAsyncActivityRestBinding = {
     token: { kind: "body-field", bodyField: "token" },
     error: { kind: "body-field", bodyField: "error" }
   },
-  extractInput: async (request) => {
-    const body = await readJsonObjectBody(request);
+  extractInput: async (request, _pathParams, context) => {
+    const body = await readJsonObjectBody(request, context);
     return {
       token: body.token,
       error: body.error

package/dist/server/operations/bulk-cancel-workflows.d.ts

@@ -3,5 +3,5 @@ import type { UnknownRestBinding } from '../rest-bindings.ts';
 import { type BulkListFilterInput, type BulkOperationControlInput } from './bulk-filter-helpers.ts';
 export type BulkCancelWorkflowsInput = BulkListFilterInput & BulkOperationControlInput;
 export type BulkCancelWorkflowsOutput = BulkCancelResult | BulkOperationDryRunResult;
-export declare const bulkCancelWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<BulkCancelWorkflowsInput, BulkCancelWorkflowsOutput>;
+export declare const bulkCancelWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<BulkCancelWorkflowsInput, BulkCancelWorkflowsOutput, unknown>;
 export declare const bulkCancelWorkflowsRestBinding: UnknownRestBinding;

package/dist/server/operations/bulk-cancel-workflows.js

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

package/dist/server/operations/bulk-delete-workflows.d.ts

@@ -3,5 +3,5 @@ import type { UnknownRestBinding } from '../rest-bindings.ts';
 import { type BulkListFilterInput, type BulkOperationControlInput } from './bulk-filter-helpers.ts';
 export type BulkDeleteWorkflowsInput = BulkListFilterInput & BulkOperationControlInput;
 export type BulkDeleteWorkflowsOutput = BulkDeleteResult | BulkOperationDryRunResult;
-export declare const bulkDeleteWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<BulkDeleteWorkflowsInput, BulkDeleteWorkflowsOutput>;
+export declare const bulkDeleteWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<BulkDeleteWorkflowsInput, BulkDeleteWorkflowsOutput, unknown>;
 export declare const bulkDeleteWorkflowsRestBinding: UnknownRestBinding;

package/dist/server/operations/bulk-delete-workflows.js

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

package/dist/server/operations/bulk-filter-helpers.d.ts

@@ -1,7 +1,8 @@
 import { z } from 'zod';
-import type { BulkOperationCommitOptions, BulkOperationDryRunOptions, FailureCategory, ListFilter, SearchAttributeValue, WorkflowStatus } from '../../core/types.ts';
+import type { AttributeFilterScalarValue, BulkOperationCommitOptions, BulkOperationDryRunOptions, FailureCategory, ListFilter, SearchAttributeValue, WorkflowStatus } from '../../core/types.ts';
 import type { OperationFault } from '../operation-fault.ts';
 import type { Principal } from '../principal.ts';
+import type { RestInputContext } from '../rest-binding.ts';
 export declare const bulkListFilterInputSchema: z.ZodObject<{
     status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<WorkflowStatus, WorkflowStatus>, z.ZodArray<z.ZodCustom<WorkflowStatus, WorkflowStatus>>]>>;
     type: z.ZodOptional<z.ZodString>;
@@ -9,10 +10,10 @@ export declare const bulkListFilterInputSchema: z.ZodObject<{
     attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
         key: z.ZodString;
         value: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
-        gt: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
-        lt: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
-        gte: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
-        lte: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
+        gt: z.ZodOptional<z.ZodCustom<AttributeFilterScalarValue, AttributeFilterScalarValue>>;
+        lt: z.ZodOptional<z.ZodCustom<AttributeFilterScalarValue, AttributeFilterScalarValue>>;
+        gte: z.ZodOptional<z.ZodCustom<AttributeFilterScalarValue, AttributeFilterScalarValue>>;
+        lte: z.ZodOptional<z.ZodCustom<AttributeFilterScalarValue, AttributeFilterScalarValue>>;
     }, z.core.$strip>>>;
     limit: z.ZodOptional<z.ZodNumber>;
     offset: z.ZodOptional<z.ZodNumber>;
@@ -42,6 +43,7 @@ export declare const bulkOperationControlInputSchema: z.ZodObject<{
     dryRun: z.ZodOptional<z.ZodBoolean>;
     confirmationToken: z.ZodOptional<z.ZodString>;
     requestId: z.ZodOptional<z.ZodString>;
+    bulkConcurrency: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 export type BulkOperationControlInput = z.infer<typeof bulkOperationControlInputSchema>;
 export declare const bulkOperatorAccessPolicy: {
@@ -54,7 +56,7 @@ export declare const bulkOperatorAccessPolicy: {
 export declare function faultMessage(error: unknown): string;
 export declare function unprocessableFault(message: string): OperationFault;
 export declare function engineFailureFault(message: string): OperationFault;
-export declare function readOptionalJsonBody(request: Request): Promise<unknown>;
+export declare function readOptionalJsonBody(request: Request, context?: RestInputContext): Promise<unknown>;
 export declare function parseBulkListFilterFromBody(body: unknown): ListFilter;
 export declare function parseRequiredBulkListFilter(body: unknown): ListFilter;
 export declare function listFilterFromBulkInput(input: BulkListFilterInput): ListFilter;