@lostgradient/weft 0.23.0 → 0.24.0

package/dist/cli/codegen-validate.js

@@ -0,0 +1,186 @@
+import { z } from "zod";
+import {
+  parseWorkflowRevisionManifest
+} from "../core/contract/index.js";
+import { MAX_CONTRACT_IDENTIFIER_BYTES } from "../core/contract/limits.js";
+import { MAX_REGISTRY_WORKFLOW_COUNT } from "../core/registry-limits.js";
+import { REGISTRY_VERSION } from "../core/registry-snapshot.js";
+import { isRecord } from "../worker/manifest/is-record.js";
+import { utf8ByteLength } from "../worker/manifest/utf8.js";
+const jsonSchema = z.union([z.boolean(), z.record(z.string(), z.unknown())]), activityEntrySchema = z.object({
+  inputSchema: jsonSchema.optional(),
+  outputSchema: jsonSchema.optional(),
+  queue: z.string(),
+  description: z.string().optional()
+}).passthrough(), objectValue = z.unknown().refine((value) => typeof value === "object" && value !== null && !Array.isArray(value), {
+  message: "expected an object"
+}), registryEnvelopeSchema = z.object({
+  registryVersion: z.literal(REGISTRY_VERSION),
+  generatedAt: z.string(),
+  workflows: z.array(objectValue),
+  activeRevisions: objectValue,
+  activities: z.record(z.string(), activityEntrySchema)
+}).passthrough();
+function normalizeRootSchema(schema) {
+  if (schema === void 0)
+    return;
+  if (typeof schema === "boolean")
+    return {};
+  return schema;
+}
+function projectActivities(raw) {
+  const projected = Object.create(null);
+  for (const [name, entry] of Object.entries(raw)) {
+    const projection = { queue: entry.queue }, input = normalizeRootSchema(entry.inputSchema), output = normalizeRootSchema(entry.outputSchema);
+    if (input !== void 0)
+      projection.inputSchema = input;
+    if (output !== void 0)
+      projection.outputSchema = output;
+    if (entry.description !== void 0)
+      projection.description = entry.description;
+    projected[name] = projection;
+  }
+  return projected;
+}
+function formatZodError(error) {
+  return error.issues.map((issue) => {
+    return `${issue.path.length === 0 ? "<root>" : issue.path.join(".")}: ${issue.message}`;
+  }).join("; ");
+}
+function readActiveRevisions(value) {
+  if (!isRecord(value))
+    return {
+      ok: !1,
+      error: "codegen: invalid registry snapshot: activeRevisions must be an object"
+    };
+  let entryCount = 0;
+  for (const name in value) {
+    entryCount += 1;
+    if (entryCount > MAX_REGISTRY_WORKFLOW_COUNT)
+      return {
+        ok: !1,
+        error: `codegen: invalid registry snapshot: activeRevisions has more than ${MAX_REGISTRY_WORKFLOW_COUNT} entries`
+      };
+    if (utf8ByteLength(name) > MAX_CONTRACT_IDENTIFIER_BYTES)
+      return {
+        ok: !1,
+        error: `codegen: invalid registry snapshot: activeRevisions key ${JSON.stringify(name)} exceeds the maximum identifier length of ${MAX_CONTRACT_IDENTIFIER_BYTES} bytes`
+      };
+    const revision = value[name];
+    if (typeof revision !== "string")
+      return {
+        ok: !1,
+        error: `codegen: invalid registry snapshot: activeRevisions[${JSON.stringify(name)}] must be a string`
+      };
+    if (utf8ByteLength(revision) > MAX_CONTRACT_IDENTIFIER_BYTES)
+      return {
+        ok: !1,
+        error: `codegen: invalid registry snapshot: activeRevisions[${JSON.stringify(name)}] exceeds the maximum identifier length of ${MAX_CONTRACT_IDENTIFIER_BYTES} bytes`
+      };
+  }
+  return { ok: !0, value };
+}
+async function parseAllManifests(workflowsRaw) {
+  const manifests = [];
+  for (const [index, raw] of workflowsRaw.entries()) {
+    const parsed = await parseWorkflowRevisionManifest(raw);
+    if (!parsed.ok) {
+      const location = parsed.path === void 0 ? "" : ` at ${parsed.path}`;
+      return {
+        ok: !1,
+        error: `codegen: invalid registry snapshot: workflows[${index}] (${parsed.reason}${location}): ${parsed.message}`
+      };
+    }
+    manifests.push(parsed.manifest);
+  }
+  return { ok: !0, value: manifests };
+}
+function indexManifestsByIdentity(manifests) {
+  const byName = new Map;
+  for (const manifest of manifests) {
+    let byRevision = byName.get(manifest.name);
+    if (byRevision === void 0) {
+      byRevision = new Map;
+      byName.set(manifest.name, byRevision);
+    }
+    if (byRevision.has(manifest.revision))
+      return {
+        ok: !1,
+        error: `codegen: invalid registry snapshot: workflows contains more than one manifest for name ${JSON.stringify(manifest.name)}, revision ${JSON.stringify(manifest.revision)}`
+      };
+    byRevision.set(manifest.revision, manifest);
+  }
+  return { ok: !0, value: byName };
+}
+function toCodegenWorkflowEntry(manifest) {
+  const entry = {
+    revision: manifest.revision,
+    workflowVersion: manifest.workflowVersion
+  };
+  if (manifest.contract.inputSchema !== void 0)
+    entry.inputSchema = manifest.contract.inputSchema;
+  if (manifest.contract.outputSchema !== void 0)
+    entry.outputSchema = manifest.contract.outputSchema;
+  if (manifest.contract.description !== void 0)
+    entry.description = manifest.contract.description;
+  if (manifest.contract.tags !== void 0 && manifest.contract.tags.length > 0)
+    entry.tags = manifest.contract.tags;
+  return entry;
+}
+async function resolveActiveWorkflowEntries(workflowsRaw, activeRevisions) {
+  const parsed = await parseAllManifests(workflowsRaw);
+  if (!parsed.ok)
+    return parsed;
+  const indexed = indexManifestsByIdentity(parsed.value);
+  if (!indexed.ok)
+    return indexed;
+  const byName = indexed.value, projected = Object.create(null);
+  for (const [name, revision] of Object.entries(activeRevisions)) {
+    const manifest = byName.get(name)?.get(revision);
+    if (manifest === void 0)
+      continue;
+    projected[name] = toCodegenWorkflowEntry(manifest);
+  }
+  return { ok: !0, value: projected };
+}
+function checkRawWorkflowsCount(value) {
+  const rawWorkflows = value !== null && typeof value === "object" ? value.workflows : void 0;
+  if (Array.isArray(rawWorkflows) && rawWorkflows.length > MAX_REGISTRY_WORKFLOW_COUNT)
+    return {
+      ok: !1,
+      error: `codegen: invalid registry snapshot: workflows has ${rawWorkflows.length} entries, exceeding the maximum of ${MAX_REGISTRY_WORKFLOW_COUNT}`
+    };
+  return;
+}
+export async function validateRegistrySnapshot(value) {
+  if (value !== null && typeof value === "object" && "registryVersion" in value) {
+    const { registryVersion: actual } = value;
+    if (actual !== REGISTRY_VERSION)
+      return {
+        ok: !1,
+        error: `codegen: registryVersion ${String(actual)} is not supported (expected ${REGISTRY_VERSION}); upgrade or regenerate the snapshot`
+      };
+  }
+  const oversizedWorkflows = checkRawWorkflowsCount(value);
+  if (oversizedWorkflows !== void 0)
+    return oversizedWorkflows;
+  const parsed = registryEnvelopeSchema.safeParse(value);
+  if (!parsed.success)
+    return {
+      ok: !1,
+      error: `codegen: invalid registry snapshot: ${formatZodError(parsed.error)}`
+    };
+  const activeRevisions = readActiveRevisions(parsed.data.activeRevisions);
+  if (!activeRevisions.ok)
+    return activeRevisions;
+  const workflows = await resolveActiveWorkflowEntries(parsed.data.workflows, activeRevisions.value);
+  if (!workflows.ok)
+    return workflows;
+  return {
+    ok: !0,
+    value: {
+      workflows: workflows.value,
+      activities: projectActivities(parsed.data.activities)
+    }
+  };
+}

