@fluidgrids/workflows 0.0.0-stage → 2026.1027.0

package/dist/chunk-27HASETB.cjs

@@ -0,0 +1,250 @@
+'use strict';
+
+// src/ir/canonical-json.ts
+var CanonicalJsonError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CanonicalJsonError";
+  }
+};
+function isPlainObject(value) {
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function serialize(value, path, out) {
+  if (value === null) {
+    out.push("null");
+    return;
+  }
+  switch (typeof value) {
+    case "boolean":
+      out.push(value ? "true" : "false");
+      return;
+    case "number":
+      if (!Number.isFinite(value)) {
+        throw new CanonicalJsonError(`${path} is not a finite number`);
+      }
+      out.push(JSON.stringify(value));
+      return;
+    case "string":
+      out.push(JSON.stringify(value));
+      return;
+    case "object":
+      break;
+    default:
+      throw new CanonicalJsonError(`${path} is a ${typeof value}, which JSON cannot represent`);
+  }
+  if (Array.isArray(value)) {
+    out.push("[");
+    value.forEach((item, index) => {
+      if (item === void 0) {
+        throw new CanonicalJsonError(`${path}[${index}] is undefined`);
+      }
+      if (index > 0) out.push(",");
+      serialize(item, `${path}[${index}]`, out);
+    });
+    out.push("]");
+    return;
+  }
+  if (!isPlainObject(value)) {
+    throw new CanonicalJsonError(`${path} is not a plain JSON object`);
+  }
+  const record = value;
+  const keys = Object.keys(record).filter((key) => record[key] !== void 0).sort();
+  out.push("{");
+  keys.forEach((key, index) => {
+    if (index > 0) out.push(",");
+    out.push(JSON.stringify(key), ":");
+    serialize(record[key], `${path}.${key}`, out);
+  });
+  out.push("}");
+}
+function canonicalJson(value) {
+  const out = [];
+  serialize(value, "$", out);
+  return out.join("");
+}
+function sortKeysDeep(value) {
+  if (Array.isArray(value)) return value.map(sortKeysDeep);
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    const sorted = {};
+    for (const key of Object.keys(record).sort()) {
+      if (record[key] !== void 0) sorted[key] = sortKeysDeep(record[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+function stableStringify(value) {
+  canonicalJson(value);
+  return `${JSON.stringify(sortKeysDeep(value), null, 2)}
+`;
+}
+
+// src/ir/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function rotr(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function utf8(text) {
+  const bytes = [];
+  for (const char of text) {
+    let code = char.codePointAt(0) ?? 0;
+    if (code >= 55296 && code <= 57343) code = 65533;
+    if (code < 128) {
+      bytes.push(code);
+    } else if (code < 2048) {
+      bytes.push(192 | code >> 6, 128 | code & 63);
+    } else if (code < 65536) {
+      bytes.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+    } else {
+      bytes.push(
+        240 | code >> 18,
+        128 | code >> 12 & 63,
+        128 | code >> 6 & 63,
+        128 | code & 63
+      );
+    }
+  }
+  return Uint8Array.from(bytes);
+}
+function sha256Hex(text) {
+  const message = utf8(text);
+  const bitLength = message.length * 8;
+  const paddedLength = Math.ceil((message.length + 9) / 64) * 64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(message);
+  padded[message.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
+  view.setUint32(paddedLength - 4, bitLength >>> 0);
+  const hash = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4);
+    for (let i = 16; i < 64; i++) {
+      const w15 = w[i - 15] ?? 0;
+      const w2 = w[i - 2] ?? 0;
+      const s0 = rotr(w15, 7) ^ rotr(w15, 18) ^ w15 >>> 3;
+      const s1 = rotr(w2, 17) ^ rotr(w2, 19) ^ w2 >>> 10;
+      w[i] = (w[i - 16] ?? 0) + s0 + (w[i - 7] ?? 0) + s1 >>> 0;
+    }
+    let a = hash[0] ?? 0;
+    let b = hash[1] ?? 0;
+    let c = hash[2] ?? 0;
+    let d = hash[3] ?? 0;
+    let e = hash[4] ?? 0;
+    let f = hash[5] ?? 0;
+    let g = hash[6] ?? 0;
+    let h = hash[7] ?? 0;
+    for (let i = 0; i < 64; i++) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const t1 = h + s1 + ch + (K[i] ?? 0) + (w[i] ?? 0) >>> 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const t2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 0;
+    }
+    hash[0] = (hash[0] ?? 0) + a >>> 0;
+    hash[1] = (hash[1] ?? 0) + b >>> 0;
+    hash[2] = (hash[2] ?? 0) + c >>> 0;
+    hash[3] = (hash[3] ?? 0) + d >>> 0;
+    hash[4] = (hash[4] ?? 0) + e >>> 0;
+    hash[5] = (hash[5] ?? 0) + f >>> 0;
+    hash[6] = (hash[6] ?? 0) + g >>> 0;
+    hash[7] = (hash[7] ?? 0) + h >>> 0;
+  }
+  return Array.from(hash, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+function sha256Tagged(text) {
+  return `sha256:${sha256Hex(text)}`;
+}
+
+exports.CanonicalJsonError = CanonicalJsonError;
+exports.canonicalJson = canonicalJson;
+exports.sha256Hex = sha256Hex;
+exports.sha256Tagged = sha256Tagged;
+exports.stableStringify = stableStringify;

package/dist/chunk-4DPEGDPW.js

@@ -0,0 +1,74 @@
+import { hashedProjection } from './chunk-SS4LT2IP.js';
+import { isRecord, deepEqual } from './chunk-REV7ZOA4.js';
+
+// src/ir/diff.ts
+function keyPath(base, key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? base ? `${base}.${key}` : key : `${base}[${JSON.stringify(key)}]`;
+}
+function diffValues(before, after, path, out) {
+  if (deepEqual(before, after)) return;
+  if (isRecord(before) && isRecord(after)) {
+    const keys = [.../* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])].sort();
+    for (const key of keys) {
+      const left = before[key];
+      const right = after[key];
+      if (left === void 0 && right !== void 0)
+        out.push({ kind: "added", path: keyPath(path, key), after: right });
+      else if (left !== void 0 && right === void 0)
+        out.push({ kind: "removed", path: keyPath(path, key), before: left });
+      else diffValues(left, right, keyPath(path, key), out);
+    }
+    return;
+  }
+  out.push({ kind: "changed", path, before, after });
+}
+function byId(items) {
+  const map = /* @__PURE__ */ new Map();
+  if (!Array.isArray(items)) return map;
+  items.forEach((item, index) => {
+    if (!isRecord(item)) return;
+    const id = typeof item["id"] === "string" ? item["id"] : `#${index}`;
+    if (!map.has(id)) map.set(id, item);
+  });
+  return map;
+}
+function diffCollection(before, after, path, out) {
+  const left = byId(before);
+  const right = byId(after);
+  for (const [id, item] of left) {
+    if (!right.has(id)) out.push({ kind: "removed", path: `${path}[${id}]`, before: item });
+  }
+  for (const [id, item] of right) {
+    const previous = left.get(id);
+    if (!previous) out.push({ kind: "added", path: `${path}[${id}]`, after: item });
+    else diffValues(previous, item, `${path}[${id}]`, out);
+  }
+  const common = (ids, other) => ids.filter((id) => other.has(id));
+  const leftOrder = common([...left.keys()], right);
+  const rightOrder = common([...right.keys()], left);
+  if (!deepEqual(leftOrder, rightOrder)) {
+    out.push({ kind: "reordered", path, before: leftOrder, after: rightOrder });
+  }
+}
+function diffDefinitions(before, after) {
+  const left = hashedProjection(before);
+  const right = hashedProjection(after);
+  const out = [];
+  if (!isRecord(left) || !isRecord(right)) {
+    diffValues(left, right, "", out);
+    return out;
+  }
+  const { data: leftData, ...leftRest } = left;
+  const { data: rightData, ...rightRest } = right;
+  diffValues(leftRest, rightRest, "", out);
+  const leftDataRecord = isRecord(leftData) ? leftData : {};
+  const rightDataRecord = isRecord(rightData) ? rightData : {};
+  const { nodes: leftNodes, edges: leftEdges, ...leftDataRest } = leftDataRecord;
+  const { nodes: rightNodes, edges: rightEdges, ...rightDataRest } = rightDataRecord;
+  diffCollection(leftNodes, rightNodes, "data.nodes", out);
+  diffCollection(leftEdges, rightEdges, "data.edges", out);
+  diffValues(leftDataRest, rightDataRest, "data", out);
+  return out;
+}
+
+export { diffDefinitions };

package/dist/chunk-5LUIDMF4.js

@@ -0,0 +1,42 @@
+// src/ir/layout.ts
+var LAYOUT_COLUMN_WIDTH = 300;
+var LAYOUT_ROW_HEIGHT = 170;
+function autoLayout(nodeIds, edges) {
+  const depth = /* @__PURE__ */ new Map();
+  const roots = nodeIds.filter((id) => !edges.some((edge) => edge.target === id));
+  const queue = [...roots];
+  for (const id of queue) depth.set(id, 0);
+  const guardLimit = nodeIds.length * nodeIds.length + 1;
+  for (let guard = 0; queue.length > 0 && guard < guardLimit; guard++) {
+    const current = queue.shift();
+    if (current === void 0) break;
+    const currentDepth = depth.get(current) ?? 0;
+    for (const edge of edges) {
+      if (edge.source !== current) continue;
+      const next = currentDepth + 1;
+      if (next > (depth.get(edge.target) ?? -1) && next < nodeIds.length) {
+        depth.set(edge.target, next);
+        queue.push(edge.target);
+      }
+    }
+  }
+  const maxDepth = Math.max(0, ...depth.values());
+  const columns = /* @__PURE__ */ new Map();
+  for (const id of nodeIds) {
+    const column = depth.get(id) ?? maxDepth + 1;
+    columns.set(column, [...columns.get(column) ?? [], id]);
+  }
+  const positions = /* @__PURE__ */ new Map();
+  for (const [column, ids] of columns) {
+    ids.forEach((id, row) => {
+      positions.set(id, {
+        x: column * LAYOUT_COLUMN_WIDTH,
+        // `+ 0` turns the -0 Math.round can return into 0, so JSON never sees -0.
+        y: Math.round((row - (ids.length - 1) / 2) * LAYOUT_ROW_HEIGHT) + 0
+      });
+    });
+  }
+  return positions;
+}
+
+export { LAYOUT_COLUMN_WIDTH, LAYOUT_ROW_HEIGHT, autoLayout };

package/dist/chunk-AU3YW7FZ.cjs

@@ -0,0 +1,279 @@
+'use strict';
+
+var chunkG4UEPUGO_cjs = require('./chunk-G4UEPUGO.cjs');
+var chunk27HASETB_cjs = require('./chunk-27HASETB.cjs');
+var chunkLRM6JXJA_cjs = require('./chunk-LRM6JXJA.cjs');
+
+// src/ir/node-types.ts
+var EXECUTOR_INTERNAL_TYPES = /* @__PURE__ */ new Set([
+  "internal:if",
+  "internal:switch",
+  "internal:loop",
+  "internal:merge",
+  "internal:set",
+  "internal:filter",
+  "internal:aggregate",
+  "internal:wait",
+  "internal:noop",
+  "internal:code",
+  "internal:http",
+  "internal:transform",
+  "internal:validate",
+  "internal:log",
+  "internal:error",
+  "internal:subworkflow",
+  "internal:compare-datasets",
+  "internal:split-out",
+  "internal:limit",
+  "internal:dedupe",
+  "internal:sort",
+  "internal:datatable",
+  "internal:respond-to-webhook",
+  "internal:send-and-wait",
+  "if",
+  "switch",
+  "loop",
+  "merge",
+  "set",
+  "filter",
+  "aggregate",
+  "wait",
+  "noop",
+  "code",
+  "http",
+  "transform",
+  "validate",
+  "log",
+  "error",
+  "subworkflow"
+]);
+var CODE_WORKFLOW_NODE_TYPE = "internal:code-workflow";
+var WAIT_FOR_SIGNAL_NODE_TYPE = "internal:wait-for-signal";
+var V2_NODE_TYPES = /* @__PURE__ */ new Set([
+  CODE_WORKFLOW_NODE_TYPE,
+  WAIT_FOR_SIGNAL_NODE_TYPE
+]);
+var INTERNAL_TRIGGER_TYPES = /* @__PURE__ */ new Set([
+  "internal:api",
+  "internal:schedule",
+  "internal:webhook",
+  "internal:form",
+  "internal:error-trigger",
+  "internal:workflow-call",
+  "internal:rss-feed",
+  "internal:http-poll",
+  "internal:database-poll",
+  "internal:email-imap",
+  "internal:file-upload",
+  "internal:record-change",
+  "internal:state-change"
+]);
+function usesMergedParameters(type) {
+  const lower = type.toLowerCase();
+  return EXECUTOR_INTERNAL_TYPES.has(lower) || V2_NODE_TYPES.has(lower);
+}
+
+// src/ir/normalize.ts
+function isNonEmptyString(value) {
+  return typeof value === "string" && value !== "";
+}
+function firstTruthy(...values) {
+  for (const value of values) if (value) return value;
+  return void 0;
+}
+function readPosition(value) {
+  if (!chunkLRM6JXJA_cjs.isRecord(value)) return void 0;
+  const { x, y } = value;
+  return typeof x === "number" && typeof y === "number" && Number.isFinite(x) && Number.isFinite(y) ? { x, y } : void 0;
+}
+function removeIfEmpty(parent, key) {
+  const value = parent[key];
+  if (chunkLRM6JXJA_cjs.isRecord(value) && Object.keys(value).length === 0) delete parent[key];
+}
+function normalizeLabel(node, data) {
+  if (node["label"] === void 0 && typeof data["label"] === "string")
+    node["label"] = data["label"];
+  if (data["label"] !== void 0 && chunkLRM6JXJA_cjs.deepEqual(data["label"], node["label"])) delete data["label"];
+}
+function normalizeOperation(node, data) {
+  if (!isNonEmptyString(node["operation_name"]) && isNonEmptyString(data["operation_name"])) {
+    node["operation_name"] = data["operation_name"];
+  }
+  if (data["operation_name"] !== void 0 && chunkLRM6JXJA_cjs.deepEqual(data["operation_name"], node["operation_name"])) {
+    delete data["operation_name"];
+  }
+}
+function normalizeVersion(node, data, merged) {
+  if (merged) return;
+  const effective = firstTruthy(data["version"], node["version"]);
+  if (typeof effective === "string") node["version"] = effective;
+  if (data["version"] !== void 0 && chunkLRM6JXJA_cjs.deepEqual(data["version"], node["version"]))
+    delete data["version"];
+  if (data["nodeVersion"] !== void 0 && chunkLRM6JXJA_cjs.deepEqual(data["nodeVersion"], node["version"])) {
+    delete data["nodeVersion"];
+  }
+}
+function normalizeExternalState(node, data) {
+  const args = chunkLRM6JXJA_cjs.isRecord(node["args"]) ? node["args"] : void 0;
+  const dataArgs = chunkLRM6JXJA_cjs.isRecord(data["args"]) ? data["args"] : void 0;
+  const effective = firstTruthy(args?.["state"], dataArgs?.["state"], data["state"]);
+  if (effective !== void 0 && args?.["state"] === void 0) {
+    const nextArgs = args ?? {};
+    nextArgs["state"] = effective;
+    node["args"] = nextArgs;
+  }
+  const rootState = chunkLRM6JXJA_cjs.isRecord(node["args"]) ? node["args"]["state"] : void 0;
+  if (dataArgs && dataArgs["state"] !== void 0 && chunkLRM6JXJA_cjs.deepEqual(dataArgs["state"], rootState)) {
+    delete dataArgs["state"];
+  }
+  if (data["state"] !== void 0 && chunkLRM6JXJA_cjs.deepEqual(data["state"], rootState)) delete data["state"];
+}
+function normalizeMergedState(node, data) {
+  const args = chunkLRM6JXJA_cjs.isRecord(node["args"]) ? node["args"] : {};
+  const dataArgs = chunkLRM6JXJA_cjs.isRecord(data["args"]) ? data["args"] : void 0;
+  const config = chunkLRM6JXJA_cjs.isRecord(node["config"]) ? node["config"] : void 0;
+  const dataState = chunkLRM6JXJA_cjs.isRecord(dataArgs?.["state"]) ? dataArgs["state"] : void 0;
+  const rootState = chunkLRM6JXJA_cjs.isRecord(args["state"]) ? args["state"] : void 0;
+  if (config === void 0 && dataState === void 0) return;
+  args["state"] = { ...config, ...dataState, ...rootState };
+  node["args"] = args;
+  if (config !== void 0) delete node["config"];
+  if (dataArgs && dataState !== void 0) delete dataArgs["state"];
+}
+function normalizeConnections(node, data) {
+  const dataArgs = chunkLRM6JXJA_cjs.isRecord(data["args"]) ? data["args"] : void 0;
+  if (!dataArgs) return;
+  for (const key of ["connections", "credentials"]) {
+    const args = chunkLRM6JXJA_cjs.isRecord(node["args"]) ? node["args"] : void 0;
+    if (!args?.[key] && dataArgs[key]) {
+      const nextArgs = args ?? {};
+      nextArgs[key] = dataArgs[key];
+      node["args"] = nextArgs;
+    }
+    const rootValue = chunkLRM6JXJA_cjs.isRecord(node["args"]) ? node["args"][key] : void 0;
+    if (dataArgs[key] !== void 0 && chunkLRM6JXJA_cjs.deepEqual(dataArgs[key], rootValue)) delete dataArgs[key];
+  }
+}
+function normalizeContext(node, data) {
+  const dataArgs = chunkLRM6JXJA_cjs.isRecord(data["args"]) ? data["args"] : void 0;
+  const args = chunkLRM6JXJA_cjs.isRecord(node["args"]) ? node["args"] : void 0;
+  if (!dataArgs || dataArgs["context"] === void 0) return;
+  if (args && chunkLRM6JXJA_cjs.deepEqual(dataArgs["context"], args["context"])) delete dataArgs["context"];
+}
+function normalizeErrorConfig(node, data) {
+  const dataArgs = chunkLRM6JXJA_cjs.isRecord(data["args"]) ? data["args"] : void 0;
+  const dataState = chunkLRM6JXJA_cjs.isRecord(dataArgs?.["state"]) ? dataArgs["state"] : void 0;
+  const effective = node["errorConfig"] ?? data["errorConfig"] ?? dataState?.["errorConfig"];
+  if (effective !== void 0 && effective !== null) node["errorConfig"] = effective;
+  if (data["errorConfig"] !== void 0 && chunkLRM6JXJA_cjs.deepEqual(data["errorConfig"], node["errorConfig"])) {
+    delete data["errorConfig"];
+  }
+}
+function normalizeExecutionSettings(node, data) {
+  const root = chunkLRM6JXJA_cjs.isRecord(node["executionSettings"]) ? node["executionSettings"] : void 0;
+  const mirror = chunkLRM6JXJA_cjs.isRecord(data["executionSettings"]) ? data["executionSettings"] : void 0;
+  if (!root && !mirror) return;
+  const merged = { ...root };
+  for (const [key, value] of Object.entries(mirror ?? {}))
+    if (!Object.hasOwn(merged, key)) merged[key] = value;
+  if (root?.["executeOnce"] === true || mirror?.["executeOnce"] === true)
+    merged["executeOnce"] = true;
+  if (mirror && Object.hasOwn(mirror, "runOn")) {
+    merged["runOn"] = mirror["runOn"];
+    data["executionSettings"] = { runOn: mirror["runOn"] };
+  } else {
+    if (mirror) delete data["executionSettings"];
+  }
+  node["executionSettings"] = merged;
+}
+function normalizeDisabled(node, data) {
+  if (node["disabled"] === true || data["disabled"] === true) node["disabled"] = true;
+  delete data["disabled"];
+}
+function normalizeNode(raw) {
+  if (!chunkLRM6JXJA_cjs.isRecord(raw)) return raw;
+  const node = chunkLRM6JXJA_cjs.cloneJson(raw);
+  const type = typeof node["type"] === "string" ? node["type"] : "";
+  const merged = usesMergedParameters(type);
+  const data = chunkLRM6JXJA_cjs.isRecord(node["data"]) ? node["data"] : {};
+  normalizeLabel(node, data);
+  normalizeOperation(node, data);
+  normalizeVersion(node, data, merged);
+  normalizeErrorConfig(node, data);
+  if (merged) normalizeMergedState(node, data);
+  else normalizeExternalState(node, data);
+  normalizeConnections(node, data);
+  normalizeContext(node, data);
+  normalizeExecutionSettings(node, data);
+  normalizeDisabled(node, data);
+  if (chunkLRM6JXJA_cjs.isRecord(data["args"])) removeIfEmpty(data, "args");
+  if (Object.keys(data).length === 0) delete node["data"];
+  else node["data"] = data;
+  return node;
+}
+function normalizeDefinition(definition) {
+  if (!chunkLRM6JXJA_cjs.isRecord(definition) || !chunkLRM6JXJA_cjs.isRecord(definition["data"])) return definition;
+  const doc = chunkLRM6JXJA_cjs.cloneJson(definition);
+  const data = doc["data"];
+  const rawNodes = Array.isArray(data["nodes"]) ? data["nodes"] : [];
+  const nodes = rawNodes.map(normalizeNode);
+  data["nodes"] = nodes;
+  const edges = Array.isArray(data["edges"]) ? data["edges"].filter(chunkLRM6JXJA_cjs.isRecord) : [];
+  const ids = nodes.flatMap(
+    (node) => chunkLRM6JXJA_cjs.isRecord(node) && typeof node["id"] === "string" ? [node["id"]] : []
+  );
+  const missing = nodes.some(
+    (node) => chunkLRM6JXJA_cjs.isRecord(node) && readPosition(node["position"]) === void 0
+  );
+  if (missing) {
+    const meta = chunkLRM6JXJA_cjs.isRecord(doc["meta"]) ? doc["meta"] : void 0;
+    const metaLayout = chunkLRM6JXJA_cjs.isRecord(meta?.["layout"]) ? meta["layout"] : void 0;
+    const computed = chunkG4UEPUGO_cjs.autoLayout(
+      ids,
+      edges.flatMap(
+        (edge) => typeof edge["source"] === "string" && typeof edge["target"] === "string" ? [{ source: edge["source"], target: edge["target"] }] : []
+      )
+    );
+    for (const node of nodes) {
+      if (!chunkLRM6JXJA_cjs.isRecord(node) || typeof node["id"] !== "string") continue;
+      if (readPosition(node["position"]) !== void 0) continue;
+      const fromMeta = readPosition(metaLayout?.[node["id"]]);
+      const position = fromMeta ?? computed.get(node["id"]);
+      if (position) node["position"] = { x: position.x, y: position.y };
+    }
+  }
+  doc["schemaVersion"] = 2;
+  return doc;
+}
+
+// src/ir/hash.ts
+function hashedProjection(definition) {
+  const normalized = normalizeDefinition(definition);
+  if (!chunkLRM6JXJA_cjs.isRecord(normalized)) return normalized;
+  const copy = { ...normalized };
+  delete copy["authoring"];
+  return copy;
+}
+function irHash(definition) {
+  return chunk27HASETB_cjs.sha256Tagged(chunk27HASETB_cjs.canonicalJson(hashedProjection(definition)));
+}
+function sourceHash(files) {
+  const entries = [...files].sort(
+    (a, b) => a.path === b.path ? a.content < b.content ? -1 : a.content > b.content ? 1 : 0 : a.path < b.path ? -1 : 1
+  ).map((file) => [file.path, file.content]);
+  return chunk27HASETB_cjs.sha256Tagged(chunk27HASETB_cjs.canonicalJson(entries));
+}
+function buildIdOf(bundle) {
+  return chunk27HASETB_cjs.sha256Tagged(bundle);
+}
+
+exports.CODE_WORKFLOW_NODE_TYPE = CODE_WORKFLOW_NODE_TYPE;
+exports.INTERNAL_TRIGGER_TYPES = INTERNAL_TRIGGER_TYPES;
+exports.V2_NODE_TYPES = V2_NODE_TYPES;
+exports.WAIT_FOR_SIGNAL_NODE_TYPE = WAIT_FOR_SIGNAL_NODE_TYPE;
+exports.buildIdOf = buildIdOf;
+exports.hashedProjection = hashedProjection;
+exports.irHash = irHash;
+exports.normalizeDefinition = normalizeDefinition;
+exports.sourceHash = sourceHash;
+exports.usesMergedParameters = usesMergedParameters;