@lostgradient/weft 0.23.1 → 0.24.1

package/dist/core/contract/manifest-parse.js

@@ -0,0 +1,189 @@
+import { isRecord } from "../../worker/manifest/is-record.js";
+import { utf8ByteLength } from "../../worker/manifest/utf8.js";
+import {
+  workflowRevisionManifestFailure
+} from "./failure.js";
+import { contractHash } from "./hash.js";
+import {
+  MAX_CONTRACT_IDENTIFIER_BYTES,
+  MAX_CONTRACT_MESSAGE_COUNT,
+  MAX_NORMALIZED_CONTRACT_BYTES
+} from "./limits.js";
+import { checkContractKey, parseContractRecord, parseSchemaPair } from "./manifest-parse-schema.js";
+import { canonicalWorkflowContractJson, normalizeWorkflowContract } from "./normalize.js";
+import { WORKFLOW_REVISION_MANIFEST_VERSION } from "./types.js";
+function parseIdentifier(value, path) {
+  if (typeof value !== "string" || value.length === 0)
+    return workflowRevisionManifestFailure("invalid-field", "must be a non-empty string", path);
+  const bytes = utf8ByteLength(value);
+  if (bytes > MAX_CONTRACT_IDENTIFIER_BYTES)
+    return workflowRevisionManifestFailure("identifier-too-long", `is ${bytes} bytes, exceeding the maximum identifier size of ${MAX_CONTRACT_IDENTIFIER_BYTES}`, path);
+  return { ok: !0, value };
+}
+function parseDescription(value, path) {
+  if (typeof value !== "string")
+    return workflowRevisionManifestFailure("invalid-field", "must be a string", path);
+  return { ok: !0, value };
+}
+function parseTag(value, path) {
+  if (typeof value !== "string")
+    return workflowRevisionManifestFailure("invalid-field", "must be a string", path);
+  return { ok: !0, value };
+}
+function parseTags(value, path) {
+  if (value === void 0)
+    return { ok: !0, value: void 0 };
+  if (!Array.isArray(value))
+    return workflowRevisionManifestFailure("invalid-field", "must be an array of strings", path);
+  if (value.length > MAX_CONTRACT_MESSAGE_COUNT)
+    return workflowRevisionManifestFailure("too-many-entries", `declares ${value.length} entries, exceeding the maximum of ${MAX_CONTRACT_MESSAGE_COUNT}`, path);
+  const tags = [];
+  let accumulatedBytes = 0;
+  for (const [index, entry] of value.entries()) {
+    const tag = parseTag(entry, `${path}[${index}]`);
+    if (!tag.ok)
+      return tag;
+    accumulatedBytes += utf8ByteLength(tag.value);
+    if (accumulatedBytes > MAX_NORMALIZED_CONTRACT_BYTES)
+      return workflowRevisionManifestFailure("manifest-too-large", `accumulated tag bytes exceed the maximum of ${MAX_NORMALIZED_CONTRACT_BYTES}`, path);
+    tags.push(tag.value);
+  }
+  return { ok: !0, value: tags.length === 0 ? void 0 : tags };
+}
+function parseContractIdentity(value, path) {
+  const name = parseIdentifier(value.name, `${path}.name`);
+  if (!name.ok)
+    return name;
+  const nameKeyFailure = checkContractKey(name.value, "workflow", `${path}.name`);
+  if (nameKeyFailure !== void 0)
+    return nameKeyFailure;
+  const workflowVersion = parseIdentifier(value.workflowVersion, `${path}.workflowVersion`);
+  if (!workflowVersion.ok)
+    return workflowVersion;
+  const identity = {
+    name: name.value,
+    workflowVersion: workflowVersion.value
+  };
+  if (value.description !== void 0) {
+    const description = parseDescription(value.description, `${path}.description`);
+    if (!description.ok)
+      return description;
+    identity.description = description.value;
+  }
+  const tags = parseTags(value.tags, `${path}.tags`);
+  if (!tags.ok)
+    return tags;
+  if (tags.value !== void 0)
+    identity.tags = tags.value;
+  return { ok: !0, value: identity };
+}
+const NAMED_RECORD_FIELDS = [
+  ["signals", void 0],
+  ["updates", void 0],
+  ["queries", void 0],
+  ["activities", "activity"]
+];
+function parseNamedRecordFields(value, path, collections) {
+  for (const [field, keyKind] of NAMED_RECORD_FIELDS) {
+    if (value[field] === void 0)
+      continue;
+    const parsed = parseContractRecord(value[field], `${path}.${field}`, keyKind);
+    if (!parsed.ok)
+      return parsed;
+    collections[field] = parsed.value;
+  }
+  return;
+}
+function parseContractCollections(value, path) {
+  const collections = {};
+  if (value.inputSchema !== void 0 || value.outputSchema !== void 0) {
+    const pair = parseSchemaPair({ inputSchema: value.inputSchema, outputSchema: value.outputSchema }, path);
+    if (!pair.ok)
+      return pair;
+    if (pair.value.inputSchema !== void 0)
+      collections.inputSchema = pair.value.inputSchema;
+    if (pair.value.outputSchema !== void 0)
+      collections.outputSchema = pair.value.outputSchema;
+  }
+  const recordFailure = parseNamedRecordFields(value, path, collections);
+  if (recordFailure !== void 0)
+    return recordFailure;
+  if (value.finalizer !== void 0) {
+    const finalizer = parseSchemaPair(value.finalizer, `${path}.finalizer`);
+    if (!finalizer.ok)
+      return finalizer;
+    collections.finalizer = finalizer.value;
+  }
+  return { ok: !0, value: collections };
+}
+function parseContract(value, path) {
+  if (!isRecord(value))
+    return workflowRevisionManifestFailure("invalid-field", "must be a JSON object", path);
+  const identity = parseContractIdentity(value, path);
+  if (!identity.ok)
+    return identity;
+  const collections = parseContractCollections(value, path);
+  if (!collections.ok)
+    return collections;
+  return { ok: !0, value: { ...identity.value, ...collections.value } };
+}
+const TOP_LEVEL_IDENTIFIER_FIELDS = [
+  ["name", "manifest.name"],
+  ["workflowVersion", "manifest.workflowVersion"],
+  ["revision", "manifest.revision"],
+  ["contractHash", "manifest.contractHash"]
+];
+function parseTopLevelIdentifiers(value) {
+  const parsed = {};
+  for (const [field, path] of TOP_LEVEL_IDENTIFIER_FIELDS) {
+    const result = parseIdentifier(value[field], path);
+    if (!result.ok)
+      return result;
+    parsed[field] = result.value;
+  }
+  return { ok: !0, value: parsed };
+}
+function checkIdentityAgreement(identifiers, contract) {
+  if (identifiers.name !== contract.name)
+    return workflowRevisionManifestFailure("invalid-field", "must equal manifest.contract.name", "manifest.name");
+  if (identifiers.workflowVersion !== contract.workflowVersion)
+    return workflowRevisionManifestFailure("invalid-field", "must equal manifest.contract.workflowVersion", "manifest.workflowVersion");
+  return;
+}
+async function finalizeManifest(identifiers, normalized) {
+  const canonicalJson = canonicalWorkflowContractJson(normalized), canonicalBytes = utf8ByteLength(canonicalJson);
+  if (canonicalBytes > MAX_NORMALIZED_CONTRACT_BYTES)
+    return workflowRevisionManifestFailure("manifest-too-large", `contract normalizes to ${canonicalBytes} bytes, exceeding the maximum of ${MAX_NORMALIZED_CONTRACT_BYTES}`, "manifest.contract");
+  const recomputedHash = await contractHash(normalized);
+  if (recomputedHash !== identifiers.contractHash)
+    return workflowRevisionManifestFailure("contract-hash-mismatch", `recomputed contractHash ${recomputedHash} does not match the supplied value`, "manifest.contractHash");
+  return {
+    ok: !0,
+    manifest: {
+      manifestVersion: WORKFLOW_REVISION_MANIFEST_VERSION,
+      name: identifiers.name,
+      workflowVersion: identifiers.workflowVersion,
+      revision: identifiers.revision,
+      contractHash: recomputedHash,
+      contract: normalized
+    },
+    canonicalJson
+  };
+}
+export async function parseWorkflowRevisionManifest(value) {
+  if (!isRecord(value))
+    return workflowRevisionManifestFailure("not-an-object", "manifest must be a JSON object");
+  if (value.manifestVersion !== WORKFLOW_REVISION_MANIFEST_VERSION)
+    return workflowRevisionManifestFailure("manifest-version-unsupported", `manifest.manifestVersion must be ${String(WORKFLOW_REVISION_MANIFEST_VERSION)}`);
+  const identifiers = parseTopLevelIdentifiers(value);
+  if (!identifiers.ok)
+    return identifiers;
+  const contract = parseContract(value.contract, "manifest.contract");
+  if (!contract.ok)
+    return contract;
+  const agreementFailure = checkIdentityAgreement(identifiers.value, contract.value);
+  if (agreementFailure !== void 0)
+    return agreementFailure;
+  const normalized = normalizeWorkflowContract(contract.value);
+  return finalizeManifest(identifiers.value, normalized);
+}

