@fluidgrids/workflows 2026.1027.0 → 2026.1028.1

package/dist/chunk-HR3BN4C4.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var chunk2DP2Y6EU_cjs = require('./chunk-2DP2Y6EU.cjs');
+
+// src/generated/vm-worker-source.ts
+var VM_WORKER_SOURCE = '"use strict";\n\nvar import_node_worker_threads = require("node:worker_threads");\n\nfunction isRecord(value) {\n  return typeof value === "object" && value !== null && !Array.isArray(value);\n}\n\nvar DETERMINISM_VIOLATION = "DeterminismViolation";\nvar DETERMINISM_PRELUDE = `(() => {\n  const NAME = ${JSON.stringify(DETERMINISM_VIOLATION)};\n  const fail = (what) => {\n    const error = new Error(\n      what + " is not allowed in workflow code: lowering must give the same IR on every build. Read times and random values at run time instead (for example wf.now)."\n    );\n    error.name = NAME;\n    throw error;\n  };\n  const lock = (target, key, value) =>\n    Object.defineProperty(target, key, { value, writable: false, enumerable: false, configurable: false });\n  const RealDate = Date;\n  const LockedDate = function Date(...args) {\n    if (new.target === undefined) return fail("Date()");\n    if (args.length === 0) return fail("new Date()");\n    return Reflect.construct(RealDate, args, new.target);\n  };\n  lock(LockedDate, "prototype", RealDate.prototype);\n  lock(RealDate.prototype, "constructor", LockedDate);\n  lock(LockedDate, "now", function now() { return fail("Date.now()"); });\n  lock(LockedDate, "parse", RealDate.parse);\n  lock(LockedDate, "UTC", RealDate.UTC);\n  lock(globalThis, "Date", LockedDate);\n  lock(Math, "random", function random() { return fail("Math.random()"); });\n  const crypto = globalThis.crypto;\n  if (crypto !== null && typeof crypto === "object") {\n    for (const name of ["getRandomValues", "randomUUID"]) {\n      if (typeof crypto[name] === "function") lock(crypto, name, function () { return fail("crypto." + name + "()"); });\n    }\n  }\n  const DateTimeFormat = typeof Intl === "object" && Intl !== null ? Intl.DateTimeFormat : undefined;\n  if (typeof DateTimeFormat === "function") {\n    const proto = DateTimeFormat.prototype;\n    const format = Object.getOwnPropertyDescriptor(proto, "format");\n    if (format && typeof format.get === "function") {\n      const get = format.get;\n      Object.defineProperty(proto, "format", {\n        get() {\n          const bound = get.call(this);\n          return (date) => (date === undefined ? fail("Intl.DateTimeFormat format()") : bound(date));\n        },\n        enumerable: false,\n        configurable: false,\n      });\n    }\n    const formatToParts = proto.formatToParts;\n    if (typeof formatToParts === "function") {\n      lock(proto, "formatToParts", function (date) {\n        return date === undefined ? fail("Intl.DateTimeFormat formatToParts()") : formatToParts.call(this, date);\n      });\n    }\n  }\n})();\n`;\nfunction failure(kind, message) {\n  return { ok: false, failure: kind, message };\n}\n\nvar import_node_vm = require("node:vm");\nvar import_node_util = require("node:util");\nvar BUNDLE_GLOBAL = "__fluidgridsBundle";\nfunction wrap(code) {\n  return `(function () {\n  const describe = (error) => {\n    let name = "Error";\n    let message = "";\n    try {\n      if (error !== null && (typeof error === "object" || typeof error === "function")) {\n        const n = error.name;\n        if (typeof n === "string") name = n;\n        const m = error.message;\n        message = typeof m === "string" ? m : m === undefined ? "" + error : "" + m;\n      } else {\n        message = "" + error;\n      }\n    } catch (_) {\n      message = "a value whose message cannot be read was thrown";\n    }\n    return (name === ${JSON.stringify(DETERMINISM_VIOLATION)} ? "D" : "E") + message;\n  };\n  try {\n${code}\n;const __fluidgridsValue = ${BUNDLE_GLOBAL}.__fluidgrids;\n    return typeof __fluidgridsValue === "string" ? "R" + __fluidgridsValue : "N";\n  } catch (error) {\n    try {\n      return describe(error);\n    } catch (_) {\n      return "Ean error that cannot be described was thrown";\n    }\n  }\n})()`;\n}\nfunction hostErrorFields(error) {\n  if (!import_node_util.types.isNativeError(error)) return {};\n  const code = Object.getOwnPropertyDescriptor(error, "code")?.value;\n  const message = Object.getOwnPropertyDescriptor(error, "message")?.value;\n  return {\n    ...typeof code === "string" ? { code } : {},\n    ...typeof message === "string" ? { message } : {}\n  };\n}\nfunction decode(result) {\n  const tag = result.charAt(0);\n  const rest = result.slice(1);\n  if (tag === "R") return { ok: true, value: rest };\n  if (tag === "N")\n    return failure("no-collection", "The bundle did not export a workflow collection");\n  if (tag === "D") return failure("determinism", rest);\n  return failure("error", rest);\n}\nfunction runInVmContext(code, timeoutMs) {\n  const context = (0, import_node_vm.createContext)(/* @__PURE__ */ Object.create(null), {\n    codeGeneration: { strings: false, wasm: false },\n    microtaskMode: "afterEvaluate",\n    name: "fluidgrids-workflow-lowering"\n  });\n  const refuseImport = () => {\n    throw new Error("Workflow code may not import modules at run time");\n  };\n  const deadline = Date.now() + timeoutMs;\n  const run = (source, filename) => new import_node_vm.Script(source, { filename, importModuleDynamically: refuseImport }).runInContext(context, {\n    timeout: Math.max(1, deadline - Date.now()),\n    breakOnSigint: true\n  });\n  try {\n    run(DETERMINISM_PRELUDE, "determinism-prelude.js");\n    const result = run(wrap(code), "workflow-bundle.js");\n    return typeof result === "string" ? decode(result) : failure("no-collection", "The bundle did not export a workflow collection");\n  } catch (error) {\n    const fields = hostErrorFields(error);\n    if (fields.code === "ERR_SCRIPT_EXECUTION_TIMEOUT" || fields.message !== void 0 && /^Script execution timed out/.test(fields.message)) {\n      return failure("timeout", `Evaluating the workflow code timed out after ${timeoutMs} ms`);\n    }\n    return failure("error", fields.message ?? "The workflow code could not be evaluated");\n  }\n}\n\nprocess.on("unhandledRejection", () => void 0);\nvar input = import_node_worker_threads.workerData;\nimport_node_worker_threads.parentPort?.postMessage(\n  isRecord(input) && typeof input["code"] === "string" && typeof input["timeoutMs"] === "number" ? runInVmContext(input["code"], input["timeoutMs"]) : failure("crashed", "The evaluation worker received no bundle")\n);\n';
+
+// src/roundtrip/node-evaluator.ts
+var MIB = 1024 * 1024;
+function createNodeVmEvaluator(options = {}) {
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  const memoryLimitBytes = options.memoryLimitBytes ?? 512 * MIB;
+  return {
+    format: "iife",
+    async evaluate(code) {
+      const outcome = await chunk2DP2Y6EU_cjs.runIsolateWorker({
+        source: VM_WORKER_SOURCE,
+        workerData: { code, timeoutMs },
+        timeoutMs,
+        resourceLimits: { maxOldGenerationSizeMb: Math.max(16, Math.ceil(memoryLimitBytes / MIB)) }
+      });
+      return chunk2DP2Y6EU_cjs.outcomeToCollection(outcome);
+    }
+  };
+}
+
+exports.createNodeVmEvaluator = createNodeVmEvaluator;

