@almadar/core 10.129.0 → 11.0.1

package/dist/chunk-GIUA3NUJ.js

@@ -1,809 +0,0 @@
-// src/state-machine/graph.ts
-function buildStateGraph(transitions) {
-  const graph = /* @__PURE__ */ new Map();
-  for (const t of transitions) {
-    if (t.from === "*") continue;
-    if (!graph.has(t.from)) graph.set(t.from, []);
-    graph.get(t.from).push({ event: t.event, to: t.to });
-  }
-  return graph;
-}
-
-// src/state-machine/bfs.ts
-function collectReachableStates(transitions, initialState, maxDepth = 5) {
-  const graph = buildStateGraph(transitions);
-  const visited = /* @__PURE__ */ new Set([initialState]);
-  const queue = [{ state: initialState, depth: 0 }];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (current.depth >= maxDepth) continue;
-    const edges = graph.get(current.state) ?? [];
-    for (const edge of edges) {
-      if (!visited.has(edge.to)) {
-        visited.add(edge.to);
-        queue.push({ state: edge.to, depth: current.depth + 1 });
-      }
-    }
-  }
-  return visited;
-}
-async function walkStatePairs(transitions, initialState, maxDepth, visitor) {
-  const graph = buildStateGraph(transitions);
-  const visitedPairs = /* @__PURE__ */ new Set();
-  const queue = [{ state: initialState, depth: 0 }];
-  let walkedEdges = 0;
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (current.depth >= maxDepth) continue;
-    const edges = graph.get(current.state) ?? [];
-    for (const edge of edges) {
-      const pairKey = `${current.state}:${edge.event}`;
-      if (visitedPairs.has(pairKey)) continue;
-      visitedPairs.add(pairKey);
-      const shouldEnqueue = await visitor(current.state, edge, current.depth);
-      walkedEdges++;
-      if (shouldEnqueue) {
-        const stateVisited = [...visitedPairs].some((k) => k.startsWith(`${edge.to}:`));
-        if (!stateVisited) {
-          queue.push({ state: edge.to, depth: current.depth + 1 });
-        }
-      }
-    }
-  }
-  return { visitedPairs, walkedEdges };
-}
-
-// src/state-machine/guard-payloads.ts
-function extractPayloadFieldRef(ref) {
-  if (typeof ref !== "string") return null;
-  const match = ref.match(/^@payload\.([A-Za-z0-9_]+)/);
-  return match ? match[1] : null;
-}
-function extractPayloadFieldPath(ref) {
-  if (typeof ref !== "string") return null;
-  const match = ref.match(/^@payload\.([A-Za-z0-9_]+(?:\.[A-Za-z0-9_]+)*)/);
-  return match ? match[1].split(".") : null;
-}
-function strDefaultPayloadPath(ref) {
-  if (!Array.isArray(ref) || ref[0] !== "str/default" || typeof ref[2] !== "string") return null;
-  return extractPayloadFieldPath(ref[1]);
-}
-function isComparedLiteral(x) {
-  return x === null || typeof x === "number" || typeof x === "boolean" || typeof x === "string" && !x.startsWith("@");
-}
-function payloadComparison(a, b) {
-  const plain = extractPayloadFieldPath(a);
-  if (plain && b !== void 0) return { path: plain, val: b };
-  for (const [side, other] of [[a, b], [b, a]]) {
-    const path = extractPayloadFieldPath(side) ?? strDefaultPayloadPath(side);
-    if (path && isComparedLiteral(other)) return { path, val: other };
-  }
-  return null;
-}
-function nestedPayload(path, leaf) {
-  let value = leaf;
-  for (let i = path.length - 1; i >= 1; i--) {
-    value = { [path[i]]: value };
-  }
-  return { [path[0]]: value };
-}
-function isPayloadObject(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Date);
-}
-function extractArrayLenPath(ref) {
-  if (!Array.isArray(ref) || ref.length !== 2 || ref[0] !== "array/len") return null;
-  return extractPayloadFieldPath(ref[1]);
-}
-function arrayOfLength(n) {
-  return Array.from({ length: Math.max(0, n) }, (_, i) => ({ id: `mock-test-id-${i}` }));
-}
-var SYNTHESIZED_GUARD_OPERATORS = /* @__PURE__ */ new Set([
-  "not-nil",
-  "not_nil",
-  "nil",
-  "eq",
-  "==",
-  "=",
-  "not-eq",
-  "!=",
-  "neq",
-  "gt",
-  ">",
-  "gte",
-  ">=",
-  "lt",
-  "<",
-  "lte",
-  "<=",
-  "and",
-  "or",
-  "not",
-  "object/has",
-  "object/get",
-  "array/includes",
-  "str/startsWith",
-  "validate/url",
-  "validate/required",
-  "agent/is-pinned",
-  "agent/memory-strength",
-  "if",
-  "let",
-  "array/some",
-  "array/every",
-  "grid/in-bounds"
-]);
-var ACKNOWLEDGED_UNSYNTHESIZED_GUARD_OPERATORS = /* @__PURE__ */ new Set();
-var CONSTANT_GUARD_FORMS = /* @__PURE__ */ new Set(["quote"]);
-function isRecognizedGuardOperator(op) {
-  return SYNTHESIZED_GUARD_OPERATORS.has(op) || ACKNOWLEDGED_UNSYNTHESIZED_GUARD_OPERATORS.has(op) || CONSTANT_GUARD_FORMS.has(op) || op.startsWith("agent/");
-}
-var unhandledGuardOperators = [];
-function recordUnhandledOperator(op) {
-  if (unhandledGuardOperators.includes(op)) return;
-  unhandledGuardOperators.push(op);
-  console.warn(
-    `[@almadar/core buildGuardPayloads] unrecognized guard operator "${op}" \u2014 synthesizing {pass:{}, fail:{}}; this guard arm cannot be walked pass/fail by verify. Add synthesis (or a tracked-gap entry) in guard-payloads.ts.`
-  );
-}
-function splitPayloadArg(a, b) {
-  const pathA = extractPayloadFieldPath(a);
-  if (pathA) return { path: pathA, collection: b };
-  const pathB = extractPayloadFieldPath(b);
-  if (pathB) return { path: pathB, collection: a };
-  return null;
-}
-function isPlainRecord(v) {
-  return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Date);
-}
-function absentKey(keys) {
-  let candidate = `${keys.reduce((longest, k) => k.length > longest.length ? k : longest, "")}_`;
-  while (keys.includes(candidate)) candidate += "_";
-  return candidate;
-}
-function mergePayloads(a, b) {
-  const out = { ...a };
-  for (const [k, v] of Object.entries(b)) {
-    const prev = out[k];
-    out[k] = prev !== void 0 && isPayloadObject(prev) && v !== void 0 && isPayloadObject(v) ? mergePayloads(prev, v) : v;
-  }
-  return out;
-}
-function extractObjectGetOperand(x) {
-  if (!Array.isArray(x) || x[0] !== "object/get") return null;
-  const split = splitPayloadArg(x[1], x[2]);
-  if (split && isPlainRecord(split.collection)) {
-    return { path: split.path, map: split.collection };
-  }
-  return null;
-}
-function resolveObjectGetComparison(a, b) {
-  const getA = extractObjectGetOperand(a);
-  if (getA) return { path: getA.path, map: getA.map, literal: b };
-  const getB = extractObjectGetOperand(b);
-  if (getB) return { path: getB.path, map: getB.map, literal: a };
-  return null;
-}
-function buildObjectGetComparisonPayload(a, b, negate) {
-  const resolved = resolveObjectGetComparison(a, b);
-  if (!resolved) return null;
-  const { path, map, literal } = resolved;
-  const keys = Object.keys(map);
-  const passKey = keys.find((k) => negate ? map[k] !== literal : map[k] === literal);
-  const failKey = keys.find((k) => negate ? map[k] === literal : map[k] !== literal);
-  return {
-    pass: passKey !== void 0 ? nestedPayload(path, passKey) : {},
-    fail: failKey !== void 0 ? nestedPayload(path, failKey) : nestedPayload(path, absentKey(keys))
-  };
-}
-function guardPassCandidateSet(guard) {
-  if (!Array.isArray(guard) || guard.length === 0) return null;
-  const op = String(guard[0]);
-  if (op === "object/has") {
-    const split = splitPayloadArg(guard[1], guard[2]);
-    if (split && isPlainRecord(split.collection)) {
-      return { path: split.path, values: Object.keys(split.collection) };
-    }
-    return null;
-  }
-  if (op === "eq" || op === "==" || op === "=" || op === "not-eq" || op === "!=" || op === "neq") {
-    const negate = op === "not-eq" || op === "!=" || op === "neq";
-    const resolved = resolveObjectGetComparison(guard[1], guard[2]);
-    if (resolved) {
-      const values = Object.keys(resolved.map).filter(
-        (k) => negate ? resolved.map[k] !== resolved.literal : resolved.map[k] === resolved.literal
-      );
-      return { path: resolved.path, values };
-    }
-    if (!negate) {
-      const path = extractPayloadFieldPath(guard[1]);
-      if (path && typeof guard[2] === "string") return { path, values: [guard[2]] };
-    }
-    return null;
-  }
-  return null;
-}
-function withoutField(payload, path) {
-  const [head, ...tail] = path;
-  if (tail.length === 0) {
-    const rest = {};
-    for (const k of Object.keys(payload)) {
-      if (k !== head) rest[k] = payload[k];
-    }
-    return rest;
-  }
-  const nested = payload[head];
-  if (!isPayloadObject(nested)) return payload;
-  return { ...payload, [head]: withoutField(nested, tail) };
-}
-function applyFieldIntersections(subs, pass) {
-  const byField = /* @__PURE__ */ new Map();
-  for (const sub of subs) {
-    const candidate = guardPassCandidateSet(sub);
-    if (!candidate) continue;
-    const key = JSON.stringify(candidate.path);
-    const entry = byField.get(key);
-    if (entry) entry.sets.push(candidate.values);
-    else byField.set(key, { path: candidate.path, sets: [candidate.values] });
-  }
-  let out = pass;
-  for (const { path, sets } of byField.values()) {
-    if (sets.length < 2) continue;
-    const intersection = sets.reduce((acc, set) => acc.filter((v) => set.includes(v)));
-    out = intersection.length > 0 ? mergePayloads(out, nestedPayload(path, intersection[0])) : withoutField(out, path);
-  }
-  return out;
-}
-function constTruth(guard) {
-  if (typeof guard === "boolean") return guard;
-  if (typeof guard === "string") {
-    if (guard.startsWith("@")) return null;
-    return guard.length > 0;
-  }
-  if (!Array.isArray(guard) || guard.length === 0) return null;
-  const op = String(guard[0]);
-  const isLiteral = (x) => x === null || typeof x === "number" || typeof x === "boolean" || typeof x === "string" && !x.startsWith("@");
-  if (op === "=" || op === "==" || op === "eq") {
-    return isLiteral(guard[1]) && isLiteral(guard[2]) ? guard[1] === guard[2] : null;
-  }
-  if (op === "!=" || op === "ne" || op === "not-eq" || op === "neq") {
-    return isLiteral(guard[1]) && isLiteral(guard[2]) ? guard[1] !== guard[2] : null;
-  }
-  if (op === "not") {
-    const inner = constTruth(guard[1]);
-    return inner === null ? null : !inner;
-  }
-  if (op === "or") {
-    const subs = guard.slice(1).map(constTruth);
-    if (subs.some((s) => s === true)) return true;
-    if (subs.every((s) => s === false)) return false;
-    return null;
-  }
-  if (op === "and") {
-    const subs = guard.slice(1).map(constTruth);
-    if (subs.some((s) => s === false)) return false;
-    if (subs.every((s) => s === true)) return true;
-    return null;
-  }
-  return null;
-}
-function substituteVar(node, name, mapRef) {
-  if (typeof node === "string") {
-    if (node === `@${name}`) return mapRef([]) ?? node;
-    if (node.startsWith(`@${name}.`)) return mapRef(node.slice(name.length + 2).split(".")) ?? node;
-    return node;
-  }
-  if (Array.isArray(node)) {
-    if (node[0] === "fn" && node[1] === name) return node;
-    if (node[0] === "object/get" && typeof node[2] === "string" && node[1] === `@${name}`) {
-      return mapRef([node[2]]) ?? node;
-    }
-    return node.map((child) => substituteVar(child, name, mapRef));
-  }
-  if (typeof node === "object" && node !== null) {
-    const out = {};
-    for (const [k, v] of Object.entries(node)) out[k] = substituteVar(v, name, mapRef);
-    return out;
-  }
-  return node;
-}
-function readLiteralPath(value, path) {
-  let cur = value;
-  for (const seg of path) {
-    if (!isPlainRecord(cur)) return null;
-    const next = cur[seg];
-    cur = next === void 0 ? null : next;
-  }
-  return cur;
-}
-function hasKeys(p) {
-  return Object.keys(p).length > 0;
-}
-function buildLetPayloads(guard) {
-  const bindings = guard[1];
-  const bodyIdx = guard.length - 1;
-  if (!Array.isArray(bindings) || bodyIdx < 2) return null;
-  const pairs = [];
-  for (const b of bindings) {
-    if (!Array.isArray(b) || typeof b[0] !== "string" || b.length < 2) return null;
-    pairs.push([b[0], b[1]]);
-  }
-  const bindingRef = (value) => (path) => {
-    if (path.length === 0) return value;
-    if (typeof value === "string" && value.startsWith("@")) return `${value}.${path.join(".")}`;
-    if (isPlainRecord(value)) return readLiteralPath(value, path);
-    return void 0;
-  };
-  let body = guard[bodyIdx];
-  const values = pairs.map(([, v]) => v);
-  for (let i = 0; i < pairs.length; i++) {
-    for (let j = i + 1; j < pairs.length; j++) values[j] = substituteVar(values[j], pairs[i][0], bindingRef(values[i]));
-  }
-  for (let i = pairs.length - 1; i >= 0; i--) body = substituteVar(body, pairs[i][0], bindingRef(values[i]));
-  return buildGuardPayloads(body);
-}
-function buildIfPayloads(guard) {
-  if (guard.length < 3) return null;
-  const elseG = guard.length > 3 ? guard[3] : false;
-  const c = buildGuardPayloads(guard[1]);
-  const t = buildGuardPayloads(guard[2]);
-  const e = buildGuardPayloads(elseG);
-  const cc = constTruth(guard[1]);
-  const ct = constTruth(guard[2]);
-  const ce = constTruth(elseG);
-  const reach = (target) => {
-    const thenOk = cc !== false && ct !== !target;
-    if (thenOk) return mergePayloads(c.pass, target ? t.pass : t.fail);
-    const elseOk = cc !== true && ce !== !target;
-    if (elseOk) return mergePayloads(c.fail, target ? e.pass : e.fail);
-    return {};
-  };
-  return { pass: reach(true), fail: reach(false) };
-}
-function buildQuantifierPayloads(op, guard) {
-  const fn = guard[2];
-  if (!Array.isArray(fn) || fn[0] !== "fn" || typeof fn[1] !== "string" || fn.length < 3) return null;
-  const name = fn[1];
-  const body = fn[fn.length - 1];
-  const some = op === "array/some";
-  const listPath = extractPayloadFieldPath(guard[1]);
-  if (listPath) {
-    const sub = substituteVar(body, name, (p) => p.length > 0 ? `@payload.${p.join(".")}` : void 0);
-    const truth = constTruth(sub);
-    const built = buildGuardPayloads(sub);
-    const witness = truth === true ? { id: "mock-test-id" } : hasKeys(built.pass) && truth !== false ? built.pass : null;
-    const violator = truth === false ? { id: "mock-test-id" } : hasKeys(built.fail) && truth !== true ? built.fail : null;
-    const list = (el) => el ? nestedPayload(listPath, [el]) : {};
-    return some ? { pass: list(witness), fail: nestedPayload(listPath, []) } : { pass: list(witness), fail: list(violator) };
-  }
-  if (Array.isArray(guard[1])) {
-    const items = guard[1];
-    const per = items.map((item) => {
-      const sub = substituteVar(body, name, (p) => readLiteralPath(item, p));
-      return { truth: constTruth(sub), built: buildGuardPayloads(sub) };
-    });
-    const mergeAll = (pick, skip) => per.reduce((acc, x) => x.truth === skip ? acc : mergePayloads(acc, pick(x.built)), {});
-    const firstWhere = (ok, pick) => {
-      const hit = per.find((x) => ok(x.truth));
-      return hit ? pick(hit.built) : {};
-    };
-    return some ? {
-      pass: per.some((x) => x.truth === true) ? {} : firstWhere((t) => t !== false, (b) => b.pass),
-      fail: mergeAll((b) => b.fail, true)
-    } : {
-      pass: mergeAll((b) => b.pass, true),
-      fail: per.some((x) => x.truth === false) ? {} : firstWhere((t) => t !== true, (b) => b.fail)
-    };
-  }
-  return null;
-}
-function buildGridInBoundsPayloads(guard) {
-  const pos = guard[1];
-  const w = guard[2];
-  const h = guard[3];
-  const emptyGrid = typeof w === "number" && w <= 0 || typeof h === "number" && h <= 0;
-  const posPath = extractPayloadFieldPath(pos);
-  if (posPath) {
-    return {
-      pass: emptyGrid ? {} : nestedPayload(posPath, { x: 0, y: 0 }),
-      fail: nestedPayload(posPath, { x: -1, y: 0 })
-    };
-  }
-  if (!isPlainRecord(pos)) return null;
-  const axes = ["x", "y"].map((k) => ({ k, path: extractPayloadFieldPath(pos[k]) }));
-  const steered = axes.filter((a) => a.path !== null);
-  if (steered.length === 0) return null;
-  const pass = emptyGrid ? {} : steered.reduce((acc, a) => mergePayloads(acc, nestedPayload(a.path, 0)), {});
-  return { pass, fail: nestedPayload(steered[0].path, -1) };
-}
-function buildGuardPayloads(guard) {
-  if (constTruth(guard) !== null) {
-    return { pass: {}, fail: {} };
-  }
-  if (Array.isArray(guard) && typeof guard[0] === "string" && CONSTANT_GUARD_FORMS.has(guard[0])) {
-    return { pass: {}, fail: {} };
-  }
-  if (typeof guard === "string") {
-    const path = extractPayloadFieldPath(guard);
-    if (path) {
-      return path.length === 1 ? { pass: { [path[0]]: { id: "mock-test-id", name: "mock-test-name" } }, fail: { [path[0]]: null } } : { pass: nestedPayload(path, "mock-test-value"), fail: nestedPayload(path, null) };
-    }
-  }
-  if (!Array.isArray(guard) || guard.length === 0) {
-    return { pass: {}, fail: {} };
-  }
-  const op = String(guard[0]);
-  if (op === "not-nil" || op === "not_nil") {
-    const path = extractPayloadFieldPath(guard[1]);
-    if (path) return { pass: nestedPayload(path, "mock-test-value"), fail: nestedPayload(path, null) };
-  }
-  if (op === "nil") {
-    const path = extractPayloadFieldPath(guard[1]);
-    if (path) return { pass: {}, fail: nestedPayload(path, "mock-test-value") };
-  }
-  if (op === "eq" || op === "==" || op === "=" || op === "not-eq" || op === "!=" || op === "neq") {
-    const arrayPath = extractArrayLenPath(guard[1]);
-    if (arrayPath && typeof guard[2] === "number") {
-      const n = guard[2];
-      const equal = { hit: nestedPayload(arrayPath, arrayOfLength(n)), miss: nestedPayload(arrayPath, arrayOfLength(n + 1)) };
-      return op === "eq" || op === "==" || op === "=" ? { pass: equal.hit, fail: equal.miss } : { pass: equal.miss, fail: equal.hit };
-    }
-  }
-  if (op === "eq" || op === "==" || op === "=") {
-    const compared = payloadComparison(guard[1], guard[2]);
-    if (compared) {
-      const { path, val } = compared;
-      const failVal = typeof val === "number" ? val + 1 : typeof val === "string" ? `not-${val}` : null;
-      return { pass: nestedPayload(path, val), fail: nestedPayload(path, failVal) };
-    }
-    const objectGetPayload = buildObjectGetComparisonPayload(guard[1], guard[2], false);
-    if (objectGetPayload) return objectGetPayload;
-  }
-  if (op === "not-eq" || op === "!=" || op === "neq") {
-    const compared = payloadComparison(guard[1], guard[2]);
-    if (compared) {
-      const { path, val } = compared;
-      const passVal = typeof val === "number" ? val + 1 : typeof val === "string" ? `not-${val}` : "other";
-      return { pass: nestedPayload(path, passVal), fail: nestedPayload(path, val) };
-    }
-    const objectGetPayload = buildObjectGetComparisonPayload(guard[1], guard[2], true);
-    if (objectGetPayload) return objectGetPayload;
-  }
-  if (op === "gt" || op === ">") {
-    const arrayPath = extractArrayLenPath(guard[1]);
-    const n = typeof guard[2] === "number" ? guard[2] : 0;
-    if (arrayPath) return { pass: nestedPayload(arrayPath, arrayOfLength(n + 1)), fail: nestedPayload(arrayPath, arrayOfLength(n)) };
-    const path = extractPayloadFieldPath(guard[1]);
-    if (path) return { pass: nestedPayload(path, n + 1), fail: nestedPayload(path, n - 1) };
-  }
-  if (op === "gte" || op === ">=") {
-    const arrayPath = extractArrayLenPath(guard[1]);
-    const n = typeof guard[2] === "number" ? guard[2] : 0;
-    if (arrayPath) return { pass: nestedPayload(arrayPath, arrayOfLength(n)), fail: nestedPayload(arrayPath, arrayOfLength(n - 1)) };
-    const path = extractPayloadFieldPath(guard[1]);
-    if (path) return { pass: nestedPayload(path, n), fail: nestedPayload(path, n - 1) };
-  }
-  if (op === "lt" || op === "<") {
-    const arrayPath = extractArrayLenPath(guard[1]);
-    const n = typeof guard[2] === "number" ? guard[2] : 0;
-    if (arrayPath) return { pass: nestedPayload(arrayPath, arrayOfLength(n - 1)), fail: nestedPayload(arrayPath, arrayOfLength(n + 1)) };
-    const path = extractPayloadFieldPath(guard[1]);
-    if (path) return { pass: nestedPayload(path, n - 1), fail: nestedPayload(path, n + 1) };
-  }
-  if (op === "lte" || op === "<=") {
-    const arrayPath = extractArrayLenPath(guard[1]);
-    const n = typeof guard[2] === "number" ? guard[2] : 0;
-    if (arrayPath) return { pass: nestedPayload(arrayPath, arrayOfLength(n)), fail: nestedPayload(arrayPath, arrayOfLength(n + 1)) };
-    const path = extractPayloadFieldPath(guard[1]);
-    if (path) return { pass: nestedPayload(path, n), fail: nestedPayload(path, n + 1) };
-  }
-  if (op === "and") {
-    const subs = guard.slice(1);
-    if (subs.length >= 2) {
-      const built = subs.map(buildGuardPayloads);
-      const merged = built.reduce((acc, b) => mergePayloads(acc, b.pass), {});
-      const pass = applyFieldIntersections(subs, merged);
-      const canFail = subs.findIndex((g) => constTruth(g) !== true);
-      return { pass, fail: built[canFail >= 0 ? canFail : 0].fail };
-    }
-    if (subs.length === 1) return buildGuardPayloads(subs[0]);
-  }
-  if (op === "or") {
-    const subs = guard.slice(1);
-    if (subs.length >= 2) {
-      const s1 = buildGuardPayloads(subs[0]);
-      const s2 = buildGuardPayloads(subs[1]);
-      const combinedPass = Object.keys(s1.pass).length > 0 ? s1.pass : s2.pass;
-      return { pass: combinedPass, fail: mergePayloads(s1.fail, s2.fail) };
-    }
-    if (subs.length === 1) return buildGuardPayloads(subs[0]);
-  }
-  if (op === "let") {
-    const r = buildLetPayloads(guard);
-    if (r) return r;
-  }
-  if (op === "if") {
-    const r = buildIfPayloads(guard);
-    if (r) return r;
-  }
-  if (op === "array/some" || op === "array/every") {
-    const r = buildQuantifierPayloads(op, guard);
-    if (r) return r;
-  }
-  if (op === "grid/in-bounds") {
-    const r = buildGridInBoundsPayloads(guard);
-    if (r) return r;
-  }
-  if (op === "not") {
-    const inner = buildGuardPayloads(guard[1]);
-    return { pass: inner.fail, fail: inner.pass };
-  }
-  if (op === "object/has") {
-    const split = splitPayloadArg(guard[1], guard[2]);
-    if (split && isPlainRecord(split.collection)) {
-      const keys = Object.keys(split.collection);
-      if (keys.length > 0) {
-        return { pass: nestedPayload(split.path, keys[0]), fail: nestedPayload(split.path, absentKey(keys)) };
-      }
-    }
-  }
-  if (op === "object/get") {
-    const split = splitPayloadArg(guard[1], guard[2]);
-    if (split && isPlainRecord(split.collection)) {
-      const map = split.collection;
-      const keys = Object.keys(map);
-      const passKey = keys.find((k) => Boolean(map[k]));
-      if (passKey !== void 0) {
-        return { pass: nestedPayload(split.path, passKey), fail: nestedPayload(split.path, absentKey(keys)) };
-      }
-    }
-  }
-  if (op === "array/includes") {
-    const split = splitPayloadArg(guard[1], guard[2]);
-    if (split && Array.isArray(split.collection) && split.collection.length > 0) {
-      const passVal = split.collection[0];
-      const failVal = typeof passVal === "string" ? `${passVal}-not-in-list` : "not-in-list";
-      return { pass: nestedPayload(split.path, passVal), fail: nestedPayload(split.path, failVal) };
-    }
-  }
-  if (op === "str/startsWith") {
-    const path = extractPayloadFieldPath(guard[1]);
-    const prefix = typeof guard[2] === "string" ? guard[2] : "";
-    if (path) {
-      return {
-        pass: nestedPayload(path, `${prefix}mock-suffix`),
-        fail: nestedPayload(path, prefix.length > 0 ? `not-${prefix}` : "mock-test-value")
-      };
-    }
-  }
-  if (op === "validate/url") {
-    const path = extractPayloadFieldPath(guard[1]);
-    if (path) {
-      return { pass: nestedPayload(path, "https://example.test/mock"), fail: nestedPayload(path, "not-a-url") };
-    }
-  }
-  if (op === "validate/required") {
-    const path = extractPayloadFieldPath(guard[1]);
-    if (path) {
-      return { pass: nestedPayload(path, "mock-required-value"), fail: nestedPayload(path, "") };
-    }
-  }
-  if (op === "agent/is-pinned") {
-    const field = extractPayloadFieldRef(guard[1]);
-    if (field) return { pass: { [field]: "mem_test_unpinned" }, fail: { [field]: "mem_test_pinned" } };
-  }
-  if (op === "agent/memory-strength") {
-    const field = extractPayloadFieldRef(guard[1]);
-    if (field) return { pass: { [field]: "mem_test_id" }, fail: { [field]: "mem_nonexistent" } };
-  }
-  if (op.startsWith("agent/")) {
-    return { pass: {}, fail: {} };
-  }
-  if (!isRecognizedGuardOperator(op)) {
-    recordUnhandledOperator(op);
-  }
-  return { pass: {}, fail: {} };
-}
-
-// src/state-machine/replay-paths.ts
-var ENTITY_PAYLOAD_FIELDS = /* @__PURE__ */ new Set(["data", "row", "item", "id"]);
-function buildReplayPaths(transitions, initialState, maxDepth = 3) {
-  const queue = [{ state: initialState, path: [] }];
-  const replayPaths = /* @__PURE__ */ new Map();
-  replayPaths.set(initialState, []);
-  while (queue.length > 0) {
-    const { state, path } = queue.shift();
-    if (path.length >= maxDepth) continue;
-    const fromHere = transitions.filter(
-      (t) => t.from === state && t.event !== "INIT"
-    );
-    for (const transition of fromHere) {
-      if (replayPaths.has(transition.to)) continue;
-      const renderEffect = transition.renderEffects.find((re) => re.patternType !== null);
-      const stepNeedsEntityData = transition.hasGuard || transition.payloadFields.some((f) => ENTITY_PAYLOAD_FIELDS.has(f));
-      const step = {
-        event: transition.event,
-        fromState: state,
-        toState: transition.to,
-        slot: renderEffect?.slot ?? "main",
-        expectedPattern: renderEffect?.patternType ?? void 0,
-        needsEntityData: stepNeedsEntityData,
-        payloadSchema: transition.payloadSchema.length > 0 ? transition.payloadSchema : void 0
-      };
-      const newPath = [...path, step];
-      replayPaths.set(transition.to, newPath);
-      queue.push({ state: transition.to, path: newPath });
-    }
-  }
-  return replayPaths;
-}
-
-// src/state-machine/edge-walk.ts
-function buildEdgeCoveringWalk(transitions, initialState) {
-  const filtered = transitions.filter(
-    (t) => t.from !== "*" && !(t.event === "INIT" && t.from === initialState)
-  );
-  const graph = /* @__PURE__ */ new Map();
-  const allStates = /* @__PURE__ */ new Set();
-  for (const t of filtered) {
-    allStates.add(t.from);
-    allStates.add(t.to);
-    if (!graph.has(t.from)) graph.set(t.from, []);
-    graph.get(t.from).push({ event: t.event, to: t.to, transition: t });
-  }
-  allStates.add(initialState);
-  const uncovered = /* @__PURE__ */ new Set();
-  const edgeMeta = /* @__PURE__ */ new Map();
-  for (const t of filtered) {
-    if (t.hasGuard) {
-      const keyPass = `${t.from}+${t.event}->${t.to}[pass]`;
-      const keyFail = `${t.from}+${t.event}->${t.to}[fail]`;
-      uncovered.add(keyPass);
-      uncovered.add(keyFail);
-      edgeMeta.set(keyPass, { transition: t, guardCase: "pass" });
-      edgeMeta.set(keyFail, { transition: t, guardCase: "fail" });
-    } else {
-      const key = `${t.from}+${t.event}->${t.to}`;
-      uncovered.add(key);
-      edgeMeta.set(key, { transition: t, guardCase: null });
-    }
-  }
-  if (uncovered.size === 0) return [];
-  const shortestPaths = /* @__PURE__ */ new Map();
-  for (const state of allStates) {
-    shortestPaths.set(state, bfsShortestPaths(state, graph));
-  }
-  const walk = [];
-  let currentState = initialState;
-  const maxIterations = uncovered.size * allStates.size * 2;
-  let iterations = 0;
-  while (uncovered.size > 0 && iterations < maxIterations) {
-    iterations++;
-    const outgoing = findUncoveredEdges(currentState, graph, uncovered);
-    if (outgoing.length > 0) {
-      const pick = outgoing[0];
-      const payload = buildPayloadForEdge(pick.transition, pick.guardCase);
-      walk.push({
-        from: currentState,
-        event: pick.transition.event,
-        to: pick.transition.to,
-        guardCase: pick.guardCase,
-        payload,
-        isRepositioning: false
-      });
-      uncovered.delete(pick.key);
-      if (pick.guardCase !== "fail") {
-        currentState = pick.transition.to;
-      }
-    } else {
-      const target = findNearestUncoveredState(currentState, graph, uncovered, shortestPaths);
-      if (!target) {
-        break;
-      }
-      const repoPath = shortestPaths.get(currentState)?.get(target);
-      if (!repoPath || repoPath.length === 0) break;
-      for (const step of repoPath) {
-        walk.push({
-          from: currentState,
-          event: step.event,
-          to: step.to,
-          guardCase: null,
-          payload: {},
-          isRepositioning: true
-        });
-        currentState = step.to;
-      }
-    }
-  }
-  return walk;
-}
-function bfsShortestPaths(source, graph) {
-  const paths = /* @__PURE__ */ new Map();
-  const visited = /* @__PURE__ */ new Set([source]);
-  const queue = [
-    { state: source, path: [] }
-  ];
-  while (queue.length > 0) {
-    const { state, path } = queue.shift();
-    const edges = graph.get(state) ?? [];
-    for (const edge of edges) {
-      if (visited.has(edge.to)) continue;
-      visited.add(edge.to);
-      const newPath = [...path, { event: edge.event, to: edge.to }];
-      paths.set(edge.to, newPath);
-      queue.push({ state: edge.to, path: newPath });
-    }
-  }
-  return paths;
-}
-function findUncoveredEdges(state, graph, uncovered) {
-  const edges = graph.get(state) ?? [];
-  const result = [];
-  for (const edge of edges) {
-    if (edge.transition.hasGuard) {
-      const keyPass = `${state}+${edge.event}->${edge.to}[pass]`;
-      const keyFail = `${state}+${edge.event}->${edge.to}[fail]`;
-      if (uncovered.has(keyPass)) {
-        result.push({ key: keyPass, transition: edge.transition, guardCase: "pass" });
-      }
-      if (uncovered.has(keyFail)) {
-        result.push({ key: keyFail, transition: edge.transition, guardCase: "fail" });
-      }
-    } else {
-      const key = `${state}+${edge.event}->${edge.to}`;
-      if (uncovered.has(key)) {
-        result.push({ key, transition: edge.transition, guardCase: null });
-      }
-    }
-  }
-  return result;
-}
-function findNearestUncoveredState(currentState, graph, uncovered, shortestPaths) {
-  const statesWithUncovered = /* @__PURE__ */ new Set();
-  for (const key of uncovered) {
-    const fromState = key.split("+")[0];
-    statesWithUncovered.add(fromState);
-  }
-  if (statesWithUncovered.has(currentState)) return currentState;
-  const paths = shortestPaths.get(currentState);
-  if (!paths) return null;
-  let nearestState = null;
-  let nearestDist = Infinity;
-  for (const target of statesWithUncovered) {
-    const path = paths.get(target);
-    if (path && path.length < nearestDist) {
-      nearestDist = path.length;
-      nearestState = target;
-    }
-  }
-  return nearestState;
-}
-function buildPayloadForEdge(transition, guardCase) {
-  if (transition.hasGuard && transition.guard && guardCase) {
-    const payloads = buildGuardPayloads(transition.guard);
-    return guardCase === "pass" ? payloads.pass : payloads.fail;
-  }
-  if (transition.payloadSchema && transition.payloadSchema.length > 0) {
-    const payload = {};
-    for (const field of transition.payloadSchema) {
-      if (field.mockValue !== void 0) {
-        payload[field.name] = field.mockValue;
-      } else if (field.type === "string") {
-        payload[field.name] = `mock-${field.name}`;
-      } else if (field.type === "number") {
-        payload[field.name] = 1;
-      } else if (field.type === "boolean") {
-        payload[field.name] = true;
-      } else if (field.type === "object" || field.type === "any") {
-        payload[field.name] = {};
-      } else {
-        payload[field.name] = `mock-${field.name}`;
-      }
-    }
-    return payload;
-  }
-  return {};
-}
-
-export { buildEdgeCoveringWalk, buildGuardPayloads, buildReplayPaths, buildStateGraph, collectReachableStates, constTruth, extractPayloadFieldPath, extractPayloadFieldRef, walkStatePairs };
-//# sourceMappingURL=chunk-GIUA3NUJ.js.map
-//# sourceMappingURL=chunk-GIUA3NUJ.js.map