@lostgradient/weft 0.3.0 → 0.4.0

package/dist/server/operations/bulk-filter-helpers.js

@@ -6,19 +6,20 @@ import {
   MAX_BULK_CONFIRMATION_TOKEN_LENGTH,
   MAX_BULK_OPERATION_REQUEST_ID_LENGTH
 } from "../../core/types/bulk.js";
+import { readRestTextBody } from "../rest-body.js";
 import { parseOptionalFailureCategoryFilter } from "./failure-category-filter.js";
-import { invalidParamsFault } from "./operation-helpers.js";
+import { invalidParamsFault, isOperationFault } from "./operation-helpers.js";
 const workflowStatusSchema = z.custom((value) => typeof value === "string"), searchAttributeValueSchema = z.custom((value) => {
   if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
     return !0;
-  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
-}), attributeFilterSchema = z.object({
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string" || typeof entry === "number" || typeof entry === "boolean");
+}), attributeFilterScalarValueSchema = z.custom((value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean"), attributeFilterSchema = z.object({
   key: z.string().min(1),
   value: searchAttributeValueSchema.optional(),
-  gt: searchAttributeValueSchema.optional(),
-  lt: searchAttributeValueSchema.optional(),
-  gte: searchAttributeValueSchema.optional(),
-  lte: searchAttributeValueSchema.optional()
+  gt: attributeFilterScalarValueSchema.optional(),
+  lt: attributeFilterScalarValueSchema.optional(),
+  gte: attributeFilterScalarValueSchema.optional(),
+  lte: attributeFilterScalarValueSchema.optional()
 }), failureCategorySchema = z.custom(isFailureCategory), timeRangeSchema = z.object({
   gte: z.number().optional(),
   gt: z.number().optional(),
@@ -40,7 +41,8 @@ export const bulkListFilterInputSchema = z.object({
 }), bulkOperationControlInputSchema = z.object({
   dryRun: z.boolean().optional(),
   confirmationToken: z.string().min(1).max(MAX_BULK_CONFIRMATION_TOKEN_LENGTH).optional(),
-  requestId: z.string().min(1).max(MAX_BULK_OPERATION_REQUEST_ID_LENGTH).optional()
+  requestId: z.string().min(1).max(MAX_BULK_OPERATION_REQUEST_ID_LENGTH).optional(),
+  bulkConcurrency: z.number().int().min(1).optional()
 }), bulkOperatorAccessPolicy = {
   kind: "scoped",
   scopes: { kind: "anyOf", scopes: ["workflows:admin"] }
@@ -62,11 +64,13 @@ export function engineFailureFault(message) {
     data: {}
   };
 }
-export async function readOptionalJsonBody(request) {
+export async function readOptionalJsonBody(request, context) {
   try {
-    const text = await request.text();
+    const text = await readRestTextBody(request, context);
     return text.trim() === "" ? void 0 : JSON.parse(text);
-  } catch {
+  } catch (error) {
+    if (isOperationFault(error))
+      throw error;
     throw invalidParamsFault("Invalid JSON body");
   }
 }
@@ -92,7 +96,13 @@ function parseAttributeFiltersFromBody(value) {
       if (attributeValue === void 0)
         continue;
       if (!isJsonSearchAttributeValue(attributeValue))
-        throw Error(`Field "filter.attributes[${index}].${property}" must be a string, number, boolean, or string array`);
+        throw Error(`Field "filter.attributes[${index}].${property}" must be a string, number, boolean, or scalar array`);
+      if (property === "value") {
+        filter.value = attributeValue;
+        continue;
+      }
+      if (Array.isArray(attributeValue))
+        throw Error(`Field "filter.attributes[${index}].${property}" must be a string, number, or boolean`);
       filter[property] = attributeValue;
     }
     return filter;
@@ -243,14 +253,23 @@ function applyBasicBulkFilterFields(filter, input) {
     filter.offset = input.offset;
 }
 function copyAttributeFilter(attribute) {
-  return {
-    key: attribute.key,
-    ...attribute.value === void 0 ? {} : { value: attribute.value },
-    ...attribute.gt === void 0 ? {} : { gt: attribute.gt },
-    ...attribute.lt === void 0 ? {} : { lt: attribute.lt },
-    ...attribute.gte === void 0 ? {} : { gte: attribute.gte },
-    ...attribute.lte === void 0 ? {} : { lte: attribute.lte }
-  };
+  const filter = { key: attribute.key };
+  if (attribute.value !== void 0)
+    filter.value = attribute.value;
+  if (attribute.gt !== void 0)
+    filter.gt = copyAttributeRangeBound(attribute.gt, "gt");
+  if (attribute.lt !== void 0)
+    filter.lt = copyAttributeRangeBound(attribute.lt, "lt");
+  if (attribute.gte !== void 0)
+    filter.gte = copyAttributeRangeBound(attribute.gte, "gte");
+  if (attribute.lte !== void 0)
+    filter.lte = copyAttributeRangeBound(attribute.lte, "lte");
+  return filter;
+}
+function copyAttributeRangeBound(value, property) {
+  if (Array.isArray(value))
+    throw Error(`Field "filter.attributes[].${property}" must be a string, number, or boolean`);
+  return value;
 }
 function applyExtendedBulkFilterFields(filter, input) {
   if (input.idPrefix !== void 0)
@@ -272,11 +291,12 @@ function applyBulkTimeRangeFields(filter, input) {
 export function parseBulkOperationControlFromBody(body) {
   if (body === void 0)
     return {};
-  const record = parseJsonObjectBody(body), dryRun = parseOptionalBooleanControl(record, "dryRun"), confirmationToken = parseOptionalNonEmptyStringControl(record, "confirmationToken"), requestId = parseOptionalBulkRequestId(record);
+  const record = parseJsonObjectBody(body), dryRun = parseOptionalBooleanControl(record, "dryRun"), confirmationToken = parseOptionalNonEmptyStringControl(record, "confirmationToken"), requestId = parseOptionalBulkRequestId(record), bulkConcurrency = parseOptionalPositiveIntegerControl(record, "bulkConcurrency");
   return {
     ...dryRun === void 0 ? {} : { dryRun },
     ...confirmationToken === void 0 ? {} : { confirmationToken },
-    ...requestId === void 0 ? {} : { requestId }
+    ...requestId === void 0 ? {} : { requestId },
+    ...bulkConcurrency === void 0 ? {} : { bulkConcurrency }
   };
 }
 export function bulkOperationOptionsFromInput(input, principal) {
@@ -285,14 +305,16 @@ export function bulkOperationOptionsFromInput(input, principal) {
     return {
       dryRun: !0,
       principal: auditPrincipal,
-      ...input.requestId === void 0 ? {} : { requestId: input.requestId }
+      ...input.requestId === void 0 ? {} : { requestId: input.requestId },
+      ...input.bulkConcurrency === void 0 ? {} : { bulkConcurrency: input.bulkConcurrency }
     };
   if (input.confirmationToken === void 0)
     throw invalidParamsFault('Field "confirmationToken" is required after a dry run');
   return {
     confirmationToken: input.confirmationToken,
     principal: auditPrincipal,
-    ...input.requestId === void 0 ? {} : { requestId: input.requestId }
+    ...input.requestId === void 0 ? {} : { requestId: input.requestId },
+    ...input.bulkConcurrency === void 0 ? {} : { bulkConcurrency: input.bulkConcurrency }
   };
 }
 function principalToBulkOperationPrincipal(principal) {
@@ -316,6 +338,14 @@ function parseOptionalBooleanControl(record, fieldName) {
     return value;
   throw Error(`Field "${fieldName}" must be a boolean`);
 }
+function parseOptionalPositiveIntegerControl(record, fieldName) {
+  const value = record[fieldName];
+  if (value === void 0)
+    return;
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 1)
+    return value;
+  throw Error(`Field "${fieldName}" must be a positive integer`);
+}
 function parseOptionalNonEmptyStringControl(record, fieldName) {
   const value = record[fieldName];
   if (value === void 0)

package/dist/server/operations/bulk-mutate-workflow-tags.d.ts

@@ -9,10 +9,10 @@ declare const bulkMutateWorkflowTagsInput: z.ZodObject<{
         attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
             key: z.ZodString;
             value: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
-            gt: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
-            lt: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
-            gte: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
-            lte: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
+            gt: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
+            lt: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
+            gte: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
+            lte: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
         }, z.core.$strip>>>;
         limit: z.ZodOptional<z.ZodNumber>;
         offset: z.ZodOptional<z.ZodNumber>;
@@ -45,6 +45,7 @@ declare const bulkMutateWorkflowTagsInput: 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 BulkMutateWorkflowTagsInput = z.infer<typeof bulkMutateWorkflowTagsInput>;
 export type BulkMutateWorkflowTagsOutput = BulkTagResult | BulkOperationDryRunResult;
@@ -58,10 +59,10 @@ export declare const bulkMutateWorkflowTagsOperation: import("../operation-catal
         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;
@@ -89,6 +90,7 @@ export declare const bulkMutateWorkflowTagsOperation: import("../operation-catal
     dryRun?: boolean | undefined;
     confirmationToken?: string | undefined;
     requestId?: string | undefined;
-}, BulkMutateWorkflowTagsOutput>;
+    bulkConcurrency?: number | undefined;
+}, BulkMutateWorkflowTagsOutput, unknown>;
 export declare const bulkMutateWorkflowTagsRestBinding: UnknownRestBinding;
 export {};

package/dist/server/operations/bulk-mutate-workflow-tags.js

@@ -67,8 +67,8 @@ export const bulkMutateWorkflowTagsRestBinding = {
     tags: { kind: "body-field", bodyField: "tags" },
     operation: { kind: "body-field", bodyField: "operation" }
   },
-  extractInput: async (request) => {
-    const raw = await readOptionalJsonBody(request);
+  extractInput: async (request, _pathParams, context) => {
+    const raw = await readOptionalJsonBody(request, context);
     if (raw === void 0 || typeof raw !== "object" || raw === null || Array.isArray(raw))
       throw invalidParamsFault("Request body must be a JSON object");
     const body = raw;

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

@@ -1,4 +1,4 @@
-import type { BulkCancelResult, BulkDeleteResult, BulkOperationDryRunResult, BulkSignalResult, BulkTagResult, ListFilter, PurgeResult } from '../../core/types.ts';
+import type { BulkCancelResult, BulkDeleteResult, BulkOperationDryRunResult, BulkRetryFailedResult, BulkSignalResult, BulkTagResult, ListFilter, PurgeResult } from '../../core/types.ts';
 import { type BulkListFilterInput } from './bulk-filter-helpers.ts';
 /**
  * Coerces filter tags (label `Field "filter.tags"`), builds a `ListFilter`
@@ -17,7 +17,7 @@ import { type BulkListFilterInput } from './bulk-filter-helpers.ts';
  * raw engine messages through unmasked.
  */
 export declare function validatedListFilterFromBulkInput(input: BulkListFilterInput): ListFilter;
-export type BulkOperationSuccessResult = BulkCancelResult | BulkDeleteResult | BulkSignalResult | BulkTagResult | BulkOperationDryRunResult | PurgeResult;
+export type BulkOperationSuccessResult = BulkCancelResult | BulkDeleteResult | BulkRetryFailedResult | BulkSignalResult | BulkTagResult | BulkOperationDryRunResult | PurgeResult;
 /**
  * Standard JSON 200 response shape for bulk-workflow operations. Used by
  * every bulk operation's REST `shapeSuccess`; the result types are unioned

package/dist/server/operations/bulk-retry-failed-workflows.d.ts

@@ -0,0 +1,7 @@
+import type { BulkOperationDryRunResult, BulkRetryFailedResult } from '../../core/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+import { type BulkListFilterInput, type BulkOperationControlInput } from './bulk-filter-helpers.ts';
+export type BulkRetryFailedWorkflowsInput = BulkListFilterInput & BulkOperationControlInput;
+export type BulkRetryFailedWorkflowsOutput = BulkRetryFailedResult | BulkOperationDryRunResult;
+export declare const bulkRetryFailedWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<BulkRetryFailedWorkflowsInput, BulkRetryFailedWorkflowsOutput, unknown>;
+export declare const bulkRetryFailedWorkflowsRestBinding: UnknownRestBinding;

package/dist/server/operations/bulk-retry-failed-workflows.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+import { BulkOperationConfirmationError } from "../../core/engine.js";
+import { defineOperation } from "../operation-registry.js";
+import {
+  bulkListFilterInputSchema,
+  bulkOperationControlInputSchema,
+  bulkOperationOptionsFromInput,
+  bulkOperatorAccessPolicy,
+  engineFailureFault,
+  faultMessage,
+  parseBulkListFilterFromBody,
+  parseBulkOperationControlFromBody,
+  readOptionalJsonBody
+} from "./bulk-filter-helpers.js";
+import {
+  shapeBulkJsonSuccess,
+  validatedListFilterFromBulkInput
+} from "./bulk-operation-helpers.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+const bulkRetryFailedWorkflowsInput = bulkListFilterInputSchema.merge(bulkOperationControlInputSchema), bulkRetryFailedWorkflowsOutput = z.unknown();
+export const bulkRetryFailedWorkflowsOperation = defineOperation({
+  name: "weft.workflows.bulk.retryfailed",
+  mcpExposable: !1,
+  summary: "Retry failed workflows in bulk",
+  destructive: !0,
+  tags: ["Workflows"],
+  inputSchema: bulkRetryFailedWorkflowsInput,
+  outputSchema: bulkRetryFailedWorkflowsOutput,
+  access: bulkOperatorAccessPolicy,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine, principal }) => {
+    const e = engine, filter = validatedListFilterFromBulkInput(input), operationOptions = bulkOperationOptionsFromInput(input, principal);
+    try {
+      if (operationOptions.dryRun === !0)
+        return await e.retryFailedAll(filter, operationOptions);
+      return await e.retryFailedAll(filter, operationOptions);
+    } catch (error) {
+      if (error instanceof BulkOperationConfirmationError)
+        throw invalidParamsFault(error.message);
+      throw engineFailureFault(faultMessage(error));
+    }
+  }
+}), bulkRetryFailedWorkflowsRestBinding = {
+  method: "POST",
+  path: "/v1/workflows/bulk/retry-failed",
+  pathParamNames: [],
+  operationName: "weft.workflows.bulk.retryfailed",
+  inputSources: {},
+  extractInput: async (request, _pathParams, context) => {
+    const raw = await readOptionalJsonBody(request, context);
+    try {
+      return {
+        ...parseBulkListFilterFromBody(raw),
+        ...parseBulkOperationControlFromBody(raw)
+      };
+    } catch (error) {
+      throw invalidParamsFault(faultMessage(error));
+    }
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => shapeBulkJsonSuccess(output),
+  shapeFault: shapeRestFault
+};

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

@@ -8,10 +8,10 @@ declare const bulkSignalWorkflowsInput: z.ZodObject<{
     attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
         key: z.ZodString;
         value: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
-        gt: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
-        lt: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
-        gte: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
-        lte: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
+        gt: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
+        lt: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
+        gte: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
+        lte: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
     }, z.core.$strip>>>;
     limit: z.ZodOptional<z.ZodNumber>;
     offset: z.ZodOptional<z.ZodNumber>;
@@ -40,6 +40,7 @@ declare const bulkSignalWorkflowsInput: 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 BulkSignalWorkflowsInput = z.infer<typeof bulkSignalWorkflowsInput>;
 export type BulkSignalWorkflowsOutput = BulkSignalResult | BulkOperationDryRunResult;
@@ -51,10 +52,10 @@ export declare const bulkSignalWorkflowsOperation: import("../operation-catalog.
     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;
@@ -82,6 +83,7 @@ export declare const bulkSignalWorkflowsOperation: import("../operation-catalog.
     dryRun?: boolean | undefined;
     confirmationToken?: string | undefined;
     requestId?: string | undefined;
-}, BulkSignalWorkflowsOutput>;
+    bulkConcurrency?: number | undefined;
+}, BulkSignalWorkflowsOutput, unknown>;
 export declare const bulkSignalWorkflowsRestBinding: UnknownRestBinding;
 export {};

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

@@ -53,8 +53,8 @@ export const bulkSignalWorkflowsOperation = defineOperation({
     name: { kind: "body-field", bodyField: "name" },
     payload: { kind: "body-field", bodyField: "payload" }
   },
-  extractInput: async (request) => {
-    const raw = await readOptionalJsonBody(request);
+  extractInput: async (request, _pathParams, context) => {
+    const raw = await readOptionalJsonBody(request, context);
     if (raw === void 0 || typeof raw !== "object" || raw === null || Array.isArray(raw))
       throw invalidParamsFault("Request body must be a JSON object");
     const body = raw;

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

@@ -8,6 +8,6 @@ export type CancelScheduleInput = z.infer<typeof cancelScheduleInput>;
 export type CancelScheduleOutput = z.infer<typeof cancelScheduleOutput>;
 export declare const cancelScheduleOperation: import("../operation-catalog.ts").OperationDefinition<{
     scheduleId: string;
-}, undefined>;
+}, undefined, unknown>;
 export declare const cancelScheduleRestBinding: UnknownRestBinding;
 export {};

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

@@ -8,6 +8,7 @@ declare const createScheduleInput: z.ZodObject<{
     id: z.ZodOptional<z.ZodUnknown>;
     overlap: z.ZodOptional<z.ZodUnknown>;
     backfill: z.ZodOptional<z.ZodUnknown>;
+    jitter: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 declare const createScheduleOutput: z.ZodObject<{
     id: z.ZodString;
@@ -22,8 +23,9 @@ export declare const createScheduleOperation: import("../operation-catalog.ts").
     id?: unknown;
     overlap?: unknown;
     backfill?: unknown;
+    jitter?: unknown;
 }, {
     id: string;
-}>;
+}, unknown>;
 export declare const createScheduleRestBinding: UnknownRestBinding;
 export {};

package/dist/server/operations/create-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 VALID_SCHEDULE_OVERLAP_POLICIES = new Set([
   "skip",
@@ -14,7 +15,8 @@ const VALID_SCHEDULE_OVERLAP_POLICIES = new Set([
   input: z.unknown().optional(),
   id: z.unknown().optional(),
   overlap: z.unknown().optional(),
-  backfill: z.unknown().optional()
+  backfill: z.unknown().optional(),
+  jitter: z.unknown().optional()
 }), createScheduleOutput = z.object({
   id: z.string()
 });
@@ -42,11 +44,22 @@ function validateOptionalScheduleFields(input) {
       throw invalidParamsFault('Field "backfill" must be a boolean');
     validatedBackfill = input.backfill;
   }
-  return { id: validatedId, overlap: validatedOverlap, backfill: validatedBackfill };
+  let validatedJitter;
+  if (input.jitter !== void 0) {
+    if (typeof input.jitter !== "string" && typeof input.jitter !== "number")
+      throw invalidParamsFault('Field "jitter" must be a duration string or a number of milliseconds');
+    validatedJitter = input.jitter;
+  }
+  return {
+    id: validatedId,
+    overlap: validatedOverlap,
+    backfill: validatedBackfill,
+    jitter: validatedJitter
+  };
 }
 function validateCreateScheduleInput(input) {
-  const { type, spec } = validateRequiredScheduleFields(input), { id, overlap, backfill } = validateOptionalScheduleFields(input);
-  return { type, spec, id, overlap, backfill };
+  const { type, spec } = validateRequiredScheduleFields(input), { id, overlap, backfill, jitter } = validateOptionalScheduleFields(input);
+  return { type, spec, id, overlap, backfill, jitter };
 }
 export const createScheduleOperation = defineOperation({
   name: "weft.schedules.create",
@@ -65,7 +78,8 @@ export const createScheduleOperation = defineOperation({
     const typedEngine = engine, validated = validateCreateScheduleInput(input), options = {
       ...validated.id !== void 0 ? { id: validated.id } : {},
       ...validated.overlap !== void 0 ? { overlap: validated.overlap } : {},
-      ...validated.backfill !== void 0 ? { backfill: validated.backfill } : {}
+      ...validated.backfill !== void 0 ? { backfill: validated.backfill } : {},
+      ...validated.jitter !== void 0 ? { jitter: validated.jitter } : {}
     };
     try {
       return { id: (await typedEngine.schedule(validated.type, input.input, validated.spec, options)).id };
@@ -89,13 +103,16 @@ export const createScheduleRestBinding = {
     input: { kind: "body-field", bodyField: "input" },
     id: { kind: "body-field", bodyField: "id" },
     overlap: { kind: "body-field", bodyField: "overlap" },
-    backfill: { kind: "body-field", bodyField: "backfill" }
+    backfill: { kind: "body-field", bodyField: "backfill" },
+    jitter: { kind: "body-field", bodyField: "jitter" }
   },
-  extractInput: async (request) => {
+  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)
@@ -108,7 +125,8 @@ export const createScheduleRestBinding = {
       input: record.input,
       id: record.id,
       overlap: record.overlap,
-      backfill: record.backfill
+      backfill: record.backfill,
+      jitter: record.jitter
     };
   },
   success: { kind: "json", status: 201 },

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

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import type { FleetEventEnvelope } from '../fleet-event-feed.ts';
+declare const fleetEventsSubscriptionInput: z.ZodObject<{
+    workflowId: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        "human-review:requested": "human-review:requested";
+        "human-review:completed": "human-review:completed";
+        "alert:fired": "alert:fired";
+        "alert:resolved": "alert:resolved";
+        "activity:started": "activity:started";
+        "activity:completed": "activity:completed";
+        "activity:async-pending": "activity:async-pending";
+        "activity:failed": "activity:failed";
+        "task:dead-lettered": "task:dead-lettered";
+        "attributes:changed": "attributes:changed";
+        "schedule:fired": "schedule:fired";
+        "schedule:missed-fire": "schedule:missed-fire";
+        "signal:received": "signal:received";
+        "signal:delivered": "signal:delivered";
+        "checkpoint:size-warning": "checkpoint:size-warning";
+        "development:warning": "development:warning";
+        "cleanup:warning": "cleanup:warning";
+        "storage:size-reported": "storage:size-reported";
+        "worker:connected": "worker:connected";
+        "worker:disconnected": "worker:disconnected";
+        "constraint:violated": "constraint:violated";
+        "update:received": "update:received";
+        "update:completed": "update:completed";
+        "workflow:started": "workflow:started";
+        "workflow:completed": "workflow:completed";
+        "workflow:failed": "workflow:failed";
+        "workflow:cancelled": "workflow:cancelled";
+        "workflow:timed-out": "workflow:timed-out";
+        "workflow:resumed": "workflow:resumed";
+        "workflow:suspended": "workflow:suspended";
+        "workflow:teardown": "workflow:teardown";
+    }>>;
+    fromCursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const fleetEventsSubscriptionEnvelope: z.ZodObject<{
+    subscriptionId: z.ZodString;
+    cursor: z.ZodString;
+}, z.core.$strip>;
+export type FleetEventsSubscriptionInput = z.infer<typeof fleetEventsSubscriptionInput>;
+export type FleetEventsSubscriptionEnvelope = z.infer<typeof fleetEventsSubscriptionEnvelope>;
+export declare const fleetEventsSubscriptionOperation: import("../operation-catalog.ts").OperationDefinition<{
+    workflowId?: string | undefined;
+    kind?: "human-review:requested" | "human-review:completed" | "alert:fired" | "alert:resolved" | "activity:started" | "activity:completed" | "activity:async-pending" | "activity:failed" | "task:dead-lettered" | "attributes:changed" | "schedule:fired" | "schedule:missed-fire" | "signal:received" | "signal:delivered" | "checkpoint:size-warning" | "development:warning" | "cleanup:warning" | "storage:size-reported" | "worker:connected" | "worker:disconnected" | "constraint:violated" | "update:received" | "update:completed" | "workflow:started" | "workflow:completed" | "workflow:failed" | "workflow:cancelled" | "workflow:timed-out" | "workflow:resumed" | "workflow:suspended" | "workflow:teardown" | undefined;
+    fromCursor?: string | undefined;
+}, {
+    subscriptionId: string;
+    cursor: string;
+}, FleetEventEnvelope>;
+export {};

package/dist/server/operations/fleet-events-subscription.js

@@ -0,0 +1,99 @@
+import { z } from "zod";
+import { raiseFault } from "../operation-catalog/raise-fault.js";
+import { defineOperation } from "../operation-registry.js";
+import { EVENTS_READ_EVENT_TYPES } from "../runtime/client-visible-events.js";
+import { decodeCursor } from "../workflow-event-feed.js";
+import { invalidParamsFault } from "./operation-helpers.js";
+const INITIAL_SUBSCRIPTION_CURSOR = "-1", MAX_FLEET_SUBSCRIPTION_REPLAY_EVENTS = 1000, fleetEventKindSchema = z.enum(EVENTS_READ_EVENT_TYPES), fleetCursorSchema = z.string().regex(/^(?:-1|\d+)$/, "Invalid cursor").refine((cursor) => decodeCursor(cursor) !== null, {
+  message: "Invalid cursor"
+}), fleetEventsSubscriptionInput = z.object({
+  workflowId: z.string().min(1).optional(),
+  kind: fleetEventKindSchema.optional(),
+  fromCursor: fleetCursorSchema.optional()
+}), fleetEventsSubscriptionEnvelope = z.object({
+  subscriptionId: z.string(),
+  cursor: z.string()
+}), fleetEventEnvelopeSchema = z.object({
+  kind: z.string(),
+  workflowId: z.string().optional(),
+  sequence: z.number(),
+  cursor: z.string(),
+  emittedAtMs: z.number(),
+  payload: z.unknown()
+});
+export const fleetEventsSubscriptionOperation = defineOperation({
+  name: "weft.events.subscribe",
+  mcpExposable: !1,
+  kind: "subscription",
+  summary: "Subscribe to fleet-wide events with replay-from-cursor",
+  description: "Subscribes to the server-level event feed across workflows. Optional filters narrow delivery by workflow id or event kind after the single fleet cursor has been applied. Historical replay is capped at 1,000 matching retained events per subscription; use a recent fromCursor for older feeds.",
+  destructive: !1,
+  tags: ["Events"],
+  inputSchema: fleetEventsSubscriptionInput,
+  outputSchema: fleetEventsSubscriptionEnvelope,
+  producibleFaults: ["UnsupportedTransport", "InvalidParams"],
+  eventSchema: fleetEventEnvelopeSchema,
+  access: {
+    kind: "scoped",
+    scopes: { kind: "anyOf", scopes: ["events:read"] }
+  },
+  discoverable: !0,
+  transports: { http: !1, jsonRpcHttp: !1, jsonRpcWebSocket: !0, jsonRpcStdio: !1 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine, transport }) => {
+    const startingCursor = input.fromCursor ?? INITIAL_SUBSCRIPTION_CURSOR;
+    if (decodeCursor(startingCursor) === null)
+      raiseFault(fleetEventsSubscriptionOperation, invalidParamsFault("Invalid cursor"));
+    const fleetFeed = getFleetEventFeed(engine, transport), controller = new AbortController, iterable = fleetFeed.subscribe({
+      ...input.fromCursor === void 0 ? {} : { fromCursor: input.fromCursor },
+      signal: controller.signal,
+      replayLimit: MAX_FLEET_SUBSCRIPTION_REPLAY_EVENTS,
+      filterEnvelope: (envelope) => matchesFleetEventFilter(envelope, input),
+      createReplayLimitError: (count, limit) => fleetReplayLimitFault(count, limit)
+    });
+    return {
+      envelope: { subscriptionId: `sub_${crypto.randomUUID()}`, cursor: startingCursor },
+      iterable,
+      close: async () => {
+        controller.abort();
+      }
+    };
+  }
+});
+function fleetReplayLimitFault(count, limit) {
+  return invalidParamsFault(`Fleet event replay window is ${count} matching events; maximum is ${limit}. Supply a more recent fromCursor.`);
+}
+function matchesFleetEventFilter(envelope, input) {
+  if (!matchesWorkflowIdFilter(envelope, input.workflowId))
+    return !1;
+  if (!matchesKindFilter(envelope, input.kind))
+    return !1;
+  return !0;
+}
+function matchesWorkflowIdFilter(envelope, workflowId) {
+  if (workflowId === void 0)
+    return !0;
+  return envelope.workflowId === workflowId;
+}
+function matchesKindFilter(envelope, kind) {
+  if (kind === void 0)
+    return !0;
+  return envelope.kind === kind;
+}
+function getFleetEventFeed(engine, transport) {
+  if (typeof engine === "object" && engine !== null && "fleetFeed" in engine) {
+    const fleetFeed = engine.fleetFeed;
+    if (isFleetEventSubscriber(fleetFeed))
+      return fleetFeed;
+  }
+  raiseFault(fleetEventsSubscriptionOperation, {
+    code: "UnsupportedTransport",
+    message: "Fleet event subscription requires a WebSocket fleet event feed",
+    data: { transport, supported: ["jsonRpcWebSocket"] }
+  });
+}
+function isFleetEventSubscriber(value) {
+  if (typeof value !== "object" || value === null)
+    return !1;
+  return typeof value.subscribe === "function";
+}

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

@@ -24,6 +24,6 @@ export declare const forkWorkflowOperation: import("../operation-catalog.ts").Op
     fromStep?: unknown;
 }, {
     id: string;
-}>;
+}, unknown>;
 export declare const forkWorkflowRestBinding: UnknownRestBinding;
 export {};