@almadar/core 10.83.0 → 10.84.0

package/dist/index.js

@@ -65593,6 +65593,61 @@ function nestedPayload(path, leaf) {
 function isPayloadObject(v) {
   return typeof v === "object" && v !== null && !Array.isArray(v) && !(v instanceof Date);
 }
+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",
+  "agent/is-pinned",
+  "agent/memory-strength"
+]);
+var ACKNOWLEDGED_UNSYNTHESIZED_GUARD_OPERATORS = /* @__PURE__ */ new Set(["if", "let", "array/some", "grid/in-bounds"]);
+function isRecognizedGuardOperator(op) {
+  return SYNTHESIZED_GUARD_OPERATORS.has(op) || ACKNOWLEDGED_UNSYNTHESIZED_GUARD_OPERATORS.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)) {
@@ -65715,6 +65770,44 @@ function buildGuardPayloads(guard) {
     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 === "agent/is-pinned") {
     const field = extractPayloadFieldRef(guard[1]);
     if (field) return { pass: { [field]: "mem_test_unpinned" }, fail: { [field]: "mem_test_pinned" } };
@@ -65726,6 +65819,9 @@ function buildGuardPayloads(guard) {
   if (op.startsWith("agent/")) {
     return { pass: {}, fail: {} };
   }
+  if (!isRecognizedGuardOperator(op)) {
+    recordUnhandledOperator(op);
+  }
   return { pass: {}, fail: {} };
 }