package/dist/core/contract/manifest.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Build a {@link WorkflowRevisionManifest} from a normalized contract.
+ *
+ * @module core/contract/manifest
+ */
+import type { WorkflowContract, WorkflowRevisionManifest } from './types.ts';
+/**
+ * Options accepted by {@link buildWorkflowRevisionManifest}.
+ *
+ * @example
+ * ```ts
+ * import type { BuildWorkflowRevisionManifestOptions } from '@lostgradient/weft';
+ *
+ * const options: BuildWorkflowRevisionManifestOptions = { revision: 'deploy-2026.09.01' };
+ * console.log(options.revision);
+ * ```
+ */
+export interface BuildWorkflowRevisionManifestOptions {
+    /**
+     * Explicit opaque revision identity. When omitted, `revision` is derived
+     * from the full contract via {@link deriveWorkflowRevision}. An empty
+     * string, or a string exceeding `MAX_CONTRACT_IDENTIFIER_BYTES`, is
+     * rejected rather than silently falling back to derivation.
+     */
+    revision?: string;
+}
+/**
+ * Build a {@link WorkflowRevisionManifest} for a workflow contract.
+ *
+ * Normalizes the contract, computes `contractHash`, and either derives
+ * `revision` (the default) or validates and preserves an explicitly
+ * supplied one.
+ *
+ * Throws a plain `Error` when `options.revision` is present but empty, or
+ * exceeds `MAX_CONTRACT_IDENTIFIER_BYTES` — a caller-supplied identity is
+ * validated the same way any other contract identifier is, since it becomes
+ * part of the manifest a consumer will trust.
+ *
+ * **Round-trips through {@link parseWorkflowRevisionManifest} before
+ * returning.** A manifest this function builds but its own parser would
+ * reject (`identifier-too-long`, `too-many-entries`, `manifest-too-large`)
+ * is a build-time bug, not a runtime condition to defer to whoever later
+ * reads the manifest back — see WFT-5 PR #943 review thread
+ * PRRT_kwDORwthfM6eWFwv. Throws a plain `Error` describing the rejection
+ * reason when that happens.
+ *
+ * @example
+ * ```ts
+ * import { buildWorkflowContract, buildWorkflowRevisionManifest } from '@lostgradient/weft';
+ *
+ * const contract = buildWorkflowContract({ name: 'checkout', version: '2.1.0' });
+ * const manifest = await buildWorkflowRevisionManifest(contract);
+ * console.log(manifest.name, manifest.contractHash.startsWith('sha256:'));
+ * ```
+ */
+export declare function buildWorkflowRevisionManifest(contract: WorkflowContract, options?: BuildWorkflowRevisionManifestOptions): Promise<WorkflowRevisionManifest>;

