@lostgradient/weft 0.23.1 → 0.24.1

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

@@ -34,7 +34,9 @@
  * `data` payload forms the basis of cross-transport parity: every fault is
  * serialized consistently across REST and JSON-RPC transports.
  */
+import type { WorkflowCompatibilityReason } from '../core/contract/compatibility.ts';
 import type { FaultCode } from '../core/fault-code.ts';
+import type { WorkflowSourceRejectionReason } from '../core/source/errors.ts';
 import { type WeftErrorCode } from '../core/weft-error.ts';
 /** Transport identifiers as seen by `executeOperation`. */
 export type TransportKind = 'http-rest' | 'jsonRpcHttp' | 'jsonRpcWebSocket' | 'jsonRpcStdio';
@@ -78,6 +80,9 @@ export type OperationFault = {
         missingTypes?: readonly string[] | undefined;
         missingWorkflowCount?: number | undefined;
         samplesTruncated?: boolean | undefined;
+        currentGeneration?: number | undefined;
+        compatibilityReasons?: readonly WorkflowCompatibilityReason[] | undefined;
+        sourceValidationReasons?: readonly WorkflowSourceRejectionReason[] | undefined;
     };
 } | {
     code: 'Unprocessable';

package/dist/server/operation-fault.js

@@ -30,7 +30,10 @@ const NO_REST_FAULT_DATA = Object.freeze({}), REST_FAULT_DATA_EXTRACTORS = {
   Conflict: (data) => filterDefined({
     missingTypes: data.missingTypes === void 0 ? void 0 : [...data.missingTypes],
     missingWorkflowCount: data.missingWorkflowCount,
-    samplesTruncated: data.samplesTruncated
+    samplesTruncated: data.samplesTruncated,
+    currentGeneration: data.currentGeneration,
+    compatibilityReasons: data.compatibilityReasons === void 0 ? void 0 : [...data.compatibilityReasons],
+    sourceValidationReasons: data.sourceValidationReasons === void 0 ? void 0 : [...data.sourceValidationReasons]
   }),
   Unprocessable: () => NO_REST_FAULT_DATA,
   PayloadTooLarge: (data) => ({ maxBytes: data.maxBytes }),

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

@@ -0,0 +1,30 @@
+/**
+ * `weft.workflows.revisions.activate` operation + REST binding.
+ *
+ * Activates an already-installed `(name, revision)` as the durably
+ * advertised active revision — bookkeeping only. See
+ * `core/engine/engine-workflows-namespace.ts`'s module doc: activation
+ * moves `RegistrySnapshot.activeRevisions`, never which in-process handler
+ * `engine.start()` dispatches to.
+ *
+ * @module server/operations/activate-workflow-revision
+ */
+import { z } from 'zod';
+import type { WorkflowCatalogActivationResult } from '../../core/catalog/index.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const activateWorkflowRevisionInput: z.ZodObject<{
+    name: z.ZodUnknown;
+    revision: z.ZodUnknown;
+    expectedGeneration: z.ZodOptional<z.ZodUnknown>;
+    policy: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type ActivateWorkflowRevisionInput = z.infer<typeof activateWorkflowRevisionInput>;
+export type ActivateWorkflowRevisionOutput = WorkflowCatalogActivationResult;
+export declare const activateWorkflowRevisionOperation: import("../operation-catalog.ts").OperationDefinition<{
+    name: unknown;
+    revision: unknown;
+    expectedGeneration?: unknown;
+    policy?: unknown;
+}, WorkflowCatalogActivationResult, unknown>;
+export declare const activateWorkflowRevisionRestBinding: UnknownRestBinding;
+export {};

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

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import {
+  activationRefusalToFault,
+  readWorkflowCatalogRestBody,
+  throwWorkflowCatalogOperationFault,
+  validateExpectedGenerationField,
+  validatePolicyField,
+  validateWorkflowNameField,
+  validateWorkflowRevisionField,
+  workflowsAdminAccess
+} from "./workflow-catalog-operation-helpers.js";
+const activateWorkflowRevisionInput = z.object({
+  name: z.unknown().describe("Workflow name. Runtime validation requires a wire-safe identifier."),
+  revision: z.unknown().describe("Installed revision to activate. Runtime validation requires a non-empty string."),
+  expectedGeneration: z.unknown().optional().describe("The durable generation this caller last observed. Required once the workflow has an " + "active revision \u2014 omitting it there refuses with expected-generation-required."),
+  policy: z.unknown().optional().describe("Optional compatibility policy override.")
+}), activateWorkflowRevisionOutput = z.unknown();
+export const activateWorkflowRevisionOperation = defineOperation({
+  name: "weft.workflows.revisions.activate",
+  mcpExposable: !1,
+  summary: "Activate an installed workflow revision",
+  description: "Activate an already-installed `(name, revision)` as the durably advertised active revision for `name`. Returns the structured result verbatim: `{ applied: true, pointer }` on success, " + "or `{ applied: false, reason, ... }` on refusal \u2014 surfaced as a Conflict fault with `reason` " + "one of `incompatible`, `stale-generation`, `expected-generation-required`, or `conflict`. Faults with NotFound when the revision was never installed. Never changes which in-process " + "handler `engine.start()` dispatches to \u2014 see the workflow-versioning guide.",
+  destructive: !0,
+  tags: ["Workflow Catalog"],
+  inputSchema: activateWorkflowRevisionInput,
+  outputSchema: activateWorkflowRevisionOutput,
+  access: workflowsAdminAccess,
+  producibleFaults: ["NotFound", "Conflict", "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), expectedGeneration = validateExpectedGenerationField(input.expectedGeneration), policy = validatePolicyField(input.policy);
+    let result;
+    try {
+      result = await e.workflows.activate(name, revision, {
+        ...expectedGeneration === void 0 ? {} : { expectedGeneration },
+        ...policy === void 0 ? {} : { policy }
+      });
+    } catch (error) {
+      throwWorkflowCatalogOperationFault(error);
+    }
+    if (!result.applied)
+      throw activationRefusalToFault(result);
+    return result;
+  }
+}), activateWorkflowRevisionRestBinding = {
+  method: "POST",
+  path: "/v1/registry/workflows/:name/activate",
+  pathParamNames: ["name"],
+  operationName: "weft.workflows.revisions.activate",
+  inputSources: {
+    name: { kind: "path", pathParam: "name" },
+    revision: { kind: "body-field", bodyField: "revision" },
+    expectedGeneration: { kind: "body-field", bodyField: "expectedGeneration" },
+    policy: { kind: "body-field", bodyField: "policy" }
+  },
+  extractInput: async (request, pathParams, context) => {
+    const body = await readWorkflowCatalogRestBody(request, context);
+    return {
+      name: pathParams.name ?? "",
+      revision: body.revision,
+      expectedGeneration: body.expectedGeneration,
+      policy: body.policy
+    };
+  },
+  success: { kind: "json", status: 200 }
+};

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

@@ -10,6 +10,7 @@ declare const createScheduleInput: 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>;
 declare const createScheduleOutput: z.ZodObject<{
     id: z.ZodString;
@@ -26,6 +27,7 @@ export declare const createScheduleOperation: import("../operation-catalog.ts").
     overlap?: unknown;
     backfill?: unknown;
     jitter?: unknown;
+    revisionPolicy?: unknown;
 }, {
     id: string;
 }, unknown>;

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

@@ -19,7 +19,8 @@ const createScheduleInput = 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"; defaults to "active-at-fire".')
 }), createScheduleOutput = z.object({
   id: z.string()
 });
