@ape-egg/vibe 2.1.11 → 2.1.13

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [2.1.13] - 2026-06-22
+
+### Fixed
+
+- **Compiler 1.9.7 → 1.9.8 — name-bindings whose expression contains whitespace were torn apart by the HTML parser** (`compiler/src/compiler/name_binding_protect.rs` (new), `compile.rs`, `manifest_builder.rs`, `iteration_optimizer.rs`; `runtime/parse.js`, `iterate.js`, `hydrate.js`) — a name-binding sits in attribute-*name* position (`<icon @[element]>`), and HTML parsers split an attribute token on whitespace. So once a prop inlined an expression that has spaces (`@[EQUIPMENT(item, true).element]`), html5ever (and the browser) tore it into broken attributes and dropped the binding from the manifest — the element silently kept its fallback in compiled mode while non-compiled mode worked. The compiler now relocates every whitespace-bearing name-binding into a single verbatim value attribute `data-vibe-namebind="@[expr]…"` *before* any parse round-trip (value attributes survive byte-for-byte); the manifest builder and iteration optimizer read the expression back out of it, and the runtime restores the `@[expr]` name-binding form (`parse.js`, `iterate.js`) and strips the transport attribute on hydrate (`hydrate.js`). Whitespace-free name-bindings are untouched. Tests: `tests/compiler/name-binding-whitespace`, `tests/e2e/name-binding-prop`, `name-bindings`.
+- **Compiler 1.9.7 → 1.9.8 — `--minify` deleted significant whitespace between inline elements** (`compiler/src/compiler/compile.rs`) — minification collapsed `>\s+<` to `><`, removing whitespace between tags. For inline content that space is significant: the browser (and the non-compiled runtime) render `<em>a</em> <em>b</em>` with a space, so a status chip glued onto its following word (`💠Concussion`) in compiled+minified mode. Minify now collapses inter-element whitespace to a *single space* rather than deleting it — matching both the browser's own collapsing and the non-minified output; where the space is insignificant (between block/table/list/head elements) the parser discards it anyway. Repro: `tests/compiler/minify-significant-whitespace`.
+- **Name-bindings inside an iteration couldn't resolve props stashed in the iter-props global** (`runtime/utils.js`) — `resolveCaseInsensitivePath` only walked the diff state, but a name-binding inside an `<!-- each -->` reads its props from a global stash (`window.__vibeiterprops._p0.statusKey`), so a state-only walk never reached it and the camelCase leaf the parser lowercased stayed unresolved (the status-chip gray-icon parity bug — resolved in compiled mode, not runtime). It now resolves the path's root against the same scope and order `evalInScope` uses — the diff state including scoped loop aliases (via `ownKeysOf`), then globals — so iter-prop stashes and scoped aliases resolve case-insensitively. Covered by `tests/unit/utils.test.js`.
+
+## [2.1.12] - 2026-06-22
+
+### Fixed
+
+- **Nodes resolving inside slot-projected branch/iteration content were orphaned from the reactive tree** (`runtime/index.js`) — `navigateTree` only walks a node's `children`, but content projected across a `<slot>` boundary (a conditional branch's or an iteration instance's slotted content) is registered in the flat manifest under a path that isn't reachable through `children` — the slot node's children don't include the projected subtree. So when a `<component src>` (or any node) mounted inside such content, `navigateTree` returned null: on add, the resolved subtree never linked into the reactive tree (so it wasn't reactive); on remove, the stale tree entry lingered beside its replacement. A new `findNodeByElement` does an identity search across the *full* tree — plain `children`, conditional branch trees (`runtime.activeInstance.parsedTree`), and iteration instance trees (`runtime.instances`) — and is used as a fallback at both the add and remove sites when path navigation can't reach the parent, so the subtree links in and cleans up regardless of slot/branch/iteration projection.
+
 ## [2.1.11] - 2026-06-22
 
 ### Fixed

package/compiler/src/Cargo.lock

@@ -1599,7 +1599,7 @@ checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "vibe-compiler"
-version = "1.9.7"
+version = "1.9.8"
 dependencies = [
  "clap",
  "colored",

package/compiler/src/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vibe-compiler"
-version = "1.9.7"
+version = "1.9.8"
 edition = "2021"
 description = "Vibe framework compiler - compiles Vibe source files into optimized output"
 authors = ["Kim Korte"]

package/compiler/src/compiler/compile.rs

@@ -968,8 +968,12 @@ impl Compiler {
         use crate::compiler::component_tagger::ComponentTagger;
         use crate::compiler::value_stamper::ValueStamper;
 
+        // Relocate whitespace-bearing name-bindings into a value-attribute BEFORE any
+        // html5ever round-trip splits them on their spaces (see name_binding_protect).
+        let protected = crate::compiler::name_binding_protect::protect(html);
+
         // Tag components with deterministic IDs and structure state
-        let tagged = ComponentTagger::tag_components(html, &source_root.to_path_buf())?;
+        let tagged = ComponentTagger::tag_components(&protected, &source_root.to_path_buf())?;
         let html = &tagged.html;  // Use modified HTML with data-vibe-component-id attributes
         let state = tagged.state;
 
@@ -2181,9 +2185,17 @@ fn minify_html(html: &str) -> String {
         }
     }
 
+    // Collapse whitespace between tags to a SINGLE space — never delete it.
+    // Inter-element whitespace is significant for inline content: the browser
+    // (and the non-compiled runtime) render `<em>a</em> <em>b</em>` with a space,
+    // so dropping it (`><`) glued words onto preceding inline elements (the
+    // status-chip "💠Concussion" parity bug). One space matches both the browser's
+    // own collapsing and the non-minified/runtime output; where the space is
+    // insignificant (between block/table/list/head elements) the parser discards
+    // it anyway, exactly as it does for the non-minified newline.
     let result = regex::Regex::new(r">\s+<")
         .unwrap()
-        .replace_all(&result, "><")
+        .replace_all(&result, "> <")
         .to_string();
 
     result.trim().to_string()

package/compiler/src/compiler/iteration_optimizer.rs

@@ -157,6 +157,28 @@ const VALUE_ATTRS: &[&str] = &[
 
 /// Whether an attribute keeps its string value (vs boolean coercion).
 /// Mirrors isValueStyleAttr in runtime/iterate.js.
+/// Turn ` data-vibe-namebind="@[A]@[B]"` back into ` @[A]="" @[B]=""` so each relocated
+/// binding is rendered as a name-binding (` resolvedName=""`) rather than having its
+/// resolved value written into the transport attribute. See name_binding_protect.
+fn restore_relocated_name_bindings(template: &str) -> String {
+    let wrapper = Regex::new(
+        r#"\s+data-vibe-namebind="((?:@\[(?:[^\[\]'"]|\[[^\]]*\]|'[^']*'|"[^"]*")+\])+)""#,
+    )
+    .unwrap();
+    let one = Regex::new(r#"@\[(?:[^\[\]'"]|\[[^\]]*\]|'[^']*'|"[^"]*")+\]"#).unwrap();
+    wrapper
+        .replace_all(template, |caps: &regex::Captures| {
+            let mut s = String::new();
+            for m in one.find_iter(&caps[1]) {
+                s.push(' ');
+                s.push_str(m.as_str());
+                s.push_str("=\"\"");
+            }
+            s
+        })
+        .to_string()
+}
+
 fn is_value_style_attr(name: &str) -> bool {
     VALUE_ATTRS.contains(&name)
         || name.starts_with("data-")
@@ -208,6 +230,12 @@ fn compile_template_to_batch_fn(
 /// Anything the runtime clone+hydrate path renders, this output has to render
 /// identically — it is the compiled twin of compileBatchFn in runtime/iterate.js.
 fn emit_template_literal(template: &str) -> String {
+    // Restore name-bindings the compiler relocated into `data-vibe-namebind` (their
+    // expression has whitespace, so it could not be an HTML attribute name) back to the
+    // `@[expr]=""` form the binding pass below renders as ` resolvedName=""`. The compiled
+    // twin of the same step in runtime/iterate.js compileBatchFn.
+    let template = &restore_relocated_name_bindings(template);
+
     let each_re = Regex::new(r"<!--\s*each\s+([^\s]+)\s+as\s+([^\s,]+)(?:\s*,\s*([^\s]+))?\s*-->").unwrap();
     let end_re = Regex::new(r"<!--\s*/each\s*-->").unwrap();
     let attr_binding_re = Regex::new(r#"(\s)([\w-]+)="@\[([^\]]+)\]""#).unwrap();

package/compiler/src/compiler/manifest_builder.rs

@@ -138,8 +138,18 @@ impl ManifestBuilder {
                     let attr_name = attr.name.local.to_string();
                     let attr_value = attr.value.to_string();
 
+                    // A relocated name-binding: its expression(s) live verbatim in the
+                    // VALUE of data-vibe-namebind because whitespace barred them from
+                    // attribute-name position. Treat the value as the name-binding — no
+                    // case restoration needed (value attrs keep their case).
+                    if attr_name == crate::compiler::name_binding_protect::NAME_BIND_ATTR {
+                        while name_bindings.len() <= idx {
+                            name_bindings.push(None);
+                        }
+                        name_bindings[idx] = Some(attr_value);
+                    }
                     // Check for name bindings (binding in attribute NAME)
-                    if self.binding_regex.is_match(&attr_name) {
+                    else if self.binding_regex.is_match(&attr_name) {
                         // Extend vec to include this index
                         while name_bindings.len() <= idx {
                             name_bindings.push(None);

package/compiler/src/compiler/mod.rs

@@ -6,6 +6,7 @@ mod iteration_optimizer;
 mod js_analyzer;
 mod component_tagger;
 mod binding_case;
+mod name_binding_protect;
 mod reassignment_analyzer;
 pub mod watcher;
 

package/compiler/src/compiler/name_binding_protect.rs

@@ -0,0 +1,207 @@
+use regex::Regex;
+use std::sync::OnceLock;
+
+/// The attribute a relocated name-binding is parked in. Mirrors the runtime
+/// constant of the same name (runtime/constants.js) — the manifest builder reads
+/// the binding back out of it, and the runtime consumes + strips it on hydrate.
+pub const NAME_BIND_ATTR: &str = "data-vibe-namebind";
+
+/// A name-binding lives in attribute-NAME position: `<icon @[expr]>`. HTML parsers
+/// split an attribute token on whitespace, so once a prop is inlined into one and the
+/// expression gains spaces — `<icon @[element]>` becoming `@[EQUIPMENT(item, true).element]`
+/// — html5ever (and the browser) tear it into broken attributes and the binding is lost.
+///
+/// We relocate every whitespace-bearing name-binding into a single verbatim
+/// value-attribute `data-vibe-namebind="@[expr]@[expr2]…"`. Value attributes are kept
+/// byte-for-byte through parsing, so the manifest builder recovers the exact expression
+/// and the runtime evaluates it through the same path it uses in non-compiled mode —
+/// identical behaviour, no expression rewriting. Whitespace-free name-bindings already
+/// survive as-is and are left untouched.
+pub fn protect(html: &str) -> String {
+    // <script>/<style> bodies are raw text — a `<` inside them must not be read as a
+    // tag. Park them behind comment placeholders for the tag scan, restore after.
+    let (masked, raw_blocks) = mask_raw_text(html);
+
+    let out = tag_open_regex()
+        .replace_all(&masked, |caps: &regex::Captures| {
+            let name = &caps[1];
+            let attrs = &caps[2];
+            let (kept, relocated) = relocate_unsafe(attrs);
+            if relocated.is_empty() {
+                return caps[0].to_string();
+            }
+            // Preserve a self-closing slash as the final token.
+            let kept_end_trimmed = kept.trim_end();
+            let (body, self_close) = match kept_end_trimmed.strip_suffix('/') {
+                Some(b) => (b.trim_end(), " /"),
+                None => (kept_end_trimmed, ""),
+            };
+            format!(
+                "<{}{} {}=\"{}\"{}>",
+                name, body, NAME_BIND_ATTR, relocated, self_close
+            )
+        })
+        .to_string();
+
+    restore_raw_text(&out, &raw_blocks)
+}
+
+/// Matches an opening tag and captures (name, attribute-section). Quoted values may
+/// hold anything but their own quote; bare attribute chars are anything but `<>"'`.
+fn tag_open_regex() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| {
+        Regex::new(r#"<([a-zA-Z][a-zA-Z0-9-]*)((?:"[^"]*"|'[^']*'|[^<>"'])*)>"#).unwrap()
+    })
+}
+
+/// Walk a tag's attribute section, moving each whitespace-bearing name-binding out of
+/// the kept attributes and into the concatenated `relocated` string. Quoted attribute
+/// values (and string literals inside an expression) are skipped so value-bindings and
+/// `@[fn('a b')]`-style literals are never mistaken for a name-binding.
+fn relocate_unsafe(attrs: &str) -> (String, String) {
+    let bytes = attrs.as_bytes();
+    let n = bytes.len();
+    let mut kept = String::with_capacity(n);
+    let mut relocated = String::new();
+    let mut i = 0;
+    let mut seg = 0;
+
+    while i < n {
+        let b = bytes[i];
+
+        // Skip a quoted attribute value verbatim (it may legally contain `@[…]`).
+        if b == b'"' || b == b'\'' {
+            i += 1;
+            while i < n && bytes[i] != b {
+                i += 1;
+            }
+            if i < n {
+                i += 1; // consume closing quote
+            }
+            continue;
+        }
+
+        // A bare name-binding in attribute-name position.
+        if b == b'@' && i + 1 < n && bytes[i + 1] == b'[' {
+            kept.push_str(&attrs[seg..i]);
+            let start = i;
+            i += 2;
+            let mut depth = 1;
+            while i < n && depth > 0 {
+                let c = bytes[i];
+                if c == b'\'' || c == b'"' {
+                    i += 1;
+                    while i < n && bytes[i] != c {
+                        i += 1;
+                    }
+                    if i < n {
+                        i += 1;
+                    }
+                    continue;
+                }
+                match c {
+                    b'[' => depth += 1,
+                    b']' => depth -= 1,
+                    _ => {}
+                }
+                i += 1;
+            }
+            let binding = &attrs[start..i];
+            let inner = &binding[2..binding.len() - 1];
+            if inner.bytes().any(|x| x.is_ascii_whitespace()) {
+                relocated.push_str(binding);
+            } else {
+                kept.push_str(binding);
+            }
+            seg = i;
+            continue;
+        }
+
+        i += 1;
+    }
+    kept.push_str(&attrs[seg..]);
+    (kept, relocated)
+}
+
+fn raw_text_regex() -> &'static Regex {
+    static RE: OnceLock<Regex> = OnceLock::new();
+    RE.get_or_init(|| Regex::new(r"(?is)<(script|style)\b[^>]*>.*?</(?:script|style)>").unwrap())
+}
+
+fn mask_raw_text(html: &str) -> (String, Vec<String>) {
+    let mut blocks = Vec::new();
+    let mut out = String::with_capacity(html.len());
+    let mut last = 0;
+    for mat in raw_text_regex().find_iter(html) {
+        out.push_str(&html[last..mat.start()]);
+        out.push_str(&format!("<!--VIBE_RAWTEXT_{}-->", blocks.len()));
+        blocks.push(html[mat.start()..mat.end()].to_string());
+        last = mat.end();
+    }
+    out.push_str(&html[last..]);
+    (out, blocks)
+}
+
+fn restore_raw_text(html: &str, blocks: &[String]) -> String {
+    let mut out = html.to_string();
+    for (i, block) in blocks.iter().enumerate() {
+        out = out.replace(&format!("<!--VIBE_RAWTEXT_{}-->", i), block);
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn relocates_whitespace_name_binding() {
+        let html = r#"<icon @[EQUIPMENT(item, true).element]></icon>"#;
+        let out = protect(html);
+        assert!(
+            out.contains(r#"data-vibe-namebind="@[EQUIPMENT(item, true).element]""#),
+            "got: {}",
+            out
+        );
+        // The raw whitespace binding must no longer sit in attribute-name position.
+        assert!(!out.contains("@[EQUIPMENT(item, true).element]>"));
+    }
+
+    #[test]
+    fn leaves_whitespace_free_name_binding_untouched() {
+        let html = r#"<icon @[(selectedEquipProps(uuid)).element]></icon>"#;
+        assert_eq!(protect(html), html);
+    }
+
+    #[test]
+    fn leaves_value_binding_untouched() {
+        let html = r#"<card tinted="@[fn(a, b).element]"></card>"#;
+        assert_eq!(protect(html), html);
+    }
+
+    #[test]
+    fn leaves_text_binding_untouched() {
+        let html = r#"<label>@[fn(a, b)]</label>"#;
+        assert_eq!(protect(html), html);
+    }
+
+    #[test]
+    fn ignores_at_bracket_inside_script() {
+        let html = r#"<script>const x = "@[fn(a, b)]";</script><icon @[fn(a, b)]></icon>"#;
+        let out = protect(html);
+        assert!(out.contains(r#"const x = "@[fn(a, b)]";"#), "script mangled: {}", out);
+        assert!(out.contains(r#"data-vibe-namebind="@[fn(a, b)]""#), "got: {}", out);
+    }
+
+    #[test]
+    fn relocates_multiple_on_one_element() {
+        let html = r#"<el @[fn(a, b)] @[gn(c, d)]></el>"#;
+        let out = protect(html);
+        assert!(
+            out.contains(r#"data-vibe-namebind="@[fn(a, b)]@[gn(c, d)]""#),
+            "got: {}",
+            out
+        );
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ape-egg/vibe",
-  "version": "2.1.11",
+  "version": "2.1.13",
   "type": "module",
   "description": "Runtime-first reactivity with optional compiler",
   "main": "index.js",

package/runtime/hydrate.js

@@ -65,6 +65,13 @@ export default (affected, state, manifest = {}, oldState = {}) => {
         } else {
           element._vibeNameBindings.delete(nameBinding);
         }
+
+        // A binding relocated into `data-vibe-namebind` (clone path) has served its
+        // transport purpose once the real attribute is set — drop it so the rendered
+        // DOM matches the batch path, which never emits it.
+        if (element.hasAttribute('data-vibe-namebind')) {
+          element.removeAttribute('data-vibe-namebind');
+        }
       } catch (e) {
         console.error('Error hydrating name binding:', e);
       }

package/runtime/index.js

@@ -81,6 +81,48 @@ const navigateTree = (tree, path) => {
   return path.split('.').filter(k => k).reduce((node, key) => node?.children?.[key], tree);
 };
 
+// Locate the tree node whose `.element` is `target`, searching the full tree:
+// plain `children`, plus conditional branch trees (`runtime.activeInstance`)
+// and iteration instance trees (`runtime.instances`). navigateTree only walks
+// `children`, so it can't reach content projected across a <slot> boundary — a
+// conditional branch's slotted content is registered in the flat manifest by
+// path, but that path isn't navigable through `children` (the slot node's
+// children don't include the projected subtree). When a <component src> resolves
+// inside such content, navigateTree returns null and the resolved subtree would
+// be orphaned from the reactive tree. This identity search recovers the real
+// parent node so the subtree links in regardless of slot/branch projection.
+const findNodeByElement = (tree, target) => {
+  if (!target) return null;
+  const seen = new Set();
+  const walk = (node) => {
+    if (!node || typeof node !== 'object' || seen.has(node)) return null;
+    seen.add(node);
+    if (node.element === target) return node;
+    if (node.children) {
+      for (const key in node.children) {
+        const hit = walk(node.children[key]);
+        if (hit) return hit;
+      }
+    }
+    const branchTree = node.runtime?.activeInstance?.parsedTree;
+    if (branchTree) {
+      const hit = walk(branchTree);
+      if (hit) return hit;
+    }
+    const instances = node.runtime?.instances;
+    if (instances) {
+      for (let i = 0; i < instances.length; i++) {
+        if (instances[i]?.tree) {
+          const hit = walk(instances[i].tree);
+          if (hit) return hit;
+        }
+      }
+    }
+    return null;
+  };
+  return walk(tree);
+};
+
 // Get or create a node in the tree at the given path
 const ensureNode = (tree, path) => {
   const keys = path.split('.').filter(k => k);
@@ -853,7 +895,12 @@ const main = (s, config = {}, stringSelector = '') => {
         const name = dotPath.pop();
         const parentDotAnnotation = dotPath.join('.');
 
-        const picked = navigateTree(parsedTree, parentDotAnnotation);
+        // Identity fallback mirrors the added-node path: a parent inside
+        // slot-projected branch content isn't reachable via navigateTree's
+        // `children` walk, so resolve it by element identity instead — otherwise
+        // the removed node's stale tree entry lingers alongside its replacement.
+        const picked =
+          navigateTree(parsedTree, parentDotAnnotation) || findNodeByElement(parsedTree, target);
 
         // If we can't navigate to the parent, skip
         if (!picked || !picked.element) return;
@@ -912,7 +959,12 @@ const main = (s, config = {}, stringSelector = '') => {
         // registration since there's no tree branch to attach to.)
         if (entry) {
           const [dotAnnotation] = entry;
-          const picked = navigateTree(parsedTree, dotAnnotation);
+          // navigateTree walks `children` only; when the parent lives in a
+          // conditional branch's slot-projected content its manifest path isn't
+          // navigable that way (see findNodeByElement). Fall back to an identity
+          // search so the resolved subtree still links into the reactive tree.
+          const picked =
+            navigateTree(parsedTree, dotAnnotation) || findNodeByElement(parsedTree, target);
 
           if (picked) {
             if (!picked.element) {

package/runtime/iterate.js

@@ -193,6 +193,17 @@ const compileBatchFn = (template, itemAlias, indexAlias, stateKeys, anchorEl) =>
 
   let templateHtml = tplClone.innerHTML.trim();
 
+  // A name-binding the compiler relocated into `data-vibe-namebind` (its expression has
+  // whitespace, so it can't be an HTML attribute name) — restore the `@[expr]=""` form
+  // the name-binding pass below understands. Safe in this template STRING: only the
+  // resolved value (no whitespace) ever reaches innerHTML. Mirrors the clone path, which
+  // reads the same binding from the manifest's nameBindings.
+  templateHtml = templateHtml.replace(
+    /\sdata-vibe-namebind="((?:@\[(?:[^[\]'"]|\[[^\]]*\]|'[^']*'|"[^"]*")+\])+)"/g,
+    (_, bindings) =>
+      bindings.replace(/@\[(?:[^[\]'"]|\[[^\]]*\]|'[^']*'|"[^"]*")+\]/g, (b) => ' ' + b + '=""'),
+  );
+
   // Rewrite `this.X` only inside @[…] expressions so literal occurrences in
   // text content (e.g. a code example explaining `this.foo`) aren't mangled.
   // Mirrors evalInScope's behavior in the clone path.

package/runtime/parse.js

@@ -42,6 +42,14 @@ const captureAttributeBindings = (element, aliasSet) => {
     const attr = element.attributes[j];
     BINDING_REGEX.lastIndex = 0;
 
+    // A name-binding the compiler relocated into data-vibe-namebind because its
+    // expression has whitespace (barred from attribute-name position): the value
+    // holds the verbatim @[expr](s). Treat it as a name binding, not a value binding.
+    if (attr.name === 'data-vibe-namebind') {
+      nameBindings.push(attr.value);
+      continue;
+    }
+
     // Attribute name itself contains a binding (e.g. <icon @[section.icon]>).
     if (BINDING_REGEX.test(attr.name)) {
       nameBindings.push(attr.name);

package/runtime/utils.js

@@ -231,8 +231,31 @@ export const resolveCaseInsensitivePath = (state, path) => {
     path = path.replace(/[()]/g, '');
     if (!/^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*)*$/.test(path)) return undefined;
   }
-  const segments = path.split('.');
-  let current = state;
+  let segments = path.split('.');
+
+  // Resolve the root against the SAME scope evalInScope reaches, in its order:
+  // the diff state (including scoped loop aliases — see ownKeysOf below), then
+  // globals. A name-binding inside an iteration reads its props from a global
+  // stash — `window.__vibeiterprops._p0.statusKey` — so a state-only walk can
+  // never reach it, and the camelCase leaf the parser lowercased stays lost
+  // (the status-chip gray-icon parity bug: resolved in compiled, not runtime).
+  const root = segments[0];
+  const rootInState =
+    state != null &&
+    (Reflect.has(Object(state), root) ||
+      ownKeysOf(Object(state)).some((k) => k.toLowerCase() === root.toLowerCase()));
+  let current;
+  if (rootInState) {
+    current = state;
+  } else if (root === 'window' || root === 'globalThis') {
+    current = globalThis;
+    segments = segments.slice(1);
+  } else if (typeof globalThis !== 'undefined' && Reflect.has(globalThis, root)) {
+    current = globalThis;
+  } else {
+    return undefined;
+  }
+
   for (const seg of segments) {
     if (current == null) return undefined;
     // Direct first — handles proxies (scoped iteration state) and plain objects.
@@ -240,8 +263,11 @@ export const resolveCaseInsensitivePath = (state, path) => {
       current = current[seg];
       continue;
     }
-    if (typeof current !== 'object') return undefined;
-    const ci = Object.keys(current).find((k) => k.toLowerCase() === seg.toLowerCase());
+    if (typeof current !== 'object' && typeof current !== 'function') return undefined;
+    // Read keys from the SAME source evalInScope does (ownKeysOf), so a scoped
+    // loop alias — present in the proxy's precomputed key list but hidden from
+    // Object.keys/Reflect.has — resolves here too.
+    const ci = ownKeysOf(current).find((k) => k.toLowerCase() === seg.toLowerCase());
     if (!ci) return undefined;
     current = current[ci];
   }