package/dist/core/contract/manifest.js

@@ -0,0 +1,31 @@
+import { utf8ByteLength } from "../../worker/manifest/utf8.js";
+import { contractHash } from "./hash.js";
+import { MAX_CONTRACT_IDENTIFIER_BYTES } from "./limits.js";
+import { parseWorkflowRevisionManifest } from "./manifest-parse.js";
+import { normalizeWorkflowContract } from "./normalize.js";
+import { deriveWorkflowRevision } from "./revision.js";
+import { WORKFLOW_REVISION_MANIFEST_VERSION } from "./types.js";
+export async function buildWorkflowRevisionManifest(contract, options) {
+  const normalized = normalizeWorkflowContract(contract), hash = await contractHash(normalized);
+  let revision;
+  if (options?.revision !== void 0) {
+    if (options.revision.length === 0)
+      throw Error("buildWorkflowRevisionManifest: options.revision must not be an empty string");
+    const bytes = utf8ByteLength(options.revision);
+    if (bytes > MAX_CONTRACT_IDENTIFIER_BYTES)
+      throw Error(`buildWorkflowRevisionManifest: options.revision is ${bytes} bytes, exceeding the maximum identifier size of ${MAX_CONTRACT_IDENTIFIER_BYTES}`);
+    revision = options.revision;
+  } else
+    revision = await deriveWorkflowRevision(normalized);
+  const manifest = {
+    manifestVersion: WORKFLOW_REVISION_MANIFEST_VERSION,
+    name: normalized.name,
+    workflowVersion: normalized.workflowVersion,
+    revision,
+    contractHash: hash,
+    contract: normalized
+  }, parsed = await parseWorkflowRevisionManifest(manifest);
+  if (!parsed.ok)
+    throw Error(`buildWorkflowRevisionManifest: built manifest fails parseWorkflowRevisionManifest validation (${parsed.reason}${parsed.path === void 0 ? "" : ` at ${parsed.path}`}): ` + parsed.message);
+  return parsed.manifest;
+}

