@runcofactor/cli 0.13.0 → 0.15.0

package/dist/{src-BGDRMOKC.js → src-UEOOC425.js}

@@ -1,30 +1,32 @@
 import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
 import {
   reconstructSnapshots
-} from "./chunk-CRHPDPRS.js";
+} from "./chunk-KCHKFYVX.js";
 import {
   buildLocatorString
 } from "./chunk-5GD47G2D.js";
 import {
-  captureSubstrateV2
-} from "./chunk-QQVWGWPI.js";
+  applyCustomAugmentors,
+  captureSubstrateV2,
+  parseSnapshot
+} from "./chunk-VGYN2KU2.js";
 import "./chunk-JWHYXEA2.js";
 import {
   MACRO_PATTERN,
   isVolatileIdentifier,
   stableAttrSelector,
   stableIdentifierPrefix
-} from "./chunk-QGI4UCJX.js";
+} from "./chunk-JYGNMKZ5.js";
 import "./chunk-6LEZCKKV.js";
 import {
   consoleLogger
-} from "./chunk-ZD3KHESI.js";
+} from "./chunk-KRWRUU6R.js";
 import "./chunk-VKVL7WBN.js";
 
 // ../workflow-cache/src/logger.ts
 var activeLogger = consoleLogger;
-function setWorkflowCacheLogger(logger3) {
-  activeLogger = logger3;
+function setWorkflowCacheLogger(logger4) {
+  activeLogger = logger4;
 }
 function createLogger(bindings) {
   if (!bindings || Object.keys(bindings).length === 0) {
@@ -53,8 +55,8 @@ function sortObjectKeys(obj) {
   }
   if (obj !== null && typeof obj === "object") {
     const sorted = Object.keys(obj).sort().reduce(
-      (acc, key) => {
-        acc[key] = sortObjectKeys(obj[key]);
+      (acc, key2) => {
+        acc[key2] = sortObjectKeys(obj[key2]);
         return acc;
       },
       {}
@@ -64,10 +66,26 @@ function sortObjectKeys(obj) {
   return obj;
 }
 function generateNodeHash(input) {
+  return hashWithPrefix(input, HASH_VERSION);
+}
+function generateNodeHashV3(input) {
+  const { playbookSteps: _playbookSteps, inlineAssertions, ...identity } = input;
+  const v3Input = {
+    ...identity,
+    ...inlineAssertions ? {
+      inlineAssertions: inlineAssertions.map(({ condition, agentic }) => ({
+        condition,
+        ...agentic !== void 0 ? { agentic } : {}
+      }))
+    } : {}
+  };
+  return hashWithPrefix(v3Input, "v3");
+}
+function hashWithPrefix(input, version) {
   const sortedInput = sortObjectKeys(input);
   const stableJson = JSON.stringify(sortedInput);
   const hash = createHash("sha256").update(stableJson).digest("hex").slice(0, 16);
-  return `${HASH_VERSION}:${hash}`;
+  return `${version}:${hash}`;
 }
 
 // ../workflow-cache/src/build-locator.ts
@@ -95,6 +113,15 @@ function buildLocator(snapshot, ref, variableValues = {}) {
   const frameContext = frameContextFor(target.el);
   const baseDynamicText = buildDynamicText(target);
   const ancestors = ancestorChain(target);
+  const augmentorAnchor = target.el.augmentorAnchor;
+  if (augmentorAnchor) {
+    return {
+      selectors: applyContexts({ css: augmentorAnchor }, frameContext, baseDynamicText),
+      predicate: "augmentorAnchor",
+      bindings: allBindings,
+      irreducible: false
+    };
+  }
   const uniqueTestId = pickUniqueTestId(target, flat);
   if (uniqueTestId) {
     return {
@@ -366,12 +393,12 @@ function buildRowScopedOrdinalLocator(args) {
     const buttonRefs = collectRoleRefs(anchor.el, "button");
     const ordinal = buttonRefs.indexOf(args.target.el.ref);
     if (ordinal < 0) continue;
-    const [key, value] = match;
+    const [key2, value] = match;
     return {
-      locator: `getByRole('${escapeLocatorString(anchor.el.role)}').filter({ hasText: '{{var.${key}}}' }).getByRole('button').nth(${ordinal})`,
+      locator: `getByRole('${escapeLocatorString(anchor.el.role)}').filter({ hasText: '{{var.${key2}}}' }).getByRole('button').nth(${ordinal})`,
       anchor,
       innerAncestors: args.ancestors.slice(i + 1),
-      key,
+      key: key2,
       value
     };
   }
@@ -392,8 +419,8 @@ function escapeLocatorString(value) {
 var MIN_TEMPLATING_LENGTH = 3;
 function templateAll(flat, variableValues) {
   const summary = /* @__PURE__ */ new Map();
-  const compiled = Object.entries(variableValues).filter(([, v]) => typeof v === "string" && v.length >= MIN_TEMPLATING_LENGTH).map(([key, value]) => ({
-    key,
+  const compiled = Object.entries(variableValues).filter(([, v]) => typeof v === "string" && v.length >= MIN_TEMPLATING_LENGTH).map(([key2, value]) => ({
+    key: key2,
     value,
     regex: new RegExp(`(^|\\W)${escapeRegex(value)}(?=\\W|$)`, "g")
   }));
@@ -870,12 +897,12 @@ function findRowVariableScope(args) {
       continue;
     }
     const anchorText = collectSubtreeText(anchor.el);
-    for (const [key, value] of entries) {
+    for (const [key2, value] of entries) {
       if (!textContainsValue(anchorText, value)) continue;
       return {
         anchor,
         innerAncestors: args.ancestors.slice(i + 1),
-        key,
+        key: key2,
         value
       };
     }
@@ -977,9 +1004,9 @@ function parseLine(line) {
   if (cleanContent.startsWith("/")) {
     const colonIdx = cleanContent.indexOf(":");
     if (colonIdx !== -1) {
-      const key = cleanContent.slice(1, colonIdx).trim();
+      const key2 = cleanContent.slice(1, colonIdx).trim();
       const value = cleanContent.slice(colonIdx + 1).trim();
-      return { indent, role: "_property", attributes: { [key]: value } };
+      return { indent, role: "_property", attributes: { [key2]: value } };
     }
   }
   if (withoutBrackets.startsWith('"') && withoutBrackets.endsWith('"')) {
@@ -1005,9 +1032,9 @@ function parseLine(line) {
   const attributes = {};
   const attrMatches = cleanContent.matchAll(/\[(\w+)=([^\]]+)\]/g);
   for (const match of attrMatches) {
-    const [, key, value] = match;
-    if (key !== "ref") {
-      attributes[key] = value;
+    const [, key2, value] = match;
+    if (key2 !== "ref") {
+      attributes[key2] = value;
     }
   }
   return {
@@ -1414,11 +1441,11 @@ function escapeForLocatorString(value) {
   return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
 }
 function hydrateLocatorVariables(locatorStr, variableValues) {
-  return locatorStr.replace(/\{\{var\.([a-zA-Z0-9_]+)\}\}/g, (_match, key) => {
-    const value = variableValues[key];
+  return locatorStr.replace(/\{\{var\.([a-zA-Z0-9_]+)\}\}/g, (_match, key2) => {
+    const value = variableValues[key2];
     if (value === void 0) {
-      getLogger().warn("[LocatorParser] Variable placeholder not found in values", { key });
-      return `{{var.${key}}}`;
+      getLogger().warn("[LocatorParser] Variable placeholder not found in values", { key: key2 });
+      return `{{var.${key2}}}`;
     }
     return escapeForLocatorString(value);
   });
@@ -1585,7 +1612,7 @@ function parseObjectArg(input) {
   for (const pair of pairs) {
     const colonIdx = pair.indexOf(":");
     if (colonIdx === -1) continue;
-    const key = pair.slice(0, colonIdx).trim().replace(/^['"]|['"]$/g, "");
+    const key2 = pair.slice(0, colonIdx).trim().replace(/^['"]|['"]$/g, "");
     const rawValue = pair.slice(colonIdx + 1).trim();
     if (rawValue.startsWith("'") || rawValue.startsWith('"')) {
       const q = rawValue[0];
@@ -1594,20 +1621,20 @@ function parseObjectArg(input) {
         if (rawValue[end] === "\\") end++;
         end++;
       }
-      obj[key] = rawValue.slice(1, end).replace(/\\'/g, "'").replace(/\\"/g, '"');
+      obj[key2] = rawValue.slice(1, end).replace(/\\'/g, "'").replace(/\\"/g, '"');
     } else if (rawValue.startsWith("/")) {
       const regexMatch = rawValue.match(/^\/([^/]+)\/([gimsuy]*)/);
       if (regexMatch) {
-        obj[key] = new RegExp(regexMatch[1], regexMatch[2]);
+        obj[key2] = new RegExp(regexMatch[1], regexMatch[2]);
       }
     } else if (rawValue === "true") {
-      obj[key] = true;
+      obj[key2] = true;
     } else if (rawValue === "false") {
-      obj[key] = false;
+      obj[key2] = false;
     } else if (/^-?\d+$/.test(rawValue)) {
-      obj[key] = parseInt(rawValue, 10);
+      obj[key2] = parseInt(rawValue, 10);
     } else {
-      obj[key] = rawValue;
+      obj[key2] = rawValue;
     }
   }
   return { value: obj, rest };
@@ -3368,8 +3395,8 @@ async function resolveElement(page, selectors, _timeoutMs, options) {
     errors.push(`CSS selector ("${selectors.css}") found no matches`);
   }
   if (selectors.dynamicText && options?.variableValues && selectors.role && !requireSelect && !skipHeuristicFallbacks) {
-    const { key } = selectors.dynamicText;
-    const currentValue = options.variableValues[key];
+    const { key: key2 } = selectors.dynamicText;
+    const currentValue = options.variableValues[key2];
     if (currentValue) {
       logger().debug("[ElementResolver] Trying structural fallback for dynamic text", {
         role: selectors.role.role,
@@ -3585,15 +3612,15 @@ function deriveSelectorsFromElementInfo(elementInfo) {
 }
 function sanitizeArgsForCache(args) {
   const sanitized = {};
-  for (const [key, value] of Object.entries(args)) {
-    if (key === "ref" || key === "startRef" || key === "endRef") {
+  for (const [key2, value] of Object.entries(args)) {
+    if (key2 === "ref" || key2 === "startRef" || key2 === "endRef") {
       continue;
     }
-    if (key === "signal" || key === "timeoutMs") {
+    if (key2 === "signal" || key2 === "timeoutMs") {
       continue;
     }
     if (Array.isArray(value)) {
-      sanitized[key] = value.map((item) => {
+      sanitized[key2] = value.map((item) => {
         if (typeof item === "object" && item !== null) {
           return sanitizeArgsForCache(item);
         }
@@ -3601,7 +3628,7 @@ function sanitizeArgsForCache(args) {
       });
       continue;
     }
-    sanitized[key] = value;
+    sanitized[key2] = value;
   }
   return sanitized;
 }
@@ -3754,12 +3781,12 @@ async function findRowAnchor(originalLocator, timeoutMs) {
           const t = raw.trim();
           if (t.length < 3) return;
           if (t.length > 120) return;
-          const key = t.toLowerCase();
-          if (key === targetText) return;
-          if (targetText.length > 0 && key.includes(targetText)) return;
-          if (targetText.length > 0 && targetText.includes(key)) return;
-          if (seen.has(key)) return;
-          seen.add(key);
+          const key2 = t.toLowerCase();
+          if (key2 === targetText) return;
+          if (targetText.length > 0 && key2.includes(targetText)) return;
+          if (targetText.length > 0 && targetText.includes(key2)) return;
+          if (seen.has(key2)) return;
+          seen.add(key2);
           texts.push(t);
         };
         if (ariaLabel) pushText(ariaLabel);
@@ -3814,7 +3841,7 @@ async function findRowAnchor(originalLocator, timeoutMs) {
 }
 async function discoverParentContext(page, selectors, selectorType, originalLocator, options) {
   const { timeoutMs, maxParentDepth } = options;
-  const logger3 = getLogger2();
+  const logger4 = getLogger2();
   const context = selectors.frameContext?.selector ? page.frameLocator(selectors.frameContext.selector) : page;
   try {
     const rowCandidate = await findRowAnchor(originalLocator, timeoutMs);
@@ -3833,7 +3860,7 @@ async function discoverParentContext(page, selectors, selectorType, originalLoca
           if (!resolved) continue;
           const isSame = await isSameDOMElement(page, originalLocator, resolved, timeoutMs);
           if (!isSame) continue;
-          logger3.debug("[SelectorDerivation] Found unique row anchor", {
+          logger4.debug("[SelectorDerivation] Found unique row anchor", {
             selectorType,
             parentContext: candidateParent
           });
@@ -3844,7 +3871,7 @@ async function discoverParentContext(page, selectors, selectorType, originalLoca
       }
     }
   } catch (err) {
-    logger3.debug("[SelectorDerivation] Row-anchor strategy error", {
+    logger4.debug("[SelectorDerivation] Row-anchor strategy error", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
@@ -3937,7 +3964,7 @@ async function discoverParentContext(page, selectors, selectorType, originalLoca
           if (resolved) {
             const isSame = await isSameDOMElement(page, originalLocator, resolved, timeoutMs);
             if (!isSame) {
-              logger3.debug(
+              logger4.debug(
                 "[SelectorDerivation] Parent-scoped selector resolved to wrong element, skipping",
                 {
                   selectorType,
@@ -3946,7 +3973,7 @@ async function discoverParentContext(page, selectors, selectorType, originalLoca
               );
               continue;
             }
-            logger3.debug("[SelectorDerivation] Found unique parent via simple scoping", {
+            logger4.debug("[SelectorDerivation] Found unique parent via simple scoping", {
               selectorType,
               parentContext: candidateParent
             });
@@ -3958,7 +3985,7 @@ async function discoverParentContext(page, selectors, selectorType, originalLoca
       }
     }
   } catch (err) {
-    logger3.debug("[SelectorDerivation] Error in simple parent scoping", {
+    logger4.debug("[SelectorDerivation] Error in simple parent scoping", {
       error: err instanceof Error ? err.message : String(err)
     });
   }
@@ -4079,7 +4106,7 @@ async function discoverParentContext(page, selectors, selectorType, originalLoca
   }
   const targetEl = elementAncestries.find((e) => e.isTarget);
   if (!targetEl) {
-    logger3.warn("[SelectorDerivation] Target not found by DOM identity in ancestry search");
+    logger4.warn("[SelectorDerivation] Target not found by DOM identity in ancestry search");
     return null;
   }
   for (let depth = 0; depth < maxParentDepth; depth++) {
@@ -4098,7 +4125,7 @@ async function discoverParentContext(page, selectors, selectorType, originalLoca
     try {
       const resolved = await resolveElement(page, strategyWithChain, timeoutMs, { mode: "verify" });
       if (resolved) {
-        logger3.debug("[SelectorDerivation] Found unique parent chain via recursive search", {
+        logger4.debug("[SelectorDerivation] Found unique parent chain via recursive search", {
           depth,
           parentChain
         });
@@ -4108,7 +4135,7 @@ async function discoverParentContext(page, selectors, selectorType, originalLoca
       continue;
     }
   }
-  logger3.warn("[SelectorDerivation] No unique parent found, using matchIndex fallback", {
+  logger4.warn("[SelectorDerivation] No unique parent found, using matchIndex fallback", {
     targetIndex: targetEl.index,
     matchCount: count
   });
@@ -4117,7 +4144,7 @@ async function discoverParentContext(page, selectors, selectorType, originalLoca
   };
 }
 async function probeChildIconCSS(page, originalLocator, role) {
-  const logger3 = getLogger2();
+  const logger4 = getLogger2();
   const iconAttr = await originalLocator.evaluate((el) => {
     const svg = el.querySelector("svg[data-icon]");
     return svg?.getAttribute("data-icon") ?? null;
@@ -4127,7 +4154,7 @@ async function probeChildIconCSS(page, originalLocator, role) {
   try {
     const count = await page.locator(baseSelector).count();
     if (count === 1) {
-      logger3.debug("[SelectorDerivation] probeChildIconCSS found unique selector", {
+      logger4.debug("[SelectorDerivation] probeChildIconCSS found unique selector", {
         css: baseSelector
       });
       return baseSelector;
@@ -4141,7 +4168,7 @@ async function probeChildIconCSS(page, originalLocator, role) {
           const hasMarker = await matches.nth(i).evaluate((el, attr) => el.hasAttribute(attr), MARKER);
           if (hasMarker) {
             const nthSelector = `${baseSelector} >> nth=${i}`;
-            logger3.debug("[SelectorDerivation] probeChildIconCSS disambiguated via nth", {
+            logger4.debug("[SelectorDerivation] probeChildIconCSS disambiguated via nth", {
               css: nthSelector,
               matchCount: count,
               index: i
@@ -4154,7 +4181,7 @@ async function probeChildIconCSS(page, originalLocator, role) {
         });
       }
     }
-    logger3.debug("[SelectorDerivation] probeChildIconCSS could not disambiguate", {
+    logger4.debug("[SelectorDerivation] probeChildIconCSS could not disambiguate", {
       css: baseSelector,
       count
     });
@@ -4164,7 +4191,7 @@ async function probeChildIconCSS(page, originalLocator, role) {
   }
 }
 async function probeElementIdCSS(page, originalLocator) {
-  const logger3 = getLogger2();
+  const logger4 = getLogger2();
   const elementId = await originalLocator.evaluate((el) => {
     if (el.id) return el.id;
     const child = el.querySelector("[id]");
@@ -4175,7 +4202,7 @@ async function probeElementIdCSS(page, originalLocator) {
   try {
     const count = await page.locator(baseSelector).count();
     if (count === 1) {
-      logger3.debug("[SelectorDerivation] probeElementIdCSS found unique selector", {
+      logger4.debug("[SelectorDerivation] probeElementIdCSS found unique selector", {
         css: baseSelector
       });
       return baseSelector;
@@ -4198,7 +4225,7 @@ async function probeElementIdCSS(page, originalLocator) {
         }
       }
       if (visibleCount === 1 && targetIsOnlyVisible) {
-        logger3.debug("[SelectorDerivation] probeElementIdCSS: single visible among duplicates", {
+        logger4.debug("[SelectorDerivation] probeElementIdCSS: single visible among duplicates", {
           css: baseSelector,
           matchCount: count
         });
@@ -4212,7 +4239,7 @@ async function probeElementIdCSS(page, originalLocator) {
           const hasMarker = await matches.nth(i).evaluate((el, attr) => el.hasAttribute(attr), MARKER);
           if (hasMarker) {
             const nthSelector = `${baseSelector} >> nth=${i}`;
-            logger3.debug("[SelectorDerivation] probeElementIdCSS disambiguated via nth", {
+            logger4.debug("[SelectorDerivation] probeElementIdCSS disambiguated via nth", {
               css: nthSelector,
               matchCount: count,
               index: i
@@ -4225,7 +4252,7 @@ async function probeElementIdCSS(page, originalLocator) {
         });
       }
     }
-    logger3.debug("[SelectorDerivation] probeElementIdCSS could not disambiguate", {
+    logger4.debug("[SelectorDerivation] probeElementIdCSS could not disambiguate", {
       css: baseSelector,
       count
     });
@@ -4235,14 +4262,14 @@ async function probeElementIdCSS(page, originalLocator) {
   }
 }
 async function probeTitleCSS(page, originalLocator) {
-  const logger3 = getLogger2();
+  const logger4 = getLogger2();
   const titleAttr = await originalLocator.evaluate((el) => el.getAttribute("title")).catch(() => null);
   if (!titleAttr) return void 0;
   const baseSelector = `[title="${titleAttr}"]`;
   try {
     const count = await page.locator(baseSelector).count();
     if (count === 1) {
-      logger3.debug("[SelectorDerivation] probeTitleCSS found unique selector", {
+      logger4.debug("[SelectorDerivation] probeTitleCSS found unique selector", {
         css: baseSelector
       });
       return baseSelector;
@@ -4256,7 +4283,7 @@ async function probeTitleCSS(page, originalLocator) {
           const hasMarker = await matches.nth(i).evaluate((el, attr) => el.hasAttribute(attr), MARKER);
           if (hasMarker) {
             const nthSelector = `${baseSelector} >> nth=${i}`;
-            logger3.debug("[SelectorDerivation] probeTitleCSS disambiguated via nth", {
+            logger4.debug("[SelectorDerivation] probeTitleCSS disambiguated via nth", {
               css: nthSelector,
               matchCount: count,
               index: i
@@ -4269,7 +4296,7 @@ async function probeTitleCSS(page, originalLocator) {
         });
       }
     }
-    logger3.debug("[SelectorDerivation] probeTitleCSS could not disambiguate", {
+    logger4.debug("[SelectorDerivation] probeTitleCSS could not disambiguate", {
       css: baseSelector,
       count
     });
@@ -4375,7 +4402,7 @@ async function probeAncestorRowIndex(elementLocator, timeoutMs = 3e3) {
 }
 async function verifySingleSelector(page, selectors, selectorType, originalLocator, options) {
   const { timeoutMs } = options;
-  const logger3 = getLogger2();
+  const logger4 = getLogger2();
   const result = {
     selectorType,
     verified: false,
@@ -4395,11 +4422,11 @@ async function verifySingleSelector(page, selectors, selectorType, originalLocat
       result.verified = true;
       return result;
     }
-    logger3.debug("[SelectorDerivation] Initial resolution failed, trying parent disambiguation", {
+    logger4.debug("[SelectorDerivation] Initial resolution failed, trying parent disambiguation", {
       selectorType
     });
     if (selectors.itemIndex !== void 0 || selectors.rowIndex !== void 0) {
-      logger3.debug("[SelectorDerivation] Data attributes present but did not disambiguate", {
+      logger4.debug("[SelectorDerivation] Data attributes present but did not disambiguate", {
         selectorType,
         itemIndex: selectors.itemIndex,
         rowIndex: selectors.rowIndex
@@ -4552,9 +4579,9 @@ var DYNAMIC_TEXT_MIN_RATIO = 0.4;
 var DYNAMIC_TEXT_DISTINCTIVE_LENGTH = 8;
 function buildDynamicValueEntries(variableValues) {
   const entries = [];
-  for (const [key, value] of Object.entries(variableValues)) {
+  for (const [key2, value] of Object.entries(variableValues)) {
     if (typeof value !== "string" || value.length < DYNAMIC_TEXT_MIN_LENGTH) continue;
-    entries.push({ source: "inputValue", key, value });
+    entries.push({ source: "inputValue", key: key2, value });
   }
   entries.sort((a, b) => b.value.length - a.value.length);
   return entries;
@@ -4709,9 +4736,9 @@ function hydrateDynamicSelectors(selectors, variableValues) {
   }
   const dynamicText = hydrated.dynamicText;
   if (!dynamicText) return hydrated;
-  const { key, originalText } = dynamicText;
+  const { key: key2, originalText } = dynamicText;
   selectors = hydrated;
-  const currentValue = variableValues[key];
+  const currentValue = variableValues[key2];
   if (!currentValue || currentValue === originalText) {
     return selectors;
   }
@@ -4720,7 +4747,7 @@ function hydrateDynamicSelectors(selectors, variableValues) {
     getLogger2().warn(
       "[SelectorDerivation] Full-field replacement triggered due to stale surrounding text",
       {
-        key,
+        key: key2,
         originalText,
         currentValue,
         roleName: selectors.role?.name,
@@ -4736,8 +4763,8 @@ function hydrateDynamicSelectors(selectors, variableValues) {
   return nextSelectors;
 }
 function hydratePlaywrightLocatorVariables(locator, variableValues) {
-  return locator.replace(/\{\{var\.([a-zA-Z0-9_]+)\}\}/g, (match, key) => {
-    const value = variableValues[key];
+  return locator.replace(/\{\{var\.([a-zA-Z0-9_]+)\}\}/g, (match, key2) => {
+    const value = variableValues[key2];
     if (value === void 0) return match;
     return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   });
@@ -4827,9 +4854,9 @@ var escapeRegex3 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 var STRING_LITERAL = /'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"/g;
 function replaceVariableValuesInString(input, sortedEntries) {
   let out = input;
-  for (const [key, value] of sortedEntries) {
+  for (const [key2, value] of sortedEntries) {
     if (!value || out.indexOf(value) === -1) continue;
-    out = out.replace(new RegExp(escapeRegex3(value), "g"), `$var.${key}`);
+    out = out.replace(new RegExp(escapeRegex3(value), "g"), `$var.${key2}`);
   }
   return out;
 }
@@ -4846,21 +4873,21 @@ function endsWithOddBackslashes(s) {
   return count % 2 === 1;
 }
 function rewriteStringLiteralInner(inner, quote, sortedEntries) {
-  for (const [key, value] of sortedEntries) {
+  for (const [key2, value] of sortedEntries) {
     if (!value || inner.indexOf(value) === -1) continue;
-    if (inner === value) return `$var.${key}`;
+    if (inner === value) return `$var.${key2}`;
     const parts = inner.split(value);
     if (parts.some((p) => p.length > 0 && endsWithOddBackslashes(p))) continue;
     const pieces = [];
     for (let i = 0; i < parts.length; i++) {
       const segment = parts[i];
       if (segment.length > 0) pieces.push(`${quote}${segment}${quote}`);
-      if (i < parts.length - 1) pieces.push(`$var.${key}`);
+      if (i < parts.length - 1) pieces.push(`$var.${key2}`);
     }
     const rebuilt = pieces.join(" + ");
     return replaceVariableValuesInJsExpression(
       rebuilt,
-      sortedEntries.filter(([k]) => k !== key)
+      sortedEntries.filter(([k]) => k !== key2)
     );
   }
   return `${quote}${inner}${quote}`;
@@ -5103,7 +5130,7 @@ var HeadlessDomSession = class {
 
 // ../workflow-cache/src/optimizer/trace-node-segmenter.ts
 var STEP_GROUP = /^Step (\d+): (.*)$/;
-var CACHE_REPLAY_GROUP = /^Cache Replay: (.*)$/;
+var CACHE_REPLAY_GROUP = /^Cache Replay(?: (\d+))?: (.*)$/;
 var INTERNAL_GROUP_PREFIX = "Canary Internal:";
 function segmentTraceByNode(groups, actions) {
   const nodeGroups = groups.filter(
@@ -5114,10 +5141,11 @@ function segmentTraceByNode(groups, actions) {
     const stepMatch = STEP_GROUP.exec(g.name);
     const replayMatch = CACHE_REPLAY_GROUP.exec(g.name);
     const effectiveEnd = g.endTime ?? sorted[idx + 1]?.startTime;
+    const stepNumberRaw = stepMatch ? stepMatch[1] : replayMatch?.[1];
     return {
       kind: stepMatch ? "agent-step" : "cache-replay",
-      stepNumber: stepMatch ? Number(stepMatch[1]) : void 0,
-      label: stepMatch ? stepMatch[2] : replayMatch[1],
+      stepNumber: stepNumberRaw !== void 0 ? Number(stepNumberRaw) : void 0,
+      label: stepMatch ? stepMatch[2] : replayMatch[2],
       groupCallId: g.callId,
       startTime: g.startTime,
       endTime: effectiveEnd,
@@ -5150,10 +5178,28 @@ function segmentTraceByNode(groups, actions) {
   }
   return segments;
 }
+function resolveSegmentNodeIds(segments, steps) {
+  let cursor = 0;
+  return segments.map((segment) => {
+    if (segment.stepNumber !== void 0) {
+      const idx = segment.stepNumber - 1;
+      cursor = Math.max(cursor, idx + 1);
+      return steps[idx]?.nodeId ?? null;
+    }
+    for (let j = cursor; j < steps.length; j++) {
+      if (steps[j].label === segment.label) {
+        cursor = j + 1;
+        return steps[j].nodeId;
+      }
+    }
+    return null;
+  });
+}
 
 // ../workflow-cache/src/optimizer/substrate-materializer.ts
 import { mkdir, writeFile } from "fs/promises";
 import path from "path";
+import { pathToFileURL } from "url";
 var logger2 = createLogger({ module: "SubstrateMaterializer" });
 var SubstrateMaterializer = class {
   constructor(opts) {
@@ -5171,8 +5217,8 @@ var SubstrateMaterializer = class {
    * `'after'` is its result (the next action's context).
    */
   async materialize(actionIndex, phase = "before") {
-    const key = `${actionIndex}:${phase}`;
-    const hit = this.cache.get(key);
+    const key2 = `${actionIndex}:${phase}`;
+    const hit = this.cache.get(key2);
     if (hit) return hit;
     const results = await reconstructSnapshots({
       traceZipPath: this.opts.traceZipPath,
@@ -5189,14 +5235,14 @@ var SubstrateMaterializer = class {
       );
     }
     await mkdir(this.opts.outDir, { recursive: true });
-    const domPath = path.join(this.opts.outDir, `${actionIndex}.${phase}.dom.html`);
+    const domPath = path.resolve(this.opts.outDir, `${actionIndex}.${phase}.dom.html`);
     await writeFile(domPath, snapshot.html, "utf-8");
     const page = await this.session.page();
     try {
-      await page.goto(`file://${domPath}`, { waitUntil: "load" });
+      await page.goto(pathToFileURL(domPath).href, { waitUntil: "load" });
       await waitForTraceDomHydration(page);
       const substrateYaml = await captureSubstrateV2(page, this.opts.logger ?? logger2);
-      const substratePath = path.join(this.opts.outDir, `${actionIndex}.${phase}.substrate.v2.yaml`);
+      const substratePath = path.resolve(this.opts.outDir, `${actionIndex}.${phase}.substrate.v2.yaml`);
       await writeFile(substratePath, substrateYaml, "utf-8");
       const out = {
         substrateYaml,
@@ -5205,7 +5251,7 @@ var SubstrateMaterializer = class {
         actionIndex,
         phase
       };
-      this.cache.set(key, out);
+      this.cache.set(key2, out);
       return out;
     } finally {
       await page.close().catch(() => void 0);
@@ -5224,6 +5270,8 @@ async function waitForTraceDomHydration(page) {
 }
 
 // ../workflow-cache/src/optimizer/locator-verifier.ts
+import path2 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
 var RESOLVE_TIMEOUT_MS2 = 5e3;
 function identifyingTokens(strategy) {
   const tokens = [];
@@ -5259,7 +5307,7 @@ var LocatorVerifier = class {
     const tokenPass = classifyStrategyTokens(opts.strategy);
     const page = await this.session.page();
     try {
-      await page.goto(`file://${opts.domPath}`, { waitUntil: "load" });
+      await page.goto(pathToFileURL2(path2.resolve(opts.domPath)).href, { waitUntil: "load" });
       await waitForTraceDomHydration(page);
       await page.ariaSnapshot({ mode: "ai" });
       const truth = page.locator(`aria-ref=${opts.targetRef}`);
@@ -5317,6 +5365,148 @@ var LocatorVerifier = class {
   }
 };
 
+// ../workflow-cache/src/optimizer/augmentor-verifier.ts
+import path3 from "path";
+import { pathToFileURL as pathToFileURL3 } from "url";
+var logger3 = createLogger({ module: "AugmentorVerifier" });
+function flatten2(roots) {
+  const out = [];
+  const walk = (n) => {
+    out.push(n);
+    for (const c of n.children) walk(c);
+  };
+  for (const r of roots) walk(r);
+  return out;
+}
+var key = (role, name) => `${role}\0${name ?? ""}`;
+var AugmentorVerifier = class {
+  session;
+  ownsSession;
+  constructor(opts) {
+    this.session = opts?.session ?? new HeadlessDomSession();
+    this.ownsSession = !opts?.session;
+  }
+  async verify(opts) {
+    const { domPath, augmentor } = opts;
+    const issues = [];
+    const page = await this.session.page();
+    try {
+      await page.goto(pathToFileURL3(path3.resolve(domPath)).href, { waitUntil: "load" });
+      await waitForTraceDomHydration(page);
+      const baselineYaml = await captureSubstrateV2(page, logger3);
+      const baselineKeys = new Set(flatten2(parseSnapshot(baselineYaml)).map((e) => key(e.role, e.text)));
+      const pass = await applyCustomAugmentors(page, [augmentor], logger3);
+      const exec = pass.executions[0];
+      const elementsAnnotated = exec?.elementsAnnotated ?? 0;
+      const errored = exec?.errored ?? false;
+      const invariantPassed = exec?.invariantPassed ?? false;
+      const durationMs = exec?.durationMs ?? 0;
+      if (errored) {
+        issues.push(`collector errored in page: ${exec?.errorMessage ?? "unknown"}`);
+      }
+      if (elementsAnnotated === 0) {
+        issues.push("collector annotated 0 elements \u2014 matchSelector found nothing, or every descriptor was rejected");
+      }
+      const augmentedYaml = await captureSubstrateV2(page, logger3);
+      const augmentedEls = flatten2(parseSnapshot(augmentedYaml));
+      const annotatedKeys = new Set(pass.annotations.map((a) => key(a.role, a.name)));
+      const newEls = augmentedEls.filter(
+        (e) => annotatedKeys.has(key(e.role, e.text)) && !baselineKeys.has(key(e.role, e.text))
+      );
+      const baselineAbsent = pass.annotations.length > 0 && newEls.length > 0;
+      if (!baselineAbsent && pass.annotations.length > 0) {
+        issues.push(
+          "annotated (role,name) pairs were already present in the un-augmented snapshot \u2014 this augmentor heals nothing (or the names are not distinctive)"
+        );
+      }
+      const sampleRefs = newEls.slice(0, 8).map((e) => e.ref);
+      const targeting = await Promise.all(
+        sampleRefs.map(async (ref) => {
+          try {
+            const handle = await page.$(`aria-ref=${ref}`);
+            const augId = handle ? await handle.getAttribute("data-augmentor-id").catch(() => null) : null;
+            await handle?.dispose();
+            if (augId !== augmentor.id) {
+              return `ref ${ref} did not resolve to an augmentor-annotated element`;
+            }
+            return null;
+          } catch (err) {
+            return `ref ${ref} could not be resolved: ${err instanceof Error ? err.message : String(err)}`;
+          }
+        })
+      );
+      const targetingIssues = targeting.filter((i) => i !== null);
+      for (const i of targetingIssues) issues.push(i);
+      const refsResolveToTargets = sampleRefs.length > 0 && targetingIssues.length === 0;
+      const cacheCheck = await page.evaluate(() => {
+        const els = Array.from(document.querySelectorAll("[data-augmentor-id]"));
+        let anchorless = 0;
+        const failures = [];
+        els.forEach((el, i) => el.setAttribute("data-aug-verify-idx", String(i)));
+        const anchors = els.map((el) => el.getAttribute("data-augmentor-anchor"));
+        for (const el of els) {
+          el.removeAttribute("role");
+          el.removeAttribute("aria-label");
+          el.removeAttribute("aria-disabled");
+          el.removeAttribute("data-augmentor-id");
+          el.removeAttribute("data-augmentor-anchor");
+        }
+        els.forEach((el, i) => {
+          const anchor = anchors[i];
+          if (!anchor) {
+            anchorless++;
+            return;
+          }
+          if (anchor.length > 500) {
+            failures.push(`stableAnchor #${i} exceeds 500 chars \u2014 too complex to be durable: ${anchor.slice(0, 80)}\u2026`);
+            return;
+          }
+          let matches = [];
+          try {
+            matches = Array.from(document.querySelectorAll(anchor));
+          } catch {
+            failures.push(`stableAnchor #${i} is not a valid selector: ${anchor}`);
+            return;
+          }
+          if (matches.length !== 1) {
+            failures.push(`stableAnchor #${i} matched ${matches.length} elements (want exactly 1): ${anchor}`);
+          } else if (matches[0]?.getAttribute("data-aug-verify-idx") !== String(i)) {
+            failures.push(`stableAnchor #${i} resolved to a different element than its target: ${anchor}`);
+          }
+        });
+        return { anchorless, failures };
+      });
+      for (const f of cacheCheck.failures) issues.push(f);
+      const cacheSafe = cacheCheck.failures.length === 0;
+      if (cacheCheck.anchorless > 0) {
+        issues.push(
+          `${cacheCheck.anchorless} annotated element(s) declared no stableAnchor \u2014 they will be visible to the agent but their locators stay irreducible (workflow-variable / L3 disambiguation)`
+        );
+      }
+      const verified = baselineAbsent && !errored && invariantPassed && elementsAnnotated > 0 && refsResolveToTargets && cacheSafe;
+      return {
+        verified,
+        baselineAbsent,
+        elementsAnnotated,
+        invariantPassed,
+        errored,
+        errorMessage: exec?.errorMessage,
+        sampleRefs,
+        refsResolveToTargets,
+        cacheSafe,
+        anchorlessCount: cacheCheck.anchorless,
+        durationMs,
+        issues
+      };
+    } finally {
+      await page.close().catch(() => void 0);
+    }
+  }
+  async close() {
+    if (this.ownsSession) await this.session.close();
+  }
+};
+
 // ../workflow-cache/src/optimizer/action-synthesizer.ts
 var ELEMENT_TARGET_ACTION_TYPES = /* @__PURE__ */ new Set([
   "click",
@@ -5426,7 +5616,7 @@ function buildCacheRecipe(opts) {
     const bindingKeys = /* @__PURE__ */ new Set();
     for (const a of actionsJson) {
       if (a.variableKey) bindingKeys.add(`$var.${a.variableKey}`);
-      for (const key of Object.values(a.variableBindings ?? {})) bindingKeys.add(`$var.${key}`);
+      for (const key2 of Object.values(a.variableBindings ?? {})) bindingKeys.add(`$var.${key2}`);
       for (const expr of Object.values(a.macroBindings ?? {})) bindingKeys.add(expr);
     }
     const missing = opts.requiredTokens.filter((t) => !present.has(t) && !bindingKeys.has(t));
@@ -5655,13 +5845,13 @@ function resolveMacros(value, ctx) {
 function resolveMacrosInRecord(values, ctx) {
   const resolved = {};
   const log = /* @__PURE__ */ new Map();
-  for (const [key, value] of Object.entries(values)) {
+  for (const [key2, value] of Object.entries(values)) {
     if (containsMacro(value)) {
       const resolvedValue = resolveMacros(value, ctx);
-      resolved[key] = resolvedValue;
-      log.set(key, { expression: value, resolved: resolvedValue });
+      resolved[key2] = resolvedValue;
+      log.set(key2, { expression: value, resolved: resolvedValue });
     } else {
-      resolved[key] = value;
+      resolved[key2] = value;
     }
   }
   return { resolved, log };
@@ -5671,12 +5861,13 @@ function resolveNodeInputMacros(inputValues, ctx, workflowState) {
   const hasMacros = Object.values(inputValues).some((v) => containsMacro(v));
   if (!hasMacros) return { resolvedValues: inputValues, macroResolutionLog: void 0 };
   const { resolved, log } = resolveMacrosInRecord(inputValues, ctx);
-  for (const [key, { resolved: val }] of log.entries()) {
-    workflowState[`macro:${key}`] = val;
+  for (const [key2, { resolved: val }] of log.entries()) {
+    workflowState[`macro:${key2}`] = val;
   }
   return { resolvedValues: resolved, macroResolutionLog: log };
 }
 export {
+  AugmentorVerifier,
   CACHE_COMPILER_VERSION,
   HeadlessDomSession,
   LocatorVerifier,
@@ -5708,6 +5899,7 @@ export {
   findElementWithAncestors,
   findFirstVisibleElement,
   generateNodeHash,
+  generateNodeHashV3,
   getFrameLocators,
   getMacro,
   getMacroNames,
@@ -5732,6 +5924,7 @@ export {
   resolveMacros,
   resolveMacrosInRecord,
   resolveNodeInputMacros,
+  resolveSegmentNodeIds,
   resolveSpecificIframeSelector,
   sanitizeArgsForCache,
   segmentTraceByNode,
@@ -5745,4 +5938,4 @@ export {
   verifySelectorAgainstRef,
   waitForTraceDomHydration
 };
-//# sourceMappingURL=src-BGDRMOKC.js.map
+//# sourceMappingURL=src-UEOOC425.js.map