package/dist/cli/codegen.js

@@ -1,37 +1,19 @@
 import { promises as fs } from "node:fs";
 import { basename, dirname } from "node:path";
-import { z } from "zod";
 import { ConnectionConfigurationError, resolveConnection } from "../connection.js";
-import {
-  REGISTRY_VERSION
-} from "../core/registry-snapshot.js";
-import { CodegenEmitError, emitRegistryDeclaration } from "./codegen-emit.js";
-const jsonSchema = z.union([z.boolean(), z.record(z.string(), z.unknown())]), workflowEntrySchema = z.object({
-  inputSchema: jsonSchema.optional(),
-  outputSchema: jsonSchema.optional(),
-  description: z.string().optional(),
-  tags: z.array(z.string()).optional()
-}).passthrough(), activityEntrySchema = z.object({
-  inputSchema: jsonSchema.optional(),
-  outputSchema: jsonSchema.optional(),
-  queue: z.string(),
-  description: z.string().optional()
-}).passthrough(), registrySnapshotSchema = z.object({
-  registryVersion: z.literal(REGISTRY_VERSION),
-  workflows: z.record(z.string(), workflowEntrySchema),
-  activities: z.record(z.string(), activityEntrySchema)
-}).passthrough();
+import { CodegenEmitError, emitRegistryDeclaration } from "./codegen-emit-registry.js";
+import { validateRegistrySnapshot } from "./codegen-validate.js";
 export async function executeCodegen(options) {
   const snapshotResult = await loadSnapshot(options);
   if (!snapshotResult.ok)
     return formatFailure(snapshotResult.error, options);
-  const validation = validateSnapshot(snapshotResult.value);
+  const validation = await validateRegistrySnapshot(snapshotResult.value);
   if (!validation.ok)
     return formatFailure(validation.error, options);
-  const snapshot = validation.value;
+  const { workflows, activities } = validation.value;
   let content;
   try {
-    content = emitRegistryDeclaration(snapshot);
+    content = emitRegistryDeclaration(workflows);
   } catch (error) {
     if (error instanceof CodegenEmitError)
       return formatFailure(`codegen: ${error.message}`, options);
@@ -41,7 +23,7 @@ export async function executeCodegen(options) {
   const writeResult = await writeOutput(options.out, content);
   if (!writeResult.ok)
     return formatFailure(writeResult.error, options);
-  const workflowCount = Object.keys(snapshot.workflows).length, activityCount = Object.keys(snapshot.activities).length;
+  const workflowCount = Object.keys(workflows).length, activityCount = Object.keys(activities).length;
   return formatSuccess(options, writeResult.action, workflowCount, activityCount);
 }
 function formatFailure(message, options) {
@@ -166,69 +148,6 @@ async function loadSnapshotFromServer(serverUrl, token, timeoutMs) {
   }
   return parseRegistryResponse(response, resolvedUrl);
 }
-function validateSnapshot(value) {
-  if (value !== null && typeof value === "object" && "registryVersion" in value) {
-    const { registryVersion: actual } = value;
-    if (actual !== REGISTRY_VERSION)
-      return {
-        ok: !1,
-        error: `codegen: registryVersion ${String(actual)} is not supported (expected ${REGISTRY_VERSION}); upgrade or regenerate the snapshot`
-      };
-  }
-  const parsed = registrySnapshotSchema.safeParse(value);
-  if (!parsed.success)
-    return {
-      ok: !1,
-      error: `codegen: invalid registry snapshot: ${formatZodError(parsed.error)}`
-    };
-  return { ok: !0, value: {
-    registryVersion: parsed.data.registryVersion,
-    workflows: projectWorkflows(parsed.data.workflows),
-    activities: projectActivities(parsed.data.activities)
-  } };
-}
-function normalizeRootSchema(schema) {
-  if (schema === void 0)
-    return;
-  if (typeof schema === "boolean")
-    return {};
-  return schema;
-}
-function projectWorkflows(raw) {
-  const projected = Object.create(null);
-  for (const [name, entry] of Object.entries(raw)) {
-    const projection = {}, input = normalizeRootSchema(entry.inputSchema), output = normalizeRootSchema(entry.outputSchema);
-    if (input !== void 0)
-      projection.inputSchema = input;
-    if (output !== void 0)
-      projection.outputSchema = output;
-    if (entry.description !== void 0)
-      projection.description = entry.description;
-    if (entry.tags !== void 0)
-      projection.tags = entry.tags;
-    projected[name] = projection;
-  }
-  return projected;
-}
-function projectActivities(raw) {
-  const projected = Object.create(null);
-  for (const [name, entry] of Object.entries(raw)) {
-    const projection = { queue: entry.queue }, input = normalizeRootSchema(entry.inputSchema), output = normalizeRootSchema(entry.outputSchema);
-    if (input !== void 0)
-      projection.inputSchema = input;
-    if (output !== void 0)
-      projection.outputSchema = output;
-    if (entry.description !== void 0)
-      projection.description = entry.description;
-    projected[name] = projection;
-  }
-  return projected;
-}
-function formatZodError(error) {
-  return error.issues.map((issue) => {
-    return `${issue.path.length === 0 ? "<root>" : issue.path.join(".")}: ${issue.message}`;
-  }).join("; ");
-}
 async function writeOutput(outPath, content) {
   const parent = dirname(outPath);
   try {

package/dist/cli/generated/operation-catalog.snapshot.json

@@ -169,6 +169,115 @@
         "type": "object"
       }
     },
+    {
+      "name": "weft.catalog.diagnostics",
+      "kind": "unary",
+      "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. Never returns manifest or contract content.",
+      "tags": ["Observability"],
+      "destructive": false,
+      "access": {
+        "kind": "scoped",
+        "scopes": ["system:read"]
+      },
+      "transports": {
+        "http": true,
+        "jsonRpcHttp": true,
+        "jsonRpcWebSocket": true,
+        "jsonRpcStdio": true
+      },
+      "producibleFaults": [],
+      "inputSchema": {
+        "additionalProperties": false,
+        "properties": {
+          "name": {
+            "minLength": 1,
+            "type": "string"
+          },
+          "revision": {
+            "minLength": 1,
+            "type": "string"
+          }
+        },
+        "required": ["name", "revision"],
+        "type": "object"
+      },
+      "outputSchema": {
+        "additionalProperties": false,
+        "properties": {
+          "active": {
+            "type": "boolean"
+          },
+          "activeRevision": {
+            "type": "string"
+          },
+          "installed": {
+            "type": "boolean"
+          },
+          "name": {
+            "type": "string"
+          },
+          "references": {
+            "additionalProperties": false,
+            "properties": {
+              "activeExecutionRealms": {
+                "maximum": 9007199254740991,
+                "minimum": 0,
+                "type": "integer"
+              },
+              "inFlightStarts": {
+                "maximum": 9007199254740991,
+                "minimum": 0,
+                "type": "integer"
+              },
+              "nonTerminalRuns": {
+                "maximum": 9007199254740991,
+                "minimum": 0,
+                "type": "integer"
+              },
+              "pendingDispatches": {
+                "maximum": 9007199254740991,
+                "minimum": 0,
+                "type": "integer"
+              },
+              "pinnedSchedules": {
+                "maximum": 9007199254740991,
+                "minimum": 0,
+                "type": "integer"
+              },
+              "registeredDefinitions": {
+                "maximum": 9007199254740991,
+                "minimum": 0,
+                "type": "integer"
+              },
+              "retainedRecoveryRecords": {
+                "maximum": 9007199254740991,
+                "minimum": 0,
+                "type": "integer"
+              }
+            },
+            "required": [
+              "registeredDefinitions",
+              "inFlightStarts",
+              "nonTerminalRuns",
+              "pinnedSchedules",
+              "pendingDispatches",
+              "activeExecutionRealms",
+              "retainedRecoveryRecords"
+            ],
+            "type": "object"
+          },
+          "removable": {
+            "type": "boolean"
+          },
+          "revision": {
+            "type": "string"
+          }
+        },
+        "required": ["name", "revision", "installed", "active", "references", "removable"],
+        "type": "object"
+      }
+    },
     {
       "name": "weft.events.sse",
       "kind": "stream",
@@ -1575,14 +1684,27 @@
       "outputSchema": {
         "additionalProperties": false,
         "properties": {
+          "activeRevisions": {},
           "activities": {},
+          "generatedAt": {
+            "type": "string"
+          },
           "registryVersion": {
-            "const": 1,
+            "const": 2,
             "type": "number"
           },
-          "workflows": {}
+          "workflows": {
+            "items": {},
+            "type": "array"
+          }
         },
-        "required": ["registryVersion", "workflows", "activities"],
+        "required": [
+          "registryVersion",
+          "generatedAt",
+          "workflows",
+          "activeRevisions",
+          "activities"
+        ],
         "type": "object"
       }
     },
@@ -4241,6 +4363,36 @@
         ]
       }
     },