package/dist/core/contract/normalize.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Deterministic normalization and canonical serialization for workflow
+ * contracts.
+ *
+ * Two contracts that describe the same workflow must produce byte-identical
+ * canonical output regardless of how their object keys were ordered in the
+ * source, so `contractHash()` and `deriveWorkflowRevision()` identify the
+ * *content* rather than an accident of construction. Serialization walks the
+ * declared contract shape explicitly instead of generically stringifying the
+ * input, which means an unknown extra property can never leak into the
+ * canonical bytes and change a hash.
+ *
+ * @module core/contract/normalize
+ */
+import type { WorkflowContract, WorkflowMessageContract } from './types.ts';
+/**
+ * Normalize a workflow contract into its canonical in-memory form.
+ *
+ * Field order follows the declared shape, every open-ended record is
+ * rebuilt with its keys sorted (and omitted entirely when empty), and every
+ * schema fragment is deep-cloned onto a null-prototype object. The result is
+ * a fresh value; the input is not mutated.
+ *
+ * @example
+ * ```ts
+ * import { normalizeWorkflowContract } from '@lostgradient/weft';
+ *
+ * const normalized = normalizeWorkflowContract({
+ *   name: 'checkout',
+ *   workflowVersion: '2.1.0',
+ *   signals: {
+ *     zeta: {},
+ *     alpha: {},
+ *   },
+ * });
+ * console.log(Object.keys(normalized.signals ?? {})); // ['alpha', 'zeta']
+ * ```
+ */
+export declare function normalizeWorkflowContract(contract: WorkflowContract): WorkflowContract;
+/**
+ * Serialize one signal/update/query/activity contract's schema pair.
+ * Shared between {@link canonicalWorkflowContractJson} (the full-identity
+ * form) and `hash.ts`'s payload-only serialization, since both walk the same
+ * `{ inputSchema?, outputSchema? }` shape — the only difference between the
+ * two identities is which *top-level* fields are included, not how a single
+ * message/activity entry serializes.
+ *
+ * @internal Exported for reuse within `core/contract/*`; not part of the
+ * package's public API.
+ */
+export declare function canonicalMessageContractJson(entry: WorkflowMessageContract): string;
+/**
+ * @internal Exported for reuse within `core/contract/*`; not part of the
+ * package's public API.
+ */
+export declare function canonicalContractRecordJson(record: Readonly<Record<string, WorkflowMessageContract>>): string;
+/**
+ * @internal Exported for reuse within `core/contract/*` (`hash.ts`'s
+ * payload-only serialization shares this field-appending logic); not part of
+ * the package's public API.
+ */
+export declare function appendContractRecordField(fields: string[], label: 'signals' | 'updates' | 'queries' | 'activities', record: Readonly<Record<string, WorkflowMessageContract>> | undefined): void;
+/**
+ * @internal Exported for reuse within `core/contract/*`; not part of the
+ * package's public API.
+ */
+export declare function appendSchemaField(fields: string[], label: 'inputSchema' | 'outputSchema', schema: Record<string, unknown> | undefined): void;
+/**
+ * Serialize a workflow contract to its canonical, full-identity JSON string
+ * — the digest input {@link deriveWorkflowRevision} uses, and the value
+ * returned as `WorkflowRevisionManifestParseSuccess.canonicalJson`.
+ *
+ * This is a *different* identity from {@link contractHash}'s payload-only
+ * serialization: it includes `name`, `workflowVersion`, `description`, and
+ * `tags`, so a documentation edit changes this output (and therefore
+ * `revision`) without changing `contractHash`. The output is byte-identical
+ * for equivalent contracts regardless of source key order, and every field
+ * this project cares about changes it.
+ *
+ * @example
+ * ```ts
+ * import { canonicalWorkflowContractJson } from '@lostgradient/weft';
+ *
+ * const left = canonicalWorkflowContractJson({
+ *   name: 'checkout',
+ *   workflowVersion: '2.1.0',
+ *   signals: { alpha: {}, zeta: {} },
+ * });
+ * const right = canonicalWorkflowContractJson({
+ *   name: 'checkout',
+ *   workflowVersion: '2.1.0',
+ *   signals: { zeta: {}, alpha: {} },
+ * });
+ * console.log(left === right); // true
+ * ```
+ */
+export declare function canonicalWorkflowContractJson(contract: WorkflowContract): string;

