@ape-egg/vibe 4.0.1 → 4.1.1

package/runtime/conditionals.js

@@ -9,20 +9,10 @@ import { evalInScope } from './utils.js';
 import { collectComponentIds, releaseOrphanedComponentState, executeCompiledComponentScriptsIn } from './component.js';
 import { isOutgoing } from './staging.js';
 
-// Registry of DOM nodes owned by conditional branches.
-// Maps a DOM node to { nodes: array_ref, index: number } so that
-// processMutations can update the reference when processComponent
-// replaces the node (el.replaceWith). Keeps conditional state in
-// sync with actual DOM without sweeps or special properties.
 export const branchNodeRegistry = new WeakMap();
 
-// Nodes that have been processed by mountBranch or renderIteration.
-// processMutations checks this to avoid re-processing already-handled content.
 export const managedNodes = new WeakSet();
 
-// Find the dot path of a conditional node in the manifest.
-// Resolves the parent element through the reverse index, then appends the
-// conditional's key.
 const findConditionalPath = (node, manifest) => {
   const parentPath = manifestPathOf(manifest, node.meta.startComment.parentNode);
   if (parentPath === null) return null;
@@ -30,7 +20,6 @@ const findConditionalPath = (node, manifest) => {
   return `${parentPath}.${node._key}`;
 };
 
-// Register branch tree nodes in the manifest (recursive)
 const addBranchToManifest = (tree, manifest, basePath) => {
   if (tree.element) {
     setManifestEntry(manifest, basePath, tree.element);
@@ -42,7 +31,6 @@ const addBranchToManifest = (tree, manifest, basePath) => {
   }
 };
 
-// Remove branch tree nodes from the manifest (recursive)
 const removeBranchFromManifest = (tree, manifest, basePath) => {
   delete manifest[basePath];
   if (tree.children) {
@@ -52,39 +40,29 @@ const removeBranchFromManifest = (tree, manifest, basePath) => {
   }
 };
 
-// Evaluate conditional expression in state context
 const evaluateCondition = (expression, state, element = null) => !!evalInScope(expression, state, element);
 
-// Extract state dependencies from an expression
-// e.g., "count > 5" → ["count"]
-// e.g., "isLoggedIn && isAdmin" → ["isLoggedIn", "isAdmin"]
 export const extractDependencies = (expression) => {
   const regex = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g;
   const matches = [];
   let match;
   while ((match = regex.exec(expression))) {
     const identifier = match[1];
-    // Filter out JavaScript keywords and common literals
     if (!['true', 'false', 'null', 'undefined', 'this', 'return'].includes(identifier)) {
       matches.push(identifier);
     }
   }
-  return [...new Set(matches)]; // Unique values
+  return [...new Set(matches)];
 };
 
-
-// Render all conditionals in the parsed tree
 export const renderAllConditionals = (tree, state, manifest, parentScope = {}) => {
   let count = 0;
 
-  // If this is a conditional node, render it
   if (tree.type === 'conditional') {
     renderConditional(tree, state, manifest, parentScope);
     return 1;
   }
 
-  // Recursively render conditionals in child nodes — except under an
-  // outgoing wrapper, whose content the pending swap will replace wholesale.
   if (tree.children && !(tree.element && isOutgoing(tree.element))) {
     Object.keys(tree.children).forEach((key) => {
       const child = tree.children[key];
@@ -97,21 +75,9 @@ export const renderAllConditionals = (tree, state, manifest, parentScope = {}) =
   return count;
 };
 
-// Re-settle every ALREADY-RENDERED conditional against the current world.
-// The boot's initial pass can run before module scripts have evaluated
-// (compiled shell: boot.js rides the vibe-module chain), so a gate on a
-// module-provided global — `<!-- if window.isDev -->` — first evaluates
-// against the pre-module world and carries no reactive dependency that would
-// ever re-check it. Walks like renderAllConditionals but routes through
-// updateConditional: value-unchanged branches are a no-op, changed ones
-// mount/unmount through the normal branch machinery.
 export const settleConditionals = (tree, state, manifest, parentScope = {}) => {
   if (tree.type === 'conditional') {
     updateConditional(tree, state, state, manifest, parentScope);
-    // A COMPILED pre-rendered conditional keeps its live content in
-    // `children` (never mountBranch'd) — nested conditionals there need
-    // settling too. Connected-root check skips a runtime conditional's
-    // detached template nodes.
     if (tree.children) {
       Object.keys(tree.children).forEach((key) => {
         const child = tree.children[key];
@@ -133,35 +99,17 @@ export const settleConditionals = (tree, state, manifest, parentScope = {}) => {
   }
 };
 
-// Initial render of a conditional block
 export const renderConditional = (node, state, manifest, parentScope = {}) => {
   const { expression, startComment, endComment, branches } = node.meta;
 
-  // Mark conditionals that live inside an iteration row so update-time branch
-  // flips can route `<component src>` props through the iteration-prop
-  // registry. Skipping this for top-level conditionals keeps their props as
-  // live `@[stateKey]` bindings — which is what global state-change reactivity
-  // depends on (the registry path snapshots a value and doesn't react to
-  // global state changes on its own).
-  // `parentScope` is populated on the initial-render path, but a conditional
-  // mounted via the update path (a parent conditional flipping true after load)
-  // — or any deeper-nested conditional — arrives with an empty parentScope, the
-  // iteration's scoped state flowing in through `state` instead. `scopeAliases`
-  // is set at parse time and persists, so it reliably marks a conditional that
-  // lexically lives inside an iteration regardless of which path mounts it — the
-  // Brawling loader, whose conditional flips true only once combat starts.
   if (Object.keys(parentScope).length > 0 || node.meta.scopeAliases?.length) {
     node.runtime.inIteration = true;
   }
 
-  // Check if already rendered (using marker on comment node)
-  // @ts-ignore - adding custom property to comment node
   if (startComment.__vibeRendered) {
     return;
   }
 
-  // Remove original template nodes from DOM (between start and end comments)
-  // Only do this on first render (when template hasn't been removed yet)
   if (!node.runtime.templateRemoved) {
     let currentNode = startComment.nextSibling;
     while (currentNode && currentNode !== endComment) {
@@ -172,58 +120,40 @@ export const renderConditional = (node, state, manifest, parentScope = {}) => {
       currentNode = nextNode;
     }
 
-    // Mark that template has been removed
     node.runtime.templateRemoved = true;
   }
 
-  // Mark comment as rendered (survives re-parsing)
-  // @ts-ignore - adding custom property to comment node
   startComment.__vibeRendered = true;
 
-  // Evaluate condition with current state — inside a tracking window, so the
-  // conditional subscribes to what its expression read from first render on.
   const trackSub = nodeSubscriberOf(node, 'conditional');
   trackSub.lastScope = state;
   beginTracking(trackSub, overlayKeysOf(state));
   const conditionResult = evaluateCondition(expression, state, startComment.parentElement);
   endTracking();
 
-  // Determine which branch to mount
   const branchToMount = conditionResult ? branches.if : branches.else;
 
-  // Mount the appropriate branch
   mountBranch(node, branchToMount, state, manifest, parentScope);
 
-  // Store active branch reference
   node.runtime.activeBranch = branchToMount;
 };
 
-// Mount a specific branch
 const mountBranch = (node, branchData, state, manifest, parentScope) => {
   const { startComment, endComment } = node.meta;
 
-  // If branch doesn't exist (no else clause), just unmount current
   if (!branchData) {
     unmountBranch(node, manifest);
     return;
   }
 
-  // Unmount current branch first (if any)
   unmountBranch(node, manifest);
 
-  // Clone the template element
   const templateContent = branchData.element.childNodes;
   const parent = startComment.parentNode;
 
-  // Create scoped state (with parent scope if inside iteration)
   const scopedState =
     Object.keys(parentScope).length > 0 ? createScopedState(state, parentScope) : state;
 
-  // Initialize block (clone, parse, hydrate). Pass the enclosing loop aliases so
-  // the re-parse rewrites loop-scoped handlers in this branch — including ones
-  // nested deeper in further conditionals, which the parser reaches by carrying
-  // the alias set down. `scopeAliases` is set at parse time and persists, so this
-  // works on both the initial-render and update (hydrate) mount paths.
   const aliasSet = node.meta.scopeAliases?.length ? new Set(node.meta.scopeAliases) : undefined;
   const {
     element: firstElement,
@@ -231,44 +161,22 @@ const mountBranch = (node, branchData, state, manifest, parentScope) => {
     clonedNodes,
   } = initializeBlock(templateContent, scopedState, null, null, aliasSet);
 
-  // For conditionals living inside an iteration, route any `<component src>`
-  // props through the iteration-prop registry against the active scopedState
-  // (which carries the iteration's local vars). Without this, processSingle
-  // would inline `@[item.x]` bindings into the component template, where
-  // `item` isn't reachable in global scope and props resolve to undefined.
-  // Skipped for top-level conditionals because their props reference live
-  // global-state bindings — going through the registry would snapshot the
-  // value and break reactivity.
   if (node.runtime.inIteration) {
     resolveIterationComponentProps(clonedNodes, scopedState, aliasSet);
   }
 
-  // Insert cloned nodes into DOM and register in branch registry
   clonedNodes.forEach((clonedNode, i) => {
     parent.insertBefore(clonedNode, endComment);
     branchNodeRegistry.set(clonedNode, { nodes: clonedNodes, index: i });
     if (clonedNode.nodeType === 1) managedNodes.add(clonedNode);
   });
 
-  // Branch content is mounted outside the enclosing iteration instance's
-  // clonedNodes, so it doesn't inherit the instance's `__vibeScope` stamp by DOM
-  // ancestry. When this conditional lives inside a loop, stamp `scopedState` —
-  // the same scope that hydrates the branch's `@[alias.x]` bindings — onto the
-  // branch's root elements so loop-scoped `$scope(this,'alias')` handlers resolve.
-  // Gate on `scopeAliases` (set at parse time, persists) rather than the runtime
-  // parentScope/inIteration, because the update path (hydrate -> updateConditional)
-  // and deeper-nested conditionals mount with an empty parentScope yet still flow
-  // the iteration's scoped state in as `state`.
   if (node.meta.scopeAliases?.length) {
     for (let i = 0; i < clonedNodes.length; i++) {
       if (clonedNodes[i].nodeType === 1) clonedNodes[i].__vibeScope = scopedState;
     }
   }
 
-  // Integrate branch tree into the conditional node's children and manifest.
-  // This makes branch content visible to the main update loop (hydrate,
-  // renderAllConditionals, renderAllIterations) and to MutationObserver
-  // (which looks up parents in the manifest).
   if (branchTree?.children) {
     for (const key in branchTree.children) {
       node.children[key] = branchTree.children[key];
@@ -282,42 +190,19 @@ const mountBranch = (node, branchData, state, manifest, parentScope) => {
     }
   }
 
-  // Compiled pages inline each component's setup script as type="vibe-module".
-  // The boot-time pass only runs scripts present at boot, so a branch that
-  // mounts (or re-mounts after unmount) must run its own scripts here to
-  // re-register component-local state. Must happen BEFORE rendering nested
-  // iterations/conditionals so `<!-- each _cN.x -->` sees the registered state.
   const scriptsPending = executeCompiledComponentScriptsIn(clonedNodes);
 
-  // Recursively render any nested iterations and conditionals
   if (branchTree) {
     renderAllIterations(branchTree, scopedState, manifest, parentScope);
     renderAllConditionals(branchTree, scopedState, manifest, parentScope);
   }
 
-  // Store active instance
   node.runtime.activeInstance = {
     branch: branchData,
     nodes: clonedNodes,
     parsedTree: branchTree,
   };
 
-  // Import-bearing branch scripts run async through the script chain, so the
-  // eager render above may evaluate expressions before the window helpers those
-  // scripts define exist — and defining a global is not a state write, so no
-  // flush ever re-dispatches them (the fetch path never has this gap: it mounts
-  // DOM only after its scripts ran). Finish the mount when the chain settles:
-  // re-render this branch's directives against the fully-scripted world.
-  // Idempotent — rendered iterations early-return, value-unchanged conditionals
-  // are a no-op — and skipped when a remount superseded this instance.
-  //
-  // The settle evaluates CURRENT state (the live `$`), never the mount-time
-  // snapshot: state that legitimately changed while the imports were pending
-  // (a nested gate flipping true off a socket flush) already dispatched and
-  // mounted — settling against the stale snapshot would unmount it again.
-  // Loop-scoped branches keep their mount scope (the row's aliases aren't
-  // reachable from the root proxy); a row update supersedes activeInstance
-  // and the guard skips the settle entirely.
   if (scriptsPending && branchTree) {
     scriptsPending.then(() => {
       if (node.runtime.activeInstance?.nodes !== clonedNodes) return;
@@ -328,13 +213,11 @@ const mountBranch = (node, branchData, state, manifest, parentScope) => {
   }
 };
 
-// Unmount currently active branch
 const unmountBranch = (node, manifest) => {
   const { activeInstance } = node.runtime;
 
   if (!activeInstance) return;
 
-  // Remove branch children from the conditional node's tree and manifest
   if (activeInstance.parsedTree?.children) {
     const condPath = manifest ? findConditionalPath(node, manifest) : null;
 
@@ -346,13 +229,6 @@ const unmountBranch = (node, manifest) => {
     }
   }
 
-  // The conditional owns everything between its comments. That's more than
-  // activeInstance.nodes: nested directives at the branch's top level (each
-  // rows, deeper if branches) insert their rendered output between their own
-  // comments after the branch mounts, so it never appears in the original
-  // clonedNodes list. Sweep the live range (same pattern as iteration
-  // teardown), collecting componentIds BEFORE detaching so we can check
-  // after removal whether any live DOM still holds them.
   const { startComment, endComment } = node.meta;
   const ids = new Set();
   let current = startComment.nextSibling;
@@ -366,22 +242,12 @@ const unmountBranch = (node, manifest) => {
     current = next;
   }
 
-  // CLEANUP OF CURRENT STATE
   releaseOrphanedComponentState(ids);
-  // The swept range's binding subscribers are dead — their anchors just left
-  // the document. (The conditional's own subscriber survives: its anchor is
-  // the start comment, which stays.)
   pruneDisconnected();
 
-  // Clear active instance
   node.runtime.activeInstance = null;
 };
 
-// Subscription dispatch: flip the branch if the expression's value moved,
-// nothing else. Branch CONTENT updates arrive through the content's own
-// subscribers — re-walking the branch here (updateConditional's else path)
-// would reintroduce a partial walk per dirty conditional. A mounting branch
-// registers its fresh subscribers through initializeBlock's hydrate pass.
 export const dispatchConditional = (node, newState, manifest, parentScope = {}) => {
   if (!node.runtime.templateRemoved) return;
   const sub = nodeSubscriberOf(node, 'conditional');
@@ -396,17 +262,13 @@ export const dispatchConditional = (node, newState, manifest, parentScope = {})
   }
 };
 
-// Update conditional when dependencies change
 export const updateConditional = (node, newState, oldState, manifest, parentScope = {}) => {
   const { expression, branches, startComment } = node.meta;
 
-  // If not yet rendered, skip (renderConditional handles initial render)
   if (!node.runtime.templateRemoved) {
     return;
   }
 
-  // Evaluate expression with new state — re-records the subscription every
-  // update, so branch-dependent reads self-heal.
   const trackSub = nodeSubscriberOf(node, 'conditional');
   trackSub.lastScope = newState;
   beginTracking(trackSub, overlayKeysOf(newState));
@@ -414,16 +276,12 @@ export const updateConditional = (node, newState, oldState, manifest, parentScop
   endTracking();
   const newBranchData = newConditionResult ? branches.if : branches.else;
 
-  // Check if branch changed (compare references)
   const branchChanged = node.runtime.activeBranch !== newBranchData;
 
   if (branchChanged) {
-    // Switch branches
     mountBranch(node, newBranchData, newState, manifest, parentScope);
     node.runtime.activeBranch = newBranchData;
   } else {
-    // Same branch, but state might have changed — rehydrate bindings
-    // and update nested conditionals/iterations
     const { activeInstance } = node.runtime;
 
     if (activeInstance && activeInstance.parsedTree) {

package/runtime/constants.js

@@ -1,49 +1,31 @@
-// The released version — check-release.js holds this in lockstep with
-// package.json, the READMEs and the CHANGELOG.
-export const VERSION = '4.0.1';
+export const VERSION = '4.1.1';
 
-// Debug logger name
 export const DEBUGGER_NAME = '[vibe-debug]:';
-export const FOUC_CLASS_OR_ATTR = 'vibe-fouc'; // Class or attribute used to prevent FOUC (default: [vibe])
-export const DEHYDRATE_CLASS_OR_ATTR = 'vibe-dehydrate'; // Class or attribute used to skip reactive processing
-
-// Lifecycle phase names for debug logging
-// ONE-OFF operations (run once during initialization)
-export const PHASE_ATTACH = 'Attached'; // Latches onto DOM element (index.js)
-export const PHASE_MANIFEST = 'Manifested'; // Creates DOM manifest (manifest.js)
-export const PHASE_OBSERVE = 'Observer'; // Starts MutationObserver (index.js)
-export const PHASE_READY = 'Ready'; // Removes [vibe-fouc] attribute (or .vibe-fouc class) and dispatches vibe:ready event (cleanup.js)
-
-// REPEATED operations (run during init + can repeat during runtime)
-export const PHASE_PARSE = 'Parsed'; // Reads DOM structure (parse.js)
-export const PHASE_HYDRATE = 'Hydrated'; // Replaces @[...] with values (hydrate.js)
-export const PHASE_ITERATE = 'Iterated'; // Renders <!-- each --> blocks (iterate.js)
-export const PHASE_CONDITION = 'Evaluated'; // Renders <!-- if --> blocks (conditionals.js)
-export const PHASE_FETCH = 'Fetched'; // Loads <component> content over the network (component.js)
-export const PHASE_FETCH_CACHED = 'Fet(ca)ched'; // Loads <component> content from the runtime template cache — a Fetch served from memory (component.js)
-export const PHASE_UPDATE = 'Proxy'; // State changes trigger re-hydration (index.js)
-export const PHASE_MUTATE = 'Mutation'; // DOM mutations detected by observer (index.js)
-export const PHASE_HYPERSPEED = 'Hyperspeed'; // Restores @[...] markers from pre-compiled manifest (pre-compiled-manifest.js)
-
-// Elements that should not have reactive bindings
-// Note: COMPONENT is NOT in this list - inline component wrappers need to be parsed
-// Fetched components (<component src="">) are handled separately by processComponent()
+export const FOUC_CLASS_OR_ATTR = 'vibe-fouc';
+export const DEHYDRATE_CLASS_OR_ATTR = 'vibe-dehydrate';
+
+export const PHASE_ATTACH = 'Attached';
+export const PHASE_MANIFEST = 'Manifested';
+export const PHASE_OBSERVE = 'Observer';
+export const PHASE_READY = 'Ready';
+
+export const PHASE_PARSE = 'Parsed';
+export const PHASE_HYDRATE = 'Hydrated';
+export const PHASE_ITERATE = 'Iterated';
+export const PHASE_CONDITION = 'Evaluated';
+export const PHASE_FETCH = 'Fetched';
+export const PHASE_FETCH_CACHED = 'Fet(ca)ched';
+export const PHASE_UPDATE = 'Proxy';
+export const PHASE_MUTATE = 'Mutation';
+export const PHASE_HYPERSPEED = 'Hyperspeed';
+
 export const NON_REACTIVE_ELEMENTS = ['SCRIPT', 'HEAD', 'PRE'];
 
-// Elements whose src-family attributes the browser fetches the moment they are
-// set — a raw `src="@[binding]"` reaching one of these fires a network request
-// for the literal binding text before hydration can stamp the real value.
-// Bindings on them are parked on data-vibe-<attr> (the established transport)
-// until hydration writes the evaluated URL. <component src> is NOT here — its
-// src is consumed by processComponent, never by the browser.
 export const FETCH_SRC_ATTRS = ['src', 'srcset', 'poster'];
 export const FETCH_SRC_SELECTOR = 'img, source, iframe, video, audio, embed, track';
 export const FETCH_SRC_ELEMENTS = ['IMG', 'SOURCE', 'IFRAME', 'VIDEO', 'AUDIO', 'EMBED', 'TRACK'];
 
-// Attributes where the string value is meaningful (should NOT be removed when falsy)
-// All other attributes are treated as boolean-like (removed when falsy, present when truthy)
 export const VALUE_ATTRS = [
-  // Global attributes
   'class',
   'style',
   'id',
@@ -59,7 +41,6 @@ export const VALUE_ATTRS = [
   'popover',
   'anchor',
 
-  // Enumerated (take specific string values, not truly boolean)
   'contenteditable',
   'draggable',
   'spellcheck',
@@ -69,7 +50,6 @@ export const VALUE_ATTRS = [
   'enterkeyhint',
   'virtualkeyboardpolicy',
 
-  // URLs and sources
   'href',
   'src',
   'action',
@@ -84,7 +64,6 @@ export const VALUE_ATTRS = [
   'manifest',
   'codebase',
 
-  // Form attributes
   'name',
   'type',
   'value',
@@ -109,13 +88,11 @@ export const VALUE_ATTRS = [
   'for',
   'dirname',
 
-  // Text/accessibility
   'alt',
   'label',
   'summary',
   'abbr',
 
-  // Dimensions and layout
   'width',
   'height',
   'cols',
@@ -127,7 +104,6 @@ export const VALUE_ATTRS = [
   'high',
   'optimum',
 
-  // Link/resource hints
   'target',
   'rel',
   'hreflang',
@@ -146,81 +122,42 @@ export const VALUE_ATTRS = [
   'imagesizes',
   'sizes',
 
-  // Media
   'preload',
   'kind',
   'srclang',
 
-  // Meta
   'content',
   'http-equiv',
 
-  // iframe/embed
   'sandbox',
   'allow',
   'srcdoc',
   'credentialless',
 
-  // Table
   'headers',
   'scope',
 
-  // Datetime
   'datetime',
 
-  // Object/embed legacy
   'coords',
   'shape',
 ];
 
-// Properties that should be set directly on the DOM element (not as attributes)
 export const DOM_PROPERTIES = ['value', 'checked', 'selected'];
 
-
-// Regex for matching reactive bindings (@[expression])
-// Supports nested brackets, single-quoted and double-quoted strings inside expressions:
-// @[items[0]], @[obj[key]], @[x.replace('.png', '-mugshot.png')]
 const BINDING_INNER = String.raw`(?:[^\[\]'"]|\[[^\]]*\]|'[^']*'|"[^"]*")+`;
 export const BINDING_REGEX = new RegExp(String.raw`\@\[(${BINDING_INNER})\]`, 'g');
 
-// Regex for detecting a pure binding (entire value is just @[expression])
 export const PURE_BINDING_REGEX = new RegExp(String.raw`^\@\[(${BINDING_INNER})\]$`);
 
-// Regex for parsing iteration comment syntax. Supported forms — the index and
-// the key are each optional and may appear in EITHER order:
-//   <!-- each items as item -->
-//   <!-- each items as item, index -->
-//   <!-- each items as item (item.id) -->                // explicit key
-//   <!-- each items as item (item.id), index -->         // key, then index
-//   <!-- each items as item, index (item.id) -->         // index, then key
-// Capture groups: arrayPath, itemAlias, keyBeforeIndex (optional), indexAlias
-// (optional), keyAfterIndex (optional). The key lands in group 3 when written
-// before the index and in group 5 when written after; parseIterationHeader
-// coalesces the two — prefer that helper over destructuring the raw match.
-// The array expression can be any JS: a state path, a window global, a method
-// call, or an inline literal. The optional key expression is evaluated per
-// item against scoped state to produce a stable identity for diffing — this
-// keeps survivors stable when earlier items are removed (otherwise the
-// fallback hash key embeds the index and triggers bulk re-render).
 export const ITERATION_REGEX = /^each\s+(.+)\s+as\s+(\w+)(?:\s*\(\s*([^)]+?)\s*\))?(?:\s*,\s*(\w+))?(?:\s*\(\s*([^)]+?)\s*\))?\s*$/;
 
-// Regex for detecting start of iteration comment
 export const ITERATION_START_REGEX = /^each\s+/;
 
-// Regex for parsing conditional comment syntax (<!-- if expression -->)
 export const CONDITIONAL_REGEX = /^if\s+(.+)$/;
 
-// Regex for detecting start of conditional comment
 export const CONDITIONAL_START_REGEX = /^if\s+/;
 
-// Regex for rewriting component-local `this.X` references to the component's
-// state path. Captures the leading identifier only — any trailing `.Y.Z`
-// chain stays attached after replacement, so `this.user.name` becomes
-// `<componentId>.user.name`. Used in expression bodies (bindings, event
-// handlers, conditional/iteration directives).
 export const THIS_PROP_REGEX = /\bthis\.(\w+)/g;
 
-// Regex for rewriting `$.this.X` writes (proxy assignment from event handlers)
-// to the component's write path. Same prefix-only semantics as THIS_PROP_REGEX
-// — `$.this.user.name = x` becomes `$.<componentId>.user.name = x`.
 export const STATE_THIS_PROP_REGEX = /\$\.this\.(\w+)/g;