+    {
+      "name": "weft.workflows.active.get",
+      "kind": "unary",
+      "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.",
+      "tags": ["Workflow Catalog"],
+      "destructive": false,
+      "access": {
+        "kind": "scoped",
+        "scopes": ["workflows:read"]
+      },
+      "transports": {
+        "http": true,
+        "jsonRpcHttp": true,
+        "jsonRpcWebSocket": true,
+        "jsonRpcStdio": true
+      },
+      "producibleFaults": ["InvalidParams", "NotFound"],
+      "inputSchema": {
+        "additionalProperties": false,
+        "properties": {
+          "name": {
+            "description": "Workflow name. Runtime validation requires a wire-safe identifier."
+          }
+        },
+        "required": ["name"],
+        "type": "object"
+      },
+      "outputSchema": {}
+    },
     {
       "name": "weft.workflows.activities.pending.list",
       "kind": "unary",
@@ -7466,6 +7618,138 @@
         "type": "object"
       }
     },
+    {
+      "name": "weft.workflows.revisions.activate",
+      "kind": "unary",
+      "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 — 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 — see the workflow-versioning guide.",
+      "tags": ["Workflow Catalog"],
+      "destructive": true,
+      "access": {
+        "kind": "scoped",
+        "scopes": ["workflows:admin"]
+      },
+      "transports": {
+        "http": true,
+        "jsonRpcHttp": true,
+        "jsonRpcWebSocket": true,
+        "jsonRpcStdio": true
+      },
+      "producibleFaults": ["Conflict", "InvalidParams", "NotFound"],
+      "inputSchema": {
+        "additionalProperties": false,
+        "properties": {
+          "expectedGeneration": {
+            "description": "The durable generation this caller last observed. Required once the workflow has an active revision — omitting it there refuses with expected-generation-required."
+          },
+          "name": {
+            "description": "Workflow name. Runtime validation requires a wire-safe identifier."
+          },
+          "policy": {
+            "description": "Optional compatibility policy override."
+          },
+          "revision": {
+            "description": "Installed revision to activate. Runtime validation requires a non-empty string."
+          }
+        },
+        "required": ["name", "revision"],
+        "type": "object"
+      },
+      "outputSchema": {}
+    },
+    {
+      "name": "weft.workflows.revisions.get",
+      "kind": "unary",
+      "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.",
+      "tags": ["Workflow Catalog"],
+      "destructive": false,
+      "access": {
+        "kind": "scoped",
+        "scopes": ["workflows:read"]
+      },
+      "transports": {
+        "http": true,
+        "jsonRpcHttp": true,
+        "jsonRpcWebSocket": true,
+        "jsonRpcStdio": true
+      },
+      "producibleFaults": ["InvalidParams", "NotFound"],
+      "inputSchema": {
+        "additionalProperties": false,
+        "properties": {
+          "name": {
+            "description": "Workflow name. Runtime validation requires a wire-safe identifier."
+          },
+          "revision": {
+            "description": "Installed revision. Runtime validation requires a non-empty string."
+          }
+        },
+        "required": ["name", "revision"],
+        "type": "object"
+      },
+      "outputSchema": {}
+    },
+    {
+      "name": "weft.workflows.revisions.install",
+      "kind": "unary",
+      "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 — that mismatch is a normal activation-time `incompatible` refusal, not an install-time error. Never changes which in-process handler `engine.start()` dispatches to.",
+      "tags": ["Workflow Catalog"],
+      "destructive": false,
+      "access": {
+        "kind": "scoped",
+        "scopes": ["workflows:admin"]
+      },
+      "transports": {
+        "http": true,
+        "jsonRpcHttp": true,
+        "jsonRpcWebSocket": true,
+        "jsonRpcStdio": true
+      },
+      "producibleFaults": ["Conflict", "InvalidParams"],
+      "inputSchema": {
+        "additionalProperties": false,
+        "properties": {
+          "manifest": {
+            "description": "An untrusted WorkflowRevisionManifest, validated at invoke time."
+          }
+        },
+        "required": ["manifest"],
+        "type": "object"
+      },
+      "outputSchema": {}
+    },
+    {
+      "name": "weft.workflows.revisions.list",
+      "kind": "unary",
+      "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 — an empty catalog is not an error.",
+      "tags": ["Workflow Catalog"],
+      "destructive": false,
+      "access": {
+        "kind": "scoped",
+        "scopes": ["workflows:read"]
+      },
+      "transports": {
+        "http": true,
+        "jsonRpcHttp": true,
+        "jsonRpcWebSocket": true,
+        "jsonRpcStdio": true
+      },
+      "producibleFaults": ["InvalidParams"],
+      "inputSchema": {
+        "additionalProperties": false,
+        "properties": {
+          "name": {
+            "description": "Workflow name. Runtime validation requires a wire-safe identifier."
+          }
+        },
+        "required": ["name"],
+        "type": "object"
+      },
+      "outputSchema": {}
+    },
     {
       "name": "weft.workflows.scheduleprovenance.get",
       "kind": "unary",