package/dist/core/contract/normalize.js

@@ -0,0 +1,127 @@
+import { canonicalJsonStringify } from "../../worker/manifest/canonical-json.js";
+import { WORKFLOW_CONTRACT_VERSION } from "./types.js";
+function sortedKeys(record) {
+  return Object.keys(record).toSorted();
+}
+function cloneSchemaFragment(value) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (Array.isArray(value))
+    return value.map((entry) => cloneSchemaFragment(entry));
+  const record = value, cloned = Object.create(null);
+  for (const key of Object.keys(record))
+    cloned[key] = cloneSchemaFragment(record[key]);
+  return cloned;
+}
+function cloneSchemaRecord(value) {
+  return value === void 0 ? void 0 : cloneSchemaFragment(value);
+}
+function normalizeMessageContract(entry) {
+  const normalized = {}, inputSchema = cloneSchemaRecord(entry.inputSchema);
+  if (inputSchema !== void 0)
+    normalized.inputSchema = inputSchema;
+  const outputSchema = cloneSchemaRecord(entry.outputSchema);
+  if (outputSchema !== void 0)
+    normalized.outputSchema = outputSchema;
+  return normalized;
+}
+function normalizeActivityContract(entry) {
+  return normalizeMessageContract(entry);
+}
+function sortedContractRecord(record, normalizeValue) {
+  if (record === void 0)
+    return;
+  const keys = sortedKeys(record);
+  if (keys.length === 0)
+    return;
+  const normalized = Object.create(null);
+  for (const key of keys)
+    normalized[key] = normalizeValue(record[key]);
+  return normalized;
+}
+function applyDescriptionAndTags(draft, contract) {
+  if (contract.description !== void 0)
+    draft.description = contract.description;
+  if (contract.tags !== void 0 && contract.tags.length > 0)
+    draft.tags = [...contract.tags].toSorted();
+}
+function applySchemas(draft, contract) {
+  const inputSchema = cloneSchemaRecord(contract.inputSchema);
+  if (inputSchema !== void 0)
+    draft.inputSchema = inputSchema;
+  const outputSchema = cloneSchemaRecord(contract.outputSchema);
+  if (outputSchema !== void 0)
+    draft.outputSchema = outputSchema;
+}
+function applyMessageRecords(draft, contract) {
+  const signals = sortedContractRecord(contract.signals, normalizeMessageContract);
+  if (signals !== void 0)
+    draft.signals = signals;
+  const updates = sortedContractRecord(contract.updates, normalizeMessageContract);
+  if (updates !== void 0)
+    draft.updates = updates;
+  const queries = sortedContractRecord(contract.queries, normalizeMessageContract);
+  if (queries !== void 0)
+    draft.queries = queries;
+}
+export function normalizeWorkflowContract(contract) {
+  const draft = {
+    name: contract.name,
+    workflowVersion: contract.workflowVersion
+  };
+  applyDescriptionAndTags(draft, contract);
+  applySchemas(draft, contract);
+  applyMessageRecords(draft, contract);
+  const activities = sortedContractRecord(contract.activities, normalizeActivityContract);
+  if (activities !== void 0)
+    draft.activities = activities;
+  if (contract.finalizer !== void 0)
+    draft.finalizer = normalizeActivityContract(contract.finalizer);
+  return draft;
+}
+export function canonicalMessageContractJson(entry) {
+  const fields = [];
+  if (entry.inputSchema !== void 0)
+    fields.push(`"inputSchema":${canonicalJsonStringify(entry.inputSchema)}`);
+  if (entry.outputSchema !== void 0)
+    fields.push(`"outputSchema":${canonicalJsonStringify(entry.outputSchema)}`);
+  return `{${fields.join(",")}}`;
+}
+export function canonicalContractRecordJson(record) {
+  return `{${sortedKeys(record).map((key) => `${JSON.stringify(key)}:${canonicalMessageContractJson(record[key])}`).join(",")}}`;
+}
+export function appendContractRecordField(fields, label, record) {
+  if (record === void 0 || Object.keys(record).length === 0)
+    return;
+  fields.push(`"${label}":${canonicalContractRecordJson(record)}`);
+}
+export function appendSchemaField(fields, label, schema) {
+  if (schema === void 0)
+    return;
+  fields.push(`"${label}":${canonicalJsonStringify(schema)}`);
+}
+function appendTagsField(fields, tags) {
+  if (tags === void 0 || tags.length === 0)
+    return;
+  const sortedTags = [...tags].toSorted().map((tag) => JSON.stringify(tag));
+  fields.push(`"tags":[${sortedTags.join(",")}]`);
+}
+export function canonicalWorkflowContractJson(contract) {
+  const fields = [
+    `"contractVersion":${JSON.stringify(WORKFLOW_CONTRACT_VERSION)}`,
+    `"name":${JSON.stringify(contract.name)}`,
+    `"workflowVersion":${JSON.stringify(contract.workflowVersion)}`
+  ];
+  if (contract.description !== void 0)
+    fields.push(`"description":${JSON.stringify(contract.description)}`);
+  appendTagsField(fields, contract.tags);
+  appendSchemaField(fields, "inputSchema", contract.inputSchema);
+  appendSchemaField(fields, "outputSchema", contract.outputSchema);
+  appendContractRecordField(fields, "signals", contract.signals);
+  appendContractRecordField(fields, "updates", contract.updates);
+  appendContractRecordField(fields, "queries", contract.queries);
+  appendContractRecordField(fields, "activities", contract.activities);
+  if (contract.finalizer !== void 0)
+    fields.push(`"finalizer":${canonicalMessageContractJson(contract.finalizer)}`);
+  return `{${fields.join(",")}}`;
+}

