@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/chunks/chunk-O2U2LO57.js

@@ -0,0 +1,466 @@
+import {
+  VERSION
+} from "./chunk-QDE4Z7KW.js";
+
+// src/runtime/continuation-core.ts
+var ENGINE_VERSION = VERSION;
+var CONTINUATION_FORMAT_VERSION = 1;
+var GENERATOR_ABI = "flow-weaver-generated-v2";
+var MAX_CONTINUATION_BYTES = 1024 * 1024;
+var MAX_CONTINUATION_DEPTH = 32;
+var MAX_CONTINUATION_ENTRIES = 1e4;
+var MAX_CONTINUATION_STRING_BYTES = 256 * 1024;
+var ENVELOPE_KEYS = [
+  "formatVersion",
+  "runId",
+  "gateId",
+  "gateKind",
+  "workflowId",
+  "bundleDigest",
+  "graphFingerprint",
+  "engineVersion",
+  "generatorAbi",
+  "location",
+  "state",
+  "receipts",
+  "createdAt",
+  "checksum"
+];
+var acceptedContinuations = /* @__PURE__ */ new WeakSet();
+function utf8BytesOf(text) {
+  const bytes = [];
+  for (let index = 0; index < text.length; index++) {
+    let code = text.charCodeAt(index);
+    if (code >= 55296 && code <= 56319 && index + 1 < text.length) {
+      const low = text.charCodeAt(index + 1);
+      if (low >= 56320 && low <= 57343) {
+        code = 65536 + (code - 55296 << 10) + (low - 56320);
+        index++;
+      }
+    }
+    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 bytes;
+}
+function utf8ByteLength(text) {
+  return utf8BytesOf(text).length;
+}
+var SHA256_K = [
+  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 sha256Hex(text) {
+  const bytes = utf8BytesOf(text);
+  const bitLength = bytes.length * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56) bytes.push(0);
+  const high = Math.floor(bitLength / 4294967296);
+  const low = bitLength >>> 0;
+  bytes.push(
+    high >>> 24 & 255,
+    high >>> 16 & 255,
+    high >>> 8 & 255,
+    high & 255,
+    low >>> 24 & 255,
+    low >>> 16 & 255,
+    low >>> 8 & 255,
+    low & 255
+  );
+  const h = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225];
+  const w = new Array(64);
+  const rotr = (value, bits) => value >>> bits | value << 32 - bits;
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let i = 0; i < 16; i++) {
+      const j = offset + i * 4;
+      w[i] = (bytes[j] << 24 | bytes[j + 1] << 16 | bytes[j + 2] << 8 | bytes[j + 3]) >>> 0;
+    }
+    for (let i = 16; i < 64; i++) {
+      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    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 temp1 = hh + S1 + ch + SHA256_K[i] + w[i] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  return h.map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+var WireValidationError = class extends Error {
+  constructor(reason, message) {
+    super(message);
+    this.reason = reason;
+    this.name = "WireValidationError";
+  }
+  reason;
+};
+var ownKeyOf = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+function assertWireValue(value, path, depth, budget) {
+  if (depth > MAX_CONTINUATION_DEPTH) {
+    throw new WireValidationError("oversized", `${path} exceeds maximum depth`);
+  }
+  budget.entries++;
+  if (budget.entries > MAX_CONTINUATION_ENTRIES) {
+    throw new WireValidationError("oversized", "continuation exceeds aggregate entry limit");
+  }
+  if (value === null || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new WireValidationError("malformed", `${path} contains a non-finite number`);
+    }
+    return;
+  }
+  if (typeof value === "string") {
+    const bytes = utf8ByteLength(value);
+    if (bytes > MAX_CONTINUATION_STRING_BYTES) {
+      throw new WireValidationError("oversized", `${path} exceeds maximum string size`);
+    }
+    budget.bytes += bytes;
+    if (budget.bytes > MAX_CONTINUATION_BYTES) {
+      throw new WireValidationError("oversized", "continuation exceeds maximum wire size");
+    }
+    return;
+  }
+  if (value === void 0 || typeof value === "bigint" || typeof value === "symbol" || typeof value === "function") {
+    throw new WireValidationError("malformed", `${path} is not a plain wire value`);
+  }
+  const seen = value;
+  if (budget.seen.has(seen)) {
+    throw new WireValidationError("malformed", `${path} contains a cycle or repeated object`);
+  }
+  budget.seen.add(seen);
+  if (Array.isArray(value)) {
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new WireValidationError("malformed", `${path} contains a symbol property`);
+    }
+    const descriptors2 = Object.getOwnPropertyDescriptors(value);
+    for (const [key, descriptor] of Object.entries(descriptors2)) {
+      if (key === "length") continue;
+      if (!/^(0|[1-9]\d*)$/.test(key) || descriptor.get || descriptor.set || !descriptor.enumerable) {
+        throw new WireValidationError("malformed", `${path} contains an accessor or property`);
+      }
+    }
+    for (let index = 0; index < value.length; index++) {
+      if (!ownKeyOf(descriptors2, String(index))) {
+        throw new WireValidationError("malformed", `${path} contains a sparse array`);
+      }
+      assertWireValue(descriptors2[String(index)].value, `${path}[${index}]`, depth + 1, budget);
+    }
+    budget.seen.delete(seen);
+    return;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new WireValidationError("malformed", `${path} contains a class or host object`);
+  }
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new WireValidationError("malformed", `${path} contains a symbol property`);
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (const [key, descriptor] of Object.entries(descriptors)) {
+    if (descriptor.get || descriptor.set || !descriptor.enumerable) {
+      throw new WireValidationError("malformed", `${path}.${key} is an accessor or non-enumerable property`);
+    }
+    const keyBytes = utf8ByteLength(key);
+    if (keyBytes > MAX_CONTINUATION_STRING_BYTES) {
+      throw new WireValidationError("oversized", `${path} contains an oversized key`);
+    }
+    budget.bytes += keyBytes;
+    assertWireValue(descriptor.value, `${path}.${key}`, depth + 1, budget);
+  }
+  budget.seen.delete(seen);
+}
+function validateWireValue(value) {
+  assertWireValue(value, "$", 0, { entries: 0, bytes: 0, seen: /* @__PURE__ */ new Set() });
+}
+function canonicalJson(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "number") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+}
+function canonicalWireValue(value) {
+  validateWireValue(value);
+  return canonicalJson(value);
+}
+function cloneAndFreezeWireValue(value) {
+  const cloned = JSON.parse(canonicalJson(value));
+  const freeze = (entry) => {
+    if (typeof entry !== "object" || entry === null) return;
+    for (const child of Array.isArray(entry) ? entry : Object.values(entry)) {
+      freeze(child);
+    }
+    Object.freeze(entry);
+  };
+  freeze(cloned);
+  return cloned;
+}
+function executionAddressKey(address) {
+  return canonicalWireValue(address);
+}
+function durableGateId(runId, kind, address) {
+  return sha256Hex(`${runId}\0${kind}\0${executionAddressKey(address)}`);
+}
+function operationKey(runId, address) {
+  validateWireValue(address);
+  return sha256Hex(`${runId}\0${canonicalJson(address)}`);
+}
+function withoutChecksum(envelope) {
+  const { checksum: _checksum, ...unsigned } = envelope;
+  return unsigned;
+}
+function continuationChecksum(envelope) {
+  validateWireValue(withoutChecksum(envelope));
+  return sha256Hex(canonicalJson(withoutChecksum(envelope)));
+}
+function createContinuationEnvelope(fields) {
+  const unsigned = {
+    formatVersion: CONTINUATION_FORMAT_VERSION,
+    runId: fields.runId,
+    gateId: fields.gateId,
+    gateKind: fields.gateKind,
+    workflowId: fields.workflowId,
+    bundleDigest: fields.bundleDigest,
+    graphFingerprint: fields.graphFingerprint,
+    engineVersion: fields.engineVersion ?? VERSION,
+    generatorAbi: fields.generatorAbi ?? GENERATOR_ABI,
+    location: fields.location,
+    state: fields.state,
+    receipts: fields.receipts,
+    createdAt: fields.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  };
+  validateWireValue(unsigned);
+  const envelope = Object.assign({}, unsigned, { checksum: "" });
+  return { ...envelope, checksum: continuationChecksum(envelope) };
+}
+function isPlainObjectRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function hasExactlyTheKeys(value, keys) {
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
+}
+function hasRequiredAndOptionalKeys(value, required, optional = []) {
+  const keys = Object.keys(value);
+  return required.every((key) => ownKeyOf(value, key)) && keys.every((key) => required.includes(key) || optional.includes(key));
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isFrameAddress(value) {
+  return isPlainObjectRecord(value) && hasRequiredAndOptionalKeys(value, ["workflowId", "invocation"], ["callerNodeId", "callerExecutionIndex"]) && typeof value.workflowId === "string" && value.workflowId.length > 0 && isNonNegativeInteger(value.invocation) && (value.callerNodeId === void 0 || typeof value.callerNodeId === "string") && (value.callerExecutionIndex === void 0 || isNonNegativeInteger(value.callerExecutionIndex)) && (value.callerNodeId === void 0 && value.callerExecutionIndex === void 0 || typeof value.callerNodeId === "string" && isNonNegativeInteger(value.callerExecutionIndex));
+}
+function isScopeAddress(value) {
+  return isPlainObjectRecord(value) && hasRequiredAndOptionalKeys(
+    value,
+    ["parentNodeId", "parentExecutionIndex", "scopeName", "invocation"],
+    ["loopIteration", "branchArm"]
+  ) && typeof value.parentNodeId === "string" && value.parentNodeId.length > 0 && isNonNegativeInteger(value.parentExecutionIndex) && typeof value.scopeName === "string" && value.scopeName.length > 0 && isNonNegativeInteger(value.invocation) && (value.loopIteration === void 0 || isNonNegativeInteger(value.loopIteration)) && (value.branchArm === void 0 || typeof value.branchArm === "string");
+}
+function isExecutionAddress(value) {
+  return isPlainObjectRecord(value) && hasExactlyTheKeys(value, ["frames", "scopes", "branches", "nodeId", "nodeType", "executionIndex"]) && Array.isArray(value.frames) && value.frames.length > 0 && value.frames.every(isFrameAddress) && Array.isArray(value.scopes) && value.scopes.every(isScopeAddress) && Array.isArray(value.branches) && value.branches.every(
+    (branch) => isPlainObjectRecord(branch) && hasExactlyTheKeys(branch, ["workflowId", "frameDepth", "nodeId", "executionIndex", "arm"]) && typeof branch.workflowId === "string" && branch.workflowId.length > 0 && isNonNegativeInteger(branch.frameDepth) && typeof branch.nodeId === "string" && branch.nodeId.length > 0 && isNonNegativeInteger(branch.executionIndex) && typeof branch.arm === "string" && branch.arm.length > 0
+  ) && typeof value.nodeId === "string" && value.nodeId.length > 0 && typeof value.nodeType === "string" && value.nodeType.length > 0 && isNonNegativeInteger(value.executionIndex);
+}
+function isContinuationVariable(value) {
+  return isPlainObjectRecord(value) && hasExactlyTheKeys(value, ["address", "portName", "value"]) && isExecutionAddress(value.address) && typeof value.portName === "string" && value.portName.length > 0;
+}
+function isEffectReceipt(value) {
+  return isPlainObjectRecord(value) && hasExactlyTheKeys(value, ["address", "operationKey", "receipt"]) && isExecutionAddress(value.address) && typeof value.operationKey === "string" && /^[0-9a-f]{64}$/.test(value.operationKey);
+}
+function isContinuationState(value) {
+  return isPlainObjectRecord(value) && hasExactlyTheKeys(value, ["completed", "variables", "nextBoundary"]) && Array.isArray(value.completed) && value.completed.every(isExecutionAddress) && Array.isArray(value.variables) && value.variables.every(isContinuationVariable) && isExecutionAddress(value.nextBoundary);
+}
+function isExactIsoUtc(value) {
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
+}
+function structurallyValidEnvelope(value) {
+  if (!isPlainObjectRecord(value) || !hasExactlyTheKeys(value, ENVELOPE_KEYS)) return false;
+  return !(typeof value.formatVersion !== "number" || typeof value.runId !== "string" || typeof value.gateId !== "string" || !["approval", "input", "agent", "timer"].includes(value.gateKind) || typeof value.workflowId !== "string" || typeof value.bundleDigest !== "string" || typeof value.graphFingerprint !== "string" || typeof value.engineVersion !== "string" || typeof value.generatorAbi !== "string" || typeof value.createdAt !== "string" || typeof value.checksum !== "string" || value.runId.length === 0 || !/^[0-9a-f]{64}$/.test(value.gateId) || value.workflowId.length === 0 || value.engineVersion.length === 0 || value.generatorAbi.length === 0 || !isExecutionAddress(value.location) || !isContinuationState(value.state) || !Array.isArray(value.receipts) || !value.receipts.every(isEffectReceipt) || !/^sha256:[0-9a-f]{64}$/.test(value.bundleDigest) || !/^[0-9a-f]{64}$/.test(value.graphFingerprint) || !/^[0-9a-f]{64}$/.test(value.checksum) || !isExactIsoUtc(value.createdAt) || executionAddressKey(value.location) !== executionAddressKey(value.state.nextBoundary));
+}
+function acceptContinuation(input, identity) {
+  let value = input;
+  if (typeof input === "string") {
+    if (utf8ByteLength(input) > MAX_CONTINUATION_BYTES) {
+      return { accepted: false, reason: "oversized", message: "continuation exceeds maximum wire size" };
+    }
+    try {
+      value = JSON.parse(input);
+    } catch {
+      return { accepted: false, reason: "malformed", message: "continuation is not valid JSON" };
+    }
+  }
+  try {
+    validateWireValue(value);
+  } catch (error) {
+    if (error instanceof WireValidationError) {
+      return { accepted: false, reason: error.reason, message: error.message };
+    }
+    return { accepted: false, reason: "malformed", message: "continuation is not a wire value" };
+  }
+  if (!structurallyValidEnvelope(value)) {
+    return { accepted: false, reason: "malformed", message: "continuation has missing, unknown, or invalid fields" };
+  }
+  if (value.formatVersion !== CONTINUATION_FORMAT_VERSION) {
+    return { accepted: false, reason: "unsupported-format", message: `unsupported continuation format ${value.formatVersion}` };
+  }
+  if (continuationChecksum(value) !== value.checksum) {
+    return { accepted: false, reason: "checksum-mismatch", message: "continuation checksum does not match" };
+  }
+  if (value.gateId !== durableGateId(value.runId, value.gateKind, value.location)) {
+    return { accepted: false, reason: "malformed", message: "continuation gate identity does not match its execution address" };
+  }
+  if (value.engineVersion !== VERSION) {
+    return { accepted: false, reason: "incompatible-engine", message: `continuation was written by engine ${value.engineVersion}, this is ${VERSION}` };
+  }
+  if (value.generatorAbi !== GENERATOR_ABI) {
+    return { accepted: false, reason: "incompatible-generator", message: "continuation generator ABI does not match" };
+  }
+  if (value.runId !== identity.runId) {
+    return { accepted: false, reason: "wrong-run", message: "continuation belongs to another run" };
+  }
+  if (value.workflowId !== identity.workflowId) {
+    return { accepted: false, reason: "wrong-workflow", message: "continuation belongs to another workflow" };
+  }
+  if (identity.gateId !== void 0 && value.gateId !== identity.gateId) {
+    return { accepted: false, reason: "stale-gate", message: "continuation gate is stale or reordered" };
+  }
+  const accepted = cloneAndFreezeWireValue(value);
+  acceptedContinuations.add(accepted);
+  return { accepted: true, envelope: accepted };
+}
+function assertAcceptedContinuation(value) {
+  if (!acceptedContinuations.has(value)) {
+    throw new Error("ContinuationEnvelope must come from a successful decodeContinuation or acceptContinuation result");
+  }
+}
+
+export {
+  ENGINE_VERSION,
+  CONTINUATION_FORMAT_VERSION,
+  GENERATOR_ABI,
+  MAX_CONTINUATION_BYTES,
+  MAX_CONTINUATION_DEPTH,
+  MAX_CONTINUATION_ENTRIES,
+  MAX_CONTINUATION_STRING_BYTES,
+  ENVELOPE_KEYS,
+  utf8ByteLength,
+  sha256Hex,
+  WireValidationError,
+  validateWireValue,
+  canonicalWireValue,
+  cloneAndFreezeWireValue,
+  executionAddressKey,
+  durableGateId,
+  operationKey,
+  continuationChecksum,
+  createContinuationEnvelope,
+  isPlainObjectRecord,
+  hasExactlyTheKeys,
+  isExecutionAddress,
+  structurallyValidEnvelope,
+  acceptContinuation,
+  assertAcceptedContinuation
+};