@@ -42,12 +43,13 @@ function validateOptionalScheduleFields(input) {
     description: validatedOptions.description,
     overlap: validatedOptions.overlap,
     backfill: validatedOptions.backfill,
-    jitter: validatedOptions.jitter
+    jitter: validatedOptions.jitter,
+    revisionPolicy: validatedOptions.revisionPolicy
   };
 }
 function validateCreateScheduleInput(input) {
-  const { type, spec } = validateRequiredScheduleFields(input), { id, description, overlap, backfill, jitter } = validateOptionalScheduleFields(input);
-  return { type, spec, id, description, overlap, backfill, jitter };
+  const { type, spec } = validateRequiredScheduleFields(input), { id, description, overlap, backfill, jitter, revisionPolicy } = validateOptionalScheduleFields(input);
+  return { type, spec, id, description, overlap, backfill, jitter, revisionPolicy };
 }
 export const createScheduleOperation = defineOperation({
   name: "weft.schedules.create",
@@ -68,7 +70,8 @@ export const createScheduleOperation = defineOperation({
       ...validated.description !== void 0 ? { description: validated.description } : {},
       ...validated.overlap !== void 0 ? { overlap: validated.overlap } : {},
       ...validated.backfill !== void 0 ? { backfill: validated.backfill } : {},
-      ...validated.jitter !== void 0 ? { jitter: validated.jitter } : {}
+      ...validated.jitter !== void 0 ? { jitter: validated.jitter } : {},
+      ...validated.revisionPolicy !== void 0 ? { revisionPolicy: validated.revisionPolicy } : {}
     };
     try {
       return { id: (await typedEngine.schedule(validated.type, input.input, validated.spec, options)).id };
@@ -90,7 +93,8 @@ export const createScheduleOperation = 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);

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

@@ -85,7 +85,7 @@ function getFleetEventFeed(engine, transport) {
     if (isFleetEventSubscriber(fleetFeed))
       return fleetFeed;
   }
-  raiseFault(fleetEventsSubscriptionOperation, {
+  return raiseFault(fleetEventsSubscriptionOperation, {
     code: "UnsupportedTransport",
     message: "Fleet event subscription requires a WebSocket fleet event feed",
     data: { transport, supported: ["jsonRpcWebSocket"] }

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

@@ -54,7 +54,7 @@ export const forkWorkflowOperation = defineOperation({
     try {
       return { id: (await typedEngine.fork(input.workflowId, options)).id };
     } catch (error) {
-      resolveForkAccess(error);
+      return resolveForkAccess(error);
     }
   }
 }), forkWorkflowRestBinding = {

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

@@ -0,0 +1,32 @@
+/**
+ * `weft.workflows.active.get` operation + REST binding.
+ *
+ * Returns the currently active revision pointer for one workflow name.
+ * Named `active.get` rather than `revisions.getActive` — `OPERATION_NAME_PATTERN`
+ * forbids camelCase wire segments, and `getActive` is only this namespace
+ * method's TypeScript name (`engine.workflows.getActive`).
+ *
+ * In-memory only: matches `RegistrySnapshot.activeRevisions`' existing
+ * staleness contract exactly (see `engine-workflows-namespace.ts`'s
+ * `getActive` JSDoc), which is what makes "operations and the registry
+ * snapshot agree" true by construction.
+ *
+ * @module server/operations/get-active-workflow-revision
+ */
+import { z } from 'zod';
+import type { WorkflowCatalogActivePointer } from '../../core/catalog/index.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getActiveWorkflowRevisionInput: z.ZodObject<{
+    name: z.ZodUnknown;
+}, z.core.$strip>;
+export type GetActiveWorkflowRevisionInput = z.infer<typeof getActiveWorkflowRevisionInput>;
+export type GetActiveWorkflowRevisionOutput = WorkflowCatalogActivePointer;
+export declare const getActiveWorkflowRevisionOperation: import("../operation-catalog.ts").OperationDefinition<{
+    name: unknown;
+}, Readonly<{
+    revision: string;
+    generation: number;
+    activatedAt: number;
+}>, unknown>;
+export declare const getActiveWorkflowRevisionRestBinding: UnknownRestBinding;
+export {};

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

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { defineOperation } from "../operation-registry.js";
+import {
+  validateWorkflowNameField,
+  workflowsReadAccess
+} from "./workflow-catalog-operation-helpers.js";
+const getActiveWorkflowRevisionInput = z.object({
+  name: z.unknown().describe("Workflow name. Runtime validation requires a wire-safe identifier.")
+}), getActiveWorkflowRevisionOutput = z.unknown();
+export const getActiveWorkflowRevisionOperation = defineOperation({
+  name: "weft.workflows.active.get",
+  mcpExposable: !1,
+  summary: "Get the currently active revision pointer for a workflow",
+  description: "Read the current `{ revision, generation, activatedAt }` active pointer for `name`. Read-only, in-memory (matches `RegistrySnapshot.activeRevisions`' staleness contract exactly). Faults with NotFound when `name` has never been activated.",
+  destructive: !1,
+  tags: ["Workflow Catalog"],
+  inputSchema: getActiveWorkflowRevisionInput,
+  outputSchema: getActiveWorkflowRevisionOutput,
+  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), pointer = await e.workflows.getActive(name);
+    if (pointer === null)
+      throw {
+        code: "NotFound",
+        message: `Workflow "${name}" has never been activated`,
+        data: { resource: "workflow-active-revision", identifier: name }
+      };
+    return pointer;
+  }
+}), getActiveWorkflowRevisionRestBinding = {
+  method: "GET",
+  path: "/v1/registry/workflows/:name/active",
+  pathParamNames: ["name"],
+  operationName: "weft.workflows.active.get",
+  inputSources: {
+    name: { kind: "path", pathParam: "name" }
+  },
+  extractInput: async (_request, pathParams) => ({
+    name: pathParams.name ?? ""
+  }),
+  success: { kind: "json", status: 200 }
+};

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

@@ -0,0 +1,113 @@
+/**
+ * `weft.catalog.diagnostics` operation + REST binding (WFT-12).
+ *
+ * Read-only, bounded diagnostics for one `(name, revision)` workflow
+ * catalog entry: whether it is installed, whether it is currently active,
+ * its full reference-count breakdown, and whether it would currently be
+ * removable. No REST/JSON-RPC removal surface exists this batch — removal
+ * (`removeWorkflowRevision`) is a plain in-process function, not a wire
+ * operation, per the coordinator's "single bounded diagnostics operation"
+ * steer.
+ *
+ * Static, not factory-built — unlike `get-worker-diagnostics.ts`'s injected
+ * `WorkerRegistry`, this operation needs no per-server state beyond the
+ * live `engine` every `invoke` already receives, matching
+ * `get-retention-overview.ts`'s shape.
+ *
+ * @module server/operations/get-catalog-diagnostics
+ */
+import { z } from 'zod';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getCatalogDiagnosticsInput: z.ZodObject<{
+    name: z.ZodString;
+    revision: z.ZodString;
+}, z.core.$strict>;
+declare const getCatalogDiagnosticsOutput: z.ZodObject<{
+    name: z.ZodString;
+    revision: z.ZodString;
+    installed: z.ZodBoolean;
+    active: z.ZodBoolean;
+    activeRevision: z.ZodOptional<z.ZodString>;
+    references: z.ZodObject<{
+        registeredDefinitions: z.ZodNumber;
+        inFlightStarts: z.ZodNumber;
+        nonTerminalRuns: z.ZodNumber;
+        pinnedSchedules: z.ZodNumber;
+        pendingDispatches: z.ZodNumber;
+        activeExecutionRealms: z.ZodNumber;
+        retainedRecoveryRecords: z.ZodNumber;
+    }, z.core.$strict>;
+    removable: z.ZodBoolean;
+    source: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"module">;
+        requestedRevision: z.ZodString;
+        state: z.ZodEnum<{
+            failed: "failed";
+            cancelled: "cancelled";
+            idle: "idle";
+            loading: "loading";
+            ready: "ready";
+        }>;
+        loadDurationMs: z.ZodOptional<z.ZodNumber>;
+        lastFailureCategory: z.ZodOptional<z.ZodEnum<{
+            application: "application";
+            timeout: "timeout";
+            cancellation: "cancellation";
+            resource: "resource";
+            system: "system";
+        }>>;
+        waiterCount: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type GetCatalogDiagnosticsInput = z.infer<typeof getCatalogDiagnosticsInput>;
+export type GetCatalogDiagnosticsOutput = z.infer<typeof getCatalogDiagnosticsOutput>;
+/**
+ * `weft.catalog.diagnostics`: bounded, per-`(name, revision)` diagnostics
+ * for the durable workflow catalog. Requires `system:read`. Never returns
+ * manifest or contract content — only identity, active-pointer state, and
+ * low-cardinality reference counts, matching the repository's "metrics
+ * remain low-cardinality" observability convention.
+ *
+ * @example
+ * ```ts
+ * import { HttpClient } from '@lostgradient/weft/client';
+ *
+ * const client = new HttpClient({ baseUrl: 'https://weft.example.com' });
+ * const diagnostics = await client.operations['weft.catalog.diagnostics']({
+ *   name: 'checkout',
+ *   revision: 'some-revision',
+ * });
+ * console.log(diagnostics.installed, diagnostics.removable);
+ * ```
+ */
+export declare const getCatalogDiagnosticsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    name: string;
+    revision: string;
+}, {
+    name: string;
+    revision: string;
+    installed: boolean;
+    active: boolean;
+    references: {
+        registeredDefinitions: number;
+        inFlightStarts: number;
+        nonTerminalRuns: number;
+        pinnedSchedules: number;
+        pendingDispatches: number;
+        activeExecutionRealms: number;
+        retainedRecoveryRecords: number;
+    };
+    removable: boolean;
+    activeRevision?: string | undefined;
+    source?: {
+        kind: "module";
+        requestedRevision: string;
+        state: "failed" | "cancelled" | "idle" | "loading" | "ready";
+        waiterCount: number;
+        loadDurationMs?: number | undefined;
+        lastFailureCategory?: "application" | "timeout" | "cancellation" | "resource" | "system" | undefined;
+    } | undefined;
+}, unknown>;
+/** REST binding for `weft.catalog.diagnostics`: `GET /v1/catalog/:name/revisions/:revision/diagnostics`. */
+export declare const getCatalogDiagnosticsRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/get-catalog-diagnostics.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+import { getWorkflowRevisionDiagnostics } from "../../core/engine.js";
+import { shapeOperationFaultAsJson } from "../operation-fault.js";
+import { defineOperation } from "../operation-registry.js";
+const workflowRevisionReferenceCountsSchema = z.object({
+  registeredDefinitions: z.number().int().nonnegative(),
+  inFlightStarts: z.number().int().nonnegative(),
+  nonTerminalRuns: z.number().int().nonnegative(),
+  pinnedSchedules: z.number().int().nonnegative(),
+  pendingDispatches: z.number().int().nonnegative(),
+  activeExecutionRealms: z.number().int().nonnegative(),
+  retainedRecoveryRecords: z.number().int().nonnegative()
+}).strict(), getCatalogDiagnosticsInput = z.object({
+  name: z.string().min(1),
+  revision: z.string().min(1)
+}).strict(), sourceLoadDiagnosticsSchema = z.object({
+  kind: z.literal("module"),
+  requestedRevision: z.string(),
+  state: z.enum(["idle", "loading", "ready", "failed", "cancelled"]),
+  loadDurationMs: z.number().nonnegative().optional(),
+  lastFailureCategory: z.enum(["application", "timeout", "cancellation", "resource", "system"]).optional(),
+  waiterCount: z.number().int().nonnegative()
+}).strict(), getCatalogDiagnosticsOutput = z.object({
+  name: z.string(),
+  revision: z.string(),
+  installed: z.boolean(),
+  active: z.boolean(),
+  activeRevision: z.string().optional(),
+  references: workflowRevisionReferenceCountsSchema,
+  removable: z.boolean(),
+  source: sourceLoadDiagnosticsSchema.optional()
+}).strict();
+export const getCatalogDiagnosticsOperation = defineOperation({
+  name: "weft.catalog.diagnostics",
+  mcpExposable: !1,
+  summary: "Get bounded reference-count and removability diagnostics for one workflow revision",
+  description: "Report whether a `(name, revision)` workflow catalog entry is installed, whether it is currently the active revision, its full reference-count breakdown, and whether it's currently removable. When `name` was ever registered as a dynamic workflow source (`engine.registerSource()`), also reports its bounded load-state diagnostics: source kind, load state, load duration, last failure category, and outstanding waiter count. Never returns manifest or contract content.",
+  destructive: !1,
+  tags: ["Observability"],
+  inputSchema: getCatalogDiagnosticsInput,
+  outputSchema: getCatalogDiagnosticsOutput,
+  access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["system:read"] } },
+  producibleFaults: [],
+  discoverable: !0,
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ engine, input }) => {
+    return getWorkflowRevisionDiagnostics(engine, input.name, input.revision);
+  }
+}), getCatalogDiagnosticsRestBinding = {
+  method: "GET",
+  path: "/v1/catalog/:name/revisions/:revision/diagnostics",
+  pathParamNames: ["name", "revision"],
+  operationName: "weft.catalog.diagnostics",
+  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 },
+  shapeFault: shapeOperationFaultAsJson
+};

