@lostgradient/weft 0.14.0 → 0.16.0

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

@@ -4,6 +4,12 @@ import { EVENTS_READ_EVENT_TYPES } from "../runtime/client-visible-events.js";
 import {
   decodeCursor
 } from "../workflow-event-feed.js";
+import {
+  createReplayAwareClosableIterable,
+  fleetEventEnvelopeSchema,
+  isClosableAsyncIterable,
+  isReplayAwareClosableIterable
+} from "./event-stream-contracts.js";
 import { invalidParamsFault } from "./operation-helpers.js";
 import {
   createEventEnvelopeSSEStream,
@@ -19,14 +25,7 @@ const INITIAL_CURSOR = "-1", MAX_FLEET_SSE_REPLAY_EVENTS = 1000, cursorSchema =
   kind: fleetEventKindSchema.optional(),
   fromCursor: cursorSchema.optional(),
   lastEventId: cursorSchema.optional()
-}), fleetEventsSseOutputSchema = z.custom(isAsyncIterable, "Expected async iterable fleet event stream"), fleetEventEnvelopeSchema = z.object({
-  kind: z.string(),
-  workflowId: z.string().optional(),
-  sequence: z.number(),
-  cursor: z.string(),
-  emittedAtMs: z.number(),
-  payload: z.unknown()
-});
+}), fleetEventsSseOutputSchema = z.custom(isAsyncIterable, "Expected async iterable fleet event stream");
 export const fleetEventsSseOperation = defineOperation({
   name: "weft.events.sse",
   mcpExposable: !1,
@@ -67,12 +66,6 @@ function isAsyncIterable(value) {
     return !1;
   return typeof value[Symbol.asyncIterator] === "function";
 }
-function isClosableFleetEventsIterable(value) {
-  return "close" in value && typeof value.close === "function";
-}
-function isReplayAwareFleetEventsIterable(value) {
-  return isClosableFleetEventsIterable(value) && "replayComplete" in value && value.replayComplete instanceof Promise;
-}
 function matchesFleetEventFilter(envelope, input) {
   if (input.workflowId !== void 0 && envelope.workflowId !== input.workflowId)
     return !1;
@@ -84,49 +77,27 @@ function createFleetEventsIterable(input, context) {
   const feed = context.fleetEventFeed;
   if (feed === void 0)
     throw unsupportedEventStreamContextFault("fleet event SSE requires a fleet event feed");
-  const controller = new AbortController, replayComplete = Promise.withResolvers();
-  let closed = !1;
-  const close = async () => {
-    if (closed)
-      return;
-    closed = !0;
-    controller.abort();
-  }, subscribeOptions = {
-    fromCursor: input.lastEventId ?? input.fromCursor ?? INITIAL_CURSOR,
-    signal: controller.signal,
-    replayLimit: MAX_FLEET_SSE_REPLAY_EVENTS,
-    filterEnvelope: (envelope) => matchesFleetEventFilter(envelope, input),
-    onReplayComplete: () => replayComplete.resolve(),
-    createReplayLimitError: (count, limit) => invalidParamsFault(`Fleet event replay window is ${count} matching events; maximum is ${limit}. Supply a more recent fromCursor.`)
-  };
-  let source;
-  try {
-    source = feed.subscribe(subscribeOptions);
-  } catch (error) {
-    close();
-    throw error;
-  }
-  return {
-    async* [Symbol.asyncIterator]() {
-      try {
-        for await (const envelope of source)
-          yield envelope;
-      } finally {
-        await close();
-      }
-    },
-    replayComplete: replayComplete.promise,
-    close
-  };
+  const controller = new AbortController, fromCursor = input.lastEventId ?? input.fromCursor ?? INITIAL_CURSOR;
+  return createReplayAwareClosableIterable((onReplayComplete) => {
+    const subscribeOptions = {
+      fromCursor,
+      signal: controller.signal,
+      replayLimit: MAX_FLEET_SSE_REPLAY_EVENTS,
+      filterEnvelope: (envelope) => matchesFleetEventFilter(envelope, input),
+      onReplayComplete,
+      createReplayLimitError: (count, limit) => invalidParamsFault(`Fleet event replay window is ${count} matching events; maximum is ${limit}. Supply a more recent fromCursor.`)
+    };
+    return feed.subscribe(subscribeOptions);
+  }, { close: () => controller.abort() });
 }
 function shapeFleetEventsSseSuccess(output, request) {
-  const close = isClosableFleetEventsIterable(output) ? () => output.close() : async () => {
+  const close = isClosableAsyncIterable(output) ? () => output.close() : async () => {
     return;
   };
   return new Response(createEventEnvelopeSSEStream({
     iterable: output,
     close,
-    ...isReplayAwareFleetEventsIterable(output) ? { ready: output.replayComplete } : {},
+    ...isReplayAwareClosableIterable(output) ? { ready: output.replayComplete } : {},
     signal: request.signal
   }), {
     status: 200,

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

@@ -3,6 +3,10 @@ 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 {
+  createReplayAwareClosableIterable,
+  fleetEventEnvelopeSchema
+} from "./event-stream-contracts.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"
@@ -13,13 +17,6 @@ const INITIAL_SUBSCRIPTION_CURSOR = "-1", MAX_FLEET_SUBSCRIPTION_REPLAY_EVENTS =
 }), 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",
@@ -44,19 +41,18 @@ export const fleetEventsSubscriptionOperation = defineOperation({
     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({
+    const fleetFeed = getFleetEventFeed(engine, transport), controller = new AbortController, iterable = createReplayAwareClosableIterable((onReplayComplete) => fleetFeed.subscribe({
       ...input.fromCursor === void 0 ? {} : { fromCursor: input.fromCursor },
       signal: controller.signal,
       replayLimit: MAX_FLEET_SUBSCRIPTION_REPLAY_EVENTS,
       filterEnvelope: (envelope) => matchesFleetEventFilter(envelope, input),
+      onReplayComplete,
       createReplayLimitError: (count, limit) => fleetReplayLimitFault(count, limit)
-    });
+    }), { close: () => controller.abort() });
     return {
       envelope: { subscriptionId: `sub_${crypto.randomUUID()}`, cursor: startingCursor },
       iterable,
-      close: async () => {
-        controller.abort();
-      }
+      close: () => iterable.close()
     };
   }
 });

package/dist/server/operations/list-alerts.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `weft.alerts.list` operation + REST binding.
+ *
+ * Reports the alert rules that are currently firing. The response deliberately
+ * omits rule actions and webhook destinations: this is an operator diagnostic
+ * surface, not a configuration export.
+ */
+import { z } from 'zod';
+import type { AlertMetric } from '../../alerting/types.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const listAlertsInput: z.ZodObject<{}, z.core.$strip>;
+declare const activeAlertSchema: z.ZodObject<{
+    metric: z.ZodType<AlertMetric, unknown, z.core.$ZodTypeInternals<AlertMetric, unknown>>;
+    threshold: z.ZodNumber;
+    currentValue: z.ZodNumber;
+    window: z.ZodNullable<z.ZodString>;
+    firedAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export type ListAlertsInput = z.infer<typeof listAlertsInput>;
+export type ActiveAlert = z.infer<typeof activeAlertSchema>;
+export type ListAlertsOutput = {
+    items: ActiveAlert[];
+};
+export declare const listAlertsOperation: import("../operation-catalog.ts").OperationDefinition<Record<string, never>, ListAlertsOutput, unknown>;
+export declare const listAlertsRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/list-alerts.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { shapeOperationFaultAsJson } from "../operation-fault.js";
+import { defineOperation } from "../operation-registry.js";
+const alertMetricSchema = z.enum([
+  "workflow.failure_rate",
+  "activity.p99_duration",
+  "storage.size"
+]), listAlertsInput = z.object({}), activeAlertSchema = z.object({
+  metric: alertMetricSchema,
+  threshold: z.number(),
+  currentValue: z.number(),
+  window: z.string().nullable(),
+  firedAt: z.number().nullable()
+}), listAlertsOutput = z.object({
+  items: z.array(activeAlertSchema)
+});
+export const listAlertsOperation = defineOperation({
+  name: "weft.alerts.list",
+  mcpExposable: !1,
+  summary: "List currently firing alerts",
+  description: "List the alert rules that are currently firing, including their metric, threshold, current value, configured window, and firing timestamp. Read-only and limited to active in-memory alert state; resolved alerts are not returned.",
+  destructive: !1,
+  tags: ["Observability"],
+  inputSchema: listAlertsInput,
+  outputSchema: listAlertsOutput,
+  access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["system:read"] } },
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ engine }) => {
+    return {
+      items: engine.getActiveAlerts().map((state) => ({
+        metric: state.rule.metric,
+        threshold: state.rule.threshold,
+        currentValue: state.currentValue,
+        window: state.rule.window ?? null,
+        firedAt: state.lastFiredAt ?? null
+      }))
+    };
+  }
+}), listAlertsRestBinding = {
+  method: "GET",
+  path: "/v1/alerts",
+  pathParamNames: [],
+  operationName: "weft.alerts.list",
+  inputSources: {},
+  extractInput: async () => ({}),
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => new Response(JSON.stringify(output), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  }),
+  shapeFault: shapeOperationFaultAsJson
+};

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