package/dist/chunk-IISBRUWJ.js

@@ -0,0 +1,13 @@
+import { HISTORY_PROTOCOL } from './chunk-DJYMDLV5.js';
+
+function failedTaskResult(cause, message) {
+  return {
+    protocol: HISTORY_PROTOCOL,
+    outcome: "failed",
+    commands: [],
+    failure: { cause, message },
+    logs: []
+  };
+}
+
+export { failedTaskResult };

package/dist/chunk-JD2VQIDZ.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+var chunk623FVQSN_cjs = require('./chunk-623FVQSN.cjs');
+
+function failedTaskResult(cause, message) {
+  return {
+    protocol: chunk623FVQSN_cjs.HISTORY_PROTOCOL,
+    outcome: "failed",
+    commands: [],
+    failure: { cause, message },
+    logs: []
+  };
+}
+
+exports.failedTaskResult = failedTaskResult;

package/dist/{chunk-PL73GJR4.js → chunk-JZ4TOOLN.js}

@@ -1,4 +1,4 @@
-import { formatRefTemplate, segmentFromKey } from './chunk-REV7ZOA4.js';
+import { formatRefTemplate, segmentFromKey } from './chunk-7AAZGVKD.js';
 
 // src/builder/refs.ts
 var REF_MODEL = /* @__PURE__ */ Symbol.for("fluidgrids.workflows.ref");