package/dist/server/operations/get-registry.js

@@ -1,14 +1,19 @@
 import { z } from "zod";
 import {
   buildRegistrySnapshot,
-  RegistrySchemaConversionError
+  REGISTRY_VERSION,
+  RegistryManifestLimitError,
+  RegistrySchemaConversionError,
+  RegistryWorkflowCountLimitError
 } from "../../core/registry-snapshot.js";
 import { defineOperation } from "../operation-registry.js";
 const getRegistryInput = z.object({}), objectValue = z.unknown().refine((value) => typeof value === "object" && value !== null && !Array.isArray(value), {
   message: "expected an object"
 }), getRegistryOutput = z.object({
-  registryVersion: z.literal(1),
-  workflows: objectValue,
+  registryVersion: z.literal(REGISTRY_VERSION),
+  generatedAt: z.string(),
+  workflows: z.array(objectValue),
+  activeRevisions: objectValue,
   activities: objectValue
 }).strict();
 export const getRegistryOperation = defineOperation({
@@ -28,7 +33,7 @@ export const getRegistryOperation = defineOperation({
   unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
   invoke: async ({ engine }) => {
     try {
-      return buildRegistrySnapshot(engine);
+      return await buildRegistrySnapshot(engine);
     } catch (error) {
       if (error instanceof RegistrySchemaConversionError)
         console.error(`[weft.system.registry] ${error.message}`, {
@@ -36,6 +41,14 @@ export const getRegistryOperation = defineOperation({
           entityName: error.entityName,
           direction: error.direction
         });
+      else if (error instanceof RegistryManifestLimitError)
+        console.error(`[weft.system.registry] ${error.message}`, {
+          workflowType: error.workflowType
+        });
+      else if (error instanceof RegistryWorkflowCountLimitError)
+        console.error(`[weft.system.registry] ${error.message}`, {
+          count: error.count
+        });
       throw error;
     }
   }

package/dist/server/operations/get-task-detail-schema.d.ts

@@ -39,6 +39,7 @@ export declare const getTaskDetailOutputSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     operationId: z.ZodString;
     workflowId: z.ZodOptional<z.ZodString>;
     workflowExecutionToken: z.ZodOptional<z.ZodString>;
+    workflowRevision: z.ZodOptional<z.ZodString>;
     workflowType: z.ZodString;
     activityName: z.ZodString;
     queue: z.ZodString;
@@ -77,6 +78,7 @@ export declare const getTaskDetailOutputSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     operationId: z.ZodString;
     workflowId: z.ZodOptional<z.ZodString>;
     workflowExecutionToken: z.ZodOptional<z.ZodString>;
+    workflowRevision: z.ZodOptional<z.ZodString>;
     workflowType: z.ZodString;
     activityName: z.ZodString;
     queue: z.ZodString;
@@ -120,6 +122,7 @@ export declare const getTaskDetailOutputSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     operationId: z.ZodString;
     workflowId: z.ZodOptional<z.ZodString>;
     workflowExecutionToken: z.ZodOptional<z.ZodString>;
+    workflowRevision: z.ZodOptional<z.ZodString>;
     workflowType: z.ZodString;
     activityName: z.ZodString;
     queue: z.ZodString;
@@ -160,6 +163,7 @@ export declare const getTaskDetailOutputSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     operationId: z.ZodString;
     workflowId: z.ZodOptional<z.ZodString>;
     workflowExecutionToken: z.ZodOptional<z.ZodString>;
+    workflowRevision: z.ZodOptional<z.ZodString>;
     workflowType: z.ZodString;
     activityName: z.ZodString;
     queue: z.ZodString;
@@ -200,6 +204,7 @@ export declare const getTaskDetailOutputSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     operationId: z.ZodString;
     workflowId: z.ZodOptional<z.ZodString>;
     workflowExecutionToken: z.ZodOptional<z.ZodString>;
+    workflowRevision: z.ZodOptional<z.ZodString>;
     workflowType: z.ZodString;
     activityName: z.ZodString;
     queue: z.ZodString;
@@ -235,6 +240,7 @@ export declare const getTaskDetailOutputSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     operationId: z.ZodString;
     workflowId: z.ZodOptional<z.ZodString>;
     workflowExecutionToken: z.ZodOptional<z.ZodString>;
+    workflowRevision: z.ZodOptional<z.ZodString>;
     workflowType: z.ZodString;
     activityName: z.ZodString;
     queue: z.ZodString;
@@ -270,6 +276,7 @@ export declare const getTaskDetailOutputSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     operationId: z.ZodString;
     workflowId: z.ZodOptional<z.ZodString>;
     workflowExecutionToken: z.ZodOptional<z.ZodString>;
+    workflowRevision: z.ZodOptional<z.ZodString>;
     workflowType: z.ZodString;
     activityName: z.ZodString;
     queue: z.ZodString;
@@ -311,6 +318,7 @@ export declare const getTaskDetailOutputSchema: z.ZodDiscriminatedUnion<[z.ZodOb
     operationId: z.ZodString;
     workflowId: z.ZodOptional<z.ZodString>;
     workflowExecutionToken: z.ZodOptional<z.ZodString>;
+    workflowRevision: z.ZodOptional<z.ZodString>;
     workflowType: z.ZodString;
     activityName: z.ZodString;
     queue: z.ZodString;

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

@@ -23,6 +23,7 @@ const taskDetailBaseFields = {
   operationId: z.string(),
   workflowId: z.string().optional(),
   workflowExecutionToken: z.string().optional(),
+  workflowRevision: z.string().optional(),
   workflowType: z.string(),
   activityName: z.string(),
   queue: z.string(),

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

@@ -60,6 +60,7 @@ export declare const getTaskDetailOperation: import("../operation-catalog.ts").O
     adoptedAt?: number | undefined;
     workflowId?: string | undefined;
     workflowExecutionToken?: string | undefined;
+    workflowRevision?: string | undefined;
     priority?: number | undefined;
     retryPolicy?: {
         maxAttempts: number;
@@ -95,6 +96,7 @@ export declare const getTaskDetailOperation: import("../operation-catalog.ts").O
     adoptedAt?: number | undefined;
     workflowId?: string | undefined;
     workflowExecutionToken?: string | undefined;
+    workflowRevision?: string | undefined;
     priority?: number | undefined;
     retryPolicy?: {
         maxAttempts: number;
@@ -130,6 +132,7 @@ export declare const getTaskDetailOperation: import("../operation-catalog.ts").O
     adoptedAt?: number | undefined;
     workflowId?: string | undefined;
     workflowExecutionToken?: string | undefined;
+    workflowRevision?: string | undefined;
     priority?: number | undefined;
     retryPolicy?: {
         maxAttempts: number;
@@ -168,6 +171,7 @@ export declare const getTaskDetailOperation: import("../operation-catalog.ts").O
     lastRequeueReason?: string | undefined;
     workflowId?: string | undefined;
     workflowExecutionToken?: string | undefined;
+    workflowRevision?: string | undefined;
     priority?: number | undefined;
     retryPolicy?: {
         maxAttempts: number;
@@ -206,6 +210,7 @@ export declare const getTaskDetailOperation: import("../operation-catalog.ts").O
     lastRequeueReason?: string | undefined;
     workflowId?: string | undefined;
     workflowExecutionToken?: string | undefined;
+    workflowRevision?: string | undefined;
     priority?: number | undefined;
     retryPolicy?: {
         maxAttempts: number;
@@ -246,6 +251,7 @@ export declare const getTaskDetailOperation: import("../operation-catalog.ts").O
     lastRequeueReason?: string | undefined;
     workflowId?: string | undefined;
     workflowExecutionToken?: string | undefined;
+    workflowRevision?: string | undefined;
     priority?: number | undefined;
     retryPolicy?: {
         maxAttempts: number;
@@ -286,6 +292,7 @@ export declare const getTaskDetailOperation: import("../operation-catalog.ts").O
     lastRequeueReason?: string | undefined;
     workflowId?: string | undefined;
     workflowExecutionToken?: string | undefined;
+    workflowRevision?: string | undefined;
     priority?: number | undefined;
     retryPolicy?: {
         maxAttempts: number;
@@ -324,6 +331,7 @@ export declare const getTaskDetailOperation: import("../operation-catalog.ts").O
     lastRequeueReason?: string | undefined;
     workflowId?: string | undefined;
     workflowExecutionToken?: string | undefined;
+    workflowRevision?: string | undefined;
     priority?: number | undefined;
     retryPolicy?: {
         maxAttempts: number;