@lostgradient/weft 0.23.1 → 0.24.1

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/conformance.js

@@ -119,14 +119,15 @@ async function readResolvedStatus(storage, operationId) {
 async function waitForResolvedStatus(storage, operationId, status, timeoutMs) {
   await waitForCondition(async () => await readResolvedStatus(storage, operationId) === status, timeoutMs, `${operationId} to resolve as ${status}`);
 }
-async function dispatchAndWait(server, storage, operationId, activityName, input, expectedStatus, timeoutMs) {
+async function dispatchAndWait(server, storage, operationId, activityName, input, expectedStatus, timeoutMs, workflowRevision) {
   if (!await server.dispatchTask({
     operationId,
     activityName,
     workflowType: "conformance",
     input,
     queue: CONFORMANCE_QUEUE,
-    visibilityTimeout: Math.max(500, timeoutMs)
+    visibilityTimeout: Math.max(500, timeoutMs),
+    ...workflowRevision !== void 0 && { workflowRevision }
   }))
     throw Error(`Could not dispatch ${operationId}`);
   await waitForResolvedStatus(storage, operationId, expectedStatus, timeoutMs);
@@ -184,6 +185,8 @@ async function runConformanceChecks(command, timeoutMs) {
     await waitForWorkerIdle(server, replacementWorkerId, timeoutMs);
     await waitForResolvedStatus(storage, reconnectOperationId, "completed", timeoutMs);
     checks.push(createCheck("reconnect", !0, "in-flight task completed after reconnect"));
+    await dispatchAndWait(server, storage, "conformance-revision-echo", "conformance.echo", { ok: !0 }, "completed", timeoutMs, "conformance-revision-1");
+    checks.push(createCheck("revision echo", !0, "workflowRevision echoed and accepted"));
     const shutdownWorkerId = server.registry.getWorker(replacementWorkerId)?.id;
     if (shutdownWorkerId === void 0)
       throw Error("No worker available for graceful shutdown check");