@@ -1,85 +1,85 @@
 import { z } from 'zod';
-import type { FailureCategory, PaginatedResult, SearchAttributeValue, WorkflowStatus, WorkflowSummary } from '../../core/types.ts';
+import type { PaginatedResult, WorkflowSummary } from '../../core/types.ts';
 import type { UnknownRestBinding } from '../rest-bindings.ts';
 declare const listWorkflowsInput: z.ZodObject<{
-    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<WorkflowStatus, WorkflowStatus>, z.ZodArray<z.ZodCustom<WorkflowStatus, WorkflowStatus>>]>>;
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     type: z.ZodOptional<z.ZodString>;
-    scheduleId: z.ZodOptional<z.ZodString>;
-    parentWorkflowId: z.ZodOptional<z.ZodString>;
-    parentWorkflowExecutionToken: z.ZodOptional<z.ZodString>;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    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>>;
-    }, z.core.$strip>>>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    offset: z.ZodOptional<z.ZodNumber>;
     idPrefix: z.ZodOptional<z.ZodString>;
     createdAt: z.ZodOptional<z.ZodObject<{
         gte: z.ZodOptional<z.ZodNumber>;
-        gt: z.ZodOptional<z.ZodNumber>;
         lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
         lt: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>>;
     updatedAt: z.ZodOptional<z.ZodObject<{
         gte: z.ZodOptional<z.ZodNumber>;
-        gt: z.ZodOptional<z.ZodNumber>;
         lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
         lt: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>>;
     executionDeadline: z.ZodOptional<z.ZodObject<{
         gte: z.ZodOptional<z.ZodNumber>;
-        gt: z.ZodOptional<z.ZodNumber>;
         lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
         lt: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<FailureCategory, FailureCategory>, z.ZodArray<z.ZodCustom<FailureCategory, FailureCategory>>]>>;
+    }, z.core.$strict>>;
+    failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     include: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-}, z.core.$strip>;
+    scheduleId: z.ZodOptional<z.ZodString>;
+    parentWorkflowId: z.ZodOptional<z.ZodString>;
+    parentWorkflowExecutionToken: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    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>>>;
+        gt: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        lt: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        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>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
 export type ListWorkflowsInput = z.infer<typeof listWorkflowsInput>;
 export type ListWorkflowsOutput = PaginatedResult<WorkflowSummary>;
 export declare const listWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<{
-    status?: WorkflowStatus | WorkflowStatus[] | undefined;
+    status?: string | string[] | undefined;
     type?: string | undefined;
-    scheduleId?: string | undefined;
-    parentWorkflowId?: string | undefined;
-    parentWorkflowExecutionToken?: string | undefined;
-    tags?: string[] | undefined;
-    attributes?: {
-        key: string;
-        value?: SearchAttributeValue | undefined;
-        gt?: SearchAttributeValue | undefined;
-        lt?: SearchAttributeValue | undefined;
-        gte?: SearchAttributeValue | undefined;
-        lte?: SearchAttributeValue | undefined;
-    }[] | undefined;
-    limit?: number | undefined;
-    offset?: number | undefined;
     idPrefix?: string | undefined;
     createdAt?: {
         gte?: number | undefined;
-        gt?: number | undefined;
         lte?: number | undefined;
+        gt?: number | undefined;
         lt?: number | undefined;
     } | undefined;
     updatedAt?: {
         gte?: number | undefined;
-        gt?: number | undefined;
         lte?: number | undefined;
+        gt?: number | undefined;
         lt?: number | undefined;
     } | undefined;
     executionDeadline?: {
         gte?: number | undefined;
-        gt?: number | undefined;
         lte?: number | undefined;
+        gt?: number | undefined;
         lt?: number | undefined;
     } | undefined;
-    failureCategory?: FailureCategory | FailureCategory[] | undefined;
+    failureCategory?: string | string[] | undefined;
     include?: string | string[] | undefined;
+    scheduleId?: string | undefined;
+    parentWorkflowId?: string | undefined;
+    parentWorkflowExecutionToken?: string | undefined;
+    tags?: string[] | undefined;
+    attributes?: {
+        key: any;
+        value?: unknown;
+        gt?: unknown;
+        lt?: unknown;
+        gte?: unknown;
+        lte?: unknown;
+    }[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
 }, ListWorkflowsOutput, unknown>;
 export declare const listWorkflowsRestBinding: UnknownRestBinding;
 export {};

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

@@ -2,45 +2,24 @@ import { z } from "zod";
 import { WorkflowListScanCapExceededError } from "../../core/engine/workflow-indexes.js";
 import {
   ListFilterValidationError,
+  listFilterObjectSchema,
   normalizeListFilter
 } from "../../core/list-filter-validation.js";
 import { coerceStartWorkflowTags } from "../../core/start-workflow-validation.js";
 import { defineOperation } from "../operation-registry.js";
 import { extractListFilterFromQuery } from "./list-filter-query-extractor.js";
 import { shapeRestFault } from "./operation-helpers.js";
-const workflowStatusSchema = z.custom((value) => typeof value === "string"), failureCategorySchema = 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({
-  key: z.string().min(1),
-  value: searchAttributeValueSchema.optional(),
-  gt: searchAttributeValueSchema.optional(),
-  lt: searchAttributeValueSchema.optional(),
-  gte: searchAttributeValueSchema.optional(),
-  lte: searchAttributeValueSchema.optional()
-}), timeRangeSchema = z.object({
-  gte: z.number().optional(),
-  gt: z.number().optional(),
-  lte: z.number().optional(),
-  lt: z.number().optional()
-}), listIncludeSchema = z.union([z.string(), z.array(z.string()).min(1)]).refine((value) => Array.isArray(value) ? value.every((entry) => entry === "failureCategory") : value === "failureCategory", { message: 'include must be "failureCategory"' }), listWorkflowsInput = z.object({
-  status: z.union([workflowStatusSchema, z.array(workflowStatusSchema)]).optional(),
+const listIncludeSchema = z.union([z.string(), z.array(z.string()).min(1)]).refine((value) => Array.isArray(value) ? value.every((entry) => entry === "failureCategory") : value === "failureCategory", { message: 'include must be "failureCategory"' }), listWorkflowsInput = z.object({
+  ...listFilterObjectSchema.shape,
+  status: z.union([z.string(), z.array(z.string())]).optional(),
   type: z.string().optional(),
-  scheduleId: z.string().min(1).optional(),
-  parentWorkflowId: z.string().min(1).optional(),
-  parentWorkflowExecutionToken: z.string().min(1).optional(),
-  tags: z.array(z.string()).optional(),
-  attributes: z.array(attributeFilterSchema).optional(),
-  limit: z.number().int().min(1).max(1000).optional(),
-  offset: z.number().int().min(0).optional(),
   idPrefix: z.string().optional(),
-  createdAt: timeRangeSchema.optional(),
-  updatedAt: timeRangeSchema.optional(),
-  executionDeadline: timeRangeSchema.optional(),
-  failureCategory: z.union([failureCategorySchema, z.array(failureCategorySchema)]).optional(),
+  createdAt: z.object(listFilterObjectSchema.shape.createdAt.unwrap().shape).strict().optional(),
+  updatedAt: z.object(listFilterObjectSchema.shape.updatedAt.unwrap().shape).strict().optional(),
+  executionDeadline: z.object(listFilterObjectSchema.shape.executionDeadline.unwrap().shape).strict().optional(),
+  failureCategory: z.union([z.string(), z.array(z.string())]).optional(),
   include: listIncludeSchema.optional()
-}), listWorkflowsOutput = z.unknown();
+}).strict(), listWorkflowsOutput = z.unknown();
 export const listWorkflowsOperation = defineOperation({
   name: "weft.workflows.list",
   mcpExposable: !1,

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

@@ -11,34 +11,34 @@ export declare const purgeWorkflowsOperation: import("../operation-catalog.ts").
     parentWorkflowExecutionToken?: string | undefined;
     tags?: string[] | undefined;
     attributes?: {
-        key: string;
-        value?: 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;
+        key: any;
+        value?: unknown;
+        gt?: unknown;
+        lt?: unknown;
+        gte?: unknown;
+        lte?: unknown;
     }[] | undefined;
-    limit?: number | undefined;
     offset?: number | undefined;
     idPrefix?: string | undefined;
-    failureCategory?: import("../../index.ts").FailureCategory | import("../../index.ts").FailureCategory[] | undefined;
     createdAt?: {
         gte?: number | undefined;
-        gt?: number | undefined;
         lte?: number | undefined;
+        gt?: number | undefined;
         lt?: number | undefined;
     } | undefined;
     updatedAt?: {
         gte?: number | undefined;
-        gt?: number | undefined;
         lte?: number | undefined;
+        gt?: number | undefined;
         lt?: number | undefined;
     } | undefined;
     executionDeadline?: {
         gte?: number | undefined;
-        gt?: number | undefined;
         lte?: number | undefined;
+        gt?: number | undefined;
         lt?: number | undefined;
     } | undefined;
+    failureCategory?: import("../../index.ts").FailureCategory | import("../../index.ts").FailureCategory[] | undefined;
+    limit?: number | undefined;
 }, PurgeResult, unknown>;
 export declare const purgeWorkflowsRestBinding: UnknownRestBinding;

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

@@ -1,6 +1,14 @@
-import type { ScheduleSpec } from '../../core/types.ts';
+import type { ScheduleSpec, ScheduleUpdateOptions } from '../../core/types.ts';
 import type { OperationFault } from '../operation-fault.ts';
 export { isOperationFault } from './operation-helpers.ts';
+export type ScheduleMutableOptionsInput = {
+    description?: unknown;
+    overlap?: unknown;
+    backfill?: unknown;
+    jitter?: unknown;
+};
+/** Validate the mutable schedule options shared by create and update. */
+export declare function validateScheduleMutableOptions(input: ScheduleMutableOptionsInput): ScheduleUpdateOptions;
 export declare function mapScheduleErrorToFault(scheduleId: string, error: unknown): OperationFault;
 /**
  * Validate the mutually exclusive schedule cadence fields (`cronExpression` or

package/dist/server/operations/schedule-faults.js

@@ -1,5 +1,56 @@
+import {
+  isValidScheduleOverlapPolicy,
+  normalizeScheduleUpdateOptions
+} from "../../core/engine/validation/schedule.js";
 import { invalidParamsFault } from "./operation-helpers.js";
 export { isOperationFault } from "./operation-helpers.js";
+export function validateScheduleMutableOptions(input) {
+  const description = validateScheduleDescription(input.description), overlap = validateScheduleOverlap(input.overlap), backfill = validateScheduleBackfill(input.backfill), jitter = validateScheduleJitter(input.jitter);
+  return {
+    ...description !== void 0 ? { description } : {},
+    ...overlap !== void 0 ? { overlap } : {},
+    ...backfill !== void 0 ? { backfill } : {},
+    ...jitter !== void 0 ? { jitter } : {}
+  };
+}
+function validateScheduleDescription(value) {
+  if (value === void 0)
+    return;
+  if (typeof value !== "string")
+    throw invalidParamsFault('Field "description" must be a string');
+  return value;
+}
+function validateScheduleOverlap(value) {
+  if (value === void 0)
+    return;
+  if (!isValidScheduleOverlapPolicy(value))
+    throw invalidParamsFault('Field "overlap" must be one of skip, queue, cancel-running, allow');
+  return value;
+}
+function validateScheduleBackfill(value) {
+  if (value === void 0)
+    return;
+  if (typeof value !== "boolean")
+    throw invalidParamsFault('Field "backfill" must be a boolean');
+  return value;
+}
+function validateScheduleJitter(value) {
+  if (value === void 0)
+    return;
+  if (typeof value !== "string" && typeof value !== "number")
+    throw invalidParamsFault('Field "jitter" must be a duration string or a number of milliseconds');
+  try {
+    normalizeScheduleUpdateOptions({ jitter: value });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw invalidParamsFault(formatJitterValidationMessage(message));
+  }
+  return value;
+}
+function formatJitterValidationMessage(message) {
+  const enginePrefix = "Invalid options.jitter: ", hasEnginePrefix = message.startsWith(enginePrefix), wireDetail = (hasEnginePrefix ? message.slice(enginePrefix.length) : message).replaceAll("options.jitter", 'Field "jitter"');
+  return hasEnginePrefix ? `Field "jitter" is invalid: ${wireDetail}` : wireDetail;
+}
 export function mapScheduleErrorToFault(scheduleId, error) {
   const message = error instanceof Error ? error.message : String(error), normalizedMessage = message.toLowerCase();
   if (normalizedMessage.includes("not found"))

package/dist/server/operations/schedule-rest-body.d.ts

@@ -0,0 +1,11 @@
+import type { RestInputContext } from '../rest-binding.ts';
+export type SharedScheduleRestFields = {
+    readonly cronExpression: unknown;
+    readonly every: unknown;
+    readonly description: unknown;
+    readonly overlap: unknown;
+    readonly backfill: unknown;
+    readonly jitter: unknown;
+};
+export declare function parseScheduleRestBodyRequestRecord(request: Request, context?: RestInputContext): Promise<Record<string, unknown>>;
+export declare function extractSharedScheduleRestFields(record: Record<string, unknown>): SharedScheduleRestFields;

package/dist/server/operations/schedule-rest-body.js

@@ -0,0 +1,28 @@
+import { readRestJsonBody } from "../rest-body.js";
+import { invalidParamsFault, isOperationFault } from "./operation-helpers.js";
+function isJsonObjectLikeRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+export async function parseScheduleRestBodyRequestRecord(request, context) {
+  let body;
+  try {
+    body = await readRestJsonBody(request, context);
+  } catch (error) {
+    if (isOperationFault(error))
+      throw error;
+    throw invalidParamsFault("Invalid JSON body");
+  }
+  if (!isJsonObjectLikeRecord(body))
+    throw invalidParamsFault("Request body must be a JSON object");
+  return body;
+}
+export function extractSharedScheduleRestFields(record) {
+  return {
+    cronExpression: Object.hasOwn(record, "cronExpression") ? record.cronExpression : void 0,
+    every: Object.hasOwn(record, "every") ? record.every : void 0,
+    description: record.description,
+    overlap: record.overlap,
+    backfill: record.backfill,
+    jitter: record.jitter
+  };
+}