@syntrologie/runtime-sdk 2.4.0-canary.17 → 2.4.0-canary.19

package/dist/{chunk-VIGV46CB.js → chunk-LRN3K2VD.js}

@@ -3,7 +3,7 @@ import {
   __privateGet,
   __privateSet,
   __publicField
-} from "./chunk-4NYS7GAW.js";
+} from "./chunk-P5G4KT2U.js";
 
 // ../adaptives/adaptive-content/dist/reconciliation-guard.js
 function guardAgainstReconciliation(container, anchor, reinsertFn, opts) {
@@ -124,9 +124,12 @@ function sanitizeHtml(html) {
 
 // ../adaptives/adaptive-content/dist/runtime.js
 var executeInsertHtml = async (action, context) => {
-  const anchorEl = context.resolveAnchor(action.anchorId);
+  let anchorEl = context.resolveAnchor(action.anchorId);
+  if (!anchorEl && context.waitForAnchor) {
+    anchorEl = await context.waitForAnchor(action.anchorId, 3e3);
+  }
   if (!anchorEl) {
-    console.error(`[adaptive-content] Anchor not found for insertHtml, skipping: ${action.anchorId.selector}`);
+    console.warn(`[adaptive-content] Anchor not found after waiting: ${action.anchorId.selector}`);
     return { cleanup: () => {
     } };
   }
@@ -201,9 +204,12 @@ var executeInsertHtml = async (action, context) => {
 };
 var executeSetText = async (action, context) => {
   var _a2;
-  const anchorEl = context.resolveAnchor(action.anchorId);
+  let anchorEl = context.resolveAnchor(action.anchorId);
+  if (!anchorEl && context.waitForAnchor) {
+    anchorEl = await context.waitForAnchor(action.anchorId, 3e3);
+  }
   if (!anchorEl) {
-    console.error(`[adaptive-content] Anchor not found for setText, skipping: ${action.anchorId.selector}`);
+    console.warn(`[adaptive-content] Anchor not found after waiting: ${action.anchorId.selector}`);
     return { cleanup: () => {
     } };
   }
@@ -226,9 +232,12 @@ var executeSetText = async (action, context) => {
   };
 };
 var executeSetAttr = async (action, context) => {
-  const anchorEl = context.resolveAnchor(action.anchorId);
+  let anchorEl = context.resolveAnchor(action.anchorId);
+  if (!anchorEl && context.waitForAnchor) {
+    anchorEl = await context.waitForAnchor(action.anchorId, 3e3);
+  }
   if (!anchorEl) {
-    console.error(`[adaptive-content] Anchor not found for setAttr, skipping: ${action.anchorId.selector}`);
+    console.warn(`[adaptive-content] Anchor not found after waiting: ${action.anchorId.selector}`);
     return { cleanup: () => {
     } };
   }
@@ -268,9 +277,12 @@ var executeSetAttr = async (action, context) => {
   };
 };
 var executeAddClass = async (action, context) => {
-  const anchorEl = context.resolveAnchor(action.anchorId);
+  let anchorEl = context.resolveAnchor(action.anchorId);
+  if (!anchorEl && context.waitForAnchor) {
+    anchorEl = await context.waitForAnchor(action.anchorId, 3e3);
+  }
   if (!anchorEl) {
-    console.error(`[adaptive-content] Anchor not found for addClass, skipping: ${action.anchorId.selector}`);
+    console.warn(`[adaptive-content] Anchor not found after waiting: ${action.anchorId.selector}`);
     return { cleanup: () => {
     } };
   }
@@ -291,9 +303,12 @@ var executeAddClass = async (action, context) => {
   };
 };
 var executeRemoveClass = async (action, context) => {
-  const anchorEl = context.resolveAnchor(action.anchorId);
+  let anchorEl = context.resolveAnchor(action.anchorId);
+  if (!anchorEl && context.waitForAnchor) {
+    anchorEl = await context.waitForAnchor(action.anchorId, 3e3);
+  }
   if (!anchorEl) {
-    console.error(`[adaptive-content] Anchor not found for removeClass, skipping: ${action.anchorId.selector}`);
+    console.warn(`[adaptive-content] Anchor not found after waiting: ${action.anchorId.selector}`);
     return { cleanup: () => {
     } };
   }
@@ -314,9 +329,12 @@ var executeRemoveClass = async (action, context) => {
   };
 };
 var executeSetStyle = async (action, context) => {
-  const anchorEl = context.resolveAnchor(action.anchorId);
+  let anchorEl = context.resolveAnchor(action.anchorId);
+  if (!anchorEl && context.waitForAnchor) {
+    anchorEl = await context.waitForAnchor(action.anchorId, 3e3);
+  }
   if (!anchorEl) {
-    console.error(`[adaptive-content] Anchor not found for setStyle, skipping: ${action.anchorId.selector}`);
+    console.warn(`[adaptive-content] Anchor not found after waiting: ${action.anchorId.selector}`);
     return { cleanup: () => {
     } };
   }
@@ -2348,9 +2366,12 @@ var WorkflowMountableWidget = {
 // ../adaptives/adaptive-overlays/dist/runtime.js
 var executeHighlight = async (action, context) => {
   var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-  const anchorEl = context.resolveAnchor(action.anchorId);
+  let anchorEl = context.resolveAnchor(action.anchorId);
+  if (!anchorEl && context.waitForAnchor) {
+    anchorEl = await context.waitForAnchor(action.anchorId, 3e3);
+  }
   if (!anchorEl) {
-    console.error(`[adaptive-overlays] Anchor not found for highlight, skipping: ${action.anchorId.selector}`);
+    console.warn(`[adaptive-overlays] Anchor not found after waiting: ${action.anchorId.selector}`);
     return { cleanup: () => {
     } };
   }
@@ -2376,9 +2397,12 @@ var executeHighlight = async (action, context) => {
 };
 var executePulse = async (action, context) => {
   var _a2;
-  const anchorEl = context.resolveAnchor(action.anchorId);
+  let anchorEl = context.resolveAnchor(action.anchorId);
+  if (!anchorEl && context.waitForAnchor) {
+    anchorEl = await context.waitForAnchor(action.anchorId, 3e3);
+  }
   if (!anchorEl) {
-    console.error(`[adaptive-overlays] Anchor not found for pulse, skipping: ${action.anchorId.selector}`);
+    console.warn(`[adaptive-overlays] Anchor not found after waiting: ${action.anchorId.selector}`);
     return { cleanup: () => {
     } };
   }
@@ -2421,9 +2445,12 @@ var executePulse = async (action, context) => {
 };
 var executeBadge = async (action, context) => {
   var _a2;
-  const anchorEl = context.resolveAnchor(action.anchorId);
+  let anchorEl = context.resolveAnchor(action.anchorId);
+  if (!anchorEl && context.waitForAnchor) {
+    anchorEl = await context.waitForAnchor(action.anchorId, 3e3);
+  }
   if (!anchorEl) {
-    console.error(`[adaptive-overlays] Anchor not found for badge, skipping: ${action.anchorId.selector}`);
+    console.warn(`[adaptive-overlays] Anchor not found after waiting: ${action.anchorId.selector}`);
     return { cleanup: () => {
     } };
   }
@@ -2486,9 +2513,12 @@ var executeBadge = async (action, context) => {
 };
 var executeTooltip = async (action, context) => {
   var _a2, _b, _c, _d;
-  const anchorEl = context.resolveAnchor(action.anchorId);
+  let anchorEl = context.resolveAnchor(action.anchorId);
+  if (!anchorEl && context.waitForAnchor) {
+    anchorEl = await context.waitForAnchor(action.anchorId, 3e3);
+  }
   if (!anchorEl) {
-    console.error(`[adaptive-overlays] Anchor not found for tooltip, skipping: ${action.anchorId.selector}`);
+    console.warn(`[adaptive-overlays] Anchor not found after waiting: ${action.anchorId.selector}`);
     return { cleanup: () => {
     } };
   }
@@ -3193,7 +3223,7 @@ function getAntiFlickerSnippet(config = {}) {
 }
 
 // src/version.ts
-var SDK_VERSION = "2.4.0-canary.17";
+var SDK_VERSION = "2.4.0-canary.19";
 
 // src/types.ts
 var SDK_SCHEMA_VERSION = "2.0";
@@ -3434,58 +3464,68 @@ var createCanvasConfigFetcher = ({
 };
 
 // src/events/registerConfigPredicates.ts
+var ELEMENT_CHAIN_FIELDS = /* @__PURE__ */ new Set(["tag_name", "$el_text"]);
+function isElementChainField(key) {
+  return ELEMENT_CHAIN_FIELDS.has(key) || key.startsWith("attr__");
+}
+function checkMatchOp(op, value) {
+  if (op.equals !== void 0) {
+    return value === op.equals;
+  }
+  if (op.contains !== void 0) {
+    return typeof value === "string" && value.includes(op.contains);
+  }
+  return false;
+}
+function buildPredicate(counter) {
+  const { events: eventNames, match } = counter;
+  return (event) => {
+    var _a2, _b;
+    if (!eventNames.includes(event.name)) return false;
+    if (match) {
+      for (const [key, op] of Object.entries(match)) {
+        if (isElementChainField(key)) {
+          const elements = (_a2 = event.props) == null ? void 0 : _a2.elements;
+          if (!elements) return false;
+          const anyMatch = elements.some((el) => checkMatchOp(op, el[key]));
+          if (!anyMatch) return false;
+        } else {
+          if (!checkMatchOp(op, (_b = event.props) == null ? void 0 : _b[key])) return false;
+        }
+      }
+    }
+    return true;
+  };
+}
+function registerFromTriggerWhen(triggerWhen, accumulator) {
+  for (const rule of triggerWhen.rules) {
+    for (const cond of rule.conditions) {
+      if (cond.type === "event_count" && cond.key) {
+        const counter = cond.counter;
+        const predicate = counter ? buildPredicate(counter) : () => true;
+        accumulator.register(cond.key, predicate);
+      }
+    }
+  }
+}
 function registerConfigPredicates(tiles, accumulator, actions) {
-  var _a2;
+  var _a2, _b;
   for (const tile of tiles) {
     const props = tile.props;
     if (!props) continue;
-    const scope = props.scope;
-    if (!(scope == null ? void 0 : scope.events)) continue;
     const tileActions = props.actions;
     if (!tileActions) continue;
-    const keys = /* @__PURE__ */ new Set();
     for (const action of tileActions) {
       if (((_a2 = action.triggerWhen) == null ? void 0 : _a2.type) === "rules") {
-        for (const rule of action.triggerWhen.rules) {
-          for (const cond of rule.conditions) {
-            if (cond.type === "event_count" && cond.key) {
-              keys.add(cond.key);
-            }
-          }
-        }
+        registerFromTriggerWhen(action.triggerWhen, accumulator);
       }
     }
-    if (keys.size === 0) continue;
-    const { events: eventNames, urlContains, props: propFilters } = scope;
-    for (const key of keys) {
-      accumulator.register(key, (event) => {
-        var _a3, _b, _c;
-        if (!eventNames.includes(event.name)) return false;
-        if (urlContains) {
-          const pathname = String((_b = (_a3 = event.props) == null ? void 0 : _a3.pathname) != null ? _b : "");
-          if (!pathname.includes(urlContains)) return false;
-        }
-        if (propFilters) {
-          for (const [k, v] of Object.entries(propFilters)) {
-            if (((_c = event.props) == null ? void 0 : _c[k]) !== v) return false;
-          }
-        }
-        return true;
-      });
-    }
   }
   if (actions) {
     for (const rawAction of actions) {
       const action = rawAction;
-      const triggerWhen = action.triggerWhen;
-      if ((triggerWhen == null ? void 0 : triggerWhen.type) === "rules") {
-        for (const rule of triggerWhen.rules) {
-          for (const cond of rule.conditions) {
-            if (cond.type === "event_count" && cond.key) {
-              accumulator.register(cond.key, () => true);
-            }
-          }
-        }
+      if (((_b = action.triggerWhen) == null ? void 0 : _b.type) === "rules") {
+        registerFromTriggerWhen(action.triggerWhen, accumulator);
       }
     }
   }
@@ -5316,7 +5356,6 @@ function SmartCanvasAppInner({
     let cancelled = false;
     const run = async () => {
       if (batchHandleRef.current) {
-        console.log("[SmartCanvasApp] Reverting previous action batch before re-apply");
         try {
           await batchHandleRef.current.revertAll();
         } catch (err) {
@@ -5326,28 +5365,16 @@ function SmartCanvasAppInner({
       }
       if (cancelled) return;
       if (configState.actions.length > 0) {
-        console.log(
-          `[SmartCanvasApp] Applying ${configState.actions.length} action(s):`,
-          configState.actions.map(
-            (a, i) => `[${i}] ${a.kind}${a.anchorId ? ` anchor="${a.anchorId}"` : ""}${a.label ? ` "${a.label}"` : ""}`
-          ).join(", ")
-        );
         try {
           const handle = await runtime3.actions.applyBatch(configState.actions);
           if (cancelled) {
             await handle.revertAll();
           } else {
             batchHandleRef.current = handle;
-            console.log("[SmartCanvasApp] Action batch applied successfully");
           }
         } catch (err) {
           if (!cancelled) {
-            console.error(
-              "[SmartCanvasApp] Failed to apply actions:",
-              err,
-              "\nActions that failed:",
-              JSON.stringify(configState.actions, null, 2)
-            );
+            console.error("[SmartCanvasApp] Failed to apply actions:", err);
           }
         }
       }
@@ -5356,9 +5383,6 @@ function SmartCanvasAppInner({
     return () => {
       cancelled = true;
       if (batchHandleRef.current) {
-        console.log(
-          "[SmartCanvasApp] Cleanup: reverting action batch (actions changed or unmount)"
-        );
         batchHandleRef.current.revertAll().catch((err) => {
           console.error("[SmartCanvasApp] Failed to revert actions on cleanup:", err);
         });
@@ -5448,7 +5472,7 @@ var SmartCanvasElement = class extends HTMLElement {
     Object.assign(__privateGet(this, _overlayContainer).style, {
       position: "fixed",
       inset: "0",
-      zIndex: "2147483647",
+      zIndex: "2147483645",
       pointerEvents: "none"
     });
     __privateGet(this, _shadow).appendChild(__privateGet(this, _overlayContainer));
@@ -5759,7 +5783,7 @@ function ensureOverlayRoot() {
     Object.assign(overlayRootEl.style, {
       position: "fixed",
       inset: "0",
-      zIndex: "2147483647",
+      zIndex: "2147483645",
       pointerEvents: "none"
     });
     document.body.appendChild(overlayRootEl);
@@ -6082,7 +6106,7 @@ var createSmartCanvas = async (config = {}) => {
         console.log(
           "[SmartCanvas] Actions to apply:",
           canvasConfig.actions.map(
-            (a, i) => `[${i}] ${a.kind}${a.anchorId ? ` anchor="${a.anchorId}"` : ""}${a.label ? ` "${a.label}"` : ""}`
+            (a, i) => `[${i}] ${a.kind}${a.anchorId ? ` anchor="${typeof a.anchorId === "string" ? a.anchorId : a.anchorId.selector}"` : ""}${a.label ? ` "${a.label}"` : ""}`
           ).join(", ")
         );
       }
@@ -7580,6 +7604,7 @@ function createActionEngine(options) {
     eventBus,
     surfaces,
     anchorResolver,
+    waitForAnchor,
     adaptiveId,
     executorRegistry: executorRegistry2 = executorRegistry,
     subscribeNavigation,
@@ -7599,6 +7624,7 @@ function createActionEngine(options) {
     return {
       overlayRoot,
       resolveAnchor: anchorResolver,
+      waitForAnchor,
       generateId,
       publishEvent,
       adaptiveId,
@@ -7858,7 +7884,7 @@ function createActionEngine(options) {
         errorMessages,
         "\nActions:",
         actions.map(
-          (a, i) => `  [${i}] ${a.kind} ${a.anchorId ? `anchor="${a.anchorId}"` : ""} ${a.label ? `label="${a.label}"` : ""}`
+          (a, i) => `  [${i}] ${a.kind} ${a.anchorId ? `anchor="${typeof a.anchorId === "string" ? a.anchorId : a.anchorId.selector}"` : ""} ${a.label ? `label="${a.label}"` : ""}`
         ).join("\n")
       );
       throw new Error(`Batch validation failed: ${errorMessages}`);
@@ -7946,6 +7972,154 @@ function createActionEngine(options) {
   };
 }
 
+// src/anchor/AnchorResolver.ts
+function createAnchorResolver(opts) {
+  var _a2, _b;
+  const root = (_a2 = opts == null ? void 0 : opts.root) != null ? _a2 : typeof document !== "undefined" ? document.body : null;
+  const defaultTimeoutMs = (_b = opts == null ? void 0 : opts.defaultTimeoutMs) != null ? _b : 5e3;
+  const waiters = /* @__PURE__ */ new Map();
+  const appearWatchers = /* @__PURE__ */ new Map();
+  let observer = null;
+  let destroyed = false;
+  function resolve(selector) {
+    if (!root) return null;
+    try {
+      return root.querySelector(selector);
+    } catch {
+      return null;
+    }
+  }
+  function checkPending() {
+    for (const [selector, set] of waiters) {
+      const el = resolve(selector);
+      if (el) {
+        for (const w of set) {
+          clearTimeout(w.timer);
+          w.resolve(el);
+        }
+        waiters.delete(selector);
+      }
+    }
+    for (const [selector, set] of appearWatchers) {
+      const el = resolve(selector);
+      if (el) {
+        for (const watcher of set) {
+          if (!watcher.cancelled) {
+            watcher.cb(el);
+          }
+        }
+        appearWatchers.delete(selector);
+      }
+    }
+    if (waiters.size === 0 && appearWatchers.size === 0) {
+      disconnectObserver();
+    }
+  }
+  function ensureObserver() {
+    if (observer || destroyed) return;
+    if (typeof MutationObserver === "undefined" || !root) return;
+    observer = new MutationObserver(() => {
+      checkPending();
+    });
+    observer.observe(root, { childList: true, subtree: true });
+  }
+  function disconnectObserver() {
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+  }
+  function removeWaiter(selector, waiter) {
+    const set = waiters.get(selector);
+    if (set) {
+      set.delete(waiter);
+      if (set.size === 0) {
+        waiters.delete(selector);
+      }
+    }
+    if (waiters.size === 0 && appearWatchers.size === 0) {
+      disconnectObserver();
+    }
+  }
+  function waitFor(selector, timeoutMs) {
+    if (destroyed) {
+      return Promise.reject(new Error("AnchorResolver destroyed"));
+    }
+    const existing = resolve(selector);
+    if (existing) return Promise.resolve(existing);
+    const timeout = timeoutMs != null ? timeoutMs : defaultTimeoutMs;
+    return new Promise((res, rej) => {
+      const waiter = {
+        resolve: res,
+        reject: rej,
+        timer: setTimeout(() => {
+          removeWaiter(selector, waiter);
+          rej(new Error(`waitFor("${selector}") timed out after ${timeout}ms`));
+        }, timeout)
+      };
+      let set = waiters.get(selector);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        waiters.set(selector, set);
+      }
+      set.add(waiter);
+      ensureObserver();
+    });
+  }
+  function onAppear(selector, cb) {
+    if (destroyed) return () => {
+    };
+    const existing = resolve(selector);
+    if (existing) {
+      cb(existing);
+      return () => {
+      };
+    }
+    const watcher = { cb, cancelled: false };
+    let set = appearWatchers.get(selector);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      appearWatchers.set(selector, set);
+    }
+    set.add(watcher);
+    ensureObserver();
+    return () => {
+      watcher.cancelled = true;
+      const s = appearWatchers.get(selector);
+      if (s) {
+        s.delete(watcher);
+        if (s.size === 0) {
+          appearWatchers.delete(selector);
+        }
+      }
+      if (waiters.size === 0 && appearWatchers.size === 0) {
+        disconnectObserver();
+      }
+    };
+  }
+  function pendingCount() {
+    let count = 0;
+    for (const set of waiters.values()) {
+      count += set.size;
+    }
+    return count;
+  }
+  function destroy() {
+    destroyed = true;
+    disconnectObserver();
+    const err = new Error("AnchorResolver destroyed");
+    for (const set of waiters.values()) {
+      for (const w of set) {
+        clearTimeout(w.timer);
+        w.reject(err);
+      }
+    }
+    waiters.clear();
+    appearWatchers.clear();
+  }
+  return { resolve, waitFor, onAppear, pendingCount, destroy };
+}
+
 // src/context/ContextManager.ts
 function createDefaultContext() {
   const now = Date.now();
@@ -8177,7 +8351,7 @@ function createContextManager(options = {}) {
 
 // src/decisions/strategies/rules.ts
 function evaluateCondition(condition, evalContext) {
-  var _a2, _b, _c, _d, _e;
+  var _a2, _b, _c, _d, _e, _f, _g;
   const { context, state, events } = evalContext;
   switch (condition.type) {
     case "page_url": {
@@ -8191,7 +8365,8 @@ function evaluateCondition(condition, evalContext) {
       return context.page.routeId === condition.routeId;
     }
     case "anchor_visible": {
-      const anchor = (_a2 = context.anchors) == null ? void 0 : _a2.find((a) => a.anchorId === condition.anchorId);
+      const condSelector = typeof condition.anchorId === "string" ? condition.anchorId : (_b = (_a2 = condition.anchorId) == null ? void 0 : _a2.selector) != null ? _b : "";
+      const anchor = (_c = context.anchors) == null ? void 0 : _c.find((a) => a.anchorId === condSelector);
       switch (condition.state) {
         case "visible":
           return (anchor == null ? void 0 : anchor.visible) === true;
@@ -8205,7 +8380,7 @@ function evaluateCondition(condition, evalContext) {
     }
     case "event_occurred": {
       if (!events) return false;
-      const withinMs = (_b = condition.withinMs) != null ? _b : 6e4;
+      const withinMs = (_d = condition.withinMs) != null ? _d : 6e4;
       return events.hasRecentEvent(condition.eventName, withinMs);
     }
     case "state_equals": {
@@ -8240,17 +8415,17 @@ function evaluateCondition(condition, evalContext) {
       }
     }
     case "dismissed": {
-      if (!state) return (_c = condition.inverted) != null ? _c : false;
+      if (!state) return (_e = condition.inverted) != null ? _e : false;
       const isDismissed = state.isDismissed(condition.key);
       return condition.inverted ? !isDismissed : isDismissed;
     }
     case "cooldown_active": {
-      if (!state) return (_d = condition.inverted) != null ? _d : false;
+      if (!state) return (_f = condition.inverted) != null ? _f : false;
       const isActive = state.isCooldownActive(condition.key);
       return condition.inverted ? !isActive : isActive;
     }
     case "frequency_limit": {
-      if (!state) return (_e = condition.inverted) != null ? _e : false;
+      if (!state) return (_g = condition.inverted) != null ? _g : false;
       const count = state.getFrequencyCount(condition.key);
       const limitReached = count >= condition.limit;
       return condition.inverted ? !limitReached : limitReached;
@@ -9861,20 +10036,11 @@ function matchRoutePattern(pathname, pattern) {
   const regex = new RegExp(`^${regexPattern}$`);
   return regex.test(pathname);
 }
-function resolveAnchorById(anchorId) {
-  const { selector, route } = anchorId;
+function matchesAnchorRoute(anchorId) {
   const pathname = typeof window !== "undefined" ? window.location.pathname : "/";
   const normalizedPath = pathname.replace(/\/$/, "") || "/";
-  const routes = Array.isArray(route) ? route : [route];
-  const matches = routes.some((pattern) => matchRoutePattern(normalizedPath, pattern));
-  if (!matches) {
-    return null;
-  }
-  try {
-    return document.querySelector(selector);
-  } catch {
-    return null;
-  }
+  const routes = Array.isArray(anchorId.route) ? anchorId.route : [anchorId.route];
+  return routes.some((pattern) => matchRoutePattern(normalizedPath, pattern));
 }
 function createSmartCanvasRuntime(options = {}) {
   var _a2, _b, _c, _d;
@@ -9903,7 +10069,19 @@ function createSmartCanvasRuntime(options = {}) {
     accumulator
   });
   const overlayRoot = ensureOverlayRoot();
-  const anchorResolver = (anchorId) => resolveAnchorById(anchorId);
+  const anchorResolverService = createAnchorResolver();
+  const anchorResolver = (anchorId) => {
+    if (!matchesAnchorRoute(anchorId)) return null;
+    return anchorResolverService.resolve(anchorId.selector);
+  };
+  const waitForAnchor = async (anchorId, timeoutMs) => {
+    if (!matchesAnchorRoute(anchorId)) return null;
+    try {
+      return await anchorResolverService.waitFor(anchorId.selector, timeoutMs);
+    } catch {
+      return null;
+    }
+  };
   const surfaces = createSurfaces({
     overlayRoot,
     eventBus: events,
@@ -9915,6 +10093,7 @@ function createSmartCanvasRuntime(options = {}) {
     eventBus: events,
     surfaces,
     anchorResolver,
+    waitForAnchor,
     executorRegistry: executors3,
     subscribeNavigation: (callback) => navigation.subscribe(callback),
     runtime: {
@@ -9935,6 +10114,7 @@ function createSmartCanvasRuntime(options = {}) {
     executors: executors3,
     apps,
     accumulator,
+    anchorResolver: anchorResolverService,
     navigation,
     version: RUNTIME_VERSION,
     mode,
@@ -9974,6 +10154,7 @@ function createSmartCanvasRuntime(options = {}) {
       apps.unbind().catch((err) => {
         console.error("[Runtime] Error unbinding apps registry:", err);
       });
+      anchorResolverService.destroy();
       accumulator.destroy();
       navigation.destroy();
       context.destroy();
@@ -10564,7 +10745,7 @@ async function init(options) {
       console.log(
         "[Syntro Bootstrap] Actions in config:",
         config.actions.map(
-          (a, i) => `[${i}] ${a.kind}${a.anchorId ? ` anchor="${a.anchorId}"` : ""}${a.label ? ` "${a.label}"` : ""}`
+          (a, i) => `[${i}] ${a.kind}${a.anchorId ? ` anchor="${typeof a.anchorId === "string" ? a.anchorId : a.anchorId.selector}"` : ""}${a.label ? ` "${a.label}"` : ""}`
         ).join(", ")
       );
     }
@@ -10696,6 +10877,7 @@ export {
   validateAction,
   validateActions,
   createActionEngine,
+  createAnchorResolver,
   ContextManager,
   createContextManager,
   evaluateCondition,
@@ -10734,4 +10916,4 @@ export {
   encodeToken,
   Syntro
 };
-//# sourceMappingURL=chunk-VIGV46CB.js.map
+//# sourceMappingURL=chunk-LRN3K2VD.js.map