tutuca 0.9.113 → 0.9.114

package/skill/tutuca-source/tutuca.ext.js

@@ -2,9 +2,8 @@
 import { is } from "immutable";
 
 // src/path.js
-var NONE = Symbol("NONE");
-
-class Step {
+var NONE = /* @__PURE__ */ Symbol("NONE");
+var Step = class {
   lookup(_v, dval = null) {
     return dval;
   }
@@ -17,15 +16,19 @@ class Step {
   toAbstractPathStep() {
     return this;
   }
+  // Freeze any field-resolved key against the value `v` entering this step (see
+  // `Path.pinKeys`). Most steps carry no live key and pin to themselves.
   pinKey(_v) {
     return this;
   }
+  // A generic `{ field, key? }` descriptor for this step, or null for frame-only
+  // steps (binds) that address no field. Used by `Path.toKeys()` so tooling can
+  // introspect a path without reaching into Step subclasses.
   toKey() {
     return null;
   }
-}
-
-class BindStep extends Step {
+};
+var BindStep = class _BindStep extends Step {
   constructor(binds) {
     super();
     this.binds = binds;
@@ -40,17 +43,16 @@ class BindStep extends Step {
     return stack.enter(next, { ...this.binds }, false);
   }
   withIndex(i) {
-    return new BindStep({ ...this.binds, key: i });
+    return new _BindStep({ ...this.binds, key: i });
   }
   withKey(key) {
-    return new BindStep({ ...this.binds, key });
+    return new _BindStep({ ...this.binds, key });
   }
   toAbstractPathStep() {
     return null;
   }
-}
-
-class ScopeBindStep extends BindStep {
+};
+var ScopeBindStep = class _ScopeBindStep extends BindStep {
   constructor(val, binds = {}) {
     super(binds);
     this.val = val;
@@ -60,14 +62,13 @@ class ScopeBindStep extends BindStep {
     return stack.enter(next, { ...this.binds, ...dyn }, false);
   }
   withIndex(i) {
-    return new ScopeBindStep(this.val, { ...this.binds, key: i });
+    return new _ScopeBindStep(this.val, { ...this.binds, key: i });
   }
   withKey(key) {
-    return new ScopeBindStep(this.val, { ...this.binds, key });
+    return new _ScopeBindStep(this.val, { ...this.binds, key });
   }
-}
-
-class FieldStep extends Step {
+};
+var FieldStep = class extends Step {
   constructor(field) {
     super();
     this.field = field;
@@ -87,9 +88,8 @@ class FieldStep extends Step {
   toKey() {
     return { field: this.field };
   }
-}
-
-class SeqStep extends Step {
+};
+var SeqStep = class extends Step {
   constructor(field, key) {
     super();
     this.field = field;
@@ -109,9 +109,8 @@ class SeqStep extends Step {
   toKey() {
     return { field: this.field, key: this.key };
   }
-}
-
-class SeqAccessStep extends Step {
+};
+var SeqAccessStep = class extends Step {
   constructor(seqField, keyField) {
     super();
     this.seqField = seqField;
@@ -127,16 +126,20 @@ class SeqAccessStep extends Step {
     const key = root?.get(this.keyField, NONE);
     return seq === NONE || key === NONE ? root : root.set(this.seqField, seq.set(key, v));
   }
+  // Resolve `keyField` against `v` now and freeze it as a literal-key `SeqStep`, so a
+  // later lookup/setValue lands on this same item even if `keyField` changes meanwhile.
   pinKey(v) {
     const key = v?.get(this.keyField, NONE);
     return key === NONE ? this : new SeqStep(this.seqField, key);
   }
+  // The key is a *field reference* resolved live, so it is unknown without a value;
+  // report the seq field (no key) rather than dropping the step, which would shift
+  // the indices of later keys. Call `Path.pinKeys(root)` first to get a concrete key.
   toKey() {
     return { field: this.seqField };
   }
-}
-
-class EachBindStep extends Step {
+};
+var EachBindStep = class extends Step {
   constructor(iterInfo, key) {
     super();
     this.iterInfo = iterInfo;
@@ -148,33 +151,34 @@ class EachBindStep extends Step {
   setValue(_root, v) {
     return v;
   }
+  // Replay the renderer's per-item binds (key, value + any @enrich-with binds)
+  // so a rebuilt stack matches the one @each rendered with.
   enterFrame(stack, _prev, next) {
     return stack.enter(next, this.iterInfo.enrichBinds(stack, this.key), false);
   }
   toAbstractPathStep() {
     return null;
   }
-}
-
-class EachRenderItStep extends SeqStep {
+};
+var EachRenderItStep = class extends SeqStep {
   enterFrame(stack, _prev, next) {
     return stack.enter(next, { key: this.key, value: next }, false).enter(next, {}, true);
   }
   toAbstractPathStep() {
     return new SeqStep(this.field, this.key);
   }
-}
+};
 function warnRawDynStep(op, step) {
   console.warn(`Path.${op} reached a DynStep: call toTransactionPath() first`, step);
 }
-
-class DynStep extends Step {
+var DynStep = class extends Step {
   constructor(producerCompId, producerSteps) {
     super();
     this.producerCompId = producerCompId;
     this.producerSteps = producerSteps;
-    this.interiorCids = new Set;
+    this.interiorCids = /* @__PURE__ */ new Set();
   }
+  // Steps spliced into the transaction path in place of this marker.
   teleportSteps() {
     return this.producerSteps;
   }
@@ -190,17 +194,15 @@ class DynStep extends Step {
     warnRawDynStep("enterFrame", this);
     return stack;
   }
-}
-
-class DynEachStep extends DynStep {
+};
+var DynEachStep = class extends DynStep {
   constructor(producerCompId, producerSteps, key) {
     super(producerCompId, producerSteps);
     this.key = key;
   }
   teleportSteps() {
     const { producerSteps, key } = this;
-    if (producerSteps.length === 0)
-      return producerSteps;
+    if (producerSteps.length === 0) return producerSteps;
     const last = producerSteps[producerSteps.length - 1];
     if (!(last instanceof FieldStep)) {
       console.warn("DynEachStep: seq-access dynamic cannot be iterated", this);
@@ -208,30 +210,34 @@ class DynEachStep extends DynStep {
     }
     return producerSteps.slice(0, -1).concat(new SeqStep(last.field, key));
   }
-}
-
-class Path {
+};
+var Path = class _Path {
   constructor(steps = []) {
     this.steps = steps;
   }
   concat(steps) {
-    return new Path(this.steps.concat(steps));
+    return new _Path(this.steps.concat(steps));
   }
   popStep() {
-    return new Path(this.steps.slice(0, -1));
+    return new _Path(this.steps.slice(0, -1));
   }
+  // The dispatch path: frame-only steps removed, one step per crossed component
+  // (DynStep included). `popStep` over it bubbles through every component.
   compact() {
     const out = [];
     for (const step of this.steps) {
       const s = step.toAbstractPathStep();
       if (s !== null) {
-        if (s !== step)
-          s._originCid = step._originCid;
+        if (s !== step) s._originCid = step._originCid;
         out.push(s);
       }
     }
-    return new Path(out);
+    return new _Path(out);
   }
+  // The abstract path used to apply a transaction: every DynStep is teleported —
+  // the steps interior to its producer..consumer span are dropped and the
+  // producer's own path spliced in — so a mutation lands on the data's real
+  // location. A path with no DynStep is returned unchanged.
   toTransactionPath() {
     let hasDyn = false;
     for (const step of this.steps)
@@ -239,76 +245,80 @@ class Path {
         hasDyn = true;
         break;
       }
-    if (!hasDyn)
-      return this;
+    if (!hasDyn) return this;
     const out = [];
     for (const step of this.steps) {
       if (step instanceof DynStep) {
-        while (out.length > 0 && step.interiorCids.has(out[out.length - 1]._originCid))
-          out.pop();
+        while (out.length > 0 && step.interiorCids.has(out[out.length - 1]._originCid)) out.pop();
         for (const ts of step.teleportSteps()) {
           ts._originCid = step.producerCompId;
           out.push(ts);
         }
-      } else
-        out.push(step);
+      } else out.push(step);
     }
-    return new Path(out);
+    return new _Path(out);
   }
+  // Resolve every field-keyed step (e.g. `SeqAccessStep`) against `root`, freezing the
+  // key as it is *now* so a later lookup/setValue lands on the same item even if the
+  // keyField changed meanwhile (e.g. the selected tab moved while a request was in
+  // flight). Returns a new Path with those steps replaced; `this` if nothing pinned.
+  // Must be called on a transaction path (no DynSteps — call toTransactionPath first).
   pinKeys(root) {
     let curVal = root;
     let out = null;
-    for (let i = 0;i < this.steps.length; i++) {
+    for (let i = 0; i < this.steps.length; i++) {
       const step = this.steps[i];
       const pinned = step.pinKey(curVal);
-      if (pinned !== step)
-        (out ??= this.steps.slice())[i] = pinned;
+      if (pinned !== step) (out ??= this.steps.slice())[i] = pinned;
       curVal = step.lookup(curVal, NONE);
-      if (curVal === NONE)
-        break;
+      if (curVal === NONE) break;
     }
-    return out ? new Path(out) : this;
+    return out ? new _Path(out) : this;
   }
   lookup(v, dval = null) {
     let curVal = v;
     for (const step of this.steps) {
       curVal = step.lookup(curVal, NONE);
-      if (curVal === NONE)
-        return dval;
+      if (curVal === NONE) return dval;
     }
     return curVal;
   }
+  // The values entered along the path, root→leaf (root included): index 0 is `root`,
+  // the last entry is the leaf this path resolves to. Stops early at the first
+  // unresolvable step. Call on a transaction path (no DynSteps). Used to walk the
+  // component instances on a dispatch path (filter via Components.getCompFor).
   resolveChain(root) {
     const out = [root];
     let curVal = root;
     for (const step of this.steps) {
       curVal = step.lookup(curVal, NONE);
-      if (curVal === NONE)
-        break;
+      if (curVal === NONE) break;
       out.push(curVal);
     }
     return out;
   }
+  // A flat `[{ field, key? }]` list of the addressing steps, skipping frame-only
+  // steps (binds). Generic path introspection so tooling (e.g. the storybook
+  // activity log) can identify which subtree a transaction touched without
+  // depending on Step internals. Call on a transaction path (no DynSteps).
   toKeys() {
     const out = [];
     for (const step of this.steps) {
       const k = step.toKey();
-      if (k !== null)
-        out.push(k);
+      if (k !== null) out.push(k);
     }
     return out;
   }
   setValue(root, v) {
     const intermediates = new Array(this.steps.length);
     let curVal = root;
-    for (let i = 0;i < this.steps.length; i++) {
+    for (let i = 0; i < this.steps.length; i++) {
       intermediates[i] = curVal;
       curVal = this.steps[i].lookup(curVal, NONE);
-      if (curVal === NONE)
-        return root;
+      if (curVal === NONE) return root;
     }
     let newVal = v;
-    for (let i = this.steps.length - 1;i >= 0; i--) {
+    for (let i = this.steps.length - 1; i >= 0; i--) {
       newVal = this.steps[i].setValue(intermediates[i], newVal);
       intermediates[i] = newVal;
     }
@@ -342,8 +352,7 @@ class Path {
       if (handlers === null && (isLeafComponent || bubbles)) {
         handlers = findHandlers(comp, eventIds, vid, eventName);
         if (handlers === null) {
-          if (isLeafComponent && stopOnNoEvent && !bubbles)
-            return false;
+          if (isLeafComponent && stopOnNoEvent && !bubbles) return false;
         } else if (!isLeafComponent) {
           pathSteps.length = 0;
           pendingDyns.length = 0;
@@ -351,8 +360,7 @@ class Path {
         }
       }
       isLeafComponent = false;
-      for (const dyn of pendingDyns)
-        dyn.interiorCids.add(cidNum);
+      for (const dyn of pendingDyns) dyn.interiorCids.add(cidNum);
       if (pushStep) {
         const step = resolvePathStep(comp, nodeIds, vid);
         if (step) {
@@ -364,9 +372,8 @@ class Path {
           }
         }
       }
-      for (let i = pendingDyns.length - 1;i >= 0; i--)
-        if (pendingDyns[i].producerCompId === cidNum)
-          pendingDyns.splice(i, 1);
+      for (let i = pendingDyns.length - 1; i >= 0; i--)
+        if (pendingDyns[i].producerCompId === cidNum) pendingDyns.splice(i, 1);
       eventIds = [];
       nodeIds = [];
       return true;
@@ -374,35 +381,32 @@ class Path {
     while (node && node !== rootNode && depth < maxDepth) {
       if (node?.dataset) {
         const { eid, cid, vid } = node.dataset;
-        if (eid !== undefined)
-          eventIds.push(eid);
+        if (eid !== void 0) eventIds.push(eid);
         const metas = metaChain(node.previousSibling);
         let sawComp = false;
         for (const m of metas) {
           if (m.$ === "Comp") {
             sawComp = true;
-            if (!crossComponent(m.cid, m.vid))
-              return NO_EVENT_INFO;
+            if (!crossComponent(m.cid, m.vid)) return NO_EVENT_INFO;
             nodeIds.push({ nid: m.nid });
           } else {
             nodeIds.push({ nid: m.nid, si: m.si, sk: m.sk });
           }
         }
-        if (!sawComp && cid !== undefined && !crossComponent(+cid, vid))
-          return NO_EVENT_INFO;
+        if (!sawComp && cid !== void 0 && !crossComponent(+cid, vid)) return NO_EVENT_INFO;
       }
       depth += 1;
       node = node.parentNode;
     }
     if (pendingDyns.length > 0)
       console.warn("event reconstruction: dynamic-var producer not found", pendingDyns);
-    return [new Path(pathSteps.reverse()), handlers];
+    return [new _Path(pathSteps.reverse()), handlers];
   }
   static fromEvent(e, rNode, maxDepth, comps, stopOnNoEvent = true) {
     const { type, target } = e;
-    return Path.fromNodeAndEventName(target, type, rNode, maxDepth, comps, stopOnNoEvent);
+    return _Path.fromNodeAndEventName(target, type, rNode, maxDepth, comps, stopOnNoEvent);
   }
-}
+};
 function metaChain(n) {
   const out = [];
   while (n?.nodeType === 8 && n.textContent[0] === "§") {
@@ -418,13 +422,11 @@ function metaChain(n) {
 function findHandlers(comp, eventIds, vid, eventName) {
   for (const eid of eventIds) {
     const handlers = comp.getEventForId(+eid, vid).getHandlersFor(eventName);
-    if (handlers !== null)
-      return handlers;
+    if (handlers !== null) return handlers;
   }
   return null;
 }
-
-class StepCtx {
+var StepCtx = class _StepCtx {
   constructor(comp, nodeIds, idx, vid) {
     this.comp = comp;
     this.nodeIds = nodeIds;
@@ -436,43 +438,38 @@ class StepCtx {
   }
   get key() {
     const m = this.meta;
-    return m.si !== undefined ? +m.si : m.sk;
+    return m.si !== void 0 ? +m.si : m.sk;
   }
   get hasKey() {
     const m = this.meta;
-    return m.si !== undefined || m.sk !== undefined;
+    return m.si !== void 0 || m.sk !== void 0;
   }
   next() {
     const { idx, nodeIds } = this;
-    return idx + 1 < nodeIds.length ? new StepCtx(this.comp, nodeIds, idx + 1, this.vid) : null;
+    return idx + 1 < nodeIds.length ? new _StepCtx(this.comp, nodeIds, idx + 1, this.vid) : null;
   }
   resolveNode() {
     return this.comp.getNodeForId(+this.meta.nid, this.vid);
   }
   applyKey(pi) {
-    if (pi === null)
-      return null;
+    if (pi === null) return null;
     const m = this.meta;
-    if (m.si !== undefined)
-      return pi.withIndex(+m.si);
-    if (m.sk !== undefined)
-      return pi.withKey(m.sk);
+    if (m.si !== void 0) return pi.withIndex(+m.si);
+    if (m.sk !== void 0) return pi.withKey(m.sk);
     return pi;
   }
-}
+};
 function resolvePathStep(comp, nodeIds, vid) {
-  for (let i = 0;i < nodeIds.length; i++) {
+  for (let i = 0; i < nodeIds.length; i++) {
     const ctx = new StepCtx(comp, nodeIds, i, vid);
     const step = ctx.resolveNode().toPathStep(ctx);
-    if (step !== null)
-      return step;
+    if (step !== null) return step;
   }
   return null;
 }
 var NO_EVENT_INFO = [null, null];
-var BUBBLING_EVENTS = new Set(["drop"]);
-
-class PathBuilder {
+var BUBBLING_EVENTS = /* @__PURE__ */ new Set(["drop"]);
+var PathBuilder = class {
   constructor() {
     this.pathChanges = [];
   }
@@ -489,7 +486,7 @@ class PathBuilder {
   key(name, key) {
     return this.add(new SeqStep(name, key));
   }
-}
+};
 
 // src/value.js
 var VALID_VAL_ID_RE = /^[a-zA-Z][a-zA-Z0-9_]*\??$/;
@@ -518,11 +515,9 @@ var G_FIELD = K_FIELD | K_METHOD | K_CONST | K_SEQ;
 var G_VALUE = K_FIELD | K_METHOD | K_BIND | K_DYN | K_NAME | K_TYPE | K_CONST;
 var G_ALL = G_VALUE | K_STRTPL | K_SEQ;
 function sizeOf(v) {
-  if (v == null)
-    return null;
+  if (v == null) return null;
   const s = v.size;
-  if (typeof s === "number")
-    return s;
+  if (typeof s === "number") return s;
   const l = v.length;
   return typeof l === "number" ? l : null;
 }
@@ -537,209 +532,174 @@ var PREDICATES = {
   "null?": { name: "null?", arity: 1, fn: (v) => v == null },
   "equals?": { name: "equals?", arity: 2, fn: (a, b) => is(a, b) }
 };
-
-class ValParser {
-  constructor() {
-    this.nullConstVal = new ConstVal(null);
-  }
-  const(v) {
-    return new ConstVal(v);
-  }
-  parseToken(s, px) {
-    const c0 = s.charCodeAt(0);
-    if (c0 === 39)
-      return s.length >= 2 && s.charCodeAt(s.length - 1) === 39 ? new ConstVal(unescapeStr(s.slice(1, -1))) : null;
-    if (c0 === 36 && s.charCodeAt(1) === 39)
-      return s.length >= 3 && s.charCodeAt(s.length - 1) === 39 ? StrTplVal.parse(s.slice(2, -1), px) : null;
-    if (s.indexOf("[") !== -1 || s.indexOf("]") !== -1)
-      return this._parseSeqAccess(s, px);
-    if (s.indexOf("{") !== -1 || s.indexOf("}") !== -1)
-      return null;
-    switch (c0) {
-      case 94: {
-        const name = s.slice(1);
-        const newS = px.frame.macroVars?.[name];
-        if (newS !== undefined) {
-          const tokens = tokenizeValue(newS.trim());
-          if (tokens.length !== 1)
-            return null;
-          const val = this.parseToken(tokens[0], px);
-          if (val instanceof ConstVal)
-            val.fromMacroVar = true;
-          return val;
-        }
-        px.onParseIssue("bad-value", { role: "macro-var", name, value: s });
-        return null;
-      }
-      case 36:
-        return mkVal(s.slice(1), MethodVal);
-      case 64: {
-        const dot = s.indexOf(".", 1);
-        if (dot === -1)
-          return mkVal(s.slice(1), BindVal);
-        const name = s.slice(1, dot);
-        const member = s.slice(dot + 1);
-        return isValidValId(name) && isValidValId(member) ? new BindMemberVal(name, member) : null;
+function parseToken(s, px) {
+  const c0 = s.charCodeAt(0);
+  if (c0 === 39)
+    return s.length >= 2 && s.charCodeAt(s.length - 1) === 39 ? new ConstVal(unescapeStr(s.slice(1, -1))) : null;
+  if (c0 === 36 && s.charCodeAt(1) === 39)
+    return s.length >= 3 && s.charCodeAt(s.length - 1) === 39 ? StrTplVal.parse(s.slice(2, -1), px) : null;
+  if (s.indexOf("[") !== -1 || s.indexOf("]") !== -1) return _parseSeqAccess(s, px);
+  if (s.indexOf("{") !== -1 || s.indexOf("}") !== -1) return null;
+  switch (c0) {
+    case 94: {
+      const name = s.slice(1);
+      const newS = px.frame.macroVars?.[name];
+      if (newS !== void 0) {
+        const tokens = tokenizeValue(newS.trim());
+        if (tokens.length !== 1) return null;
+        const val = parseToken(tokens[0], px);
+        if (val instanceof ConstVal) val.fromMacroVar = true;
+        return val;
       }
-      case 42:
-        return mkVal(s.slice(1), DynVal);
-      case 46:
-        return mkVal(s.slice(1), FieldVal);
+      px.onParseIssue("bad-value", { role: "macro-var", name, value: s });
+      return null;
+    }
+    case 36:
+      return mkVal(s.slice(1), MethodVal);
+    case 64: {
+      const dot = s.indexOf(".", 1);
+      if (dot === -1) return mkVal(s.slice(1), BindVal);
+      const name = s.slice(1, dot);
+      const member = s.slice(dot + 1);
+      return isValidValId(name) && isValidValId(member) ? new BindMemberVal(name, member) : null;
     }
-    const num = VALID_FLOAT_RE.test(s) ? parseFloat(s) : null;
-    if (Number.isFinite(num))
-      return new ConstVal(num);
-    if (s === "true" || s === "false")
-      return new ConstVal(s === "true");
-    if (c0 >= 97 && c0 <= 122)
-      return mkVal(s, NameVal);
-    if (c0 >= 65 && c0 <= 90)
-      return mkVal(s, TypeVal);
+    case 42:
+      return mkVal(s.slice(1), DynVal);
+    case 46:
+      return mkVal(s.slice(1), FieldVal);
+  }
+  const num = VALID_FLOAT_RE.test(s) ? parseFloat(s) : null;
+  if (Number.isFinite(num)) return new ConstVal(num);
+  if (s === "true" || s === "false") return new ConstVal(s === "true");
+  if (c0 >= 97 && c0 <= 122) return mkVal(s, NameVal);
+  if (c0 >= 65 && c0 <= 90) return mkVal(s, TypeVal);
+  return null;
+}
+function _parseSeqAccess(s, px) {
+  const open = s.indexOf("[");
+  const close = s.indexOf("]");
+  if (open < 1 || close !== s.length - 1 || close < open || s.indexOf("[", open + 1) !== -1)
+    return null;
+  const left = parseToken(s.slice(0, open), px);
+  const right = parseToken(s.slice(open + 1, close), px);
+  return left instanceof FieldVal && right instanceof FieldVal ? new SeqAccessVal(left, right) : null;
+}
+function _parseSingle(s, px, group) {
+  const tokens = tokenizeValue(s.trim());
+  if (tokens.length !== 1) return null;
+  const val = parseToken(tokens[0], px);
+  return val !== null && kindOf(val) & group ? val : null;
+}
+function parseBool(s, px) {
+  const t = s.trim();
+  const tokens = tokenizeValue(t);
+  if (tokens.length !== 1) return tokens.length === 0 ? null : _parsePredicate(t, tokens, px);
+  const val = parseToken(tokens[0], px);
+  return val !== null && kindOf(val) & G_BOOL ? val : null;
+}
+function parseText(s, px) {
+  return _parseSingle(s, px, G_TEXT);
+}
+function parseComponent(s, px) {
+  return _parseSingle(s, px, G_COMPONENT);
+}
+function parseSequence(s, px) {
+  return _parseSingle(s, px, G_SEQUENCE);
+}
+function parseField(s, px) {
+  return _parseSingle(s, px, G_FIELD);
+}
+function parseProvide(s, px) {
+  return _parseSingle(s, px, G_PROVIDE);
+}
+function parseMacroAttr(s, px) {
+  return _parseSingle(s, px, G_ALL);
+}
+function parseInputHandler(s, px) {
+  return _parseHandler(s, px, "input", true, true);
+}
+function parseAlterHandler(s, px) {
+  const r = _parseHandler(s, px, "alter", false, false);
+  return r === null ? null : r.handlerVal;
+}
+function _parseHandler(s, px, namespace, allowArgs, report) {
+  const tokens = tokenizeValue(s.trim());
+  const headTok = tokens[0] ?? "";
+  const head = headTok === "" ? null : parseToken(headTok, px);
+  const hk = kindOf(head);
+  let handlerVal;
+  if (hk & K_METHOD) handlerVal = head;
+  else if (hk & K_NAME) handlerVal = new HandlerNameVal(head.name, namespace);
+  else {
+    if (report) px.onParseIssue("bad-value", { role: "handler-name", value: headTok });
     return null;
   }
-  _parseSeqAccess(s, px) {
-    const open = s.indexOf("[");
-    const close = s.indexOf("]");
-    if (open < 1 || close !== s.length - 1 || close < open || s.indexOf("[", open + 1) !== -1)
-      return null;
-    const left = this.parseToken(s.slice(0, open), px);
-    const right = this.parseToken(s.slice(open + 1, close), px);
-    return left instanceof FieldVal && right instanceof FieldVal ? new SeqAccessVal(left, right) : null;
-  }
-  _parseSingle(s, px, group) {
-    const tokens = tokenizeValue(s.trim());
-    if (tokens.length !== 1)
-      return null;
-    const val = this.parseToken(tokens[0], px);
-    return val !== null && kindOf(val) & group ? val : null;
-  }
-  parseBool(s, px) {
-    const t = s.trim();
-    const tokens = tokenizeValue(t);
-    if (tokens.length !== 1)
-      return tokens.length === 0 ? null : this._parsePredicate(t, tokens, px);
-    const val = this.parseToken(tokens[0], px);
-    return val !== null && kindOf(val) & G_BOOL ? val : null;
-  }
-  parseText(s, px) {
-    return this._parseSingle(s, px, G_TEXT);
-  }
-  parseComponent(s, px) {
-    return this._parseSingle(s, px, G_COMPONENT);
-  }
-  parseSequence(s, px) {
-    return this._parseSingle(s, px, G_SEQUENCE);
-  }
-  parseField(s, px) {
-    return this._parseSingle(s, px, G_FIELD);
-  }
-  parseProvide(s, px) {
-    return this._parseSingle(s, px, G_PROVIDE);
-  }
-  parseHandlerArg(s, px) {
-    return this._parseSingle(s, px, G_VALUE);
-  }
-  parseMacroAttr(s, px) {
-    return this._parseSingle(s, px, G_ALL);
-  }
-  parseInputHandler(s, px) {
-    return this._parseHandler(s, px, "input", true, true);
-  }
-  parseAlterHandler(s, px) {
-    const r = this._parseHandler(s, px, "alter", false, false);
-    return r === null ? null : r.handlerVal;
-  }
-  _parseHandler(s, px, namespace, allowArgs, report) {
-    const tokens = tokenizeValue(s.trim());
-    const headTok = tokens[0] ?? "";
-    const head = headTok === "" ? null : this.parseToken(headTok, px);
-    const hk = kindOf(head);
-    let handlerVal;
-    if (hk & K_METHOD)
-      handlerVal = head;
-    else if (hk & K_NAME)
-      handlerVal = new HandlerNameVal(head.name, namespace);
+  if (!allowArgs) return tokens.length === 1 ? { handlerVal, args: [] } : null;
+  const args = new Array(tokens.length - 1);
+  for (let i = 1; i < tokens.length; i++) {
+    const val = parseToken(tokens[i], px);
+    if (val !== null && kindOf(val) & G_VALUE) args[i - 1] = val;
     else {
-      if (report)
-        px.onParseIssue("bad-value", { role: "handler-name", value: headTok });
-      return null;
-    }
-    if (!allowArgs)
-      return tokens.length === 1 ? { handlerVal, args: [] } : null;
-    const args = new Array(tokens.length - 1);
-    for (let i = 1;i < tokens.length; i++) {
-      const val = this.parseToken(tokens[i], px);
-      if (val !== null && kindOf(val) & G_VALUE)
-        args[i - 1] = val;
-      else {
-        if (report)
-          px.onParseIssue("bad-value", { role: "handler-arg", value: tokens[i] });
-        args[i - 1] = this.nullConstVal;
-      }
+      if (report) px.onParseIssue("bad-value", { role: "handler-arg", value: tokens[i] });
+      args[i - 1] = NULL_CONST_VAL;
     }
-    return { handlerVal, args };
   }
-  _parsePredicate(s, tokens, px) {
-    const predName = tokens[0];
-    const pred = PREDICATES[predName];
-    if (pred === undefined) {
-      px.onParseIssue("bad-value", { role: "predicate", value: predName });
-      return null;
-    }
-    const arity = tokens.length - 1;
-    if (arity !== pred.arity) {
-      px.onParseIssue("bad-value", { role: "predicate-arity", value: s, predicate: predName });
+  return { handlerVal, args };
+}
+function _parsePredicate(s, tokens, px) {
+  const predName = tokens[0];
+  const pred = PREDICATES[predName];
+  if (pred === void 0) {
+    px.onParseIssue("bad-value", { role: "predicate", value: predName });
+    return null;
+  }
+  const arity = tokens.length - 1;
+  if (arity !== pred.arity) {
+    px.onParseIssue("bad-value", { role: "predicate-arity", value: s, predicate: predName });
+    return null;
+  }
+  const args = new Array(arity);
+  for (let i = 0; i < arity; i++) {
+    const tok = tokens[i + 1];
+    const val = parseToken(tok, px);
+    if (val === null || !(kindOf(val) & G_BOOL)) {
+      px.onParseIssue("bad-value", { role: "predicate-arg", value: tok });
       return null;
     }
-    const args = new Array(arity);
-    for (let i = 0;i < arity; i++) {
-      const tok = tokens[i + 1];
-      const val = this.parseToken(tok, px);
-      if (val === null || !(kindOf(val) & G_BOOL)) {
-        px.onParseIssue("bad-value", { role: "predicate-arg", value: tok });
-        return null;
-      }
-      args[i] = val;
-    }
-    return new PredicateVal(pred, args);
+    args[i] = val;
   }
+  return new PredicateVal(pred, args);
 }
 function kindOf(val) {
-  if (val === null)
-    return 0;
-  if (val instanceof ConstVal)
-    return val.kind;
-  if (val instanceof StrTplVal)
-    return val.kind;
-  if (val instanceof SeqAccessVal)
-    return K_SEQ;
-  if (val instanceof FieldVal)
-    return K_FIELD;
-  if (val instanceof MethodVal)
-    return K_METHOD;
-  if (val instanceof BindVal)
-    return K_BIND;
-  if (val instanceof DynVal)
-    return K_DYN;
-  if (val instanceof TypeVal)
-    return K_TYPE;
-  if (val instanceof NameVal)
-    return K_NAME;
+  if (val === null) return 0;
+  if (val instanceof ConstVal) return val.kind;
+  if (val instanceof StrTplVal) return val.kind;
+  if (val instanceof SeqAccessVal) return K_SEQ;
+  if (val instanceof FieldVal) return K_FIELD;
+  if (val instanceof MethodVal) return K_METHOD;
+  if (val instanceof BindVal) return K_BIND;
+  if (val instanceof DynVal) return K_DYN;
+  if (val instanceof TypeVal) return K_TYPE;
+  if (val instanceof NameVal) return K_NAME;
   return 0;
 }
-
-class BaseVal {
-  render(_stack, _rx) {}
-  eval(_stack) {}
+var BaseVal = class {
+  render(_stack, _rx) {
+  }
+  eval(_stack) {
+  }
   toPathItem() {
     return null;
   }
+  // Value of this expression when it sits in handler position (`@on.<event>`,
+  // `@when`, `@enrich-with`, `@loop-with`): the dispatch machinery calls the
+  // result with the event args. Defaults to `eval`; `MethodVal` overrides it
+  // to hand back the raw function instead of invoking it.
   evalAsHandler(stack) {
     return this.eval(stack);
   }
-}
-
-class ConstVal extends BaseVal {
+};
+var ConstVal = class extends BaseVal {
   constructor(val, kind = K_CONST) {
     super();
     this.val = val;
@@ -755,9 +715,9 @@ class ConstVal extends BaseVal {
     const v = this.val;
     return typeof v === "string" ? `'${v.replace(/(['\\])/g, "\\$1")}'` : `${v}`;
   }
-}
-
-class PredicateVal extends BaseVal {
+};
+var NULL_CONST_VAL = new ConstVal(null);
+var PredicateVal = class extends BaseVal {
   constructor(pred, args) {
     super();
     this.pred = pred;
@@ -766,28 +726,26 @@ class PredicateVal extends BaseVal {
   eval(stack) {
     const n = this.args.length;
     const vals = new Array(n);
-    for (let i = 0;i < n; i++)
-      vals[i] = this.args[i].eval(stack);
+    for (let i = 0; i < n; i++) vals[i] = this.args[i].eval(stack);
     return this.pred.fn(...vals);
   }
   toString() {
     return `${this.pred.name} ${this.args.map(String).join(" ")}`;
   }
-}
-
-class VarVal extends BaseVal {
-}
-
-class StrTplVal extends VarVal {
+};
+var VarVal = class extends BaseVal {
+};
+var StrTplVal = class _StrTplVal extends VarVal {
   constructor(vals) {
     super();
     this.vals = vals;
     this.kind = this.isLiteral() ? K_CONST : K_STRTPL;
   }
+  // True when this template carries no dynamic placeholder: every part is a
+  // plain `ConstVal` and none was bound from a macro variable (the macro
+  // placeholder is real in the body even when it resolved to a constant).
   isLiteral() {
-    for (const v of this.vals)
-      if (!(v instanceof ConstVal) || v.fromMacroVar)
-        return false;
+    for (const v of this.vals) if (!(v instanceof ConstVal) || v.fromMacroVar) return false;
     return true;
   }
   render(stack, _rx) {
@@ -795,38 +753,41 @@ class StrTplVal extends VarVal {
   }
   eval(stack) {
     const strs = new Array(this.vals.length);
-    for (let i = 0;i < this.vals.length; i++)
-      strs[i] = this.vals[i]?.eval(stack, "");
+    for (let i = 0; i < this.vals.length; i++) strs[i] = this.vals[i]?.eval(stack, "");
     return strs.join("");
   }
+  // When this is a placeholderless literal (see `isLiteral`), returns the
+  // string it spells out, in `'…'` source form; otherwise null. The linter
+  // uses this to nudge `$'foo'` → `'foo'` (PLACEHOLDERLESS_TEMPLATE_STRING).
   toLiteralSource() {
-    if (!this.isLiteral())
-      return null;
+    if (!this.isLiteral()) return null;
     let out = "";
-    for (const v of this.vals)
-      out += v.val;
+    for (const v of this.vals) out += v.val;
     return new ConstVal(out).toString();
   }
+  // `s` is the interior of a `$'…'` template (the text between `$'` and `'`).
+  // The interior is unescaped once (`\'`, `\\`) then split on `{…}` groups:
+  // text between them becomes a `ConstVal`, expressions inside braces are
+  // parsed via `parseText`. A constant-only template is left as a `StrTplVal`
+  // (not folded to a `ConstVal`) so the linter can flag it — see
+  // `toLiteralSource` and the PLACEHOLDERLESS_TEMPLATE_STRING lint rule.
   static parse(s, px) {
     const parts = unescapeStr(s).split(STR_TPL_SPLIT_RE);
     const vals = new Array(parts.length);
-    for (let i = 0;i < parts.length; i++) {
+    for (let i = 0; i < parts.length; i++) {
       const part = parts[i];
       const isExpr = part[0] === "{" && part.at(-1) === "}";
-      vals[i] = isExpr ? vp.parseText(part.slice(1, -1), px) : new ConstVal(part);
+      vals[i] = isExpr ? parseText(part.slice(1, -1), px) : new ConstVal(part);
     }
     let lo = 0;
     let hi = vals.length;
     const isTrimmable = (v) => v instanceof ConstVal && v.val === "" && !v.fromMacroVar;
-    while (lo < hi && isTrimmable(vals[lo]))
-      lo++;
-    while (hi > lo && isTrimmable(vals[hi - 1]))
-      hi--;
-    return new StrTplVal(lo === 0 && hi === vals.length ? vals : vals.slice(lo, hi));
+    while (lo < hi && isTrimmable(vals[lo])) lo++;
+    while (hi > lo && isTrimmable(vals[hi - 1])) hi--;
+    return new _StrTplVal(lo === 0 && hi === vals.length ? vals : vals.slice(lo, hi));
   }
-}
-
-class NameVal extends VarVal {
+};
+var NameVal = class extends VarVal {
   constructor(name) {
     super();
     this.name = name;
@@ -837,9 +798,8 @@ class NameVal extends VarVal {
   toString() {
     return this.name;
   }
-}
-
-class HandlerNameVal extends NameVal {
+};
+var HandlerNameVal = class extends NameVal {
   constructor(name, namespace) {
     super(name);
     this.namespace = namespace;
@@ -847,41 +807,36 @@ class HandlerNameVal extends NameVal {
   eval(stack) {
     return stack.getHandlerFor(this.name, this.namespace) ?? mk404Handler(this.namespace, this.name);
   }
-}
+};
 var mk404Handler = (type, name) => function(...args) {
   console.warn("handler not found", { type, name, args }, this);
   return this;
 };
-
-class TypeVal extends NameVal {
+var TypeVal = class extends NameVal {
   eval(stack) {
     return stack.lookupType(this.name);
   }
-}
-
-class RenderVal extends BaseVal {
+};
+var RenderVal = class extends BaseVal {
   render(stack, _rx) {
     return this.eval(stack);
   }
-}
-
-class RenderNameVal extends RenderVal {
+};
+var RenderNameVal = class extends RenderVal {
   constructor(name) {
     super();
     this.name = name;
   }
-}
-
-class BindVal extends RenderNameVal {
+};
+var BindVal = class extends RenderNameVal {
   eval(stack) {
     return stack.lookupBind(this.name);
   }
   toString() {
     return `@${this.name}`;
   }
-}
-
-class BindMemberVal extends BindVal {
+};
+var BindMemberVal = class extends BindVal {
   constructor(name, member) {
     super(name);
     this.member = member;
@@ -893,18 +848,16 @@ class BindMemberVal extends BindVal {
   toString() {
     return `@${this.name}.${this.member}`;
   }
-}
-
-class DynVal extends RenderNameVal {
+};
+var DynVal = class extends RenderNameVal {
   eval(stack) {
     return stack.lookupDynamic(this.name);
   }
   toString() {
     return `*${this.name}`;
   }
-}
-
-class FieldVal extends RenderNameVal {
+};
+var FieldVal = class extends RenderNameVal {
   eval(stack) {
     return stack.lookupFieldRaw(this.name);
   }
@@ -914,9 +867,8 @@ class FieldVal extends RenderNameVal {
   toString() {
     return `.${this.name}`;
   }
-}
-
-class MethodVal extends RenderNameVal {
+};
+var MethodVal = class extends RenderNameVal {
   eval(stack) {
     return stack.lookupMethod(this.name);
   }
@@ -926,9 +878,8 @@ class MethodVal extends RenderNameVal {
   toString() {
     return `$${this.name}`;
   }
-}
-
-class SeqAccessVal extends RenderVal {
+};
+var SeqAccessVal = class extends RenderVal {
   constructor(seqVal, keyVal) {
     super();
     this.seqVal = seqVal;
@@ -944,11 +895,10 @@ class SeqAccessVal extends RenderVal {
   toString() {
     return `${this.seqVal}[${this.keyVal}]`;
   }
-}
-var vp = new ValParser;
+};
 
 // src/attribute.js
-class Attributes {
+var Attributes = class {
   constructor(items) {
     this.items = items;
   }
@@ -961,11 +911,10 @@ class Attributes {
   isConstant() {
     return false;
   }
-}
+};
 var booleanAttrsRaw = "itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected";
 var booleanAttrs = new Set(booleanAttrsRaw.split(","));
-
-class AttrParser {
+var AttrParser = class {
   constructor(px) {
     this.clear(px);
   }
@@ -980,13 +929,12 @@ class AttrParser {
     this.events = null;
   }
   parseAttr(name, value, parseAll = false) {
-    const val = parseAll ? vp.parseMacroAttr(value, this.px) : vp.parseText(value, this.px);
+    const val = parseAll ? parseMacroAttr(value, this.px) : parseText(value, this.px);
     if (val !== null) {
       this.attrs ??= [];
       this.attrs.push(new Attr(name, val));
       this.hasDynamic ||= !(val instanceof ConstVal);
-    } else
-      this.px.onParseIssue("bad-value", { role: "attr", attr: name, value });
+    } else this.px.onParseIssue("bad-value", { role: "attr", attr: name, value });
   }
   pushWrapper(name, raw, val) {
     const node = { name, val, raw };
@@ -995,7 +943,7 @@ class AttrParser {
     return node;
   }
   parseIf(directiveName, value) {
-    const dynVal = vp.parseBool(value, this.px);
+    const dynVal = parseBool(value, this.px);
     if (dynVal) {
       this.ifAttr = new IfAttr(directiveName.slice(3), dynVal);
       this.attrs ??= [];
@@ -1007,12 +955,10 @@ class AttrParser {
     }
   }
   parseThen(s) {
-    if (this.ifAttr)
-      this.ifAttr.thenVal = vp.parseText(s, this.px) ?? NOT_SET_VAL;
+    if (this.ifAttr) this.ifAttr.thenVal = parseText(s, this.px) ?? NOT_SET_VAL;
   }
   parseElse(value) {
-    if (this.ifAttr)
-      this.ifAttr.elseVal = vp.parseText(value, this.px) ?? NOT_SET_VAL;
+    if (this.ifAttr) this.ifAttr.elseVal = parseText(value, this.px) ?? NOT_SET_VAL;
   }
   parseEvent(directiveName, value) {
     const [eventName, ...modifiers] = directiveName.slice(3).split("+");
@@ -1021,13 +967,13 @@ class AttrParser {
       if (this.events === null) {
         this.events = this.px.registerEvents();
         this.attrs ??= [];
-        this.attrs.push(new ConstAttr("data-eid", vp.const(this.events.id)));
+        this.attrs.push(new ConstAttr("data-eid", new ConstVal(this.events.id)));
       }
       this.events.add(eventName, handler, modifiers);
     }
   }
   _parseDirectiveValue(directiveName, s, parserFn) {
-    const val = parserFn.call(vp, s, this.px);
+    const val = parserFn(s, this.px);
     if (val === null) {
       const info = { role: "directive", directive: directiveName, value: s };
       this.px.onParseIssue("bad-value", info);
@@ -1038,31 +984,39 @@ class AttrParser {
     switch (directiveName) {
       case "dangerouslysetinnerhtml":
         this.attrs ??= [];
-        this.attrs.push(new RawHtmlAttr(this._parseDirectiveValue(directiveName, s, vp.parseText)));
+        this.attrs.push(new RawHtmlAttr(this._parseDirectiveValue(directiveName, s, parseText)));
         this.hasDynamic = true;
         return;
       case "push-view":
-        this.pushWrapper("push-view", s, this._parseDirectiveValue(directiveName, s, vp.parseText));
+        this.pushWrapper("push-view", s, this._parseDirectiveValue(directiveName, s, parseText));
         return;
       case "text":
-        this.textChild = this._parseDirectiveValue(directiveName, s, vp.parseText);
+        this.textChild = this._parseDirectiveValue(directiveName, s, parseText);
         return;
       case "show":
-        this.pushWrapper("show", s, this._parseDirectiveValue(directiveName, s, vp.parseBool));
+        this.pushWrapper("show", s, this._parseDirectiveValue(directiveName, s, parseBool));
         return;
       case "hide":
-        this.pushWrapper("hide", s, this._parseDirectiveValue(directiveName, s, vp.parseBool));
+        this.pushWrapper("hide", s, this._parseDirectiveValue(directiveName, s, parseBool));
         return;
       case "each": {
-        const val = this._parseDirectiveValue(directiveName, s, vp.parseSequence);
+        const val = this._parseDirectiveValue(directiveName, s, parseSequence);
         this.eachAttr = this.pushWrapper("each", s, val);
         return;
       }
       case "enrich-with":
         if (this.eachAttr !== null)
-          this.eachAttr.enrichWithVal = this._parseDirectiveValue(directiveName, s, vp.parseAlterHandler);
+          this.eachAttr.enrichWithVal = this._parseDirectiveValue(
+            directiveName,
+            s,
+            parseAlterHandler
+          );
         else
-          this.pushWrapper("scope", s, this._parseDirectiveValue(directiveName, s, vp.parseAlterHandler));
+          this.pushWrapper(
+            "scope",
+            s,
+            this._parseDirectiveValue(directiveName, s, parseAlterHandler)
+          );
         return;
       case "when":
         this._parseWhen(s);
@@ -1077,14 +1031,10 @@ class AttrParser {
         this.parseElse(s);
         return;
     }
-    if (directiveName.startsWith("on."))
-      this.parseEvent(directiveName, s);
-    else if (directiveName.startsWith("if."))
-      this.parseIf(directiveName, s);
-    else if (directiveName.startsWith("then."))
-      this.parseThen(s);
-    else if (directiveName.startsWith("else."))
-      this.parseElse(s);
+    if (directiveName.startsWith("on.")) this.parseEvent(directiveName, s);
+    else if (directiveName.startsWith("if.")) this.parseIf(directiveName, s);
+    else if (directiveName.startsWith("then.")) this.parseThen(s);
+    else if (directiveName.startsWith("else.")) this.parseElse(s);
     else {
       const info = { name: directiveName, value: s };
       this.px.onParseIssue("unknown-directive", info);
@@ -1092,59 +1042,54 @@ class AttrParser {
   }
   _parseWhen(s) {
     if (this.eachAttr !== null)
-      this.eachAttr.whenVal = this._parseDirectiveValue("when", s, vp.parseAlterHandler);
+      this.eachAttr.whenVal = this._parseDirectiveValue("when", s, parseAlterHandler);
   }
   _parseLoopWith(s) {
     if (this.eachAttr !== null)
-      this.eachAttr.loopWithVal = this._parseDirectiveValue("loop-with", s, vp.parseAlterHandler);
+      this.eachAttr.loopWithVal = this._parseDirectiveValue("loop-with", s, parseAlterHandler);
   }
   parse(attributes, parseAll = false) {
     for (const { name, value } of attributes) {
       const charCode = name.charCodeAt(0);
       if (charCode === 58)
         this.parseAttr(name === ":viewbox" ? "viewBox" : name.slice(1), value, parseAll);
-      else if (charCode === 64)
-        this.parseDirective(value, name.slice(1));
+      else if (charCode === 64) this.parseDirective(value, name.slice(1));
       else {
         this.attrs ??= [];
         const constVal = value === "" && booleanAttrs.has(name) ? true : value;
-        this.attrs.push(new ConstAttr(name, vp.const(constVal)));
+        this.attrs.push(new ConstAttr(name, new ConstVal(constVal)));
       }
     }
     const { attrs, hasDynamic } = this;
     const pAttrs = hasDynamic ? new DynAttrs(attrs) : ConstAttrs.fromAttrs(attrs ?? []);
     return [pAttrs, this.wrapperAttrs, this.textChild];
   }
-}
-
-class ConstAttrs extends Attributes {
+};
+var ConstAttrs = class _ConstAttrs extends Attributes {
   eval(_stack) {
     return this.items;
   }
   static fromAttrs(attrs) {
     const attrsObj = {};
-    for (const attr of attrs)
-      attrsObj[attr.name] = attr.val.eval(null);
-    return new ConstAttrs(attrsObj);
+    for (const attr of attrs) attrsObj[attr.name] = attr.val.eval(null);
+    return new _ConstAttrs(attrsObj);
   }
   setDataAttr(key, val) {
     this.items[key] = val;
   }
   toMacroVars() {
     const r = {};
-    for (const name in this.items)
-      r[name] = new ConstVal(`${this.items[name]}`).toString();
+    for (const name in this.items) r[name] = new ConstVal(`${this.items[name]}`).toString();
     return r;
   }
   isConstant() {
     return true;
   }
-}
-
-class DynAttrs extends Attributes {
+};
+var DynAttrs = class extends Attributes {
   eval(stack) {
     const attrs = {};
-    for (let i = 0;i < this.items.length; i++) {
+    for (let i = 0; i < this.items.length; i++) {
       const attr = this.items[i];
       attrs[attr.name] = attr.eval(stack);
     }
@@ -1155,19 +1100,16 @@ class DynAttrs extends Attributes {
   }
   toMacroVars() {
     const r = {};
-    for (const attr of this.items)
-      r[attr.name] = attr.val.toString();
+    for (const attr of this.items) r[attr.name] = attr.val.toString();
     return r;
   }
-}
-
-class BaseAttr {
+};
+var BaseAttr = class {
   constructor(name) {
     this.name = name;
   }
-}
-
-class Attr extends BaseAttr {
+};
+var Attr = class extends BaseAttr {
   constructor(name, val) {
     super(name);
     this.val = val;
@@ -1175,22 +1117,19 @@ class Attr extends BaseAttr {
   eval(stack) {
     return this.val.eval(stack);
   }
-}
-
-class ConstAttr extends Attr {
-}
-
-class RawHtmlAttr extends Attr {
+};
+var ConstAttr = class extends Attr {
+};
+var RawHtmlAttr = class extends Attr {
   constructor(val) {
-    super("dangerouslySetInnerHTML", val ?? vp.nullConstVal);
+    super("dangerouslySetInnerHTML", val ?? NULL_CONST_VAL);
   }
   eval(stack) {
     return { __html: `${this.val.eval(stack)}` };
   }
-}
-var NOT_SET_VAL = vp.nullConstVal;
-
-class IfAttr extends BaseAttr {
+};
+var NOT_SET_VAL = NULL_CONST_VAL;
+var IfAttr = class extends BaseAttr {
   constructor(name, condVal) {
     super(name);
     this.condVal = condVal;
@@ -1202,73 +1141,66 @@ class IfAttr extends BaseAttr {
   eval(stack) {
     return this.condVal.eval(stack) ? this.thenVal.eval(stack) : this.elseVal.eval(stack);
   }
-}
+};
 var _attrParser = null;
 function getAttrParser(px) {
   _attrParser ??= new AttrParser(px);
   _attrParser.clear(px);
   return _attrParser;
 }
-
-class EventHandler {
+var EventHandler = class _EventHandler {
   constructor(handlerVal, args = []) {
     this.handlerVal = handlerVal;
     this.args = args;
   }
   getHandlerAndArgs(stack, _event) {
     const argValues = new Array(this.args.length);
-    for (let i = 0;i < argValues.length; i++)
-      argValues[i] = this.args[i].eval(stack);
+    for (let i = 0; i < argValues.length; i++) argValues[i] = this.args[i].eval(stack);
     return [this.handlerVal.evalAsHandler(stack), argValues];
   }
   static parse(s, px) {
-    const r = vp.parseInputHandler(s, px);
-    return r === null ? null : new EventHandler(r.handlerVal, r.args);
+    const r = parseInputHandler(s, px);
+    return r === null ? null : new _EventHandler(r.handlerVal, r.args);
   }
-}
-
-class RequestHandler {
+};
+var RequestHandler = class {
   constructor(name, fn) {
     this.name = name;
     this.fn = fn;
   }
-}
+};
 
 // src/renderer.js
 import { isIndexed, isKeyed } from "immutable";
 
 // src/cache.js
 var isWeakKey = (k) => k !== null && (typeof k === "object" || typeof k === "function");
-
-class NullDomCache {
-  get(_keys, _cacheKey) {}
-  set(_keys, _cacheKey, _v) {}
+var NullDomCache = class {
+  get(_keys, _cacheKey) {
+  }
+  set(_keys, _cacheKey, _v) {
+  }
   evict() {
     return { hit: 0, miss: 0, badKey: 0 };
   }
-}
-
-class WeakMapDomCache {
+};
+var WeakMapDomCache = class {
   constructor() {
     this.hit = this.miss = this.badKey = 0;
-    this.keysByLen = new Map;
+    this.keysByLen = /* @__PURE__ */ new Map();
   }
   _returnValue(r) {
-    if (r === undefined)
-      this.miss += 1;
-    else
-      this.hit += 1;
+    if (r === void 0) this.miss += 1;
+    else this.hit += 1;
     return r;
   }
   get(keys, cacheKey) {
     const len = keys.length;
     let cur = this.keysByLen.get(len);
-    if (!cur)
-      return this._returnValue(undefined);
-    for (let i = 0;i < len - 1; i++) {
+    if (!cur) return this._returnValue(void 0);
+    for (let i = 0; i < len - 1; i++) {
       cur = cur.get(keys[i]);
-      if (!cur)
-        return this._returnValue(undefined);
+      if (!cur) return this._returnValue(void 0);
     }
     return this._returnValue(cur.get(keys[len - 1])?.[cacheKey]);
   }
@@ -1276,10 +1208,10 @@ class WeakMapDomCache {
     const len = keys.length;
     let cur = this.keysByLen.get(len);
     if (!cur) {
-      cur = new WeakMap;
+      cur = /* @__PURE__ */ new WeakMap();
       this.keysByLen.set(len, cur);
     }
-    for (let i = 0;i < len - 1; i++) {
+    for (let i = 0; i < len - 1; i++) {
       const key = keys[i];
       let next = cur.get(key);
       if (!next) {
@@ -1287,27 +1219,24 @@ class WeakMapDomCache {
           this.badKey += 1;
           return;
         }
-        next = new WeakMap;
+        next = /* @__PURE__ */ new WeakMap();
         cur.set(key, next);
       }
       cur = next;
     }
     const lastKey = keys[len - 1];
     const leaf = cur.get(lastKey);
-    if (leaf)
-      leaf[cacheKey] = v;
-    else if (isWeakKey(lastKey))
-      cur.set(lastKey, { [cacheKey]: v });
-    else
-      this.badKey += 1;
+    if (leaf) leaf[cacheKey] = v;
+    else if (isWeakKey(lastKey)) cur.set(lastKey, { [cacheKey]: v });
+    else this.badKey += 1;
   }
   evict() {
     const { hit, miss, badKey } = this;
     this.hit = this.miss = this.badKey = 0;
-    this.keysByLen = new Map;
+    this.keysByLen = /* @__PURE__ */ new Map();
     return { hit, miss, badKey };
   }
-}
+};
 
 // src/vdom.js
 var HTML_NS = "http://www.w3.org/1999/xhtml";
@@ -1323,7 +1252,7 @@ function childOpts(vnode, ns, opts) {
   const target = ns === SVG_NS && isForeignObject(vnode.tag) ? null : ns;
   return target === (opts.namespace ?? null) ? opts : { ...opts, namespace: target };
 }
-var NEVER_ASSIGN = new Set([
+var NEVER_ASSIGN = /* @__PURE__ */ new Set([
   "width",
   "height",
   "href",
@@ -1339,39 +1268,35 @@ var NEVER_ASSIGN = new Set([
 var PROP_ATTR_NAME = { className: "class", htmlFor: "for" };
 function applyProperties(node, props) {
   const namespaced = isNamespaced(node);
-  for (const name in props)
-    setProp(node, name, props[name], namespaced);
+  for (const name in props) setProp(node, name, props[name], namespaced);
 }
 function setProp(node, name, value, namespaced) {
   if (name === "dangerouslySetInnerHTML") {
-    if (value === undefined)
-      node.replaceChildren();
+    if (value === void 0) node.replaceChildren();
     else {
-      const html = value.__html ?? "";
-      if (html !== node.innerHTML)
-        node.innerHTML = html;
+      const html2 = value.__html ?? "";
+      if (html2 !== node.innerHTML) node.innerHTML = html2;
     }
     return;
   }
-  if (typeof value === "function")
-    return;
+  if (typeof value === "function") return;
   const usesProp = !namespaced && !NEVER_ASSIGN.has(name) && name in node;
   if (usesProp && value != null) {
     try {
       node[name] = value;
       return;
-    } catch {}
+    } catch {
+    }
   }
   if (value == null || value === false && name[4] !== "-") {
     if (usesProp) {
       try {
         node[name] = "";
-      } catch {}
+      } catch {
+      }
       node.removeAttribute(PROP_ATTR_NAME[name] ?? name);
-    } else
-      node.removeAttribute(name);
-  } else
-    node.setAttribute(name, value);
+    } else node.removeAttribute(name);
+  } else node.setAttribute(name, value);
 }
 function applyValueLast(node, value) {
   if (node.tagName === "PROGRESS" && (value == null || value === 0)) {
@@ -1380,39 +1305,28 @@ function applyValueLast(node, value) {
     setProp(node, "value", value, isNamespaced(node));
   }
 }
-
-class VBase {
-}
-var getKey = (child) => child instanceof VNode ? child.key : undefined;
+var VBase = class {
+};
+var getKey = (child) => child instanceof VNode ? child.key : void 0;
 var isIterable = (obj) => obj != null && typeof obj !== "string" && typeof obj[Symbol.iterator] === "function";
 function childsEqual(a, b) {
-  if (a === b)
-    return true;
-  for (let i = 0;i < a.length; i++)
-    if (!a[i].isEqualTo(b[i]))
-      return false;
+  if (a === b) return true;
+  for (let i = 0; i < a.length; i++) if (!a[i].isEqualTo(b[i])) return false;
   return true;
 }
 function appendChildNodes(parent, childs, opts) {
-  for (const child of childs)
-    parent.appendChild(child.toDom(opts));
+  for (const child of childs) parent.appendChild(child.toDom(opts));
 }
 function addChild(normalizedChildren, child) {
-  if (child == null)
-    return;
+  if (child == null) return;
   if (isIterable(child)) {
-    for (const c of child)
-      addChild(normalizedChildren, c);
+    for (const c of child) addChild(normalizedChildren, c);
   } else if (child instanceof VBase) {
-    if (child instanceof VFragment)
-      normalizedChildren.push(...child.childs);
-    else
-      normalizedChildren.push(child);
-  } else
-    normalizedChildren.push(new VText(child));
+    if (child instanceof VFragment) normalizedChildren.push(...child.childs);
+    else normalizedChildren.push(child);
+  } else normalizedChildren.push(new VText(child));
 }
-
-class VText extends VBase {
+var VText = class _VText extends VBase {
   constructor(text) {
     super();
     this.text = String(text);
@@ -1421,14 +1335,13 @@ class VText extends VBase {
     return 3;
   }
   isEqualTo(other) {
-    return other instanceof VText && this.text === other.text;
+    return other instanceof _VText && this.text === other.text;
   }
   toDom(opts) {
     return opts.document.createTextNode(this.text);
   }
-}
-
-class VComment extends VBase {
+};
+var VComment = class _VComment extends VBase {
   constructor(text) {
     super();
     this.text = text;
@@ -1437,14 +1350,13 @@ class VComment extends VBase {
     return 8;
   }
   isEqualTo(other) {
-    return other instanceof VComment && this.text === other.text;
+    return other instanceof _VComment && this.text === other.text;
   }
   toDom(opts) {
     return opts.document.createComment(this.text);
   }
-}
-
-class VFragment extends VBase {
+};
+var VFragment = class _VFragment extends VBase {
   constructor(childs) {
     super();
     this.childs = [];
@@ -1454,8 +1366,7 @@ class VFragment extends VBase {
     return 11;
   }
   isEqualTo(other) {
-    if (!(other instanceof VFragment) || this.childs.length !== other.childs.length)
-      return false;
+    if (!(other instanceof _VFragment) || this.childs.length !== other.childs.length) return false;
     return childsEqual(this.childs, other.childs);
   }
   toDom(opts) {
@@ -1463,15 +1374,14 @@ class VFragment extends VBase {
     appendChildNodes(fragment, this.childs, opts);
     return fragment;
   }
-}
-
-class VNode extends VBase {
+};
+var VNode = class _VNode extends VBase {
   constructor(tag, attrs, childs, key, namespace) {
     super();
     this.tag = tag;
     this.attrs = attrs ?? {};
     this.childs = childs ?? [];
-    this.key = key != null ? String(key) : undefined;
+    this.key = key != null ? String(key) : void 0;
     this.namespace = typeof namespace === "string" ? namespace : null;
   }
   get nodeType() {
@@ -1481,18 +1391,13 @@ class VNode extends VBase {
     return this.tag === other.tag && this.namespace === other.namespace && this.key === other.key;
   }
   isEqualTo(other) {
-    if (this === other)
-      return true;
-    if (!(other instanceof VNode) || !this.isSameKind(other) || this.childs.length !== other.childs.length) {
+    if (this === other) return true;
+    if (!(other instanceof _VNode) || !this.isSameKind(other) || this.childs.length !== other.childs.length) {
       return false;
     }
     if (this.attrs !== other.attrs) {
-      for (const key in this.attrs)
-        if (this.attrs[key] !== other.attrs[key])
-          return false;
-      for (const key in other.attrs)
-        if (!Object.hasOwn(this.attrs, key))
-          return false;
+      for (const key in this.attrs) if (this.attrs[key] !== other.attrs[key]) return false;
+      for (const key in other.attrs) if (!Object.hasOwn(this.attrs, key)) return false;
     }
     return childsEqual(this.childs, other.childs);
   }
@@ -1501,32 +1406,29 @@ class VNode extends VBase {
     const ns = effectiveNs(this, opts);
     const tag = ns !== null && this.tag === this.tag.toUpperCase() ? this.tag.toLowerCase() : this.tag;
     const attrs = this.attrs;
-    const createOpts = attrs.is != null ? { is: attrs.is } : undefined;
+    const createOpts = attrs.is != null ? { is: attrs.is } : void 0;
     const node = ns === null ? doc.createElement(tag, createOpts) : doc.createElementNS(ns, tag, createOpts);
     const cOpts = childOpts(this, ns, opts);
     if ("value" in attrs || "checked" in attrs) {
       const { value, checked, ...rest } = attrs;
       applyProperties(node, rest);
       appendChildNodes(node, this.childs, cOpts);
-      if (value !== undefined)
-        applyValueLast(node, value);
-      if (checked !== undefined)
-        setProp(node, "checked", checked, false);
+      if (value !== void 0) applyValueLast(node, value);
+      if (checked !== void 0) setProp(node, "checked", checked, false);
     } else {
       applyProperties(node, attrs);
       appendChildNodes(node, this.childs, cOpts);
     }
     return node;
   }
-}
+};
 function diffProps(a, b) {
-  if (a === b)
-    return null;
+  if (a === b) return null;
   let diff = null;
   for (const aKey in a) {
     if (!Object.hasOwn(b, aKey)) {
       diff ??= {};
-      diff[aKey] = undefined;
+      diff[aKey] = void 0;
     } else if (a[aKey] !== b[aKey]) {
       diff ??= {};
       diff[aKey] = b[aKey];
@@ -1541,8 +1443,7 @@ function diffProps(a, b) {
   return diff;
 }
 function morphNode(domNode, source, target, opts) {
-  if (source === target || source.isEqualTo(target))
-    return domNode;
+  if (source === target || source.isEqualTo(target)) return domNode;
   const type = source.nodeType;
   if (type === target.nodeType) {
     if (type === 3 || type === 8) {
@@ -1557,19 +1458,16 @@ function morphNode(domNode, source, target, opts) {
         if (hasValue || hasChecked) {
           const { value: _v, checked: _c, ...rest } = propsDiff;
           applyProperties(domNode, rest);
-        } else
-          applyProperties(domNode, propsDiff);
+        } else applyProperties(domNode, propsDiff);
       }
       if (!target.attrs.dangerouslySetInnerHTML) {
         const ns = effectiveNs(target, opts);
         morphChildren(domNode, source.childs, target.childs, childOpts(target, ns, opts));
       }
-      if (hasValue)
-        applyValueLast(domNode, propsDiff.value);
-      else if (source.tag === "SELECT" && target.attrs.value !== undefined)
+      if (hasValue) applyValueLast(domNode, propsDiff.value);
+      else if (source.tag === "SELECT" && target.attrs.value !== void 0)
         applyValueLast(domNode, target.attrs.value);
-      if (hasChecked)
-        setProp(domNode, "checked", propsDiff.checked, false);
+      if (hasChecked) setProp(domNode, "checked", propsDiff.checked, false);
       return domNode;
     }
     if (type === 11) {
@@ -1592,7 +1490,7 @@ function morphChildren(parentDom, oldChilds, newChilds, opts) {
   }
   if (oldChilds.length === newChilds.length) {
     let hasKey = false;
-    for (let i = 0;i < oldChilds.length; i++) {
+    for (let i = 0; i < oldChilds.length; i++) {
       if (getKey(oldChilds[i]) != null || getKey(newChilds[i]) != null) {
         hasKey = true;
         break;
@@ -1600,7 +1498,7 @@ function morphChildren(parentDom, oldChilds, newChilds, opts) {
     }
     if (!hasKey) {
       let dom = parentDom.firstChild;
-      for (let i = 0;i < oldChilds.length; i++) {
+      for (let i = 0; i < oldChilds.length; i++) {
         const next = dom.nextSibling;
         morphNode(dom, oldChilds[i], newChilds[i], opts);
         dom = next;
@@ -1609,21 +1507,19 @@ function morphChildren(parentDom, oldChilds, newChilds, opts) {
     }
   }
   const domNodes = Array.from(parentDom.childNodes);
-  const oldKeyMap = Object.create(null);
-  for (let i = 0;i < oldChilds.length; i++) {
+  const oldKeyMap = /* @__PURE__ */ Object.create(null);
+  for (let i = 0; i < oldChilds.length; i++) {
     const key = getKey(oldChilds[i]);
-    if (key != null)
-      oldKeyMap[key] = i;
+    if (key != null) oldKeyMap[key] = i;
   }
   const used = new Uint8Array(oldChilds.length);
   let unkeyedCursor = 0;
-  for (let j = 0;j < newChilds.length; j++) {
+  for (let j = 0; j < newChilds.length; j++) {
     const newChild = newChilds[j];
     const newKey = getKey(newChild);
     let oldIdx = -1;
     if (newKey != null) {
-      if (newKey in oldKeyMap && !used[oldKeyMap[newKey]])
-        oldIdx = oldKeyMap[newKey];
+      if (newKey in oldKeyMap && !used[oldKeyMap[newKey]]) oldIdx = oldKeyMap[newKey];
     } else {
       while (unkeyedCursor < oldChilds.length) {
         if (!used[unkeyedCursor] && getKey(oldChilds[unkeyedCursor]) == null) {
@@ -1637,16 +1533,14 @@ function morphChildren(parentDom, oldChilds, newChilds, opts) {
       used[oldIdx] = 1;
       const newDom = morphNode(domNodes[oldIdx], oldChilds[oldIdx], newChild, opts);
       const ref = parentDom.childNodes[j] ?? null;
-      if (newDom !== ref)
-        parentDom.insertBefore(newDom, ref);
+      if (newDom !== ref) parentDom.insertBefore(newDom, ref);
     } else {
       const ref = parentDom.childNodes[j] ?? null;
       parentDom.insertBefore(newChild.toDom(opts), ref);
     }
   }
-  for (let i = oldChilds.length - 1;i >= 0; i--)
-    if (!used[i] && domNodes[i].parentNode === parentDom)
-      parentDom.removeChild(domNodes[i]);
+  for (let i = oldChilds.length - 1; i >= 0; i--)
+    if (!used[i] && domNodes[i].parentNode === parentDom) parentDom.removeChild(domNodes[i]);
 }
 function render(vnode, container, options, prev) {
   const isFragment = vnode instanceof VFragment;
@@ -1665,12 +1559,9 @@ function h(tagName, properties, children, namespace) {
   if (properties) {
     for (const propName in properties) {
       const propVal = properties[propName];
-      if (propName === "key")
-        key = propVal;
-      else if (propName === "namespace")
-        namespace = namespace ?? propVal;
-      else
-        props[propName] = propVal;
+      if (propName === "key") key = propVal;
+      else if (propName === "namespace") namespace = namespace ?? propVal;
+      else props[propName] = propVal;
     }
   }
   if (namespace == null) {
@@ -1692,11 +1583,10 @@ function h(tagName, properties, children, namespace) {
 
 // src/renderer.js
 var DATASET_ATTRS = ["nid", "cid", "eid", "vid", "si", "sk"];
-
-class Renderer {
+var Renderer = class {
   constructor(comps) {
     this.comps = comps;
-    this.cache = new WeakMapDomCache;
+    this.cache = new WeakMapDomCache();
     this.renderTag = h;
   }
   renderFragment(childs) {
@@ -1706,7 +1596,7 @@ class Renderer {
     return new VComment(text);
   }
   setNullCache() {
-    this.cache = new NullDomCache;
+    this.cache = new NullDomCache();
   }
   renderToDOM(stack, val) {
     const rootNode = document.createElement("div");
@@ -1718,33 +1608,33 @@ class Renderer {
     const dom = this.renderToDOM(stack, val);
     if (cleanAttrs) {
       const nodes = dom.querySelectorAll("[data-nid],[data-cid],[data-eid]");
-      for (const { dataset } of nodes)
-        for (const name of DATASET_ATTRS)
-          delete dataset[name];
+      for (const { dataset } of nodes) for (const name of DATASET_ATTRS) delete dataset[name];
     }
     return dom.innerHTML;
   }
   renderRoot(stack, val, viewName = null) {
     const comp = this.comps.getCompFor(val);
-    if (comp === null)
-      return null;
+    if (comp === null) return null;
     return this._rValComp(stack, val, comp, comp.getView(viewName).anode, "ROOT", viewName);
   }
   renderIt(stack, node, key, viewName) {
     const comp = this.comps.getCompFor(stack.it);
     return comp ? this._rValComp(stack, stack.it, comp, node, key, viewName) : null;
   }
+  // `node` is the parse node of the render site (`<x render>` / `render-it` /
+  // `render-each`, or the view's root anode for the app root). It keys the
+  // cache as a globally-unique object: node ids alone are unique only within a
+  // single view, so the same value rendered by two components (e.g. through a
+  // shared dynamic-var sequence) would otherwise collide in the cache.
   _rValComp(stack, val, comp, node, key, viewName) {
-    const cacheKey = `${viewName ?? ""}\x1F${stack.viewsId ?? ""}\x1F${key}`;
+    const cacheKey = `${viewName ?? ""}${stack.viewsId ?? ""}${key}`;
     const cachePath = [node, val];
     stack._pushDynBindValuesToArray(cachePath, comp);
     const cachedNode = this.cache.get(cachePath, cacheKey);
-    if (cachedNode)
-      return cachedNode;
+    if (cachedNode) return cachedNode;
     const view = viewName ? comp.getView(viewName) : stack.lookupBestView(comp.views, "main");
     const body = this.renderView(view, stack);
-    if (body == null)
-      return null;
+    if (body == null) return null;
     const meta = this._renderMetadata({
       $: "Comp",
       nid: node?.nodeId ?? null,
@@ -1762,30 +1652,33 @@ class Renderer {
     const { seq, filter, loopWith, enricher } = iterInfo.eval(stack);
     const r = [];
     const it = stack.it;
-    const { iterData, start, end, keys } = unpackLoopResult(loopWith.call(it, seq, makeLoopCtx(stack, filter)), seq);
+    const { iterData, start, end, keys } = unpackLoopResult(
+      loopWith.call(it, seq, makeLoopCtx(stack, filter)),
+      seq
+    );
     const renderOne = (key, value, attrName) => {
       const cachePath = enricher ? [view, it, value] : [view, value];
       const binds = { key, value };
-      const cacheKey = `${stack.viewsId ?? ""}\x1F${nid}\x1F${key}`;
-      if (enricher)
-        callEnricher(enricher, it, binds, key, value, iterData);
+      const cacheKey = `${stack.viewsId ?? ""}${nid}${key}`;
+      if (enricher) callEnricher(enricher, it, binds, key, value, iterData);
       const cachedNode = this.cache.get(cachePath, cacheKey);
-      if (cachedNode)
-        this.pushEachEntry(r, nid, attrName, key, cachedNode);
+      if (cachedNode) this.pushEachEntry(r, nid, attrName, key, cachedNode);
       else {
         const dom = this.renderView(view, stack.enter(value, binds, false));
-        if (dom != null)
-          this.pushEachEntry(r, nid, attrName, key, dom);
+        if (dom != null) this.pushEachEntry(r, nid, attrName, key, dom);
         this.cache.set(cachePath, cacheKey, dom);
       }
     };
-    if (keys)
-      imKeysIter(seq, renderOne, keys);
+    if (keys) imKeysIter(seq, renderOne, keys);
     else
-      getSeqInfo(seq)(seq, (key, value, attrName) => {
-        if (filter.call(it, key, value, iterData))
-          renderOne(key, value, attrName);
-      }, start, end);
+      getSeqInfo(seq)(
+        seq,
+        (key, value, attrName) => {
+          if (filter.call(it, key, value, iterData)) renderOne(key, value, attrName);
+        },
+        start,
+        end
+      );
     return r;
   }
   renderView(view, stack) {
@@ -1793,8 +1686,7 @@ class Renderer {
     while (n !== null) {
       const b = n[0];
       if (b.isFrame) {
-        if (stack.it !== b.it)
-          break;
+        if (stack.it !== b.it) break;
         console.error("recursion detected", stack.it, b.it);
         return new VComment("RECURSION AVOIDED");
       }
@@ -1805,10 +1697,12 @@ class Renderer {
   _renderMetadata(info) {
     return new VComment(`§${JSON.stringify(info)}§`);
   }
+  // Prefix a loop-less @enrich-with subtree with a boundary meta so event-path
+  // reconstruction replays its binds (mirrors the §Each§ / §Comp§ metas).
   renderScopeMeta(nid, dom) {
     return new VFragment([this._renderMetadata({ $: "Scope", nid }), dom]);
   }
-}
+};
 var getSeqInfo = (seq) => isIndexed(seq) ? imIndexedIter : isKeyed(seq) ? imKeyedIter : seq?.[SEQ_INFO] ?? unkIter;
 var normalizeRange = (start, end, size) => {
   let s = start == null ? 0 : start < 0 ? size + start : start;
@@ -1819,7 +1713,10 @@ var normalizeRange = (start, end, size) => {
 };
 var callEnricher = (enricher, it, binds, key, value, iterData) => {
   enricher.call(it, binds, key, value, iterData);
-  console.assert(binds.key === key && binds.value === value, "@enrich-with handlers must not overwrite binds.key or binds.value");
+  console.assert(
+    binds.key === key && binds.value === value,
+    "@enrich-with handlers must not overwrite binds.key or binds.value"
+  );
   binds.key = key;
   binds.value = value;
 };
@@ -1831,8 +1728,7 @@ var unpackLoopResult = (result, seq) => {
 };
 var imKeysIter = (seq, visit, keys) => {
   const attrName = isIndexed(seq) ? "si" : "sk";
-  for (const key of keys)
-    visit(key, seq.get(key), attrName);
+  for (const key of keys) visit(key, seq.get(key), attrName);
 };
 var makeLoopCtx = (stack, filter) => ({
   lookup: (name) => stack.lookupBind(name),
@@ -1840,22 +1736,20 @@ var makeLoopCtx = (stack, filter) => ({
 });
 var imIndexedIter = (seq, visit, start, end) => {
   const [s, e] = normalizeRange(start, end, seq.size);
-  for (let i = s;i < e; i++)
-    visit(i, seq.get(i), "si");
+  for (let i = s; i < e; i++) visit(i, seq.get(i), "si");
 };
 var imKeyedIter = (seq, visit, start, end) => {
   const [s, e] = normalizeRange(start, end, seq.size);
   let i = 0;
   for (const [k, v] of seq.toSeq().entries()) {
-    if (i >= e)
-      break;
-    if (i >= s)
-      visit(k, v, "sk");
+    if (i >= e) break;
+    if (i >= s) visit(k, v, "sk");
     i++;
   }
 };
-var unkIter = () => {};
-var SEQ_INFO = Symbol.for("tutuca.seqInfo");
+var unkIter = () => {
+};
+var SEQ_INFO = /* @__PURE__ */ Symbol.for("tutuca.seqInfo");
 
 // src/util/env.js
 var isMac = (globalThis.navigator?.userAgent ?? "").toLowerCase().includes("mac");
@@ -1869,18 +1763,15 @@ function resolveDynProducer(comp, name) {
     producerProvide = producerComp?.provide?.[lk.provideName];
   } else {
     const p = comp?.provide?.[name];
-    if (p == null)
-      return null;
+    if (p == null) return null;
     producerComp = comp;
     producerProvide = p;
   }
-  if (producerComp == null || producerProvide == null)
-    return null;
+  if (producerComp == null || producerProvide == null) return null;
   const pi = producerProvide.val?.toPathItem?.() ?? null;
   return { producerCompId: producerComp.id, producerSteps: pi ? [pi] : [] };
 }
-
-class BaseNode {
+var BaseNode = class {
   render(_stack, _rx) {
     return null;
   }
@@ -1893,10 +1784,10 @@ class BaseNode {
   isWhiteSpace() {
     return false;
   }
-  optimize() {}
-}
-
-class TextNode extends BaseNode {
+  optimize() {
+  }
+};
+var TextNode = class extends BaseNode {
   constructor(val) {
     super();
     this.val = val;
@@ -1905,18 +1796,16 @@ class TextNode extends BaseNode {
     return this.val;
   }
   isWhiteSpace() {
-    for (let i = 0;i < this.val.length; i++) {
+    for (let i = 0; i < this.val.length; i++) {
       const c = this.val.charCodeAt(i);
-      if (!(c === 32 || c === 10 || c === 9 || c === 13))
-        return false;
+      if (!(c === 32 || c === 10 || c === 9 || c === 13)) return false;
     }
     return true;
   }
   hasNewLine() {
-    for (let i = 0;i < this.val.length; i++) {
+    for (let i = 0; i < this.val.length; i++) {
       const c = this.val.charCodeAt(i);
-      if (c === 10 || c === 13)
-        return true;
+      if (c === 10 || c === 13) return true;
     }
     return false;
   }
@@ -1926,31 +1815,27 @@ class TextNode extends BaseNode {
   isConstant() {
     return true;
   }
-  setDataAttr(_key, _val) {}
-}
-
-class CommentNode extends TextNode {
+  setDataAttr(_key, _val) {
+  }
+};
+var CommentNode = class extends TextNode {
   render(_stack, rx) {
     return rx.renderComment(this.val);
   }
-}
+};
 function optimizeChilds(childs) {
-  for (let i = 0;i < childs.length; i++) {
+  for (let i = 0; i < childs.length; i++) {
     const child = childs[i];
-    if (child.isConstant())
-      childs[i] = new RenderOnceNode(child);
-    else
-      child.optimize();
+    if (child.isConstant()) childs[i] = new RenderOnceNode(child);
+    else child.optimize();
   }
 }
 function optimizeNode(node) {
-  if (node.isConstant())
-    return new RenderOnceNode(node);
+  if (node.isConstant()) return new RenderOnceNode(node);
   node.optimize();
   return node;
 }
-
-class ChildsNode extends BaseNode {
+var ChildsNode = class extends BaseNode {
   constructor(childs) {
     super();
     this.childs = childs;
@@ -1961,9 +1846,8 @@ class ChildsNode extends BaseNode {
   optimize() {
     optimizeChilds(this.childs);
   }
-}
-
-class DomNode extends ChildsNode {
+};
+var DomNode = class extends ChildsNode {
   constructor(tagName, attrs, childs, namespace = null) {
     super(childs);
     this.tagName = tagName;
@@ -1972,7 +1856,7 @@ class DomNode extends ChildsNode {
   }
   render(stack, rx) {
     const childNodes = new Array(this.childs.length);
-    for (let i = 0;i < childNodes.length; i++)
+    for (let i = 0; i < childNodes.length; i++)
       childNodes[i] = this.childs[i]?.render?.(stack, rx) ?? null;
     return rx.renderTag(this.tagName, this.attrs.eval(stack), childNodes, this.namespace);
   }
@@ -1982,21 +1866,18 @@ class DomNode extends ChildsNode {
   isConstant() {
     return this.attrs.isConstant() && super.isConstant();
   }
-}
-
-class FragmentNode extends ChildsNode {
+};
+var FragmentNode = class extends ChildsNode {
   render(stack, rx) {
     return rx.renderFragment(this.childs.map((c) => c?.render(stack, rx)));
   }
   setDataAttr(key, val) {
-    for (const child of this.childs)
-      child.setDataAttr(key, val);
+    for (const child of this.childs) child.setDataAttr(key, val);
   }
-}
+};
 var maybeFragment = (xs) => xs.length === 1 ? xs[0] : new FragmentNode(xs);
 var VALID_NODE_RE = /^[a-zA-Z][a-zA-Z0-9-]*$/;
-
-class ANode extends BaseNode {
+var ANode = class _ANode extends BaseNode {
   constructor(nodeId, val) {
     super();
     this.nodeId = nodeId;
@@ -2005,41 +1886,33 @@ class ANode extends BaseNode {
   toPathStep(ctx) {
     return ctx.applyKey(this.val?.toPathItem?.() ?? null);
   }
-  static parse(html, px) {
-    const nodes = px.parseHTML(html);
-    if (nodes.length === 0)
-      return new CommentNode("Empty View in ANode.parse");
-    if (nodes.length === 1)
-      return ANode.fromDOM(nodes[0], px);
+  static parse(html2, px) {
+    const nodes = px.parseHTML(html2);
+    if (nodes.length === 0) return new CommentNode("Empty View in ANode.parse");
+    if (nodes.length === 1) return _ANode.fromDOM(nodes[0], px);
     const childs = [];
-    for (let i = 0;i < nodes.length; i++) {
-      const child = ANode.fromDOM(nodes[i], px);
-      if (child !== null)
-        childs.push(child);
+    for (let i = 0; i < nodes.length; i++) {
+      const child = _ANode.fromDOM(nodes[i], px);
+      if (child !== null) childs.push(child);
     }
     const trimmed = condenseChildsWhites(childs);
-    if (trimmed.length === 0)
-      return new CommentNode("Empty View in ANode.parse");
+    if (trimmed.length === 0) return new CommentNode("Empty View in ANode.parse");
     return maybeFragment(trimmed);
   }
   static fromDOM(node, px) {
-    if (node instanceof px.Text)
-      return new TextNode(node.textContent);
-    else if (node instanceof px.Comment)
-      return new CommentNode(node.textContent);
+    if (node instanceof px.Text) return new TextNode(node.textContent);
+    else if (node instanceof px.Comment) return new CommentNode(node.textContent);
     const { childNodes, attributes: attrs, tagName: tag } = node;
     const childs = [];
-    for (let i = 0;i < childNodes.length; i++) {
-      const child = ANode.fromDOM(childNodes[i], px);
-      if (child !== null)
-        childs.push(child);
+    for (let i = 0; i < childNodes.length; i++) {
+      const child = _ANode.fromDOM(childNodes[i], px);
+      if (child !== null) childs.push(child);
     }
     const prevTag = px.currentTag;
     px.currentTag = tag;
     try {
       const isPseudoX = attrs[0]?.name === "@x";
-      if (tag === "X" || isPseudoX)
-        return parseXOp(attrs, childs, isPseudoX ? 1 : 0, px);
+      if (tag === "X" || isPseudoX) return parseXOp(attrs, childs, isPseudoX ? 1 : 0, px);
       else if (tag.charCodeAt(1) === 58 && (tag.charCodeAt(0) === 88 || tag.charCodeAt(0) === 120)) {
         const macroName = tag.slice(2).toLowerCase();
         if (macroName === "slot") {
@@ -2052,8 +1925,7 @@ class ANode extends BaseNode {
       } else if (VALID_NODE_RE.test(tag)) {
         const [nAttrs, wrappers, textChild] = Attributes.parse(attrs, px);
         px.onAttributes(nAttrs, wrappers, textChild, false, tag);
-        if (textChild)
-          childs.unshift(new RenderTextNode(null, textChild));
+        if (textChild) childs.unshift(new RenderTextNode(null, textChild));
         const domChilds = tag !== "PRE" ? condenseChildsWhites(childs) : childs;
         const ns = node.namespaceURI;
         const namespace = ns && ns !== HTML_NS ? ns : null;
@@ -2064,10 +1936,9 @@ class ANode extends BaseNode {
       px.currentTag = prevTag;
     }
   }
-}
+};
 function parseXOp(attrs, childs, opIdx, px) {
-  if (attrs.length <= opIdx)
-    return maybeFragment(childs);
+  if (attrs.length <= opIdx) return maybeFragment(childs);
   const { name, value } = attrs[opIdx];
   if (X_OPS[name]?.ignoresChildren && hasMeaningfulChilds(childs))
     px.onParseIssue("x-op-ignores-children", { op: name });
@@ -2076,13 +1947,13 @@ function parseXOp(attrs, childs, opIdx, px) {
   let node;
   switch (name) {
     case "slot":
-      node = new SlotNode(null, vp.const(value), maybeFragment(childs));
+      node = new SlotNode(null, new ConstVal(value), maybeFragment(childs));
       break;
     case "text":
-      node = px.addNodeIf(RenderTextNode, parseXOpVal(name, value, px, vp.parseText));
+      node = px.addNodeIf(RenderTextNode, parseXOpVal(name, value, px, parseText));
       break;
     case "render":
-      node = px.addNodeIf(RenderNode, parseXOpVal(name, value, px, vp.parseComponent), as);
+      node = px.addNodeIf(RenderNode, parseXOpVal(name, value, px, parseComponent), as);
       break;
     case "render-it":
       node = px.addNode(RenderItNode, as);
@@ -2091,12 +1962,12 @@ function parseXOp(attrs, childs, opIdx, px) {
       node = parseRenderEach(px, value, as, attrs);
       break;
     case "show": {
-      const val = parseXOpVal(name, value, px, vp.parseBool);
+      const val = parseXOpVal(name, value, px, parseBool);
       node = px.addNodeIf(ShowNode, val, maybeFragment(childs));
       break;
     }
     case "hide": {
-      const val = parseXOpVal(name, value, px, vp.parseBool);
+      const val = parseXOpVal(name, value, px, parseBool);
       node = px.addNodeIf(HideNode, val, maybeFragment(childs));
       break;
     }
@@ -2107,39 +1978,35 @@ function parseXOp(attrs, childs, opIdx, px) {
   return processXExtras(node, attrs, name, opIdx + 1, px);
 }
 function parseXOpVal(opName, value, px, parserFn) {
-  const val = parserFn.call(vp, value, px);
-  if (val === null)
-    px.onParseIssue("bad-value", { role: "x-op", op: opName, value });
+  const val = parserFn(value, px);
+  if (val === null) px.onParseIssue("bad-value", { role: "x-op", op: opName, value });
   return val;
 }
 function parseViewName(s, px) {
-  return vp.parseText(s, px) ?? vp.const(s);
+  return parseText(s, px) ?? new ConstVal(s);
 }
 function processXExtras(node, attrs, opName, startIdx, px) {
   const { consumed, wrappable } = X_OPS[opName];
   const wrappers = [];
-  for (let i = startIdx;i < attrs.length; i++) {
+  for (let i = startIdx; i < attrs.length; i++) {
     const a = attrs[i];
     const aName = a.name;
-    if (consumed.has(aName))
-      continue;
+    if (consumed.has(aName)) continue;
     const atPrefixed = aName.charCodeAt(0) === 64;
     const baseName = atPrefixed ? aName.slice(1) : aName;
     const wrapper = wrappable ? X_OPS[baseName]?.wrapper : null;
     if (wrapper) {
-      if (!atPrefixed)
-        maybeDeprecateBareXDirective(px, opName, baseName);
-      wrappers.push([wrapper, vp.parseBool(a.value, px)]);
+      if (!atPrefixed) maybeDeprecateBareXDirective(px, opName, baseName);
+      wrappers.push([wrapper, parseBool(a.value, px)]);
       continue;
     }
     const issueInfo = { op: opName, name: aName, value: a.value };
     px.onParseIssue("unknown-x-attr", issueInfo);
   }
-  for (let i = wrappers.length - 1;i >= 0; i--) {
+  for (let i = wrappers.length - 1; i >= 0; i--) {
     const [Cls, val] = wrappers[i];
     const wrapper = px.addNodeIf(Cls, val, node);
-    if (wrapper !== null)
-      node = wrapper;
+    if (wrapper !== null) node = wrapper;
   }
   return node;
 }
@@ -2148,7 +2015,7 @@ function maybeDeprecateBareXDirective(px, opName, name) {
 }
 function wrap(node, px, wrappers) {
   if (wrappers) {
-    for (let i = wrappers.length - 1;i >= 0; i--) {
+    for (let i = wrappers.length - 1; i >= 0; i--) {
       const wrapperNode = makeWrapperNode(wrappers[i], px);
       if (wrapperNode) {
         wrapperNode.wrapNode(node);
@@ -2168,8 +2035,7 @@ function makeWrapperNode(data, px) {
   }
   return node;
 }
-
-class MacroNode extends BaseNode {
+var MacroNode = class extends BaseNode {
   constructor(name, attrs, slots, px) {
     super();
     this.name = name;
@@ -2181,16 +2047,13 @@ class MacroNode extends BaseNode {
   }
   compile(scope) {
     const { name, attrs, slots } = this;
-    if (this.px.isInsideMacro(name))
-      throw new Error(`Recursive macro expansion: ${name}`);
-    const macro = scope.lookupMacro(name);
-    if (macro === null)
-      this.node = new CommentNode(`bad macro: ${name}`);
+    if (this.px.isInsideMacro(name)) throw new Error(`Recursive macro expansion: ${name}`);
+    const macro2 = scope.lookupMacro(name);
+    if (macro2 === null) this.node = new CommentNode(`bad macro: ${name}`);
     else {
-      const vars = { ...macro.defaults, ...attrs };
-      this.node = macro.expand(this.px.enterMacro(name, vars, slots));
-      for (const key in this.dataAttrs)
-        this.node.setDataAttr(key, this.dataAttrs[key]);
+      const vars = { ...macro2.defaults, ...attrs };
+      this.node = macro2.expand(this.px.enterMacro(name, vars, slots));
+      for (const key in this.dataAttrs) this.node.setDataAttr(key, this.dataAttrs[key]);
     }
   }
   render(stack, rx) {
@@ -2205,9 +2068,8 @@ class MacroNode extends BaseNode {
   optimize() {
     this.node = optimizeNode(this.node);
   }
-}
-
-class Macro {
+};
+var Macro = class {
   constructor(defaults, rawView) {
     this.defaults = defaults;
     this.rawView = rawView;
@@ -2215,46 +2077,47 @@ class Macro {
   expand(px) {
     return ANode.parse(this.rawView, px);
   }
-}
-
-class RenderViewId extends ANode {
+};
+var RenderViewId = class extends ANode {
   constructor(nodeId, val, viewVal) {
     super(nodeId, val);
     this.viewVal = viewVal;
   }
+  // The `as=` view selector, evaluated against the host (enclosing) stack like
+  // `@push-view`. Null when `as=` is absent, so the renderer falls through to
+  // `stack.lookupBestView`.
   evalViewName(stack) {
     return this.viewVal ? this.viewVal.eval(stack) : null;
   }
-  setDataAttr(_key, _val) {}
-}
+  // A `<x render*>` produces no DOM element of its own to carry `data-cid`;
+  // when it is a view's root the component boundary is recorded in the `Comp`
+  // meta comment instead (see Renderer._rValComp), so this is a no-op.
+  setDataAttr(_key, _val) {
+  }
+};
 function dynRenderStep(comp, name, key) {
   const p = resolveDynProducer(comp, name);
-  if (!p)
-    return null;
-  return key === undefined ? new DynStep(p.producerCompId, p.producerSteps) : new DynEachStep(p.producerCompId, p.producerSteps, key);
+  if (!p) return null;
+  return key === void 0 ? new DynStep(p.producerCompId, p.producerSteps) : new DynEachStep(p.producerCompId, p.producerSteps, key);
 }
-
-class RenderNode extends RenderViewId {
+var RenderNode = class extends RenderViewId {
   render(stack, rx) {
     const newStack = stack.enter(this.val.eval(stack), {}, true);
     return rx.renderIt(newStack, this, "", this.evalViewName(stack));
   }
   toPathStep(ctx) {
-    if (this.val instanceof DynVal)
-      return dynRenderStep(ctx.comp, this.val.name);
+    if (this.val instanceof DynVal) return dynRenderStep(ctx.comp, this.val.name);
     return super.toPathStep(ctx);
   }
-}
-
-class RenderItNode extends RenderViewId {
+};
+var RenderItNode = class extends RenderViewId {
   render(stack, rx) {
     const newStack = stack.enter(stack.it, {}, true);
     return rx.renderIt(newStack, this, "", this.evalViewName(stack));
   }
   toPathStep(ctx) {
     const next = ctx.next();
-    if (next === null)
-      return null;
+    if (next === null) return null;
     const nextNode = next.resolveNode();
     if (nextNode instanceof EachNode && next.hasKey) {
       if (nextNode.val instanceof DynVal)
@@ -2263,18 +2126,16 @@ class RenderItNode extends RenderViewId {
     }
     return null;
   }
-}
+};
 function parseRenderEach(px, value, as, attrs) {
-  const seqVal = parseXOpVal("render-each", value, px, vp.parseSequence);
-  if (seqVal === null)
-    return null;
+  const seqVal = parseXOpVal("render-each", value, px, parseSequence);
+  if (seqVal === null) return null;
   const renderIt = px.addNode(RenderItNode, as);
   const attrParser = getAttrParser(px);
   const eachAttr = attrParser.eachAttr = attrParser.pushWrapper("each", value, seqVal);
   const when = attrs.getNamedItem("@when") ?? attrs.getNamedItem("when");
   if (when) {
-    if (when.name.charCodeAt(0) !== 64)
-      maybeDeprecateBareXDirective(px, "render-each", "when");
+    if (when.name.charCodeAt(0) !== 64) maybeDeprecateBareXDirective(px, "render-each", "when");
     attrParser._parseWhen(when.value);
   }
   const lWith = attrs.getNamedItem("@loop-with") ?? attrs.getNamedItem("loop-with");
@@ -2290,15 +2151,15 @@ function parseRenderEach(px, value, as, attrs) {
   each.wrapNode(renderIt);
   return each;
 }
-
-class RenderTextNode extends ANode {
+var RenderTextNode = class extends ANode {
   render(stack, _rx) {
     return this.val.eval(stack);
   }
-  setDataAttr(_key, _val) {}
-}
-
-class RenderOnceNode extends BaseNode {
+  // Renders to a text node, which can't carry `data-cid`.
+  setDataAttr(_key, _val) {
+  }
+};
+var RenderOnceNode = class extends BaseNode {
   constructor(node) {
     super();
     this.node = node;
@@ -2311,9 +2172,8 @@ class RenderOnceNode extends BaseNode {
   render(stack, rx) {
     return this._render(stack, rx);
   }
-}
-
-class WrapperNode extends ANode {
+};
+var WrapperNode = class extends ANode {
   constructor(nodeId, val, node = null) {
     super(nodeId, val);
     this.node = node;
@@ -2328,34 +2188,33 @@ class WrapperNode extends ANode {
     this.node = optimizeNode(this.node);
   }
   static register = false;
-}
-
-class ShowNode extends WrapperNode {
+};
+var ShowNode = class extends WrapperNode {
   render(stack, rx) {
     return this.val.eval(stack) ? this.node.render(stack, rx) : null;
   }
-}
-
-class HideNode extends WrapperNode {
+};
+var HideNode = class extends WrapperNode {
   render(stack, rx) {
     return this.val.eval(stack) ? null : this.node.render(stack, rx);
   }
-}
-
-class PushViewNameNode extends WrapperNode {
+};
+var PushViewNameNode = class extends WrapperNode {
   render(stack, rx) {
     return this.node.render(stack.pushViewName(this.val.eval(stack)), rx);
   }
-}
-
-class SlotNode extends WrapperNode {
+};
+var SlotNode = class extends WrapperNode {
+  // Marker instead of `instanceof`: newMacroNode receives nodes that may come
+  // from a different copy of this module (CLI tools import src/ while the
+  // module under render imports the dist bundle), and cross-copy instanceof
+  // is always false.
   isSlotNode = true;
   optimize() {
     this.node.optimize();
   }
-}
-
-class ScopeNode extends WrapperNode {
+};
+var ScopeNode = class extends WrapperNode {
   render(stack, rx) {
     const binds = this.val.evalAsHandler(stack)?.call(stack.it) ?? {};
     const dom = this.node.render(stack.enter(stack.it, binds, false), rx);
@@ -2369,9 +2228,8 @@ class ScopeNode extends WrapperNode {
     this.node.setDataAttr("data-nid", this.nodeId);
   }
   static register = true;
-}
-
-class EachNode extends WrapperNode {
+};
+var EachNode = class extends WrapperNode {
   constructor(nodeId, val) {
     super(nodeId, val);
     this.iterInfo = new IterInfo(val, null, null, null);
@@ -2383,9 +2241,8 @@ class EachNode extends WrapperNode {
     return ctx.hasKey ? new EachBindStep(this.iterInfo, ctx.key) : null;
   }
   static register = true;
-}
-
-class IterInfo {
+};
+var IterInfo = class {
   constructor(val, whenVal, loopWithVal, enrichWithVal) {
     this.val = val;
     this.whenVal = whenVal;
@@ -2399,17 +2256,22 @@ class IterInfo {
     const enricher = this.enrichWithVal?.evalAsHandler(stack) ?? null;
     return { seq, filter, loopWith, enricher };
   }
+  // Rebuild the per-item binds for `key`, mirroring renderEachWhen: seed
+  // { key, value }, then run @enrich-with (with @loop-with's iterData) if any.
   enrichBinds(stack, key) {
     const { seq, filter, loopWith, enricher } = this.eval(stack);
     const value = seq?.get ? seq.get(key, null) : null;
     const binds = { key, value };
     if (enricher) {
-      const { iterData } = unpackLoopResult(loopWith.call(stack.it, seq, makeLoopCtx(stack, filter)), seq);
+      const { iterData } = unpackLoopResult(
+        loopWith.call(stack.it, seq, makeLoopCtx(stack, filter)),
+        seq
+      );
       callEnricher(enricher, stack.it, binds, key, value, iterData);
     }
     return binds;
   }
-}
+};
 function xOp(consumed = [], { wrappable = false, wrapper = null, ignoresChildren = false } = {}) {
   return { consumed: new Set(consumed), wrappable, wrapper, ignoresChildren };
 }
@@ -2418,6 +2280,10 @@ var X_OPS = {
   text: xOp([], { wrappable: true, ignoresChildren: true }),
   render: xOp(["as"], { wrappable: true, ignoresChildren: true }),
   "render-it": xOp(["as"], { wrappable: true, ignoresChildren: true }),
+  // `@when`/`@loop-with` are consumed here (handled in parseRenderEach) so
+  // `processXExtras` does not flag them as unknown attrs. TEMPORARY: the bare
+  // `when`/`loop-with` spellings are deprecated in favor of the `@` form — see
+  // maybeDeprecateBareXDirective (added 2026-07-08).
   "render-each": xOp(["as", "when", "loop-with", "@when", "@loop-with"], {
     wrappable: true,
     ignoresChildren: true
@@ -2429,11 +2295,11 @@ var WRAPPER_NODES = {
   show: ShowNode,
   hide: HideNode,
   each: EachNode,
+  // internal wrapper produced by a loop-less @enrich-with (no surface @scope directive)
   scope: ScopeNode,
   "push-view": PushViewNameNode
 };
-
-class ParseContext {
+var ParseContext = class _ParseContext {
   constructor(document2, Text, Comment, nodes, events, macroNodes, frame, parent) {
     this.nodes = nodes ?? [];
     this.events = events ?? [];
@@ -2452,11 +2318,11 @@ class ParseContext {
   enterMacro(macroName, macroVars, macroSlots) {
     const { document: document2, Text, Comment, nodes, events, macroNodes } = this;
     const frame = { macroName, macroVars, macroSlots };
-    return new ParseContext(document2, Text, Comment, nodes, events, macroNodes, frame, this);
+    return new _ParseContext(document2, Text, Comment, nodes, events, macroNodes, frame, this);
   }
-  parseHTML(html) {
+  parseHTML(html2) {
     const t = this.document.createElement("template");
-    t.innerHTML = html;
+    t.innerHTML = html2;
     return t.content.childNodes;
   }
   addNodeIf(Class, val, extra) {
@@ -2468,6 +2334,8 @@ class ParseContext {
     }
     return null;
   }
+  // For nodes that carry no value (e.g. RenderItNode, which reads stack.it at
+  // render time); addNodeIf treats a null val as a failed parse.
   addNode(Class, extra) {
     const nodeId = this.nodes.length;
     const node = new Class(nodeId, null, extra);
@@ -2484,21 +2352,17 @@ class ParseContext {
     const anySlot = [];
     const slots = { _: new FragmentNode(anySlot) };
     for (const child of childs)
-      if (child.isSlotNode)
-        slots[child.val.val] = child.node;
-      else if (!child.isWhiteSpace())
-        anySlot.push(child);
+      if (child.isSlotNode) slots[child.val.val] = child.node;
+      else if (!child.isWhiteSpace()) anySlot.push(child);
     const node = new MacroNode(macroName, mAttrs, slots, this);
     this.macroNodes.push(node);
     return node;
   }
   compile(scope) {
-    for (let i = 0;i < this.macroNodes.length; i++)
-      this.macroNodes[i].compile(scope);
+    for (let i = 0; i < this.macroNodes.length; i++) this.macroNodes[i].compile(scope);
   }
   *genEventNames() {
-    for (const event of this.events)
-      yield* event.genEventNames();
+    for (const event of this.events) yield* event.genEventNames();
   }
   getEventForId(id) {
     return this.events[id] ?? null;
@@ -2506,12 +2370,16 @@ class ParseContext {
   getNodeForId(id) {
     return this.nodes[id] ?? null;
   }
-  onAttributes(_attrs, _wrapperAttrs, _textChild, _isMacroCall, _tag) {}
+  onAttributes(_attrs, _wrapperAttrs, _textChild, _isMacroCall, _tag) {
+  }
   onParseIssue(kind, info) {
     console.warn(`tutuca parse issue [${kind}]`, info);
   }
-  onDeprecatedSyntax(_kind, _info) {}
-}
+  // Lint-only channel for deprecation nudges on still-valid syntax; the base
+  // (runtime) context ignores them so live apps stay quiet. See LintParseContext.
+  onDeprecatedSyntax(_kind, _info) {
+  }
+};
 var _htmlBlockTags = "ADDRESS,ARTICLE,ASIDE,BLOCKQUOTE,CAPTION,COL,COLGROUP,DETAILS,DIALOG,DIV,DD,DL,DT,FIELDSET,FIGCAPTION,FIGURE,FOOTER,FORM,H1,H2,H3,H4,H5,H6,HEADER,HGROUP,HR,LEGEND,LI,MAIN,MENU,NAV,OL,P,PRE,SECTION,SUMMARY,TABLE,TBODY,TD,TFOOT,TH,THEAD,TR,UL";
 var HTML_BLOCK_TAGS = new Set(_htmlBlockTags.split(","));
 var isBlockDomNode = (n) => {
@@ -2522,31 +2390,25 @@ var isEmptyText = (c) => c instanceof TextNode && c.val === "";
 var isIgnorableXChild = (c) => c instanceof CommentNode || (c.isWhiteSpace?.() ?? false);
 var hasMeaningfulChilds = (childs) => childs.some((c) => !isIgnorableXChild(c));
 function trimEdgeWhite(node) {
-  if (!node.isWhiteSpace?.())
-    return false;
+  if (!node.isWhiteSpace?.()) return false;
   node.condenseWhiteSpace();
   return true;
 }
 function condenseChildsWhites(childs) {
-  if (childs.length === 0)
-    return childs;
+  if (childs.length === 0) return childs;
   const last = childs.length - 1;
   let emptied = trimEdgeWhite(childs[0]);
-  if (last > 0 && trimEdgeWhite(childs[last]))
-    emptied = true;
-  for (let i = 1;i < last; i++) {
+  if (last > 0 && trimEdgeWhite(childs[last])) emptied = true;
+  for (let i = 1; i < last; i++) {
     const cur = childs[i];
-    if (!(cur.isWhiteSpace?.() && cur.hasNewLine()))
-      continue;
+    if (!(cur.isWhiteSpace?.() && cur.hasNewLine())) continue;
     const bothBlock = isBlockDomNode(childs[i - 1]) && isBlockDomNode(childs[i + 1]);
     cur.condenseWhiteSpace(bothBlock ? "" : " ");
-    if (bothBlock)
-      emptied = true;
+    if (bothBlock) emptied = true;
   }
   return emptied ? childs.filter((c) => !isEmptyText(c)) : childs;
 }
-
-class View {
+var View = class {
   constructor(name, rawView = "No View Defined", style = "", anode = null, ctx = null) {
     this.name = name;
     this.anode = anode;
@@ -2560,18 +2422,18 @@ class View {
     this.anode.setDataAttr("data-cid", cid);
     this.anode.setDataAttr("data-vid", this.name);
     this.ctx.compile(scope);
-    if (ctx.cacheConstNodes)
-      this.anode = optimizeNode(this.anode);
+    if (ctx.cacheConstNodes) this.anode = optimizeNode(this.anode);
   }
   render(stack, rx) {
     if (this.anode === null) {
-      throw new Error(`tutuca: view "${this.name}" was rendered before it was compiled — its ` + `component is not registered in this app/scope. Source: ` + `${String(this.rawView).slice(0, 80).replace(/\s+/g, " ")}…`);
+      throw new Error(
+        `tutuca: view "${this.name}" was rendered before it was compiled — its component is not registered in this app/scope. Source: ${String(this.rawView).slice(0, 80).replace(/\s+/g, " ")}…`
+      );
     }
     return this.anode.render(stack, rx);
   }
-}
-
-class NodeEvents {
+};
+var NodeEvents = class {
   constructor(id) {
     this.id = id;
     this.handlers = [];
@@ -2580,8 +2442,7 @@ class NodeEvents {
     this.handlers.push(new NodeEvent(name, handlerCall, modifiers));
   }
   *genEventNames() {
-    for (const handler of this.handlers)
-      yield handler.name;
+    for (const handler of this.handlers) yield handler.name;
   }
   getHandlersFor(eventName) {
     let r = null;
@@ -2592,9 +2453,8 @@ class NodeEvents {
       }
     return r;
   }
-}
-
-class NodeEvent {
+};
+var NodeEvent = class {
   constructor(name, handlerCall, modifiers) {
     this.name = name;
     this.handlerCall = handlerCall;
@@ -2609,7 +2469,7 @@ class NodeEvent {
     r[0] = this.modifierWrapper(r[0], event);
     return r;
   }
-}
+};
 var fwdIfCtxPred = (pred) => (w) => (that, f, args, ctx) => pred(ctx) ? w(that, f, args, ctx) : that;
 var fwdIfKey = (keyName) => fwdIfCtxPred((ctx) => ctx.e.key === keyName);
 var fwdCtrl = fwdIfCtxPred(({ e }) => isMac && e.metaKey || e.ctrlKey);
@@ -2626,14 +2486,12 @@ var MOD_WRAPPERS_BY_EVENT = {
 };
 var identityModifierWrapper = (f, _ctx) => f;
 function compileModifiers(eventName, names) {
-  if (names.length === 0)
-    return identityModifierWrapper;
+  if (names.length === 0) return identityModifierWrapper;
   const wrappers = MOD_WRAPPERS_BY_EVENT[eventName] ?? {};
   let w = (that, f, args, _ctx) => f.apply(that, args);
   for (const name of names) {
     const wrapper = wrappers[name];
-    if (wrapper !== undefined)
-      w = wrapper(w);
+    if (wrapper !== void 0) w = wrapper(w);
   }
   return (f, ctx) => function(...args) {
     return w(this, f, args, ctx);
@@ -2641,10 +2499,10 @@ function compileModifiers(eventName, names) {
 }
 
 // src/components.js
-class Components {
+var Components = class {
   constructor() {
-    this.getComponentSymbol = Symbol("getComponent");
-    this.byId = new Map;
+    this.getComponentSymbol = /* @__PURE__ */ Symbol("getComponent");
+    this.byId = /* @__PURE__ */ new Map();
   }
   registerComponent(comp) {
     comp.Class.prototype[this.getComponentSymbol] = () => comp;
@@ -2664,15 +2522,12 @@ class Components {
   }
   compileStyles() {
     const styles = [];
-    for (const comp of this.byId.values())
-      styles.push(comp.compileStyle());
-    return styles.join(`
-`);
+    for (const comp of this.byId.values()) styles.push(comp.compileStyle());
+    return styles.join("\n");
   }
-}
-
-class ComponentStack {
-  constructor(comps = new Components, parent = null) {
+};
+var ComponentStack = class _ComponentStack {
+  constructor(comps = new Components(), parent = null) {
     this.comps = comps;
     this.parent = parent;
     this.byName = {};
@@ -2680,11 +2535,11 @@ class ComponentStack {
     this.macros = {};
   }
   enter() {
-    return new ComponentStack(this.comps, this);
+    return new _ComponentStack(this.comps, this);
   }
   registerComponents(comps, opts) {
     const { aliases = {} } = opts ?? {};
-    for (let i = 0;i < comps.length; i++) {
+    for (let i = 0; i < comps.length; i++) {
       const comp = comps[i];
       comp.scope = this.enter();
       comp.Class.scope = comp.scope;
@@ -2693,17 +2548,15 @@ class ComponentStack {
     }
     for (const alias in aliases) {
       const comp = this.byName[aliases[alias]];
-      console.assert(this.byName[alias] === undefined, "alias overrides component", alias);
-      if (comp !== undefined)
-        this.byName[alias] = comp;
-      else
-        console.warn("alias", alias, "to inexistent component", aliases[alias]);
+      console.assert(this.byName[alias] === void 0, "alias overrides component", alias);
+      if (comp !== void 0) this.byName[alias] = comp;
+      else console.warn("alias", alias, "to inexistent component", aliases[alias]);
     }
   }
   registerMacros(macros) {
     for (const key in macros) {
       const lower = key.toLowerCase();
-      console.assert(this.macros[lower] === undefined, "macro key collision", lower);
+      console.assert(this.macros[lower] === void 0, "macro key collision", lower);
       this.macros[lower] = macros[key];
     }
   }
@@ -2711,8 +2564,7 @@ class ComponentStack {
     return this.comps.getCompFor(v);
   }
   registerRequestHandlers(handlers) {
-    for (const name in handlers)
-      this.reqsByName[name] = new RequestHandler(name, handlers[name]);
+    for (const name in handlers) this.reqsByName[name] = new RequestHandler(name, handlers[name]);
   }
   lookupRequest(name) {
     return this.reqsByName[name] ?? this.parent?.lookupRequest(name) ?? null;
@@ -2723,36 +2575,33 @@ class ComponentStack {
   lookupMacro(name) {
     return this.macros[name] ?? this.parent?.lookupMacro(name) ?? null;
   }
-}
-
-class ProvideInfo {
+};
+var ProvideInfo = class {
   constructor(name, val, symbol) {
     this.name = name;
     this.val = val;
     this.symbol = symbol;
   }
-}
-
-class LookupInfo {
+};
+var LookupInfo = class {
   constructor(name, compName, provideName, val) {
     this.name = name;
     this.compName = compName;
     this.provideName = provideName;
     this.val = val;
-    this._sym = undefined;
+    this._sym = void 0;
   }
   getProducerSymbol(stack) {
-    if (this._sym === undefined)
+    if (this._sym === void 0)
       this._sym = stack.lookupType(this.compName)?.provide?.[this.provideName]?.symbol ?? null;
     return this._sym;
   }
-}
+};
 var isString = (v) => typeof v === "string";
 var _rawSpecKeys = "name view style commonStyle globalStyle input receive bubble response alter views provide lookup fields methods statics";
 var KNOWN_SPEC_KEYS = new Set(_rawSpecKeys.split(" "));
 var _compId = 0;
-
-class Component {
+var Component = class {
   constructor(Class, o) {
     this.id = _compId++;
     this.name = o.name ?? "UnkComp";
@@ -2777,31 +2626,27 @@ class Component {
     this.scope = null;
     this.spec = o;
     this.extra = {};
-    for (const key of Object.keys(o))
-      if (!KNOWN_SPEC_KEYS.has(key))
-        this.extra[key] = o[key];
+    for (const key of Object.keys(o)) if (!KNOWN_SPEC_KEYS.has(key)) this.extra[key] = o[key];
   }
   compile(ParseContext2) {
     for (const name in this.views)
-      this.views[name].compile(new ParseContext2, this.scope, this.id);
+      this.views[name].compile(new ParseContext2(), this.scope, this.id);
     const ctx = this.views.main.ctx;
     for (const key in this._rawProvide) {
-      const val = vp.parseProvide(this._rawProvide[key], ctx);
-      if (val)
-        this.provide[key] = new ProvideInfo(key, val, Symbol(key));
+      const val = parseProvide(this._rawProvide[key], ctx);
+      if (val) this.provide[key] = new ProvideInfo(key, val, Symbol(key));
     }
     for (const key in this._rawLookup) {
       const linfo = this._rawLookup[key];
       const forStr = isString(linfo) ? linfo : isString(linfo?.for) ? linfo.for : null;
       const [compName, provideName] = forStr === null ? [] : forStr.split(".");
-      if (!isString(compName) || !isString(provideName))
-        continue;
+      if (!isString(compName) || !isString(provideName)) continue;
       const defStr = isString(linfo?.default) ? linfo.default : null;
-      const val = defStr === null ? null : vp.parseField(defStr, ctx);
+      const val = defStr === null ? null : parseField(defStr, ctx);
       this.lookup[key] = new LookupInfo(key, compName, provideName, val);
     }
     for (const key in this.lookup)
-      if (this.provide[key] !== undefined)
+      if (this.provide[key] !== void 0)
         console.warn("name declared in both provide and lookup", this.name, key);
   }
   make(args, opts) {
@@ -2819,35 +2664,29 @@ class Component {
   compileStyle() {
     const { id, commonStyle, globalStyle, views } = this;
     const styles = commonStyle ? [`[data-cid="${id}"]{${commonStyle}}`] : [];
-    if (globalStyle !== "")
-      styles.push(globalStyle);
+    if (globalStyle !== "") styles.push(globalStyle);
     for (const name in views) {
       const { style } = views[name];
-      if (style !== "")
-        styles.push(`[data-cid="${id}"][data-vid="${name}"]{${style}}`);
+      if (style !== "") styles.push(`[data-cid="${id}"][data-vid="${name}"]{${style}}`);
     }
-    return styles.join(`
-`);
+    return styles.join("\n");
   }
-}
+};
 
 // src/stack.js
-var STOP = Symbol("STOP");
-var NEXT = Symbol("NEXT");
+var STOP = /* @__PURE__ */ Symbol("STOP");
+var NEXT = /* @__PURE__ */ Symbol("NEXT");
 function lookup(chain, name, dv = null) {
   let n = chain;
   while (n !== null) {
     const r = n[0].lookup(name);
-    if (r === STOP)
-      return dv;
-    if (r !== NEXT)
-      return r;
+    if (r === STOP) return dv;
+    if (r !== NEXT) return r;
     n = n[1];
   }
   return dv;
 }
-
-class BindFrame {
+var BindFrame = class {
   constructor(it, binds, isFrame) {
     this.it = it;
     this.binds = binds;
@@ -2855,19 +2694,18 @@ class BindFrame {
   }
   lookup(name) {
     const v = this.binds[name];
-    return v === undefined ? this.isFrame ? STOP : NEXT : v;
+    return v === void 0 ? this.isFrame ? STOP : NEXT : v;
   }
-}
-
-class ObjectFrame {
+};
+var ObjectFrame = class {
   constructor(binds) {
     this.binds = binds;
   }
   lookup(key) {
     const v = this.binds[key];
-    return v === undefined ? NEXT : v;
+    return v === void 0 ? NEXT : v;
   }
-}
+};
 function computeViewsId(views) {
   let s = "";
   let n = views;
@@ -2877,8 +2715,7 @@ function computeViewsId(views) {
   }
   return s === "main" ? "" : s;
 }
-
-class Stack {
+var Stack = class _Stack {
   constructor(comps, it, binds, dynBinds, views, viewsId, ctx = null) {
     this.comps = comps;
     this.it = it;
@@ -2888,44 +2725,42 @@ class Stack {
     this.viewsId = viewsId;
     this.ctx = ctx;
   }
+  // Evaluate every provide the entered component publishes and push them as one
+  // dynBinds frame (keyed by each provide's symbol). No-op when there are no provides.
   _pushProvides() {
     const provide = this.comps.getCompFor(this.it)?.provide;
-    if (provide == null)
-      return this;
+    if (provide == null) return this;
     const dynObj = {};
-    let has = false;
+    let has2 = false;
     for (const k in provide) {
       dynObj[provide[k].symbol] = provide[k].val.eval(this);
-      has = true;
+      has2 = true;
     }
-    if (!has)
-      return this;
+    if (!has2) return this;
     const newDynBinds = [new ObjectFrame(dynObj), this.dynBinds];
     const { comps, it, binds, views, viewsId, ctx } = this;
-    return new Stack(comps, it, binds, newDynBinds, views, viewsId, ctx);
+    return new _Stack(comps, it, binds, newDynBinds, views, viewsId, ctx);
   }
   static root(comps, it, ctx) {
     const binds = [new BindFrame(it, {}, true), null];
     const dynBinds = [new ObjectFrame({}), null];
     const views = ["main", null];
-    return new Stack(comps, it, binds, dynBinds, views, "", ctx)._pushProvides();
+    return new _Stack(comps, it, binds, dynBinds, views, "", ctx)._pushProvides();
   }
   enter(it, bindings = {}, isFrame = true) {
     const { comps, binds, dynBinds, views, viewsId, ctx } = this;
     const newBinds = [new BindFrame(it, bindings, isFrame), binds];
-    const stack = new Stack(comps, it, newBinds, dynBinds, views, viewsId, ctx);
+    const stack = new _Stack(comps, it, newBinds, dynBinds, views, viewsId, ctx);
     return isFrame ? stack._pushProvides() : stack;
   }
   pushViewName(name) {
     const { comps, it, binds, dynBinds, views, ctx } = this;
     const newViews = [name, views];
-    return new Stack(comps, it, binds, dynBinds, newViews, computeViewsId(newViews), ctx);
+    return new _Stack(comps, it, binds, dynBinds, newViews, computeViewsId(newViews), ctx);
   }
   _pushDynBindValuesToArray(arr, comp) {
-    for (const k in comp.provide)
-      arr.push(this._lookupProvide(comp.provide[k]));
-    for (const k in comp.lookup)
-      arr.push(this._lookupAlias(comp.lookup[k]));
+    for (const k in comp.provide) arr.push(this._lookupProvide(comp.provide[k]));
+    for (const k in comp.lookup) arr.push(this._lookupAlias(comp.lookup[k]));
   }
   _lookupProvide(p) {
     return lookup(this.dynBinds, p.symbol) ?? p.val.eval(this) ?? null;
@@ -2936,13 +2771,11 @@ class Stack {
   }
   lookupDynamic(name) {
     const comp = this.comps.getCompFor(this.it);
-    if (comp == null)
-      return null;
+    if (comp == null) return null;
     const lk = comp.lookup[name];
-    if (lk !== undefined)
-      return this._lookupAlias(lk);
+    if (lk !== void 0) return this._lookupAlias(lk);
     const p = comp.provide[name];
-    return p !== undefined ? this._lookupProvide(p) : null;
+    return p !== void 0 ? this._lookupProvide(p) : null;
   }
   lookupBind(name) {
     return lookup(this.binds, name);
@@ -2967,16 +2800,15 @@ class Stack {
     let n = this.views;
     while (n !== null) {
       const view = views[n[0]];
-      if (view !== undefined)
-        return view;
+      if (view !== void 0) return view;
       n = n[1];
     }
     return views[defaultViewName];
   }
-}
+};
 
 // src/transactor.js
-class State {
+var State = class {
   constructor(val) {
     this.val = val;
     this.changeSubs = [];
@@ -2987,44 +2819,47 @@ class State {
   set(val, info) {
     const old = this.val;
     this.val = val;
-    for (const sub of this.changeSubs)
-      sub({ val, old, info, timestamp: Date.now() });
+    for (const sub of this.changeSubs) sub({ val, old, info, timestamp: Date.now() });
   }
   update(fn, info) {
     return this.set(fn(this.val), info);
   }
-}
-
-class Transactor {
+};
+var Transactor = class {
   constructor(comps, rootValue) {
     this.comps = comps;
     this.transactions = [];
     this.state = new State(rootValue);
-    this.onTransactionPushed = () => {};
+    this.onTransactionPushed = () => {
+    };
     this._observers = [];
-    this._inflight = new Set;
+    this._inflight = /* @__PURE__ */ new Set();
   }
   pushTransaction(t) {
     this.transactions.push(t);
     this.onTransactionPushed(t);
   }
+  // Subscribe to a normalized record for every handler invocation (send/receive,
+  // bubble, request/response, input). Returns an unsubscribe function. Records
+  // carry: kind, name, args, path, pathKeys, targetPath, handler, handlerName,
+  // matched, before, after, parent, timestamp. Purely observational.
   observe(cb) {
     this._observers.push(cb);
     return () => {
       const i = this._observers.indexOf(cb);
-      if (i !== -1)
-        this._observers.splice(i, 1);
+      if (i !== -1) this._observers.splice(i, 1);
     };
   }
   _emit(record) {
-    for (const cb of this._observers)
-      cb(record);
+    for (const cb of this._observers) cb(record);
   }
+  // Build and dispatch the observer record for a settled transaction. The
+  // resolved handler (`_resolvedHandler`/`_matched`) and per-leaf before/after
+  // (`_before`/`_after`) were captured while the handler ran (see callHandler /
+  // updateRootValue). No-op when nobody is observing.
   _emitTransaction(transaction, root) {
-    if (this._observers.length === 0)
-      return;
-    if (transaction._resolvedHandler === undefined)
-      return;
+    if (this._observers.length === 0) return;
+    if (transaction._resolvedHandler === void 0) return;
     const path = transaction.getTransactionPath().pinKeys(root);
     this._emit({
       kind: transaction.observeKind,
@@ -3042,6 +2877,10 @@ class Transactor {
       timestamp: Date.now()
     });
   }
+  // Make `child` a tracked unit of `parent`'s subtree: the parent's completion stays open
+  // until the child's *whole* subtree settles. Tracking happens at dispatch time — during
+  // the parent's handler or afterTransaction — while the parent's self-unit is still held,
+  // so the parent counter can't reach zero before the child is registered. Returns `child`.
   _link(child, parent) {
     if (parent) {
       const release = parent.completion.track();
@@ -3072,12 +2911,13 @@ class Transactor {
     p.finally(() => this._inflight.delete(p));
     return p;
   }
+  // Drain queued transactions and await in-flight requests until quiescent. Each
+  // awaited request enqueues a ResponseEvent, which may dispatch more work, so we
+  // loop. `maxTurns` backstops a pathological non-terminating cascade.
   async settle(maxTurns = 1e4) {
     while ((this.hasPendingTransactions || this._inflight.size) && maxTurns-- > 0) {
-      while (this.hasPendingTransactions)
-        this.transactNext();
-      if (this._inflight.size)
-        await Promise.allSettled([...this._inflight]);
+      while (this.hasPendingTransactions) this.transactNext();
+      if (this._inflight.size) await Promise.allSettled([...this._inflight]);
     }
   }
   async _runRequest(path, name, args = [], opts = {}, parent = null, release = null) {
@@ -3107,7 +2947,7 @@ class Transactor {
           handlerName: found?.fn?.name || name,
           matched: found ? "exact" : "none",
           before: curLeaf,
-          after: undefined,
+          after: void 0,
           parent,
           timestamp: Date.now()
         });
@@ -3128,27 +2968,24 @@ class Transactor {
         push(opts?.onErrorName, resHandlerName, error, null, error);
       }
     } finally {
-      if (release && !released)
-        release();
+      if (release && !released) release();
     }
   }
   get hasPendingTransactions() {
     return this.transactions.length > 0;
   }
   transactNext() {
-    if (this.hasPendingTransactions)
-      this.transact(this.transactions.shift());
+    if (this.hasPendingTransactions) this.transact(this.transactions.shift());
   }
   transact(transaction) {
     try {
       const curState = this.state.val;
       const newState = transaction.run(curState, this.comps);
-      if (newState !== undefined) {
+      if (newState !== void 0) {
         this.state.set(newState, { transaction });
         transaction.afterTransaction();
         this._emitTransaction(transaction, curState);
-      } else
-        console.warn("undefined new state", { curState, transaction });
+      } else console.warn("undefined new state", { curState, transaction });
     } finally {
       transaction._completion?.ensureSelfSettled();
       transaction._completion?.releaseSelf();
@@ -3157,7 +2994,7 @@ class Transactor {
   transactInputNow(path, event, eventHandler, dragInfo) {
     this.transact(new InputEvent(path, event, eventHandler, this, dragInfo));
   }
-}
+};
 function mkReq404(name) {
   const fn = () => {
     throw new Error(`Request not found: ${name}`);
@@ -3167,37 +3004,46 @@ function mkReq404(name) {
 function nullHandler() {
   return this;
 }
-
-class Transaction {
+var Transaction = class {
   constructor(path, transactor, parentTransaction = null) {
     this.path = path;
     this.transactor = transactor;
     this.parentTransaction = parentTransaction;
     this._completion = null;
   }
+  // Lazily created (like the rest of the per-transaction state): a leaf event that
+  // nobody tracks or awaits never allocates one. See `class Completion`.
   get completion() {
-    this._completion ??= new Completion;
+    this._completion ??= new Completion();
     return this._completion;
   }
+  // Resolves once this transaction's own handler has run.
   whenSettled() {
     return this.completion.whenSettled();
   }
+  // Resolves once this transaction AND all transitively-derived work (sends, bubbles,
+  // requests and the responses they produce, recursively) have settled.
   whenSubtreeSettled() {
     return this.completion.whenSubtreeSettled();
   }
   run(rootValue, comps) {
     return this.updateRootValue(rootValue, comps);
   }
-  afterTransaction() {}
+  afterTransaction() {
+  }
   buildRootStack(root, comps) {
     return Stack.root(comps, root);
   }
   buildStack(root, comps) {
     return this.path.toTransactionPath().buildStack(this.buildRootStack(root, comps));
   }
+  // The kind reported to observers (see Transactor.observe); null on the base.
   get observeKind() {
     return null;
   }
+  // The name reported to observers; null on the base. Overridden by NameArgs (the
+  // dispatched message name) and InputEvent (the DOM event type). Kept separate from
+  // `name`/`ctx.name` so it can't change handler-visible behavior.
   get observeName() {
     return null;
   }
@@ -3209,6 +3055,9 @@ class Transaction {
   getHandlerAndArgs(_root, _instance, _comps) {
     return null;
   }
+  // The path used to apply the mutation. Teleports dynamic-var renders so it lands on
+  // the data's real location (the dispatch `this.path` keeps intermediates). A subclass
+  // may override to supply a pre-resolved path (see ResponseEvent's pinned keys).
   getTransactionPath() {
     return this.path.toTransactionPath();
   }
@@ -3224,13 +3073,12 @@ class Transaction {
   lookupName(_name) {
     return null;
   }
-}
+};
 var toNullIfNaN = (v) => Number.isNaN(v) ? null : v;
 function getValue(e) {
   return e.target.type === "checkbox" ? e.target.checked : (e instanceof CustomEvent ? e.detail : e.target.value) ?? null;
 }
-
-class InputEvent extends Transaction {
+var InputEvent = class extends Transaction {
   constructor(path, e, handler, transactor, dragInfo) {
     super(path, transactor);
     this.e = e;
@@ -3238,6 +3086,8 @@ class InputEvent extends Transaction {
     this.dragInfo = dragInfo;
     this._dispatchPath = null;
   }
+  // Frame steps removed, DynStep + one step per crossed component kept: bubbling
+  // it visits every component (including intermediates of a dynamic-var render).
   get dispatchPath() {
     this._dispatchPath ??= this.path.compact();
     return this._dispatchPath;
@@ -3276,6 +3126,7 @@ class InputEvent extends Transaction {
       case "isShift":
         return e.shiftKey;
       case "isCtrl":
+      /* falls through */
       case "isCmd":
         return isMac && e.metaKey || e.ctrlKey;
       case "key":
@@ -3299,9 +3150,8 @@ class InputEvent extends Transaction {
     }
     return null;
   }
-}
-
-class NameArgsTransaction extends Transaction {
+};
+var NameArgsTransaction = class extends Transaction {
   constructor(path, transactor, name, args, parentTransaction, opts = {}) {
     super(path, transactor, parentTransaction);
     this.name = name;
@@ -3310,6 +3160,8 @@ class NameArgsTransaction extends Transaction {
     this.targetPath = path;
   }
   handlerProp = null;
+  // NameArgs verbs map their handler bucket straight to the observed kind:
+  // receive / bubble / response / input.
   get observeKind() {
     return this.handlerProp;
   }
@@ -3335,9 +3187,8 @@ class NameArgsTransaction extends Transaction {
     const handler = this.getHandlerForName(comps.getCompFor(instance));
     return [handler, [...this.args, new EventContext(this.path, this.transactor, this)]];
   }
-}
-
-class ResponseEvent extends NameArgsTransaction {
+};
+var ResponseEvent = class extends NameArgsTransaction {
   handlerProp = "response";
   constructor(path, transactor, name, args, parent, txnPath = null) {
     super(path, transactor, name, args, parent);
@@ -3346,9 +3197,8 @@ class ResponseEvent extends NameArgsTransaction {
   getTransactionPath() {
     return this._txnPath ?? super.getTransactionPath();
   }
-}
-
-class SendEvent extends NameArgsTransaction {
+};
+var SendEvent = class extends NameArgsTransaction {
   handlerProp = "receive";
   run(rootVal, comps) {
     return this.opts.skipSelf ? rootVal : this.updateRootValue(rootVal, comps);
@@ -3358,9 +3208,8 @@ class SendEvent extends NameArgsTransaction {
     if (opts.bubbles && path.steps.length > 0)
       this.transactor.pushBubble(path.popStep(), name, args, opts, this, targetPath);
   }
-}
-
-class BubbleEvent extends SendEvent {
+};
+var BubbleEvent = class extends SendEvent {
   handlerProp = "bubble";
   constructor(path, transactor, name, args, parent, opts, targetPath) {
     super(path, transactor, name, args, parent, opts);
@@ -3369,15 +3218,13 @@ class BubbleEvent extends SendEvent {
   stopPropagation() {
     this.opts.bubbles = false;
   }
-}
-
-class InputDispatchEvent extends NameArgsTransaction {
+};
+var InputDispatchEvent = class extends NameArgsTransaction {
   handlerProp = "input";
-}
-
-class Completion {
+};
+var Completion = class {
   constructor() {
-    this.val = undefined;
+    this.val = void 0;
     this.selfSettled = false;
     this.subtreeSettled = false;
     this.pending = 1;
@@ -3388,45 +3235,42 @@ class Completion {
     this._selfReleased = false;
   }
   whenSettled() {
-    if (this.selfSettled)
-      return Promise.resolve(this.val);
+    if (this.selfSettled) return Promise.resolve(this.val);
     this._selfPromise ??= new Promise((res) => {
       this._selfResolve = res;
     });
     return this._selfPromise;
   }
   whenSubtreeSettled() {
-    if (this.subtreeSettled)
-      return Promise.resolve(this.val);
+    if (this.subtreeSettled) return Promise.resolve(this.val);
     this._subtreePromise ??= new Promise((res) => {
       this._subtreeResolve = res;
     });
     return this._subtreePromise;
   }
+  // The transaction's own handler ran (records its {value, old}). Does not touch the counter.
   markSelfSettled(val) {
-    if (this.selfSettled)
-      return;
+    if (this.selfSettled) return;
     this.selfSettled = true;
     this.val = val;
     this._selfResolve?.(val);
   }
+  // Settle self even when no handler produced a value (skipSelf / undefined / throw paths).
   ensureSelfSettled() {
-    if (!this.selfSettled)
-      this.markSelfSettled(this.val);
+    if (!this.selfSettled) this.markSelfSettled(this.val);
   }
+  // Register an outstanding unit; returns a one-shot release.
   track() {
     this.pending++;
     let done = false;
     return () => {
-      if (done)
-        return;
+      if (done) return;
       done = true;
       this._release();
     };
   }
   releaseSelf() {
-    if (this._selfReleased)
-      return;
+    if (this._selfReleased) return;
     this._selfReleased = true;
     this._release();
   }
@@ -3436,22 +3280,22 @@ class Completion {
       this._subtreeResolve?.(this.val);
     }
   }
-}
-
-class Dispatcher {
+};
+var Dispatcher = class {
   constructor(path, transactor, parentTransaction, root = transactor.state.val) {
     this.path = path;
     this.transactor = transactor;
     this.parent = parentTransaction;
     this.root = root;
   }
+  // Walk the component instances on this ctx's path, leaf→root, calling
+  // callback(Component, instance). Return false from the callback to stop early.
   walkPath(callback) {
     const comps = this.transactor.comps;
     const chain = this.path.toTransactionPath().resolveChain(this.root);
-    for (let i = chain.length - 1;i >= 0; i--) {
+    for (let i = chain.length - 1; i >= 0; i--) {
       const comp = comps.getCompFor(chain[i]);
-      if (comp && callback(comp, chain[i]) === false)
-        return;
+      if (comp && callback(comp, chain[i]) === false) return;
     }
   }
   get at() {
@@ -3478,9 +3322,8 @@ class Dispatcher {
   lookupTypeFor(name, inst) {
     return this.transactor.comps.getCompFor(inst).scope.lookupComponent(name);
   }
-}
-
-class EventContext extends Dispatcher {
+};
+var EventContext = class extends Dispatcher {
   get name() {
     return this.parent?.name ?? null;
   }
@@ -3490,12 +3333,10 @@ class EventContext extends Dispatcher {
   stopPropagation() {
     return this.parent.stopPropagation();
   }
-}
-
-class RequestContext extends Dispatcher {
-}
-
-class PathChanges extends PathBuilder {
+};
+var RequestContext = class extends Dispatcher {
+};
+var PathChanges = class extends PathBuilder {
   constructor(dispatcher) {
     super();
     this.dispatcher = dispatcher;
@@ -3509,15 +3350,14 @@ class PathChanges extends PathBuilder {
   buildPath() {
     return this.dispatcher.path.concat(this.pathChanges);
   }
-}
+};
 function rootDispatcher(transactor) {
   return new Dispatcher(new Path([]), transactor, null);
 }
 
 // src/app.js
 var _evs = "dragstart dragover dragend touchstart touchmove touchend touchcancel".split(" ");
-
-class App {
+var App = class {
   constructor(rootNode, comps, renderer, ParseContext2) {
     this.rootNode = rootNode;
     this.comps = comps;
@@ -3531,8 +3371,7 @@ class App {
     this.dragInfo = this.curDragOver = null;
     this._touch = null;
     this.transactor.onTransactionPushed = (_transaction) => {
-      if (this._transactNextBatchId === null)
-        this._scheduleNextTransactionBatchExecution();
+      if (this._transactNextBatchId === null) this._scheduleNextTransactionBatchExecution();
     };
     this._compiled = false;
     this._renderOpts = { document: rootNode.ownerDocument };
@@ -3555,29 +3394,23 @@ class App {
     const isDrag = type === "dragover" || type === "dragstart" || type === "dragend" || type === "drop";
     const { rootNode: root, maxEventNodeDepth: maxDepth, comps, transactor } = this;
     const [path, handlers] = Path.fromEvent(e, root, maxDepth, comps, !isDrag);
-    if (isDrag)
-      this._handleDragEvent(e, type, path);
+    if (isDrag) this._handleDragEvent(e, type, path);
     if (path !== null && handlers !== null)
-      for (const handler of handlers)
-        transactor.transactInputNow(path, e, handler, this.dragInfo);
+      for (const handler of handlers) transactor.transactInputNow(path, e, handler, this.dragInfo);
   }
   _handleTouchEvent(e) {
     const { type } = e;
     if (type === "touchstart") {
-      if (this._touch !== null || e.touches.length !== 1)
-        return;
+      if (this._touch !== null || e.touches.length !== 1) return;
       const t = e.touches[0];
       const draggable = t.target?.closest?.('[draggable="true"]');
-      if (!draggable)
-        return;
+      if (!draggable) return;
       this._touch = makeTouchInfo(t.identifier, t.clientX, t.clientY, draggable, false);
       return;
     }
-    if (this._touch === null)
-      return;
+    if (this._touch === null) return;
     const touch = findTouch(e, this._touch.id);
-    if (touch === null)
-      return;
+    if (touch === null) return;
     const { rootNode, _touch } = this;
     const { clientX, clientY } = touch;
     const fire = (type2, target) => {
@@ -3588,8 +3421,7 @@ class App {
       if (!_touch.active) {
         const dx = clientX - _touch.startX;
         const dy = clientY - _touch.startY;
-        if (dx * dx + dy * dy < 100)
-          return;
+        if (dx * dx + dy * dy < 100) return;
         _touch.active = true;
         e.preventDefault();
         fire("dragstart", _touch.target);
@@ -3601,8 +3433,7 @@ class App {
     }
     if (type === "touchend" || type === "touchcancel") {
       if (_touch.active) {
-        if (type === "touchend")
-          fire("drop", hitTest(rootNode, clientX, clientY));
+        if (type === "touchend") fire("drop", hitTest(rootNode, clientX, clientY));
         fire("dragend", _touch.target);
       }
       this._touch = null;
@@ -3649,13 +3480,20 @@ class App {
     const root = this.state.val;
     const stack = this.makeStack(root);
     const { renderer, rootNode, _renderOpts, _renderState } = this;
-    const newState = render(renderer.renderRoot(stack, root, this.rootViewName), rootNode, _renderOpts, _renderState);
+    const newState = render(
+      renderer.renderRoot(stack, root, this.rootViewName),
+      rootNode,
+      _renderOpts,
+      _renderState
+    );
     this._renderState = newState;
     return newState.dom;
   }
   onChange(callback) {
     this.transactor.state.onChange(callback);
   }
+  // Subscribe to a normalized record for every handler invocation. Returns an
+  // unsubscribe function. See Transactor.observe.
   observe(callback) {
     return this.transactor.observe(callback);
   }
@@ -3663,31 +3501,25 @@ class App {
     for (const Comp of this.comps.byId.values()) {
       Comp.compile(this.ParseContext);
       for (const key in Comp.views)
-        for (const name of Comp.views[key].ctx.genEventNames())
-          this._eventNames.add(name);
+        for (const name of Comp.views[key].ctx.genEventNames()) this._eventNames.add(name);
     }
     this._compiled = true;
   }
   subscribeToEvents(eventNames) {
-    for (const name of eventNames)
-      this.rootNode.addEventListener(name, this, listenerOpts(name));
+    for (const name of eventNames) this.rootNode.addEventListener(name, this, listenerOpts(name));
   }
   recompileStyles(opts) {
     injectCss("tutuca-app", this.comps.compileStyles(), opts?.head ?? document.head);
   }
   start(opts) {
-    if (!this._compiled)
-      this.compile();
+    if (!this._compiled) this.compile();
     this.subscribeToEvents(this._eventNames);
     this.onChange((info) => {
-      if (info.val !== info.old)
-        this.render();
+      if (info.val !== info.old) this.render();
     });
     this.recompileStyles(opts);
-    if (opts?.noCache)
-      this.renderer.setNullCache();
-    else
-      this.startCacheEvictionInterval();
+    if (opts?.noCache) this.renderer.setNullCache();
+    else this.startCacheEvictionInterval();
     this.render();
   }
   stop() {
@@ -3707,42 +3539,36 @@ class App {
     this._transactNextBatchId = null;
     const startTs = Date.now();
     const t = this.transactor;
-    while (t.hasPendingTransactions && Date.now() - startTs < maxRunTimeMs)
-      t.transactNext();
-    if (t.hasPendingTransactions)
-      this._scheduleNextTransactionBatchExecution();
+    while (t.hasPendingTransactions && Date.now() - startTs < maxRunTimeMs) t.transactNext();
+    if (t.hasPendingTransactions) this._scheduleNextTransactionBatchExecution();
   }
   _scheduleNextTransactionBatchExecution() {
     this._transactNextBatchId = setTimeout(() => this._transactNextBatch(), 0);
   }
-  startCacheEvictionInterval(intervalMs = 30000) {
+  startCacheEvictionInterval(intervalMs = 3e4) {
     this._evictCacheId = setInterval(() => this.renderer.cache.evict(), intervalMs);
   }
   stopCacheEvictionInterval() {
     clearInterval(this._evictCacheId);
     this._evictCacheId = null;
   }
-}
+};
 function injectCss(nodeId, style, styleTarget = document.head) {
   const styleNode = document.createElement("style");
   const currentNodeWithId = styleTarget.querySelector(`#${nodeId}`);
-  if (currentNodeWithId)
-    styleTarget.removeChild(currentNodeWithId);
+  if (currentNodeWithId) styleTarget.removeChild(currentNodeWithId);
   styleNode.id = nodeId;
   styleNode.innerHTML = style;
   styleTarget.appendChild(styleNode);
 }
-var NOOP = () => {};
+var NOOP = () => {
+};
 function findTouch(e, id) {
-  for (const t of e.changedTouches)
-    if (t.identifier === id)
-      return t;
-  for (const t of e.touches)
-    if (t.identifier === id)
-      return t;
+  for (const t of e.changedTouches) if (t.identifier === id) return t;
+  for (const t of e.touches) if (t.identifier === id) return t;
   return null;
 }
-var listenerOpts = (name) => name === "touchmove" ? { passive: false } : undefined;
+var listenerOpts = (name) => name === "touchmove" ? { passive: false } : void 0;
 function makeTouchInfo(id, startX, startY, target, active) {
   return { id, startX, startY, target, active };
 }
@@ -3751,8 +3577,7 @@ function hitTest(rootNode, x, y) {
   let el = root.elementFromPoint?.(x, y) ?? null;
   while (el?.shadowRoot) {
     const next = el.shadowRoot.elementFromPoint(x, y);
-    if (next === null || next === el)
-      break;
+    if (next === null || next === el) break;
     el = next;
   }
   return el ?? rootNode;
@@ -3760,14 +3585,12 @@ function hitTest(rootNode, x, y) {
 function getClosestDropTarget(target, rootNode, count) {
   let node = target;
   while (count-- > 0 && node !== rootNode) {
-    if (node.dataset?.droptarget !== undefined)
-      return node;
+    if (node.dataset?.droptarget !== void 0) return node;
     node = node.parentNode;
   }
   return null;
 }
-
-class DragInfo {
+var DragInfo = class {
   constructor(path, stack, e, val, type, node) {
     this.path = path;
     this.stack = stack;
@@ -3779,7 +3602,7 @@ class DragInfo {
   lookupBind(name) {
     return this.stack.lookupBind(name);
   }
-}
+};
 
 // index.js
 import {
@@ -3840,26 +3663,20 @@ import {
 var OP_KINDS = ["send", "bubble", "request", "input"];
 function phaseOps(phase) {
   const ops = [];
-  for (const type of OP_KINDS)
-    for (const a of phase[type] ?? [])
-      ops.push({ type, ...a });
-  for (const a of phase.do ?? [])
-    ops.push(a);
+  for (const type of OP_KINDS) for (const a of phase[type] ?? []) ops.push({ type, ...a });
+  for (const a of phase.do ?? []) ops.push(a);
   return ops;
 }
 function resolveArgs(args, self) {
   return typeof args === "function" ? args(self) ?? [] : args ?? [];
 }
 function phaseHasBubble(phase) {
-  if (!phase)
-    return false;
-  if (phase.bubble?.length)
-    return true;
+  if (!phase) return false;
+  if (phase.bubble?.length) return true;
   return (phase.do ?? []).some((op) => op.type === "bubble");
 }
 function dispatchPhase(dispatcher, targetPath, phase, self) {
-  if (!phase)
-    return;
+  if (!phase) return;
   for (const op of phaseOps(phase)) {
     const args = resolveArgs(op.args, self);
     switch (op.type) {
@@ -3882,12 +3699,12 @@ function dispatchPhase(dispatcher, targetPath, phase, self) {
     }
   }
 }
+
 // src/oo.js
 import { Map as IMap, Set as ISet, List, OrderedMap, Record } from "immutable";
-var BAD_VALUE = Symbol("BadValue");
+var BAD_VALUE = /* @__PURE__ */ Symbol("BadValue");
 var nullCoercer = (v) => v;
-
-class Field {
+var Field = class {
   constructor(type, name, typeCheck, coercer, defaultValue = null) {
     this.type = type;
     this.name = name;
@@ -3901,30 +3718,27 @@ class Field {
     return { type, defaultValue: dv?.toJS ? dv.toJS() : dv };
   }
   getFirstFailingCheck(v) {
-    if (!this.typeCheck.isValid(v))
-      return this.typeCheck;
-    for (const check of this.checks)
-      if (!check.isValid(v))
-        return check;
+    if (!this.typeCheck.isValid(v)) return this.typeCheck;
+    for (const check2 of this.checks) if (!check2.isValid(v)) return check2;
     return null;
   }
   isValid(v) {
     return this.getFirstFailingCheck(v) === null;
   }
-  addCheck(check) {
-    this.checks.push(check);
+  addCheck(check2) {
+    this.checks.push(check2);
     return this;
   }
   coerceOr(v, defaultValue = null) {
-    if (this.isValid(v))
-      return v;
+    if (this.isValid(v)) return v;
     const v1 = this.coercer(v);
     return this.isValid(v1) ? v1 : defaultValue;
   }
   coerceOrDefault(v) {
     return this.coerceOr(v, this.defaultValue);
   }
-  extendProtoForType(_proto, _uname) {}
+  extendProtoForType(_proto, _uname) {
+  }
   extendProto(proto) {
     const { name } = this;
     const uname = name[0].toUpperCase() + name.slice(1);
@@ -3946,22 +3760,19 @@ class Field {
     };
     this.extendProtoForType(proto, uname);
   }
-}
-
-class Check {
+};
+var Check = class {
   isValid(_v) {
     return true;
   }
   getMessage(_v) {
     return "Invalid";
   }
-}
-
-class CheckTypeAny extends Check {
-}
-var CHECK_TYPE_ANY = new CheckTypeAny;
-
-class FnCheck extends Check {
+};
+var CheckTypeAny = class extends Check {
+};
+var CHECK_TYPE_ANY = new CheckTypeAny();
+var FnCheck = class extends Check {
   constructor(isValidFn, getMessageFn) {
     super();
     this._isValid = isValidFn;
@@ -3973,18 +3784,41 @@ class FnCheck extends Check {
   getMessage(v) {
     return this._getMessage(v);
   }
-}
-var CHECK_TYPE_INT = new FnCheck((v) => Number.isInteger(v), () => "Integer expected");
-var CHECK_TYPE_FLOAT = new FnCheck((v) => Number.isFinite(v), () => "Float expected");
-var CHECK_TYPE_BOOL = new FnCheck((v) => typeof v === "boolean", () => "Boolean expected");
-var CHECK_TYPE_STRING = new FnCheck((v) => typeof v === "string", () => "String expected");
-var CHECK_TYPE_LIST = new FnCheck((v) => List.isList(v), () => "List expected");
-var CHECK_TYPE_MAP = new FnCheck((v) => IMap.isMap(v), () => "Map expected");
-var CHECK_TYPE_OMAP = new FnCheck((v) => OrderedMap.isOrderedMap(v), () => "OrderedMap expected");
-var CHECK_TYPE_SET = new FnCheck((v) => ISet.isSet(v), () => "Set expected");
+};
+var CHECK_TYPE_INT = new FnCheck(
+  (v) => Number.isInteger(v),
+  () => "Integer expected"
+);
+var CHECK_TYPE_FLOAT = new FnCheck(
+  (v) => Number.isFinite(v),
+  () => "Float expected"
+);
+var CHECK_TYPE_BOOL = new FnCheck(
+  (v) => typeof v === "boolean",
+  () => "Boolean expected"
+);
+var CHECK_TYPE_STRING = new FnCheck(
+  (v) => typeof v === "string",
+  () => "String expected"
+);
+var CHECK_TYPE_LIST = new FnCheck(
+  (v) => List.isList(v),
+  () => "List expected"
+);
+var CHECK_TYPE_MAP = new FnCheck(
+  (v) => IMap.isMap(v),
+  () => "Map expected"
+);
+var CHECK_TYPE_OMAP = new FnCheck(
+  (v) => OrderedMap.isOrderedMap(v),
+  () => "OrderedMap expected"
+);
+var CHECK_TYPE_SET = new FnCheck(
+  (v) => ISet.isSet(v),
+  () => "Set expected"
+);
 var boolCoercer = (v) => !!v;
-
-class FieldBool extends Field {
+var FieldBool = class extends Field {
   constructor(name, defaultValue = false) {
     super("bool", name, CHECK_TYPE_BOOL, boolCoercer, defaultValue);
   }
@@ -3997,9 +3831,8 @@ class FieldBool extends Field {
       return this.set(name, !!v);
     };
   }
-}
-
-class FieldAny extends Field {
+};
+var FieldAny = class extends Field {
   constructor(name, defaultValue = null) {
     super("any", name, CHECK_TYPE_ANY, nullCoercer, defaultValue);
   }
@@ -4008,34 +3841,30 @@ class FieldAny extends Field {
     const type = getTypeName(dv) ?? "any";
     return { type, defaultValue: dv?.toJS ? dv.toJS() : dv };
   }
-}
+};
 var stringCoercer = (v) => v?.toString?.() ?? "";
-
-class FieldString extends Field {
+var FieldString = class extends Field {
   constructor(name, defaultValue = "") {
     super("text", name, CHECK_TYPE_STRING, stringCoercer, defaultValue);
   }
   extendProtoForType(proto, _uname) {
     extendProtoSized(proto, this.name, "", "length");
   }
-}
+};
 var intCoercer = (v) => Number.isFinite(v) ? Math.trunc(v) : null;
-
-class FieldInt extends Field {
+var FieldInt = class extends Field {
   constructor(name, defaultValue = 0) {
     super("int", name, CHECK_TYPE_INT, intCoercer, defaultValue);
   }
-}
+};
 var floatCoercer = (_) => null;
-
-class FieldFloat extends Field {
+var FieldFloat = class extends Field {
   constructor(name, defaultValue = 0) {
     super("float", name, CHECK_TYPE_FLOAT, floatCoercer, defaultValue);
   }
-}
+};
 var getTypeName = (v) => v?.constructor?.getMetaClass?.()?.name;
-
-class CheckTypeName {
+var CheckTypeName = class {
   constructor(typeName) {
     this.typeName = typeName;
   }
@@ -4046,9 +3875,8 @@ class CheckTypeName {
     const got = getTypeName(v);
     return `Expected "${this.typeName}", got "${got}"`;
   }
-}
-
-class FieldComp extends Field {
+};
+var FieldComp = class extends Field {
   constructor(type, name, args) {
     super(type, name, new CheckTypeName(type), nullCoercer, null);
     this.args = args;
@@ -4056,8 +3884,8 @@ class FieldComp extends Field {
   toDataDef() {
     return { component: this.typeName, args: this.args };
   }
-}
-var NONE2 = Symbol("NONE");
+};
+var NONE2 = /* @__PURE__ */ Symbol("NONE");
 function extendProtoForKeyed(proto, name, uname) {
   extendProtoSized(proto, name, EMPTY_LIST);
   proto[`setIn${uname}At`] = function(i, v) {
@@ -4069,8 +3897,7 @@ function extendProtoForKeyed(proto, name, uname) {
   proto[`updateIn${uname}At`] = function(i, fn) {
     const col = this.get(name);
     const v = col.get(i, NONE2);
-    if (v !== NONE2)
-      return this.set(name, col.set(i, fn(v)));
+    if (v !== NONE2) return this.set(name, col.set(i, fn(v)));
     console.warn("key", i, "not found in", name, col);
     return this;
   };
@@ -4084,8 +3911,7 @@ function extendDeleteInAt(proto, name, uname) {
 }
 var EMPTY_LIST = List();
 var listCoercer = (v) => Array.isArray(v) ? List(v) : null;
-
-class FieldList extends Field {
+var FieldList = class extends Field {
   constructor(name, defaultValue = EMPTY_LIST) {
     super("list", name, CHECK_TYPE_LIST, listCoercer, defaultValue);
   }
@@ -4099,27 +3925,25 @@ class FieldList extends Field {
       return this.set(name, this.get(name).insert(i, v));
     };
   }
-}
+};
 var imapCoercer = (v) => IMap(v);
-
-class FieldMap extends Field {
+var FieldMap = class extends Field {
   constructor(name, defaultValue = IMap()) {
     super("map", name, CHECK_TYPE_MAP, imapCoercer, defaultValue);
   }
   extendProtoForType(proto, uname) {
     extendProtoForKeyed(proto, this.name, uname);
   }
-}
+};
 var omapCoercer = (v) => OrderedMap(v);
-
-class FieldOMap extends Field {
+var FieldOMap = class extends Field {
   constructor(name, defaultValue = OrderedMap()) {
     super("omap", name, CHECK_TYPE_OMAP, omapCoercer, defaultValue);
   }
   extendProtoForType(proto, uname) {
     extendProtoForKeyed(proto, this.name, uname);
   }
-}
+};
 function extendProtoSized(proto, name, defaultEmpty, propName = "size") {
   proto[`${name}Len`] = function() {
     return this.get(name, defaultEmpty)[propName];
@@ -4127,8 +3951,7 @@ function extendProtoSized(proto, name, defaultEmpty, propName = "size") {
 }
 var EMPTY_SET = ISet();
 var isetCoercer = (v) => Array.isArray(v) ? ISet(v) : v instanceof Set ? ISet(v) : null;
-
-class FieldSet extends Field {
+var FieldSet = class extends Field {
   constructor(name, defaultValue = EMPTY_SET) {
     super("set", name, CHECK_TYPE_SET, isetCoercer, defaultValue);
   }
@@ -4147,18 +3970,19 @@ class FieldSet extends Field {
       return this.set(name, current.has(v) ? current.delete(v) : current.add(v));
     };
   }
-}
+};
 function mkCompField(field, scope, args) {
   const Comp = scope?.lookupComponent(field.type) ?? null;
   if (Comp === null)
-    console.warn(scope ? `component field "${field.name}": component "${field.type}" not found in scope` : `component field "${field.name}": cannot resolve component "${field.type}" — built without a registered scope (use ${field.type}.make({}) as the default, or build via a registered component)`);
+    console.warn(
+      scope ? `component field "${field.name}": component "${field.type}" not found in scope` : `component field "${field.name}": cannot resolve component "${field.type}" — built without a registered scope (use ${field.type}.make({}) as the default, or build via a registered component)`
+    );
   return Comp?.make({ ...field.args, ...args }, { scope }) ?? null;
 }
-
-class ClassBuilder {
+var ClassBuilder = class {
   constructor(name) {
     const fields = {};
-    const compFields = new Set;
+    const compFields = /* @__PURE__ */ new Set();
     this.name = name;
     this.fields = fields;
     this.compFields = compFields;
@@ -4169,16 +3993,13 @@ class ClassBuilder {
         const scope = opts.scope ?? this.scope;
         for (const key in inArgs) {
           const field = fields[key];
-          if (compFields.has(key))
-            args[key] = mkCompField(field, scope, inArgs[key]);
-          else if (field === undefined)
+          if (compFields.has(key)) args[key] = mkCompField(field, scope, inArgs[key]);
+          else if (field === void 0)
             console.warn("extra argument to constructor:", name, key, inArgs);
-          else
-            args[key] = field.coerceOrDefault(inArgs[key]);
+          else args[key] = field.coerceOrDefault(inArgs[key]);
         }
         for (const key of compFields)
-          if (args[key] === undefined)
-            args[key] = mkCompField(fields[key], scope, inArgs[key]);
+          if (args[key] === void 0) args[key] = mkCompField(fields[key], scope, inArgs[key]);
         return this(args);
       }
     };
@@ -4199,12 +4020,10 @@ class ClassBuilder {
     return Class;
   }
   methods(proto) {
-    for (const k in proto)
-      this._methods[k] = proto[k];
+    for (const k in proto) this._methods[k] = proto[k];
   }
   statics(proto) {
-    for (const k in proto)
-      this._statics[k] = proto[k];
+    for (const k in proto) this._statics[k] = proto[k];
   }
   addField(name, dval, FieldCls) {
     const field = new FieldCls(name, dval);
@@ -4217,8 +4036,8 @@ class ClassBuilder {
     this.fields[name] = field;
     return field;
   }
-}
-var FIELD_CLASS = Symbol.for("tutuca.fieldClass");
+};
+var FIELD_CLASS = /* @__PURE__ */ Symbol.for("tutuca.fieldClass");
 var fieldsByTypeName = {
   text: FieldString,
   int: FieldInt,
@@ -4235,22 +4054,16 @@ function classFromData(name, { fields = {}, methods, statics }) {
   for (const field in fields) {
     const value = fields[field];
     const type = typeof value;
-    if (type === "string")
-      b.addField(field, value, FieldString);
-    else if (type === "number")
-      b.addField(field, value, FieldFloat);
-    else if (type === "boolean")
-      b.addField(field, value, FieldBool);
-    else if (List.isList(value) || Array.isArray(value))
-      b.addField(field, List(value), FieldList);
-    else if (ISet.isSet(value) || value instanceof Set)
-      b.addField(field, ISet(value), FieldSet);
-    else if (OrderedMap.isOrderedMap(value))
-      b.addField(field, value, FieldOMap);
-    else if (value?.type && value?.defaultValue !== undefined) {
+    if (type === "string") b.addField(field, value, FieldString);
+    else if (type === "number") b.addField(field, value, FieldFloat);
+    else if (type === "boolean") b.addField(field, value, FieldBool);
+    else if (List.isList(value) || Array.isArray(value)) b.addField(field, List(value), FieldList);
+    else if (ISet.isSet(value) || value instanceof Set) b.addField(field, ISet(value), FieldSet);
+    else if (OrderedMap.isOrderedMap(value)) b.addField(field, value, FieldOMap);
+    else if (value?.type && value?.defaultValue !== void 0) {
       const Field2 = fieldsByTypeName[value.type] ?? FieldAny;
       b.addField(field, new Field2().coerceOr(value.defaultValue), Field2);
-    } else if (value?.component && value?.args !== undefined)
+    } else if (value?.component && value?.args !== void 0)
       b.addCompField(field, value.component, value.args);
     else if (IMap.isMap(value) || value?.constructor === Object)
       b.addField(field, IMap(value), FieldMap);
@@ -4259,10 +4072,8 @@ function classFromData(name, { fields = {}, methods, statics }) {
       b.addField(field, value, Field2);
     }
   }
-  if (methods)
-    b.methods(methods);
-  if (statics)
-    b.statics(statics);
+  if (methods) b.methods(methods);
+  if (statics) b.statics(statics);
   return b.build();
 }
 Component.fromSpec = (opts) => new Component(classFromData(opts.name, opts), opts);
@@ -4279,82 +4090,84 @@ async function test(_opts) {
   return null;
 }
 function collectIterBindings() {
-  console.warn("collectIterBindings is a no-op in the core tutuca build; use the tutuca-dev build for a functional implementation");
+  console.warn(
+    "collectIterBindings is a no-op in the core tutuca build; use the tutuca-dev build for a functional implementation"
+  );
   return [];
 }
 function tutuca(nodeOrSelector) {
   const rootNode = typeof nodeOrSelector === "string" ? document.querySelector(nodeOrSelector) : nodeOrSelector;
-  const comps = new Components;
+  const comps = new Components();
   const renderer = new Renderer(comps);
   return new App(rootNode, comps, renderer, ParseContext);
 }
 export {
-  version,
-  updateIn,
-  update,
-  tutuca,
-  test,
-  setIn,
-  set,
-  rootDispatcher,
-  resolveArgs,
-  removeIn,
-  remove,
-  phaseOps,
-  phaseHasBubble,
-  mergeWith,
-  mergeDeepWith,
-  mergeDeep,
-  merge,
-  macro,
-  isValueObject,
-  isStack,
-  isSet,
-  isSeq,
-  isRecord,
-  isPlainObject,
-  isOrderedSet,
-  isOrderedMap,
-  isOrdered,
-  isOrderedMap2 as isOMap,
-  isMap,
-  isList,
-  isKeyed2 as isKeyed,
-  isIndexed2 as isIndexed,
-  isImmutable,
-  isMap2 as isIMap,
-  isCollection,
-  isAssociative,
-  is2 as is,
-  injectCss,
-  html,
-  hash,
-  hasIn,
-  has,
-  getIn,
-  get,
-  fromJS,
-  dispatchPhase,
-  css,
-  component,
-  collectIterBindings,
-  check,
-  Stack2 as Stack,
-  Set2 as Set,
-  Seq,
-  SEQ_INFO,
-  Repeat,
-  Record2 as Record,
-  Range,
-  ParseContext,
-  PairSorting,
-  OrderedSet,
-  OrderedMap2 as OrderedMap,
-  OrderedMap3 as OMap,
-  Map2 as Map,
-  List2 as List,
-  Set3 as ISet,
-  Map3 as IMap,
+  Collection,
   FIELD_CLASS,
-  Collection
+  Map3 as IMap,
+  Set3 as ISet,
+  List2 as List,
+  Map2 as Map,
+  OrderedMap3 as OMap,
+  OrderedMap2 as OrderedMap,
+  OrderedSet,
+  PairSorting,
+  ParseContext,
+  Range,
+  Record2 as Record,
+  Repeat,
+  SEQ_INFO,
+  Seq,
+  Set2 as Set,
+  Stack2 as Stack,
+  check,
+  collectIterBindings,
+  component,
+  css,
+  dispatchPhase,
+  fromJS,
+  get,
+  getIn,
+  has,
+  hasIn,
+  hash,
+  html,
+  injectCss,
+  is2 as is,
+  isAssociative,
+  isCollection,
+  isMap2 as isIMap,
+  isImmutable,
+  isIndexed2 as isIndexed,
+  isKeyed2 as isKeyed,
+  isList,
+  isMap,
+  isOrderedMap2 as isOMap,
+  isOrdered,
+  isOrderedMap,
+  isOrderedSet,
+  isPlainObject,
+  isRecord,
+  isSeq,
+  isSet,
+  isStack,
+  isValueObject,
+  macro,
+  merge,
+  mergeDeep,
+  mergeDeepWith,
+  mergeWith,
+  phaseHasBubble,
+  phaseOps,
+  remove,
+  removeIn,
+  resolveArgs,
+  rootDispatcher,
+  set,
+  setIn,
+  test,
+  tutuca,
+  update,
+  updateIn,
+  version
 };