package/dist/chunk-L24YIZY7.cjs

@@ -0,0 +1,207 @@
+'use strict';
+
+// src/runtime/shims.ts
+var SHIM_VIOLATION = "DeterminismViolation";
+var SHIM_HOOK = "__fluidgridsShims";
+var TASK_PRELUDE = `(() => {
+  const NAME = ${JSON.stringify(SHIM_VIOLATION)};
+  const fail = (what) => {
+    const error = new Error(what + " is not allowed in workflow code: use ctx.now(), ctx.random(), ctx.sleep() or an activity.");
+    error.name = NAME;
+    throw error;
+  };
+  let hooks = null;
+  const now = (what) => (hooks !== null ? hooks.now() : fail(what + " outside a workflow task"));
+  const lock = (target, key, value) =>
+    Object.defineProperty(target, key, { value, writable: false, enumerable: false, configurable: false });
+  const RealDate = Date;
+  // ---- Built-ins that differ between hosts and engines --------------------
+  // Local time is UTC whatever the host's TZ, locale formatting is fixed
+  // (en-US shapes, no ICU), Intl is absent and garbage collection cannot be
+  // observed, so QuickJS and vm on any host run workflow code the same way.
+  const proto = RealDate.prototype;
+  const hostOffset = proto.getTimezoneOffset;
+  const realParse = RealDate.parse;
+  const isInvalid = (date) => Number.isNaN(proto.getTime.call(date));
+  for (const unit of ["FullYear", "Month", "Date", "Day", "Hours", "Minutes", "Seconds", "Milliseconds"]) {
+    lock(proto, "get" + unit, proto["getUTC" + unit]);
+    if (unit !== "Day") lock(proto, "set" + unit, proto["setUTC" + unit]);
+  }
+  lock(proto, "getTimezoneOffset", function getTimezoneOffset() { return isInvalid(this) ? NaN : 0; });
+  if (typeof proto.getYear === "function")
+    lock(proto, "getYear", function getYear() { return isInvalid(this) ? NaN : this.getUTCFullYear() - 1900; });
+  if (typeof proto.setYear === "function")
+    lock(proto, "setYear", function setYear(value) {
+      const year = Number(value);
+      if (Number.isNaN(year)) return this.setTime(NaN);
+      const whole = Math.trunc(year);
+      const base = new RealDate(isInvalid(this) ? 0 : this.getTime());
+      base.setUTCFullYear(whole >= 0 && whole <= 99 ? 1900 + whole : whole);
+      return this.setTime(base.getTime());
+    });
+  const DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const pad = (value, width) => String(value).padStart(width, "0");
+  const yearText = (year) => (year < 0 ? "-" + pad(-year, 6) : pad(year, 4));
+  const dateText = (d) =>
+    DAYS[d.getUTCDay()] + " " + MONTHS[d.getUTCMonth()] + " " + pad(d.getUTCDate(), 2) + " " + yearText(d.getUTCFullYear());
+  const timeText = (d) =>
+    pad(d.getUTCHours(), 2) + ":" + pad(d.getUTCMinutes(), 2) + ":" + pad(d.getUTCSeconds(), 2) + " GMT+0000 (Coordinated Universal Time)";
+  const localeDate = (d) => d.getUTCMonth() + 1 + "/" + d.getUTCDate() + "/" + d.getUTCFullYear();
+  const localeTime = (d) => {
+    const hours = d.getUTCHours();
+    return ((hours + 11) % 12) + 1 + ":" + pad(d.getUTCMinutes(), 2) + ":" + pad(d.getUTCSeconds(), 2) + (hours < 12 ? " AM" : " PM");
+  };
+  const formatter = (format) => function () { return isInvalid(this) ? "Invalid Date" : format(this); };
+  lock(proto, "toString", formatter((d) => dateText(d) + " " + timeText(d)));
+  lock(proto, "toDateString", formatter(dateText));
+  lock(proto, "toTimeString", formatter(timeText));
+  lock(proto, "toLocaleString", formatter((d) => localeDate(d) + ", " + localeTime(d)));
+  lock(proto, "toLocaleDateString", formatter(localeDate));
+  lock(proto, "toLocaleTimeString", formatter(localeTime));
+  // A date-time without an offset is local time to the host's parser; read it as UTC.
+  const DATE_ONLY = /^[+-]?\\d{4,6}(?:-\\d{2}(?:-\\d{2})?)?$/;
+  const ZONE_AFTER_TIME = /\\d:\\d{2}(?::\\d{2}(?:[.,]\\d+)?)?\\s*(?:[AP]M\\s*)?(?:Z|[+-]\\d{2}(?::?\\d{2})?|[ECMP][SD]T)\\s*(?:\\([^)]*\\))?\\s*$/i;
+  const NAMED_ZONE = /\\b(?:GMT|UTC|UT)\\b(?:\\s*[+-]\\d{2}:?\\d{2})?\\s*(?:\\([^)]*\\))?\\s*$/i;
+  const parse = function parse(value) {
+    const text = String(value);
+    const time = realParse(text);
+    if (Number.isNaN(time)) return time;
+    const trimmed = text.trim();
+    if (DATE_ONLY.test(trimmed) || ZONE_AFTER_TIME.test(trimmed) || NAMED_ZONE.test(trimmed)) return time;
+    return time - hostOffset.call(new RealDate(time)) * 60000;
+  };
+  const toTimeValue = (value) => {
+    if (value instanceof RealDate) return value.getTime();
+    let primitive = value;
+    if (typeof value === "object" && value !== null) {
+      primitive = value.valueOf();
+      if (typeof primitive === "object" && primitive !== null) primitive = String(value);
+    }
+    return typeof primitive === "string" ? parse(primitive) : primitive;
+  };
+  // ---- Number, string and array locale methods ----------------------------
+  const group = (digits) => digits.replace(/\\B(?=(\\d{3})+(?!\\d))/g, ",");
+  lock(Number.prototype, "toLocaleString", function toLocaleString() {
+    const x = Number.prototype.valueOf.call(this);
+    if (Number.isNaN(x)) return "NaN";
+    const sign = x < 0 || Object.is(x, -0) ? "-" : "";
+    const abs = Math.abs(x);
+    if (abs === Infinity) return sign + "\\u221e";
+    const fixed = abs < 1e21 ? abs.toFixed(3) : BigInt(abs).toString() + ".000";
+    const [whole, fraction] = fixed.split(".");
+    const kept = fraction.replace(/0+$/, "");
+    return sign + group(whole) + (kept === "" ? "" : "." + kept);
+  });
+  if (typeof BigInt === "function")
+    lock(BigInt.prototype, "toLocaleString", function toLocaleString() {
+      const text = BigInt.prototype.toString.call(this);
+      return text.startsWith("-") ? "-" + group(text.slice(1)) : group(text);
+    });
+  lock(String.prototype, "localeCompare", function localeCompare(that) {
+    const a = String(this);
+    const b = String(that);
+    return a < b ? -1 : a > b ? 1 : 0;
+  });
+  lock(String.prototype, "toLocaleUpperCase", function toLocaleUpperCase() { return String(this).toUpperCase(); });
+  lock(String.prototype, "toLocaleLowerCase", function toLocaleLowerCase() { return String(this).toLowerCase(); });
+  const listLocale = function toLocaleString() {
+    return Array.prototype.map.call(this, (item) => (item === null || item === undefined ? "" : item.toLocaleString())).join(",");
+  };
+  lock(Array.prototype, "toLocaleString", listLocale);
+  lock(Object.getPrototypeOf(Uint8Array.prototype), "toLocaleString", listLocale);
+  // ---- Absent or refused ---------------------------------------------------
+  if (!Reflect.deleteProperty(globalThis, "Intl")) lock(globalThis, "Intl", undefined);
+  for (const name of ["WeakRef", "FinalizationRegistry"]) {
+    lock(globalThis, name, function () { return fail(name + " (garbage collection is not deterministic)"); });
+  }
+  const LockedDate = function Date(...args) {
+    if (new.target === undefined) return new RealDate(now("Date()")).toString();
+    if (args.length === 0) return Reflect.construct(RealDate, [now("new Date()")], new.target);
+    if (args.length === 1) return Reflect.construct(RealDate, [toTimeValue(args[0])], new.target);
+    return Reflect.construct(RealDate, [RealDate.UTC(...args)], new.target);
+  };
+  lock(LockedDate, "prototype", RealDate.prototype);
+  lock(RealDate.prototype, "constructor", LockedDate);
+  lock(LockedDate, "now", function now_() { return now("Date.now()"); });
+  lock(LockedDate, "parse", parse);
+  lock(LockedDate, "UTC", RealDate.UTC);
+  lock(globalThis, "Date", LockedDate);
+  lock(Math, "random", function random() {
+    return hooks !== null ? hooks.random() : fail("Math.random() outside a workflow task");
+  });
+  const crypto = globalThis.crypto;
+  if (crypto !== null && typeof crypto === "object") {
+    if (typeof crypto.getRandomValues === "function")
+      lock(crypto, "getRandomValues", function getRandomValues(array) {
+        if (hooks === null) return fail("crypto.getRandomValues() outside a workflow task");
+        for (let i = 0; i < array.length; i++) array[i] = Math.floor(hooks.random() * 256);
+        return array;
+      });
+    if (typeof crypto.randomUUID === "function")
+      lock(crypto, "randomUUID", function randomUUID() { return fail("crypto.randomUUID(): use ctx.uuid()"); });
+  }
+  for (const name of ["setTimeout", "setInterval", "setImmediate", "clearTimeout", "clearInterval", "clearImmediate"]) {
+    lock(globalThis, name, function () { return fail(name + "(): use ctx.sleep()"); });
+  }
+  for (const name of ["fetch", "XMLHttpRequest", "WebSocket", "EventSource"]) {
+    lock(globalThis, name, function () { return fail(name + ": do I/O in an activity (ctx.run)"); });
+  }
+  Object.defineProperty(globalThis, ${JSON.stringify(SHIM_HOOK)}, {
+    value: Object.freeze({
+      attach(next) { hooks = next; },
+      detach() { hooks = null; },
+    }),
+    writable: false,
+    enumerable: false,
+    configurable: true,
+  });
+})();
+`;
+function isShimControl(value) {
+  return typeof value === "object" && value !== null && typeof value.attach === "function" && typeof value.detach === "function";
+}
+function takeShimControl() {
+  const holder = globalThis;
+  const control = holder[SHIM_HOOK];
+  if (!isShimControl(control)) return void 0;
+  delete holder[SHIM_HOOK];
+  return control;
+}
+function seedOf(text) {
+  let hash = 2166136261;
+  for (let index = 0; index < text.length; index++) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash >>> 0;
+}
+function createRandom(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state = state + 1831565813 >>> 0;
+    let t = state;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function uuidFrom(random) {
+  const hex = [];
+  for (let index = 0; index < 16; index++) {
+    let byte = Math.floor(random() * 256) & 255;
+    if (index === 6) byte = byte & 15 | 64;
+    if (index === 8) byte = byte & 63 | 128;
+    hex.push(byte.toString(16).padStart(2, "0"));
+  }
+  const text = hex.join("");
+  return `${text.slice(0, 8)}-${text.slice(8, 12)}-${text.slice(12, 16)}-${text.slice(16, 20)}-${text.slice(20)}`;
+}
+
+exports.SHIM_HOOK = SHIM_HOOK;
+exports.SHIM_VIOLATION = SHIM_VIOLATION;
+exports.TASK_PRELUDE = TASK_PRELUDE;
+exports.createRandom = createRandom;
+exports.seedOf = seedOf;
+exports.takeShimControl = takeShimControl;
+exports.uuidFrom = uuidFrom;

package/dist/chunk-LNUQE6D6.js

@@ -0,0 +1,39 @@
+// src/ir/duration.ts
+var SHORT = /^(\d+(?:\.\d+)?)(ms|s|m|h|d|w)$/;
+var ISO = /^P(?:(\d+(?:\.\d+)?)W)?(?:(\d+(?:\.\d+)?)D)?(?:T(?:(\d+(?:\.\d+)?)H)?(?:(\d+(?:\.\d+)?)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;
+var SECOND_MS = 1e3;
+var MINUTE_MS = 60 * SECOND_MS;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+var WEEK_MS = 7 * DAY_MS;
+var UNIT_MS = {
+  ms: 1,
+  s: SECOND_MS,
+  m: MINUTE_MS,
+  h: HOUR_MS,
+  d: DAY_MS,
+  w: WEEK_MS
+};
+function durationMs(value, numberUnit) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value < 0) return void 0;
+    return numberUnit === "s" ? value * 1e3 : value;
+  }
+  if (typeof value !== "string") return void 0;
+  const text = value.trim();
+  const short = SHORT.exec(text);
+  if (short?.[1] !== void 0 && short[2] !== void 0) {
+    const unit = UNIT_MS[short[2]];
+    return unit === void 0 ? void 0 : Number(short[1]) * unit;
+  }
+  const iso = ISO.exec(text);
+  if (iso && text !== "P" && text !== "PT") {
+    const [, weeks, days, hours, minutes, seconds] = iso;
+    const parts = [weeks, days, hours, minutes, seconds];
+    if (parts.every((part) => part === void 0)) return void 0;
+    return Number(weeks ?? 0) * WEEK_MS + Number(days ?? 0) * DAY_MS + Number(hours ?? 0) * HOUR_MS + Number(minutes ?? 0) * MINUTE_MS + Number(seconds ?? 0) * SECOND_MS;
+  }
+  return void 0;
+}
+
+export { durationMs };