package/dist/core/contract/revision.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Content-derived workflow revision identity.
+ *
+ * `revision` is the broader identity companion to `contractHash`: it hashes
+ * the *entire* normalized contract — `name`, `workflowVersion`,
+ * `description`, and `tags` included — so it changes whenever anything
+ * about the definition changes, including documentation. This is the same
+ * formula the (now-refactored) `buildWorkerManifestFromRegistry()` used for
+ * its `workflowRevision` field before this module existed.
+ *
+ * @module core/contract/revision
+ */
+import type { WorkflowContract } from './types.ts';
+/**
+ * Derive a content-addressed revision identity for a workflow contract.
+ *
+ * Two calls on an equivalent contract (regardless of source key order)
+ * produce the same revision, and any field the full canonical serialization
+ * carries — including `description` and `tags` — changes it.
+ *
+ * @example
+ * ```ts
+ * import { deriveWorkflowRevision } from '@lostgradient/weft';
+ *
+ * const revision = await deriveWorkflowRevision({ name: 'checkout', workflowVersion: '2.1.0' });
+ * console.log(revision.startsWith('sha256:')); // true
+ * ```
+ */
+export declare function deriveWorkflowRevision(contract: WorkflowContract): Promise<string>;

package/dist/core/contract/revision.js

@@ -0,0 +1,5 @@
+import { digestCanonicalWorkflowContract } from "./hash.js";
+import { canonicalWorkflowContractJson } from "./normalize.js";
+export async function deriveWorkflowRevision(contract) {
+  return digestCanonicalWorkflowContract(canonicalWorkflowContractJson(contract));
+}