@fluidgrids/workflows 0.0.0-stage → 2026.1027.1

package/dist/chunk-G4UEPUGO.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+// 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;
+}
+
+exports.LAYOUT_COLUMN_WIDTH = LAYOUT_COLUMN_WIDTH;
+exports.LAYOUT_ROW_HEIGHT = LAYOUT_ROW_HEIGHT;
+exports.autoLayout = autoLayout;

package/dist/chunk-IHKXLG6I.js

@@ -0,0 +1,246 @@
+import { setOwn } from './chunk-UJNHTS6D.js';
+
+// 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) setOwn(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)}`;
+}
+
+export { CanonicalJsonError, canonicalJson, sha256Hex, sha256Tagged, stableStringify };