@lostgradient/weft 0.23.1 → 0.24.1

package/dist/server/operations/get-task-detail.js

@@ -38,6 +38,7 @@ function baseEnvelopeFields(record) {
     operationId: record.operationId,
     ...record.workflowId !== void 0 ? { workflowId: record.workflowId } : {},
     ...record.workflowExecutionToken !== void 0 ? { workflowExecutionToken: record.workflowExecutionToken } : {},
+    ...record.workflowRevision !== void 0 ? { workflowRevision: record.workflowRevision } : {},
     workflowType: record.workflowType,
     activityName: record.activityName,
     queue: record.queue,

package/dist/server/operations/get-task-diagnostics.d.ts

@@ -60,8 +60,8 @@ declare const taskDiagnosticItemSchema: z.ZodUnion<readonly [z.ZodObject<{
     }>;
     state: z.ZodEnum<{
         "dead-lettered": "dead-lettered";
-        queued: "queued";
         resolved: "resolved";
+        queued: "queued";
         inflight: "inflight";
         capacity: "capacity";
     }>;
@@ -122,8 +122,8 @@ declare const getTaskDiagnosticsOutput: z.ZodObject<{
         }>;
         state: z.ZodEnum<{
             "dead-lettered": "dead-lettered";
-            queued: "queued";
             resolved: "resolved";
+            queued: "queued";
             inflight: "inflight";
             capacity: "capacity";
         }>;
@@ -217,7 +217,7 @@ export declare function createGetTaskDiagnosticsOperation(options?: GetTaskDiagn
 }, {
     items: ({
         kind: "dead-lettered" | "stuck-queued" | "stale-inflight" | "retry-storm" | "all-workers-at-capacity";
-        state: "dead-lettered" | "queued" | "resolved" | "inflight" | "capacity";
+        state: "dead-lettered" | "resolved" | "queued" | "inflight" | "capacity";
         retryCount: number;
         requeueCount: number;
         evidence: string[];
@@ -279,7 +279,7 @@ export declare const getTaskDiagnosticsOperation: import("../operation-catalog.t
 }, {
     items: ({
         kind: "dead-lettered" | "stuck-queued" | "stale-inflight" | "retry-storm" | "all-workers-at-capacity";
-        state: "dead-lettered" | "queued" | "resolved" | "inflight" | "capacity";
+        state: "dead-lettered" | "resolved" | "queued" | "inflight" | "capacity";
         retryCount: number;
         requeueCount: number;
         evidence: string[];

package/dist/server/operations/get-workflow-revision.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `weft.workflows.revisions.get` operation + REST binding.
+ *
+ * Returns one installed `(name, revision)` workflow catalog record.
+ *
+ * @module server/operations/get-workflow-revision
+ */
+import { z } from 'zod';
+import type { WorkflowRevisionRecord } from '../../core/catalog/index.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getWorkflowRevisionInput: z.ZodObject<{
+    name: z.ZodUnknown;
+    revision: z.ZodUnknown;
+}, z.core.$strip>;
+export type GetWorkflowRevisionInput = z.infer<typeof getWorkflowRevisionInput>;
+export type GetWorkflowRevisionOutput = WorkflowRevisionRecord;
+export declare const getWorkflowRevisionOperation: import("../operation-catalog.ts").OperationDefinition<{
+    name: unknown;
+    revision: unknown;
+}, Readonly<{
+    manifest: import("../../index.ts").WorkflowRevisionManifest;
+    installedAt: number;
+}>, unknown>;
+export declare const getWorkflowRevisionRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/get-workflow-revision.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import {
+  validateWorkflowNameField,
+  validateWorkflowRevisionField,
+  workflowsReadAccess
+} from "./workflow-catalog-operation-helpers.js";
+const getWorkflowRevisionInput = z.object({
+  name: z.unknown().describe("Workflow name. Runtime validation requires a wire-safe identifier."),
+  revision: z.unknown().describe("Installed revision. Runtime validation requires a non-empty string.")
+}), getWorkflowRevisionOutput = z.unknown();
+export const getWorkflowRevisionOperation = defineOperation({
+  name: "weft.workflows.revisions.get",
+  mcpExposable: !1,
+  summary: "Get one installed workflow revision",
+  description: "Read one durably installed `(name, revision)` workflow catalog record. Read-only. Faults with NotFound when no such revision was installed.",
+  destructive: !1,
+  tags: ["Workflow Catalog"],
+  inputSchema: getWorkflowRevisionInput,
+  outputSchema: getWorkflowRevisionOutput,
+  access: workflowsReadAccess,
+  producibleFaults: ["NotFound", "InvalidParams"],
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine, name = validateWorkflowNameField(input.name), revision = validateWorkflowRevisionField(input.revision), record = await e.workflows.getRevision(name, revision);
+    if (record === null)
+      throw {
+        code: "NotFound",
+        message: `Workflow "${name}" has no installed revision "${revision}"`,
+        data: { resource: "workflow-revision", identifier: `${name}:${revision}` }
+      };
+    return record;
+  }
+}), getWorkflowRevisionRestBinding = {
+  method: "GET",
+  path: "/v1/registry/workflows/:name/revisions/:revision",
+  pathParamNames: ["name", "revision"],
+  operationName: "weft.workflows.revisions.get",
+  inputSources: {
+    name: { kind: "path", pathParam: "name" },
+    revision: { kind: "path", pathParam: "revision" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    name: pathParams.name ?? "",
+    revision: pathParams.revision ?? ""
+  }),
+  success: { kind: "json", status: 200 }
+};

package/dist/server/operations/install-workflow-revision.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `weft.workflows.revisions.install` operation + REST binding.
+ *
+ * Durably installs a validated {@link WorkflowRevisionManifest} for a
+ * workflow the engine already has an in-process definition for. Catalog
+ * bookkeeping only — see `core/engine/engine-workflows-namespace.ts`'s
+ * module doc: installing (and later activating) a revision never changes
+ * which in-process handler `engine.start()` dispatches to.
+ *
+ * @module server/operations/install-workflow-revision
+ */
+import { z } from 'zod';
+import type { WorkflowRevisionRecord } from '../../core/catalog/index.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const installWorkflowRevisionInput: z.ZodObject<{
+    manifest: z.ZodUnknown;
+}, z.core.$strip>;
+export type InstallWorkflowRevisionInput = z.infer<typeof installWorkflowRevisionInput>;
+export type InstallWorkflowRevisionOutput = WorkflowRevisionRecord;
+export declare const installWorkflowRevisionOperation: import("../operation-catalog.ts").OperationDefinition<{
+    manifest: unknown;
+}, Readonly<{
+    manifest: import("../../index.ts").WorkflowRevisionManifest;
+    installedAt: number;
+}>, unknown>;
+export declare const installWorkflowRevisionRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/install-workflow-revision.js

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import {
+  readWorkflowCatalogRestBody,
+  throwWorkflowCatalogOperationFault,
+  validateManifestField,
+  workflowsAdminAccess
+} from "./workflow-catalog-operation-helpers.js";
+const installWorkflowRevisionInput = z.object({
+  manifest: z.unknown().describe("An untrusted WorkflowRevisionManifest, validated at invoke time.")
+}), installWorkflowRevisionOutput = z.unknown();
+export const installWorkflowRevisionOperation = defineOperation({
+  name: "weft.workflows.revisions.install",
+  mcpExposable: !1,
+  summary: "Durably install a workflow revision manifest",
+  description: "Validate and durably install a `WorkflowRevisionManifest` for a workflow the engine already has an in-process definition for. Idempotent on a byte-identical reinstall of the same (name, revision). Faults with InvalidParams when the manifest fails validation or names a workflow with no in-process definition, and Conflict when (name, revision) is already installed with different contract content. Does not check `manifest.workflowVersion` " + "against the in-process definition's own version \u2014 that mismatch is a normal " + "activation-time `incompatible` refusal, not an install-time error. Never changes which in-process handler `engine.start()` dispatches to.",
+  destructive: !1,
+  tags: ["Workflow Catalog"],
+  inputSchema: installWorkflowRevisionInput,
+  outputSchema: installWorkflowRevisionOutput,
+  access: workflowsAdminAccess,
+  producibleFaults: ["InvalidParams", "Conflict"],
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine, manifest = await validateManifestField(input.manifest);
+    try {
+      return await e.workflows.install(manifest);
+    } catch (error) {
+      return throwWorkflowCatalogOperationFault(error);
+    }
+  }
+}), installWorkflowRevisionRestBinding = {
+  method: "POST",
+  path: "/v1/registry/revisions",
+  pathParamNames: [],
+  operationName: "weft.workflows.revisions.install",
+  inputSources: {
+    manifest: { kind: "body-field", bodyField: "manifest" }
+  },
+  extractInput: async (request, _pathParams, context) => {
+    return { manifest: (await readWorkflowCatalogRestBody(request, context)).manifest };
+  },
+  success: { kind: "json", status: 201 }
+};

package/dist/server/operations/list-workflow-revisions.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `weft.workflows.revisions.list` operation + REST binding.
+ *
+ * Lists every durably installed revision of one workflow name.
+ *
+ * @module server/operations/list-workflow-revisions
+ */
+import { z } from 'zod';
+import type { WorkflowRevisionRecord } from '../../core/catalog/index.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const listWorkflowRevisionsInput: z.ZodObject<{
+    name: z.ZodUnknown;
+}, z.core.$strip>;
+export type ListWorkflowRevisionsInput = z.infer<typeof listWorkflowRevisionsInput>;
+export type ListWorkflowRevisionsOutput = readonly WorkflowRevisionRecord[];
+export declare const listWorkflowRevisionsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    name: unknown;
+}, ListWorkflowRevisionsOutput, unknown>;
+export declare const listWorkflowRevisionsRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/list-workflow-revisions.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import {
+  validateWorkflowNameField,
+  workflowsReadAccess
+} from "./workflow-catalog-operation-helpers.js";
+const listWorkflowRevisionsInput = z.object({
+  name: z.unknown().describe("Workflow name. Runtime validation requires a wire-safe identifier.")
+}), listWorkflowRevisionsOutput = z.unknown();
+export const listWorkflowRevisionsOperation = defineOperation({
+  name: "weft.workflows.revisions.list",
+  mcpExposable: !1,
+  summary: "List every installed revision of a workflow",
+  description: "Read every durably installed revision of `name`, sorted deterministically by revision. Read-only. Returns an empty array for a name with no installed revisions, rather than a " + "NotFound fault \u2014 an empty catalog is not an error.",
+  destructive: !1,
+  tags: ["Workflow Catalog"],
+  inputSchema: listWorkflowRevisionsInput,
+  outputSchema: listWorkflowRevisionsOutput,
+  access: workflowsReadAccess,
+  producibleFaults: ["InvalidParams"],
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine, name = validateWorkflowNameField(input.name);
+    return e.workflows.listRevisions(name);
+  }
+}), listWorkflowRevisionsRestBinding = {
+  method: "GET",
+  path: "/v1/registry/workflows/:name/revisions",
+  pathParamNames: ["name"],
+  operationName: "weft.workflows.revisions.list",
+  inputSources: {
+    name: { kind: "path", pathParam: "name" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    name: pathParams.name ?? ""
+  }),
+  success: { kind: "json", status: 200 }
+};

package/dist/server/operations/preload-workflow-revision.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `weft.workflows.revisions.preload` operation + REST binding.
+ *
+ * Loads, validates, and installs one dynamic workflow source revision
+ * previously recorded via `engine.registerSource()` — a thin, documented
+ * exposure of `engine.workflows.preload()` (WFT-15/16). Modeled on
+ * `install-workflow-revision.ts` / `activate-workflow-revision.ts`.
+ *
+ * @module server/operations/preload-workflow-revision
+ */
+import { z } from 'zod';
+import type { WorkflowRevisionRecord } from '../../core/catalog/index.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const preloadWorkflowRevisionInput: z.ZodObject<{
+    name: z.ZodUnknown;
+    revision: z.ZodUnknown;
+}, z.core.$strip>;
+export type PreloadWorkflowRevisionInput = z.infer<typeof preloadWorkflowRevisionInput>;
+export type PreloadWorkflowRevisionOutput = WorkflowRevisionRecord;
+export declare const preloadWorkflowRevisionOperation: import("../operation-catalog.ts").OperationDefinition<{
+    name: unknown;
+    revision: unknown;
+}, Readonly<{
+    manifest: import("../../index.ts").WorkflowRevisionManifest;
+    installedAt: number;
+}>, unknown>;
+export declare const preloadWorkflowRevisionRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/preload-workflow-revision.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { isWeftError } from "../../core/weft-error.js";
+import { defineOperation } from "../operation-registry.js";
+import {
+  readWorkflowCatalogRestBody,
+  throwWorkflowCatalogOperationFault,
+  validateWorkflowNameField,
+  validateWorkflowRevisionField,
+  workflowsAdminAccess
+} from "./workflow-catalog-operation-helpers.js";
+const preloadWorkflowRevisionInput = z.object({
+  name: z.unknown().describe("Workflow name. Runtime validation requires a wire-safe identifier."),
+  revision: z.unknown().describe("The registerSource()-registered revision to load, validate, and install. Runtime validation requires a non-empty string.")
+}), preloadWorkflowRevisionOutput = z.unknown();
+export const preloadWorkflowRevisionOperation = defineOperation({
+  name: "weft.workflows.revisions.preload",
+  mcpExposable: !1,
+  summary: "Load, validate, and install a registered dynamic workflow source revision",
+  description: "Load, validate, and install `(name, revision)` \u2014 previously recorded via " + "engine.registerSource() \u2014 durably into the workflow catalog. Faults NotFound when no " + "source was ever registered for this exact key, and Conflict when the load fails or the loaded module fails validation.",
+  destructive: !1,
+  tags: ["Workflow Catalog"],
+  inputSchema: preloadWorkflowRevisionInput,
+  outputSchema: preloadWorkflowRevisionOutput,
+  access: workflowsAdminAccess,
+  producibleFaults: ["InvalidParams", "NotFound", "Conflict"],
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine, name = validateWorkflowNameField(input.name), revision = validateWorkflowRevisionField(input.revision);
+    try {
+      return await e.workflows.preload(name, revision);
+    } catch (error) {
+      if (!isWeftError(error))
+        throw {
+          code: "Conflict",
+          message: `Dynamic workflow source "${name}" revision "${revision}" failed to load.`,
+          data: { reason: "load-failed" }
+        };
+      return throwWorkflowCatalogOperationFault(error);
+    }
+  }
+}), preloadWorkflowRevisionRestBinding = {
+  method: "POST",
+  path: "/v1/registry/workflows/:name/preload",
+  pathParamNames: ["name"],
+  operationName: "weft.workflows.revisions.preload",
+  inputSources: {
+    name: { kind: "path", pathParam: "name" },
+    revision: { kind: "body-field", bodyField: "revision" }
+  },
+  extractInput: async (request, pathParams, context) => {
+    const body = await readWorkflowCatalogRestBody(request, context);
+    return {
+      name: pathParams.name ?? "",
+      revision: body.revision
+    };
+  },
+  success: { kind: "json", status: 200 }
+};

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