package/dist/{chunk-BYJ7QTLY.cjs → chunk-NEIUQASE.cjs}

@@ -1,19 +1,19 @@
 'use strict';
 
-var chunkAU3YW7FZ_cjs = require('./chunk-AU3YW7FZ.cjs');
-var chunkLRM6JXJA_cjs = require('./chunk-LRM6JXJA.cjs');
+var chunkGBQ33SIZ_cjs = require('./chunk-GBQ33SIZ.cjs');
+var chunkSAENRNBJ_cjs = require('./chunk-SAENRNBJ.cjs');
 
 // 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 (chunkLRM6JXJA_cjs.deepEqual(before, after)) return;
-  if (chunkLRM6JXJA_cjs.isRecord(before) && chunkLRM6JXJA_cjs.isRecord(after)) {
+  if (chunkSAENRNBJ_cjs.deepEqual(before, after)) return;
+  if (chunkSAENRNBJ_cjs.isRecord(before) && chunkSAENRNBJ_cjs.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];
+      const left = chunkSAENRNBJ_cjs.ownValue(before, key);
+      const right = chunkSAENRNBJ_cjs.ownValue(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)
@@ -28,7 +28,7 @@ function byId(items) {
   const map = /* @__PURE__ */ new Map();
   if (!Array.isArray(items)) return map;
   items.forEach((item, index) => {
-    if (!chunkLRM6JXJA_cjs.isRecord(item)) return;
+    if (!chunkSAENRNBJ_cjs.isRecord(item)) return;
     const id = typeof item["id"] === "string" ? item["id"] : `#${index}`;
     if (!map.has(id)) map.set(id, item);
   });
@@ -48,23 +48,23 @@ function diffCollection(before, after, path, out) {
   const common = (ids, other) => ids.filter((id) => other.has(id));
   const leftOrder = common([...left.keys()], right);
   const rightOrder = common([...right.keys()], left);
-  if (!chunkLRM6JXJA_cjs.deepEqual(leftOrder, rightOrder)) {
+  if (!chunkSAENRNBJ_cjs.deepEqual(leftOrder, rightOrder)) {
     out.push({ kind: "reordered", path, before: leftOrder, after: rightOrder });
   }
 }
 function diffDefinitions(before, after) {
-  const left = chunkAU3YW7FZ_cjs.hashedProjection(before);
-  const right = chunkAU3YW7FZ_cjs.hashedProjection(after);
+  const left = chunkGBQ33SIZ_cjs.hashedProjection(before);
+  const right = chunkGBQ33SIZ_cjs.hashedProjection(after);
   const out = [];
-  if (!chunkLRM6JXJA_cjs.isRecord(left) || !chunkLRM6JXJA_cjs.isRecord(right)) {
+  if (!chunkSAENRNBJ_cjs.isRecord(left) || !chunkSAENRNBJ_cjs.isRecord(right)) {
     diffValues(left, right, "", out);
     return out;
   }
   const { data: leftData, ...leftRest } = left;
   const { data: rightData, ...rightRest } = right;
   diffValues(leftRest, rightRest, "", out);
-  const leftDataRecord = chunkLRM6JXJA_cjs.isRecord(leftData) ? leftData : {};
-  const rightDataRecord = chunkLRM6JXJA_cjs.isRecord(rightData) ? rightData : {};
+  const leftDataRecord = chunkSAENRNBJ_cjs.isRecord(leftData) ? leftData : {};
+  const rightDataRecord = chunkSAENRNBJ_cjs.isRecord(rightData) ? rightData : {};
   const { nodes: leftNodes, edges: leftEdges, ...leftDataRest } = leftDataRecord;
   const { nodes: rightNodes, edges: rightEdges, ...rightDataRest } = rightDataRecord;
   diffCollection(leftNodes, rightNodes, "data.nodes", out);