@@ -6,6 +6,7 @@ export type ScheduleMutableOptionsInput = {
     overlap?: unknown;
     backfill?: unknown;
     jitter?: unknown;
+    revisionPolicy?: unknown;
 };
 /** Validate the mutable schedule options shared by create and update. */
 export declare function validateScheduleMutableOptions(input: ScheduleMutableOptionsInput): ScheduleUpdateOptions;

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

@@ -1,16 +1,19 @@
+import { WorkflowRevisionUnavailableError } from "../../core/engine/revision-errors.js";
 import {
   isValidScheduleOverlapPolicy,
+  isValidScheduleRevisionPolicy,
   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);
+  const description = validateScheduleDescription(input.description), overlap = validateScheduleOverlap(input.overlap), backfill = validateScheduleBackfill(input.backfill), jitter = validateScheduleJitter(input.jitter), revisionPolicy = validateScheduleRevisionPolicy(input.revisionPolicy);
   return {
     ...description !== void 0 ? { description } : {},
     ...overlap !== void 0 ? { overlap } : {},
     ...backfill !== void 0 ? { backfill } : {},
-    ...jitter !== void 0 ? { jitter } : {}
+    ...jitter !== void 0 ? { jitter } : {},
+    ...revisionPolicy !== void 0 ? { revisionPolicy } : {}
   };
 }
 function validateScheduleDescription(value) {
@@ -27,6 +30,13 @@ function validateScheduleOverlap(value) {
     throw invalidParamsFault('Field "overlap" must be one of skip, queue, cancel-running, allow');
   return value;
 }
+function validateScheduleRevisionPolicy(value) {
+  if (value === void 0)
+    return;
+  if (!isValidScheduleRevisionPolicy(value))
+    throw invalidParamsFault('Field "revisionPolicy" must be one of active-at-fire, pinned');
+  return value;
+}
 function validateScheduleBackfill(value) {
   if (value === void 0)
     return;
@@ -51,7 +61,25 @@ 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;
 }
+function mapRevisionUnavailableToFault(error) {
+  if (!(error instanceof WorkflowRevisionUnavailableError))
+    return;
+  return {
+    code: "Conflict",
+    message: error.message,
+    data: { reason: error.reason }
+  };
+}
+function isScheduleConflictMessage(normalizedMessage) {
+  return normalizedMessage.includes("already exists") || normalizedMessage.includes("cannot be resumed");
+}
+function isScheduleInvalidParamsMessage(message, normalizedMessage) {
+  return message.includes("Missing required field") || normalizedMessage.includes("must be") || normalizedMessage.includes("no workflow registered") || normalizedMessage.includes("cron") || normalizedMessage.includes("interval");
+}
 export function mapScheduleErrorToFault(scheduleId, error) {
+  const revisionFault = mapRevisionUnavailableToFault(error);
+  if (revisionFault !== void 0)
+    return revisionFault;
   const message = error instanceof Error ? error.message : String(error), normalizedMessage = message.toLowerCase();
   if (normalizedMessage.includes("not found"))
     return {
@@ -59,13 +87,13 @@ export function mapScheduleErrorToFault(scheduleId, error) {
       message,
       data: { resource: "schedule", identifier: scheduleId }
     };
-  if (normalizedMessage.includes("already exists") || normalizedMessage.includes("cannot be resumed"))
+  if (isScheduleConflictMessage(normalizedMessage))
     return {
       code: "Conflict",
       message,
       data: { reason: message }
     };
-  if (message.includes("Missing required field") || normalizedMessage.includes("must be") || normalizedMessage.includes("no workflow registered") || normalizedMessage.includes("cron") || normalizedMessage.includes("interval"))
+  if (isScheduleInvalidParamsMessage(message, normalizedMessage))
     return {
       code: "InvalidParams",
       message,

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

@@ -6,6 +6,7 @@ export type SharedScheduleRestFields = {
     readonly overlap: unknown;
     readonly backfill: unknown;
     readonly jitter: unknown;
+    readonly revisionPolicy: 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

@@ -23,6 +23,7 @@ export function extractSharedScheduleRestFields(record) {
     description: record.description,
     overlap: record.overlap,
     backfill: record.backfill,
-    jitter: record.jitter
+    jitter: record.jitter,
+    revisionPolicy: record.revisionPolicy
   };
 }

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

@@ -103,7 +103,7 @@ export const startOrSignalWorkflowOperation = defineOperation({
       const { handle, outcome } = await typedEngine.startOrSignal(type, input.input, signal, options);
       return { id: handle.id, outcome };
     } catch (error) {
-      resolveStartOrSignalWorkflowFault(error);
+      return resolveStartOrSignalWorkflowFault(error);
     }
   }
 }), startOrSignalWorkflowRestBinding = {

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

@@ -77,7 +77,7 @@ export const startWorkflowOperation = defineOperation({
     try {
       return { id: (await typedEngine.start(type, input.input, options)).id };
     } catch (error) {
-      resolveStartWorkflowAccess(error);
+      return resolveStartWorkflowAccess(error);
     }
   }
 }), startWorkflowRestBinding = {

package/dist/server/operations/static-registrations.js

@@ -1,3 +1,7 @@
+import {
+  activateWorkflowRevisionOperation,
+  activateWorkflowRevisionRestBinding
+} from "./activate-workflow-revision.js";
 import { addWorkflowTagsOperation, addWorkflowTagsRestBinding } from "./add-workflow-tags.js";
 import {
   aggregateWorkflowsOperation,
@@ -30,6 +34,14 @@ import { createScheduleOperation, createScheduleRestBinding } from "./create-sch
 import { fleetEventsSseOperation, fleetEventsSseRestBinding } from "./fleet-events-sse.js";
 import { fleetEventsSubscriptionOperation } from "./fleet-events-subscription.js";
 import { forkWorkflowOperation, forkWorkflowRestBinding } from "./fork-workflow.js";
+import {
+  getActiveWorkflowRevisionOperation,
+  getActiveWorkflowRevisionRestBinding
+} from "./get-active-workflow-revision.js";
+import {
+  getCatalogDiagnosticsOperation,
+  getCatalogDiagnosticsRestBinding
+} from "./get-catalog-diagnostics.js";
 import { getCheckpointAtOperation, getCheckpointAtRestBinding } from "./get-checkpoint-at.js";
 import { getPrincipalOperation, getPrincipalRestBinding } from "./get-principal.js";
 import { getRegistryOperation, getRegistryRestBinding } from "./get-registry.js";
@@ -55,17 +67,33 @@ import {
 import { getWorkflowEventsOperation, getWorkflowEventsRestBinding } from "./get-workflow-events.js";
 import * as workflowObservability from "./get-workflow-observability.js";
 import { getWorkflowResultOperation, getWorkflowResultRestBinding } from "./get-workflow-result.js";
+import {
+  getWorkflowRevisionOperation,
+  getWorkflowRevisionRestBinding
+} from "./get-workflow-revision.js";
 import {
   getWorkflowTimelineOperation,
   getWorkflowTimelineRestBinding
 } from "./get-workflow-timeline.js";
 import { getWorkflowOperation, getWorkflowRestBinding } from "./get-workflow.js";
+import {
+  installWorkflowRevisionOperation,
+  installWorkflowRevisionRestBinding
+} from "./install-workflow-revision.js";
 import { listAlertsOperation, listAlertsRestBinding } from "./list-alerts.js";
 import { listCheckpointsOperation, listCheckpointsRestBinding } from "./list-checkpoints.js";
 import { listReviewsOperation, listReviewsRestBinding } from "./list-reviews.js";
 import { listSchedulesOperation, listSchedulesRestBinding } from "./list-schedules.js";
+import {
+  listWorkflowRevisionsOperation,
+  listWorkflowRevisionsRestBinding
+} from "./list-workflow-revisions.js";
 import { listWorkflowsOperation, listWorkflowsRestBinding } from "./list-workflows.js";
 import { pauseScheduleOperation, pauseScheduleRestBinding } from "./pause-schedule.js";
+import {
+  preloadWorkflowRevisionOperation,
+  preloadWorkflowRevisionRestBinding
+} from "./preload-workflow-revision.js";
 import { purgeWorkflowsOperation, purgeWorkflowsRestBinding } from "./purge-workflows.js";
 import {
   queryWorkflowOperation,
@@ -130,6 +158,7 @@ export const STATIC_REST_BINDINGS = [
   bulkRetryFailedWorkflowsRestBinding,
   bulkDeleteWorkflowsRestBinding,
   bulkMutateWorkflowTagsRestBinding,
+  getCatalogDiagnosticsRestBinding,
   getWorkflowRestBinding,
   cancelWorkflowRestBinding,
   getWorkflowResultRestBinding,
@@ -151,6 +180,12 @@ export const STATIC_REST_BINDINGS = [
   createScheduleRestBinding,
   updateScheduleRestBinding,
   getRegistryRestBinding,
+  installWorkflowRevisionRestBinding,
+  activateWorkflowRevisionRestBinding,
+  preloadWorkflowRevisionRestBinding,
+  getWorkflowRevisionRestBinding,
+  listWorkflowRevisionsRestBinding,
+  getActiveWorkflowRevisionRestBinding,
   getSystemLeaseRestBinding,
   getRetentionOverviewRestBinding,
   getUpdateResultRestBinding,
@@ -194,6 +229,7 @@ export const STATIC_REST_BINDINGS = [
   bulkRetryFailedWorkflowsOperation,
   bulkDeleteWorkflowsOperation,
   bulkMutateWorkflowTagsOperation,
+  getCatalogDiagnosticsOperation,
   getWorkflowOperation,
   cancelWorkflowOperation,
   getWorkflowResultOperation,
@@ -214,6 +250,12 @@ export const STATIC_REST_BINDINGS = [
   createScheduleOperation,
   updateScheduleOperation,
   getRegistryOperation,
+  installWorkflowRevisionOperation,
+  activateWorkflowRevisionOperation,
+  preloadWorkflowRevisionOperation,
+  getWorkflowRevisionOperation,
+  listWorkflowRevisionsOperation,
+  getActiveWorkflowRevisionOperation,
   getSystemLeaseOperation,
   getRetentionOverviewOperation,
   getUpdateResultOperation,

package/dist/server/operations/storage.js

@@ -42,14 +42,14 @@ const rawStorageAccess = {
 }), emptyOutput = z.null(), storageGetOutput = binaryValueSchema.nullable(), storageScanOutput = z.custom((value) => typeof value === "object" && value !== null && (Symbol.asyncIterator in value) && typeof value[Symbol.asyncIterator] === "function", "Storage scan output must be an async iterable."), storageConditionalBatchOutput = z.object({ applied: z.boolean() });
 function resolveAuthorizedStorage(engine, principal, operation) {
   if (!isAuthenticated(principal))
-    raiseFault(operation, {
+    return raiseFault(operation, {
       code: "Unauthorized",
       message: "authentication required",
       data: { reason: "authentication required" }
     });
   if (principal.hasScope("storage:admin"))
     return engine.storage;
-  raiseFault(operation, {
+  return raiseFault(operation, {
     code: "Forbidden",
     message: "Raw storage access requires storage:admin.",
     data: { reason: "Raw storage access requires storage:admin." }

package/dist/server/operations/submit-review-decision.js

@@ -89,7 +89,7 @@ export const submitReviewDecisionOperation = defineOperation({
       await e.submitReview(input.reviewId, reviewOptions);
       return { ok: !0 };
     } catch (error) {
-      mapReviewDecisionError(error, input.reviewId);
+      return mapReviewDecisionError(error, input.reviewId);
     }
   }
 }), submitReviewDecisionRestBinding = {

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

@@ -8,6 +8,7 @@ declare const updateScheduleInput: z.ZodObject<{
     overlap: z.ZodOptional<z.ZodUnknown>;
     backfill: z.ZodOptional<z.ZodUnknown>;
     jitter: z.ZodOptional<z.ZodUnknown>;
+    revisionPolicy: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 export type UpdateScheduleInput = z.infer<typeof updateScheduleInput>;
 export declare const updateScheduleOperation: import("../operation-catalog.ts").OperationDefinition<{
@@ -18,6 +19,7 @@ export declare const updateScheduleOperation: import("../operation-catalog.ts").
     overlap?: unknown;
     backfill?: unknown;
     jitter?: unknown;
+    revisionPolicy?: unknown;
 }, null, unknown>;
 export declare const updateScheduleRestBinding: UnknownRestBinding;
 export {};

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

@@ -16,7 +16,8 @@ const updateScheduleInput = z.object({
   description: z.unknown().optional().describe("Operator-facing schedule description. Runtime validation requires a string."),
   overlap: z.unknown().optional(),
   backfill: z.unknown().optional(),
-  jitter: z.unknown().optional()
+  jitter: z.unknown().optional(),
+  revisionPolicy: z.unknown().optional().describe('Revision policy (WFT-20). Runtime validation requires "active-at-fire" or "pinned". Omitted preserves the current policy (and pin); "pinned" always re-resolves and re-captures the pin against the revision active right now.')
 });
 export const updateScheduleOperation = defineOperation({
   name: "weft.schedules.update",
@@ -52,7 +53,8 @@ export const updateScheduleOperation = defineOperation({
     description: { kind: "body-field", bodyField: "description" },
     overlap: { kind: "body-field", bodyField: "overlap" },
     backfill: { kind: "body-field", bodyField: "backfill" },
-    jitter: { kind: "body-field", bodyField: "jitter" }
+    jitter: { kind: "body-field", bodyField: "jitter" },
+    revisionPolicy: { kind: "body-field", bodyField: "revisionPolicy" }
   },
   extractInput: async (request, pathParams, context) => {
     const record = await parseScheduleRestBodyRequestRecord(request, context);