@hyperfixi/core 3.3.0 → 4.0.1

package/dist/bundle-generator/index.cjs

@@ -1,2804 +0,0 @@
-'use strict';
-
-function stripTypes(code, format) {
-    if (format === 'ts')
-        return code;
-    return (code
-        .replace(/\s+as\s+\w+(?:\[\])?/g, '')
-        .replace(/\((\w+):\s*\w+\)/g, '($1)')
-        .replace(/\((\w+):\s*any\)/g, '($1)')
-        .replace(/Promise<void>\[\]/g, 'Promise[]')
-        .replace(/Promise<void>/g, 'Promise')
-        .replace(/:\s*TransitionEvent/g, ''));
-}
-const COMMAND_IMPLEMENTATIONS_TS = {
-    toggle: `
-    case 'toggle': {
-      const raw = getClassName(cmd.args[0]) || String(await evaluate(cmd.args[0], ctx));
-      const targets = await getTarget();
-      if (raw.startsWith('@')) {
-        const attr = raw.slice(1);
-        for (const el of targets) {
-          if (el.hasAttribute(attr)) el.removeAttribute(attr);
-          else el.setAttribute(attr, '');
-        }
-      } else {
-        for (const el of targets) el.classList.toggle(raw);
-      }
-      ctx.it = targets.length === 1 ? targets[0] : targets;
-      return ctx.it;
-    }`,
-    add: `
-    case 'add': {
-      const raw = getClassName(cmd.args[0]) || String(await evaluate(cmd.args[0], ctx));
-      const targets = await getTarget();
-      if (raw.startsWith('@')) {
-        const attr = raw.slice(1);
-        for (const el of targets) el.setAttribute(attr, '');
-      } else {
-        for (const el of targets) el.classList.add(raw);
-      }
-      ctx.it = targets.length === 1 ? targets[0] : targets;
-      return ctx.it;
-    }`,
-    remove: `
-    case 'remove': {
-      const targets = await getTarget();
-      for (const el of targets) el.remove();
-      return null;
-    }`,
-    removeClass: `
-    case 'removeClass': {
-      const raw = getClassName(cmd.args[0]) || String(await evaluate(cmd.args[0], ctx));
-      const targets = await getTarget();
-      if (raw.startsWith('@')) {
-        const attr = raw.slice(1);
-        for (const el of targets) el.removeAttribute(attr);
-      } else {
-        for (const el of targets) el.classList.remove(raw);
-      }
-      return targets;
-    }`,
-    show: `
-    case 'show': {
-      const targets = await getTarget();
-      for (const el of targets) {
-        (el as HTMLElement).style.display = '';
-        el.classList.remove('hidden');
-      }
-      return targets;
-    }`,
-    hide: `
-    case 'hide': {
-      const targets = await getTarget();
-      for (const el of targets) (el as HTMLElement).style.display = 'none';
-      return targets;
-    }`,
-    set: `
-    case 'set': {
-      const target = cmd.args[0];
-      const value = await evaluate(cmd.args[1], ctx);
-
-      if (target.type === 'variable') {
-        const varName = target.name.slice(1);
-        const map = target.scope === 'local' ? elemScope(ctx.me) : globalVars;
-        map.set(varName, value);
-        ctx.it = value;
-        return value;
-      }
-
-      if (target.type === 'possessive' || target.type === 'member') {
-        const obj = await evaluate(target.object, ctx);
-        if (obj) {
-          if (obj instanceof Element && isStyleProp(target.property)) {
-            setStyleProp(obj, target.property, value);
-          } else {
-            (obj as any)[target.property] = value;
-          }
-          ctx.it = value;
-          return value;
-        }
-      }
-
-      ctx.it = value;
-      return value;
-    }`,
-    get: `
-    case 'get': {
-      const value = await evaluate(cmd.args[0], ctx);
-      ctx.it = value;
-      return value;
-    }`,
-    wait: `
-    case 'wait': {
-      const duration = await evaluate(cmd.args[0], ctx);
-      const ms = typeof duration === 'number' ? duration : parseInt(String(duration));
-      await new Promise(resolve => setTimeout(resolve, ms));
-      return ms;
-    }
-
-    case 'waitFor': {
-      const eventName = await evaluate(cmd.args[0], ctx);
-      const targets = await getTarget();
-      const target = targets[0] || ctx.me;
-      return new Promise(resolve => {
-        target.addEventListener(
-          String(eventName),
-          e => {
-            ctx.it = e;
-            resolve(e);
-          },
-          { once: true }
-        );
-      });
-    }`,
-    transition: `
-    case 'transition': {
-      const property = String(await evaluate(cmd.args[0], ctx)).replace(/^\\*/, '');
-      const toValue = await evaluate(cmd.args[1], ctx);
-      const durationVal = await evaluate(cmd.args[2], ctx);
-      const duration = typeof durationVal === 'number' ? durationVal :
-                       String(durationVal).endsWith('ms') ? parseInt(String(durationVal)) :
-                       String(durationVal).endsWith('s') ? parseFloat(String(durationVal)) * 1000 :
-                       parseInt(String(durationVal)) || 300;
-
-      const targets = await getTarget();
-      const promises: Promise<void>[] = [];
-
-      for (const el of targets) {
-        const htmlEl = el as HTMLElement;
-        const kebabProp = property.replace(/([A-Z])/g, '-$1').toLowerCase();
-
-        const oldTransition = htmlEl.style.transition;
-        htmlEl.style.transition = \`\${kebabProp} \${duration}ms ease\`;
-        htmlEl.style.setProperty(kebabProp, String(toValue));
-
-        promises.push(new Promise<void>(resolve => {
-          const cleanup = () => {
-            htmlEl.style.transition = oldTransition;
-            resolve();
-          };
-
-          const onEnd = (e: TransitionEvent) => {
-            if (e.propertyName === kebabProp) {
-              htmlEl.removeEventListener('transitionend', onEnd);
-              cleanup();
-            }
-          };
-
-          htmlEl.addEventListener('transitionend', onEnd);
-          setTimeout(cleanup, duration + 50);
-        }));
-      }
-
-      await Promise.all(promises);
-      ctx.it = targets.length === 1 ? targets[0] : targets;
-      return ctx.it;
-    }`,
-    go: `
-    case 'go': {
-      const dest = await evaluate(cmd.args[0], ctx);
-      const d = String(dest).toLowerCase();
-      if (d === 'back') history.back();
-      else if (d === 'forward') history.forward();
-      else if (d === 'bottom') ctx.me.scrollIntoView({ block: 'end', behavior: 'smooth' });
-      else if (d === 'top') ctx.me.scrollIntoView({ block: 'start', behavior: 'smooth' });
-      else window.location.href = String(dest);
-      return null;
-    }`,
-    call: `
-    case 'call': {
-      const result = await evaluate(cmd.args[0], ctx);
-      ctx.it = result;
-      return result;
-    }`,
-    log: `
-    case 'log': {
-      const values = await Promise.all(cmd.args.map((a: any) => evaluate(a, ctx)));
-      console.log(...values);
-      return values[0];
-    }`,
-    send: `
-    case 'send': {
-      const eventName = await evaluate(cmd.args[0], ctx);
-      const targets = await getTarget();
-      const event = new CustomEvent(String(eventName), { bubbles: true, detail: ctx.it });
-      for (const el of targets) el.dispatchEvent(event);
-      ctx.it = event;
-      return event;
-    }`,
-    put: `
-    case 'put': {
-      const content = await evaluate(cmd.args[0], ctx);
-      const modifier = cmd.modifier || 'into';
-
-      if (cmd.target?.type === 'possessive' && isStyleProp(cmd.target.property)) {
-        const obj = await evaluate(cmd.target.object, ctx);
-        const elements = toElementArray(obj);
-        for (const el of elements) {
-          setStyleProp(el, cmd.target.property, content);
-        }
-        ctx.it = content;
-        return content;
-      }
-
-      const targets = await getTarget();
-      for (const el of targets) {
-        const html = String(content);
-        if (modifier === 'into') el.innerHTML = html;
-        else if (modifier === 'before') el.insertAdjacentHTML('beforebegin', html);
-        else if (modifier === 'after') el.insertAdjacentHTML('afterend', html);
-        else if (modifier === 'at start of') el.insertAdjacentHTML('afterbegin', html);
-        else if (modifier === 'at end of') el.insertAdjacentHTML('beforeend', html);
-      }
-      ctx.it = content;
-      return content;
-    }`,
-    append: `
-    case 'append': {
-      const content = await evaluate(cmd.args[0], ctx);
-      const targets = await getTarget();
-      for (const el of targets) el.insertAdjacentHTML('beforeend', String(content));
-      ctx.it = content;
-      return content;
-    }`,
-    prepend: `
-    case 'prepend': {
-      const content = await evaluate(cmd.args[0], ctx);
-      const targets = await getTarget();
-      for (const el of targets) el.insertAdjacentHTML('afterbegin', String(content));
-      ctx.it = content;
-      return content;
-    }`,
-    morph: `
-    case 'morph': {
-      const targets = await getTarget();
-      const content = await evaluate(cmd.args[0], ctx);
-      const contentStr = String(content);
-      const isOuter = cmd.modifier === 'over';
-
-      for (const target of targets) {
-        try {
-          if (isOuter) {
-            morphlexMorph(target, contentStr);
-          } else {
-            // Upstream's morph MERGES a lone root element that has the
-            // target's tag (attributes and children); anything else morphs the
-            // children \u2014 the full runtime's 'morphMerge' (lib/swap-executor.ts).
-            const template = document.createElement('template');
-            template.innerHTML = contentStr;
-            const root = template.content.firstElementChild;
-            if (root && !root.nextElementSibling && root.tagName === target.tagName) {
-              morphlexMorph(target, root);
-            } else {
-              // morphlex's morphInner takes an ELEMENT, not a string \u2014 the same
-              // wrapping src/lib/morph-adapter.ts does. Passing the string threw
-              // straight into the fallback below, so inner morph never actually
-              // morphed (it silently degraded to innerHTML on every call).
-              const wrapper = document.createElement(target.tagName);
-              wrapper.innerHTML = contentStr;
-              morphlexMorphInner(target, wrapper);
-            }
-          }
-        } catch (error) {
-          // Fallback to innerHTML/outerHTML if morph fails
-          console.warn('[LokaScript] Morph failed, falling back:', error);
-          if (isOuter) {
-            target.outerHTML = contentStr;
-          } else {
-            target.innerHTML = contentStr;
-          }
-        }
-      }
-      ctx.it = targets.length === 1 ? targets[0] : targets;
-      return ctx.it;
-    }`,
-    take: `
-    case 'take': {
-      // getClassName reads a NODE (as toggle/add/removeClass all do). Passing the
-      // EVALUATED value handed it a NodeList, which yielded '' and then threw
-      // 'Invalid selector .' \u2014 a command the parse-level reachability check
-      // certified while every generated bundle carrying it crashed.
-      const className = getClassName(cmd.args[0]);
-      const from = cmd.target ? await getTarget() : [ctx.me.parentElement!];
-      for (const container of from) {
-        const siblings = container.querySelectorAll('.' + className);
-        siblings.forEach(el => el.classList.remove(className));
-      }
-      ctx.me.classList.add(className);
-      return ctx.me;
-    }`,
-    increment: `
-    case 'increment': {
-      const target = cmd.args[0];
-      const amount = cmd.args[1] ? await evaluate(cmd.args[1], ctx) : 1;
-
-      if (target.type === 'variable') {
-        const varName = target.name.slice(1);
-        const map = target.scope === 'local' ? elemScope(ctx.me) : globalVars;
-        const current = map.get(varName) || 0;
-        const newVal = current + amount;
-        map.set(varName, newVal);
-        ctx.it = newVal;
-        return newVal;
-      }
-
-      if (target.type === 'possessive') {
-        const style = isStyleProp(target.property);
-        const obj = await evaluate(target.object, ctx);
-        const elements = toElementArray(obj);
-        for (const el of elements) {
-          const was = style ? getStyleProp(el, target.property) : Reflect.get(el, target.property);
-          const newVal = (parseFloat(was || '0') || 0) + amount;
-          if (style) setStyleProp(el, target.property, newVal);
-          else Reflect.set(el, target.property, newVal);
-          ctx.it = newVal;
-        }
-        return ctx.it;
-      }
-
-      const elements = toElementArray(await evaluate(target, ctx));
-      for (const el of elements) {
-        const current = parseFloat(el.textContent || '0') || 0;
-        const newVal = current + amount;
-        el.textContent = String(newVal);
-        ctx.it = newVal;
-      }
-      return ctx.it;
-    }`,
-    decrement: `
-    case 'decrement': {
-      const target = cmd.args[0];
-      const amount = cmd.args[1] ? await evaluate(cmd.args[1], ctx) : 1;
-
-      if (target.type === 'variable') {
-        const varName = target.name.slice(1);
-        const map = target.scope === 'local' ? elemScope(ctx.me) : globalVars;
-        const current = map.get(varName) || 0;
-        const newVal = current - amount;
-        map.set(varName, newVal);
-        ctx.it = newVal;
-        return newVal;
-      }
-
-      if (target.type === 'possessive') {
-        const style = isStyleProp(target.property);
-        const obj = await evaluate(target.object, ctx);
-        const elements = toElementArray(obj);
-        for (const el of elements) {
-          const was = style ? getStyleProp(el, target.property) : Reflect.get(el, target.property);
-          const newVal = (parseFloat(was || '0') || 0) - amount;
-          if (style) setStyleProp(el, target.property, newVal);
-          else Reflect.set(el, target.property, newVal);
-          ctx.it = newVal;
-        }
-        return ctx.it;
-      }
-
-      const elements = toElementArray(await evaluate(target, ctx));
-      for (const el of elements) {
-        const current = parseFloat(el.textContent || '0') || 0;
-        const newVal = current - amount;
-        el.textContent = String(newVal);
-        ctx.it = newVal;
-      }
-      return ctx.it;
-    }`,
-    focus: `
-    case 'focus': {
-      const targets = await getTarget();
-      for (const el of targets) (el as HTMLElement).focus();
-      return targets;
-    }`,
-    blur: `
-    case 'blur': {
-      const targets = await getTarget();
-      for (const el of targets) (el as HTMLElement).blur();
-      return targets;
-    }`,
-    empty: `
-    case 'empty': {
-      const targets = await getTarget();
-      for (const el of targets) (el as HTMLElement).innerHTML = '';
-      return targets;
-    }`,
-    return: `
-    case 'return': {
-      const value = cmd.args[0] ? await evaluate(cmd.args[0], ctx) : ctx.it;
-      throw { type: 'return', value };
-    }`,
-    break: `
-    case 'break': {
-      throw { type: 'break' };
-    }`,
-    continue: `
-    case 'continue': {
-      throw { type: 'continue' };
-    }`,
-    halt: `
-    case 'halt': {
-      // Check for "halt the event" pattern
-      const firstArg = cmd.args[0];
-      let targetEvent = ctx.event;
-      if (firstArg?.type === 'identifier' && firstArg.name === 'the' && cmd.args[1]?.name === 'event') {
-        targetEvent = ctx.event;
-      } else if (firstArg) {
-        const evaluated = await evaluate(firstArg, ctx);
-        if (evaluated?.preventDefault) targetEvent = evaluated;
-      }
-
-      if (targetEvent && typeof targetEvent.preventDefault === 'function') {
-        targetEvent.preventDefault();
-        targetEvent.stopPropagation();
-        return { halted: true, eventHalted: true };
-      }
-
-      // Regular halt - stop execution
-      const haltError = new Error('HALT_EXECUTION');
-      (haltError as any).isHalt = true;
-      throw haltError;
-    }`,
-    exit: `
-    case 'exit': {
-      const exitError = new Error('EXIT_COMMAND');
-      (exitError as any).isExit = true;
-      throw exitError;
-    }`,
-    throw: `
-    case 'throw': {
-      const message = cmd.args[0] ? await evaluate(cmd.args[0], ctx) : 'Error';
-      const errorToThrow = message instanceof Error ? message : new Error(String(message));
-      throw errorToThrow;
-    }`,
-    beep: `
-    case 'beep': {
-      const values = await Promise.all(cmd.args.map((a: any) => evaluate(a, ctx)));
-      const displayValues = values.length > 0 ? values : [ctx.it];
-
-      for (const val of displayValues) {
-        const typeInfo = val === null ? 'null' :
-                        val === undefined ? 'undefined' :
-                        Array.isArray(val) ? \`Array[\${val.length}]\` :
-                        val instanceof Element ? \`Element<\${val.tagName.toLowerCase()}>\` :
-                        typeof val;
-        console.log('[beep]', typeInfo + ':', val);
-      }
-      return displayValues[0];
-    }`,
-    js: `
-    case 'js': {
-      const codeArg = cmd.args[0];
-      let jsCode = '';
-
-      if (codeArg.type === 'string') {
-        jsCode = codeArg.value;
-      } else if (codeArg.type === 'template') {
-        jsCode = await evaluate(codeArg, ctx);
-      } else {
-        jsCode = String(await evaluate(codeArg, ctx));
-      }
-
-      // Build context object for the Function
-      //
-      // \`target\` is \`ctx.me\` outright, not \`ctx.target || ctx.me\`. No Context
-      // in any bundle declares a \`target\` field and no executor assigns one, so
-      // the left operand was always \`undefined\` and the expression always
-      // yielded \`ctx.me\` \u2014 same value, and a type error the moment the template
-      // lands in a file that is actually typechecked (Arc E step 4, where it
-      // did). Generated bundles are written, imported and executed but never
-      // \`tsc\`'d, which is how a phantom property survived here.
-      const jsContext = {
-        me: ctx.me,
-        it: ctx.it,
-        event: ctx.event,
-        target: ctx.me,
-        locals: Object.fromEntries(ctx.locals),
-        globals: Object.fromEntries(globalVars),
-        document: typeof document !== 'undefined' ? document : undefined,
-        window: typeof window !== 'undefined' ? window : undefined,
-      };
-
-      try {
-        const fn = new Function('ctx', \`with(ctx) { return (async () => { \${jsCode} })(); }\`);
-        const result = await fn(jsContext);
-        ctx.it = result;
-        return result;
-      } catch (error) {
-        console.error('[js] Execution error:', error);
-        throw error;
-      }
-    }`,
-    copy: `
-    case 'copy': {
-      const source = await evaluate(cmd.args[0], ctx);
-      let textToCopy = '';
-
-      if (typeof source === 'string') {
-        textToCopy = source;
-      } else if (source instanceof Element) {
-        textToCopy = source.textContent || '';
-      } else {
-        textToCopy = String(source);
-      }
-
-      try {
-        if (navigator.clipboard) {
-          await navigator.clipboard.writeText(textToCopy);
-        } else {
-          // Fallback for older browsers
-          const textarea = document.createElement('textarea');
-          textarea.value = textToCopy;
-          textarea.style.cssText = 'position:fixed;top:0;left:-9999px';
-          document.body.appendChild(textarea);
-          textarea.select();
-          document.execCommand('copy');
-          document.body.removeChild(textarea);
-        }
-
-        if (ctx.me instanceof Element) {
-          ctx.me.dispatchEvent(new CustomEvent('copy:success', {
-            bubbles: true,
-            detail: { text: textToCopy }
-          }));
-        }
-        ctx.it = textToCopy;
-        return textToCopy;
-      } catch (error) {
-        if (ctx.me instanceof Element) {
-          ctx.me.dispatchEvent(new CustomEvent('copy:error', {
-            bubbles: true,
-            detail: { error }
-          }));
-        }
-        throw error;
-      }
-    }`,
-    push: `
-    case 'push': {
-      const url = String(await evaluate(cmd.args[0], ctx));
-      let title = '';
-
-      // Check for "with title" modifier
-      if (cmd.modifiers?.title) {
-        title = String(await evaluate(cmd.modifiers.title, ctx));
-      }
-
-      window.history.pushState(null, '', url);
-      if (title) document.title = title;
-
-      window.dispatchEvent(new CustomEvent('lokascript:pushurl', {
-        detail: { url, title }
-      }));
-
-      return { url, title, mode: 'push' };
-    }`,
-    replace: `
-    case 'replace': {
-      const url = String(await evaluate(cmd.args[0], ctx));
-      let title = '';
-
-      // Check for "with title" modifier
-      if (cmd.modifiers?.title) {
-        title = String(await evaluate(cmd.modifiers.title, ctx));
-      }
-
-      window.history.replaceState(null, '', url);
-      if (title) document.title = title;
-
-      window.dispatchEvent(new CustomEvent('lokascript:replaceurl', {
-        detail: { url, title }
-      }));
-
-      return { url, title, mode: 'replace' };
-    }`,
-};
-const BLOCK_IMPLEMENTATIONS_TS = {
-    if: `
-    case 'if': {
-      const condition = await evaluate(block.condition!, ctx);
-      if (condition) {
-        return executeSequenceWithBlocks(block.body, ctx);
-      } else if (block.elseBody) {
-        return executeSequenceWithBlocks(block.elseBody, ctx);
-      }
-      return null;
-    }`,
-    repeat: `
-    case 'repeat': {
-      const count = await evaluate(block.condition!, ctx);
-      // A count reads as upstream's \`index < times\` does, and core's loopCount:
-      // "6.5" loops 7 times, "6abc" none (parseInt read 6 for both), true once.
-      const n = Number(count) || 0;
-      for (let i = 0; i < n && i < MAX_LOOP_ITERATIONS; i++) {
-        ctx.locals.set('__loop_index__', i);
-        ctx.locals.set('__loop_count__', i + 1);
-        try {
-          await executeSequenceWithBlocks(block.body, ctx);
-        } catch (e: any) {
-          if (e?.type === 'break') break;
-          if (e?.type === 'continue') continue;
-          throw e;
-        }
-      }
-      return null;
-    }`,
-    for: `
-    case 'for': {
-      const { variable, iterable } = block.condition as any;
-      const items = await evaluate(iterable, ctx);
-      const arr = Array.isArray(items) ? items : items instanceof NodeList ? Array.from(items) : [items];
-      const varName = variable.startsWith(':') ? variable.slice(1) : variable;
-      for (let i = 0; i < arr.length && i < MAX_LOOP_ITERATIONS; i++) {
-        ctx.locals.set(varName, arr[i]);
-        ctx.locals.set('__loop_index__', i);
-        ctx.locals.set('__loop_count__', i + 1);
-        try {
-          await executeSequenceWithBlocks(block.body, ctx);
-        } catch (e: any) {
-          if (e?.type === 'break') break;
-          if (e?.type === 'continue') continue;
-          throw e;
-        }
-      }
-      return null;
-    }`,
-    while: `
-    case 'while': {
-      let iterations = 0;
-      while (await evaluate(block.condition!, ctx) && iterations < MAX_LOOP_ITERATIONS) {
-        ctx.locals.set('__loop_index__', iterations);
-        try {
-          await executeSequenceWithBlocks(block.body, ctx);
-        } catch (e: any) {
-          if (e?.type === 'break') break;
-          if (e?.type === 'continue') { iterations++; continue; }
-          throw e;
-        }
-        iterations++;
-      }
-      return null;
-    }`,
-    fetch: `
-    case 'fetch': {
-      const { url, responseType, options, method } = block.condition as any;
-      try {
-        const urlVal = await evaluate(url, ctx);
-        const fetchInit = {} as RequestInit;
-
-        if (method) {
-          const methodVal = await evaluate(method, ctx);
-          fetchInit.method = String(methodVal).toUpperCase();
-        }
-
-        if (options) {
-          const optionsVal = await evaluate(options, ctx);
-          if (optionsVal instanceof FormData) {
-            fetchInit.body = optionsVal;
-          } else if (optionsVal && typeof optionsVal === 'object' && !(optionsVal instanceof Element)) {
-            Object.assign(fetchInit, optionsVal);
-          }
-        }
-
-        const response = await fetch(String(urlVal), fetchInit);
-        if (!response.ok) throw new Error(\`HTTP \${response.status}\`);
-
-        const resType = await evaluate(responseType, ctx);
-        let data: any;
-        if (resType === 'json') data = await response.json();
-        else if (resType === 'html') {
-          const text = await response.text();
-          const doc = new DOMParser().parseFromString(text, 'text/html');
-          data = doc.body.innerHTML;
-        } else data = await response.text();
-
-        ctx.it = data;
-        ctx.locals.set('it', data);
-        ctx.locals.set('result', data);
-        ctx.locals.set('response', response);
-
-        await executeSequenceWithBlocks(block.body, ctx);
-      } catch (error: any) {
-        if (error?.type === 'return') throw error;
-        ctx.locals.set('error', error);
-        console.error('Fetch error:', error);
-      }
-      return null;
-    }`,
-};
-const STYLE_COMMANDS = ['set', 'put', 'increment', 'decrement'];
-const STYLE_READ_COMMANDS = ['increment', 'decrement'];
-const ELEMENT_ARRAY_COMMANDS = ['put', 'increment', 'decrement'];
-const MORPH_COMMANDS = ['morph'];
-function getCommandImplementations(format = 'ts') {
-    const result = {};
-    for (const [name, code] of Object.entries(COMMAND_IMPLEMENTATIONS_TS)) {
-        result[name] = stripTypes(code, format);
-    }
-    return result;
-}
-function getBlockImplementations(format = 'ts') {
-    const result = {};
-    for (const [name, code] of Object.entries(BLOCK_IMPLEMENTATIONS_TS)) {
-        result[name] = stripTypes(code, format);
-    }
-    return result;
-}
-function getAvailableCommands() {
-    return Object.keys(COMMAND_IMPLEMENTATIONS_TS);
-}
-function getAvailableBlocks() {
-    return Object.keys(BLOCK_IMPLEMENTATIONS_TS);
-}
-const COMMAND_IMPLEMENTATIONS = COMMAND_IMPLEMENTATIONS_TS;
-const BLOCK_IMPLEMENTATIONS = BLOCK_IMPLEMENTATIONS_TS;
-
-const AVAILABLE_COMMANDS = [
-    'toggle',
-    'add',
-    'remove',
-    'removeClass',
-    'show',
-    'hide',
-    'put',
-    'append',
-    'prepend',
-    'take',
-    'empty',
-    'set',
-    'get',
-    'increment',
-    'decrement',
-    'wait',
-    'transition',
-    'send',
-    'trigger',
-    'log',
-    'call',
-    'copy',
-    'beep',
-    'go',
-    'push',
-    'push-url',
-    'replace',
-    'replace-url',
-    'focus',
-    'blur',
-    'return',
-    'break',
-    'continue',
-    'halt',
-    'exit',
-    'throw',
-    'js',
-    'morph',
-];
-const AVAILABLE_BLOCKS = ['if', 'repeat', 'for', 'while', 'fetch'];
-const FULL_RUNTIME_ONLY_COMMANDS = [
-    'make',
-    'swap',
-    'process',
-    'default',
-    'tell',
-    'pick',
-    'unless',
-    'settle',
-    'measure',
-    'install',
-    'breakpoint',
-    'clear',
-    'close',
-    'open',
-    'pseudo-command',
-    'render',
-    'reset',
-    'scroll',
-    'select',
-    'start',
-];
-const COMMAND_ALIASES = {
-    'push-url': 'push',
-    'replace-url': 'replace',
-    trigger: 'send',
-};
-function resolveCommandKey(command) {
-    return COMMAND_ALIASES[command] ?? command;
-}
-function isAvailableCommand(command) {
-    return AVAILABLE_COMMANDS.includes(command);
-}
-function isAvailableBlock(block) {
-    return AVAILABLE_BLOCKS.includes(block);
-}
-function requiresFullRuntime(command) {
-    return FULL_RUNTIME_ONLY_COMMANDS.includes(command);
-}
-
-function emitCommandCases(commands, format = 'ts') {
-    const impls = getCommandImplementations(format);
-    return [...new Set(commands.map(resolveCommandKey))]
-        .filter(key => impls[key])
-        .map(key => impls[key])
-        .join('\n');
-}
-function emitBlockCases(blocks, format = 'ts') {
-    const impls = getBlockImplementations(format);
-    return blocks
-        .filter(key => impls[key])
-        .map(key => impls[key])
-        .join('\n');
-}
-
-function generateBundleCode(config) {
-    const { name, commands, blocks = [], htmxIntegration = false, globalName = 'hyperfixi', positionalExpressions = false, parserImportPath = '../parser/hybrid', autoInit = true, esModule = true, format = 'ts', maxLoopIterations = 1000, } = config;
-    const needsStyleHelpers = commands.some(cmd => STYLE_COMMANDS.includes(cmd));
-    const needsStyleReadHelper = commands.some(cmd => STYLE_READ_COMMANDS.includes(cmd));
-    const needsElementArrayHelper = commands.some(cmd => ELEMENT_ARRAY_COMMANDS.includes(cmd));
-    const needsMorphlex = commands.some(cmd => MORPH_COMMANDS.includes(cmd));
-    const hasBlocks = blocks.length > 0;
-    const hasReturn = commands.includes('return');
-    const commandCases = emitCommandCases(commands, format);
-    const blockCases = emitBlockCases(blocks, format);
-    return `/**
- * HyperFixi ${name} Bundle (Auto-Generated)
- *
- * Generated by: @hyperfixi/core bundle-generator
- * Commands: ${commands.join(', ')}${blocks.length > 0 ? `\n * Blocks: ${blocks.join(', ')}` : ''}${positionalExpressions ? '\n * Positional expressions: enabled' : ''}
- *
- * DO NOT EDIT - Regenerate with the build script.
- */
-
-// =============================================================================
-// MODULAR PARSER IMPORTS
-// =============================================================================
-
-import { HybridParser } from '${parserImportPath}/parser-core';
-import type { ASTNode, CommandNode, EventNode${hasBlocks ? ', BlockNode' : ''} } from '${parserImportPath}/ast-types';
-${needsMorphlex ? "import { morph as morphlexMorph, morphInner as morphlexMorphInner } from 'morphlex';" : ''}
-
-// =============================================================================
-// RUNTIME
-// =============================================================================
-
-interface Context {
-  me: Element;
-  event?: Event;
-  it?: any;
-  you?: Element;
-  locals: Map<string, any>;
-}
-
-const globalVars = new Map<string, any>();
-// Per-element store for \`:name\` variables (scope 'local' from the mini-parser).
-// Persists per-element across event firings, isolated per element.
-const elementVars = new WeakMap<Element, Map<string, any>>();
-function elemScope(el: Element): Map<string, any> {
-  let m = elementVars.get(el);
-  if (!m) { m = new Map<string, any>(); elementVars.set(el, m); }
-  return m;
-}
-${hasBlocks ? `const MAX_LOOP_ITERATIONS = ${maxLoopIterations};` : ''}
-
-async function evaluate(node: ASTNode, ctx: Context): Promise<any> {
-  switch (node.type) {
-    case 'literal': return node.value;
-
-    case 'identifier':
-      if (node.value === 'me' || node.value === 'my') return ctx.me;
-      if (node.value === 'it') return ctx.it;
-      if (node.value === 'you') return ctx.you;
-      if (node.value === 'event') return ctx.event;
-      if (node.value === 'body') return document.body;
-      if (node.value === 'document') return document;
-      if (node.value === 'window') return window;
-      if (ctx.locals.has(node.value)) return ctx.locals.get(node.value);
-      if (node.value in (ctx.me as any)) return (ctx.me as any)[node.value];
-      return node.value;
-
-    case 'variable':
-      if (node.scope === 'local') return elemScope(ctx.me).get(node.name.slice(1));
-      const gName = node.name.slice(1);
-      if (globalVars.has(gName)) return globalVars.get(gName);
-      return (window as any)[node.name];
-
-    case 'selector':
-      const elements = document.querySelectorAll(node.value);
-      return elements.length === 1 ? elements[0] : Array.from(elements);
-
-    case 'binary':
-      return evaluateBinary(node, ctx);
-
-    case 'possessive':
-    case 'member':
-      const obj = await evaluate(node.object, ctx);
-      if (obj == null) return undefined;
-      const prop = node.computed ? await evaluate(node.property, ctx) : node.property;
-      if (prop === 'values' && obj instanceof Element) {
-        if (obj instanceof HTMLFormElement) return new FormData(obj);
-        const fd = new FormData();
-        obj.querySelectorAll('input, select, textarea').forEach(input => {
-          const name = input.getAttribute('name');
-          if (name && 'value' in input) fd.append(name, (input as HTMLInputElement).value);
-        });
-        return fd;
-      }
-      return obj[prop];
-
-    case 'call': {
-      let callContext: any = null;
-      let callee: any;
-
-      if (node.callee.type === 'member' || node.callee.type === 'possessive') {
-        callContext = await evaluate(node.callee.object, ctx);
-        const p = node.callee.computed
-          ? await evaluate(node.callee.property, ctx)
-          : node.callee.property;
-        callee = callContext?.[p];
-      } else {
-        callee = await evaluate(node.callee, ctx);
-      }
-
-      const args = await Promise.all(node.args.map((a: ASTNode) => evaluate(a, ctx)));
-      if (typeof callee === 'function') return callee.apply(callContext, args);
-      return undefined;
-    }
-${positionalExpressions
-        ? `
-    case 'positional':
-      return evaluatePositional(node, ctx);
-`
-        : ''}
-    default: return undefined;
-  }
-}
-
-async function evaluateBinary(node: ASTNode, ctx: Context): Promise<any> {
-  if (node.operator === 'has') {
-    const left = await evaluate(node.left, ctx);
-    if (left instanceof Element && node.right.type === 'selector' && node.right.value.startsWith('.')) {
-      return left.classList.contains(node.right.value.slice(1));
-    }
-    return false;
-  }
-
-  const left = await evaluate(node.left, ctx);
-  const right = await evaluate(node.right, ctx);
-
-  switch (node.operator) {
-    case '+': return left + right;
-    case '-': return left - right;
-    case '*': return left * right;
-    case '/': return left / right;
-    case '%': return left % right;
-    case '==': case 'is': return left == right;
-    case '!=': case 'is not': return left != right;
-    case '<': return left < right;
-    case '>': return left > right;
-    case '<=': return left <= right;
-    case '>=': return left >= right;
-    case 'and': case '&&': return left && right;
-    case 'or': case '||': return left || right;
-    case 'contains': case 'includes':
-      if (typeof left === 'string') return left.includes(right);
-      if (Array.isArray(left)) return left.includes(right);
-      if (left instanceof Element) return left.contains(right);
-      return false;
-    case 'matches':
-      if (left instanceof Element) return left.matches(right);
-      if (typeof left === 'string') return new RegExp(right).test(left);
-      return false;
-    default: return undefined;
-  }
-}
-${positionalExpressions
-        ? `
-function evaluatePositional(node: ASTNode, ctx: Context): Element | null {
-  const target = node.target;
-  let elements: Element[] = [];
-
-  let selector: string | null = null;
-  if (target.type === 'selector') {
-    selector = target.value;
-  } else if (target.type === 'identifier') {
-    selector = target.value;
-  } else if (target.type === 'htmlSelector') {
-    selector = target.value;
-  }
-  if (selector) {
-    elements = Array.from(document.querySelectorAll(selector));
-  }
-
-  switch (node.position) {
-    case 'first': return elements[0] || null;
-    case 'last': return elements[elements.length - 1] || null;
-    case 'next': {
-      if (selector) {
-        let el = ctx.me.nextElementSibling;
-        while (el) { if (el.matches(selector)) return el; el = el.nextElementSibling; }
-        return null;
-      }
-      return ctx.me.nextElementSibling;
-    }
-    case 'previous': {
-      if (selector) {
-        let el = ctx.me.previousElementSibling;
-        while (el) { if (el.matches(selector)) return el; el = el.previousElementSibling; }
-        return null;
-      }
-      return ctx.me.previousElementSibling;
-    }
-    case 'closest': return selector ? ctx.me.closest(selector) : null;
-    case 'parent': {
-      if (selector) {
-        let el = ctx.me.parentElement;
-        while (el) { if (el.matches(selector)) return el; el = el.parentElement; }
-        return null;
-      }
-      return ctx.me.parentElement;
-    }
-    default: return elements[0] || null;
-  }
-}
-`
-        : ''}
-// =============================================================================
-// COMMAND EXECUTOR
-// =============================================================================
-
-${needsStyleHelpers
-        ? `
-const isStyleProp = (prop: string) => prop?.startsWith('*');
-const getStyleName = (prop: string) => prop.substring(1);
-const setStyleProp = (el: Element, prop: string, value: any): boolean => {
-  if (!isStyleProp(prop)) return false;
-  (el as HTMLElement).style.setProperty(getStyleName(prop), String(value));
-  return true;
-};
-${needsStyleReadHelper
-            ? `const getStyleProp = (el: Element, prop: string): string | undefined => {
-  if (!isStyleProp(prop)) return undefined;
-  return getComputedStyle(el as HTMLElement).getPropertyValue(getStyleName(prop));
-};
-`
-            : ''}`
-        : ''}
-
-${needsElementArrayHelper
-        ? `
-const toElementArray = (val: any): Element[] => {
-  if (Array.isArray(val)) return val.filter(e => e instanceof Element);
-  if (val instanceof Element) return [val];
-  if (typeof val === 'string') return Array.from(document.querySelectorAll(val));
-  return [];
-};
-`
-        : ''}
-
-async function executeCommand(cmd: CommandNode, ctx: Context): Promise<any> {
-  const getTarget = async (): Promise<Element[]> => {
-    if (!cmd.target) return [ctx.me];
-    const t = await evaluate(cmd.target, ctx);
-    if (Array.isArray(t)) return t;
-    if (t instanceof Element) return [t];
-    if (typeof t === 'string') return Array.from(document.querySelectorAll(t));
-    return [ctx.me];
-  };
-
-  const getClassName = (node: any): string => {
-    if (!node) return '';
-    if (node.type === 'selector') {
-      // \`@attr\` passes through unsliced; .class / #id lose their prefix.
-      if (node.value.startsWith('@')) return node.value;
-      return node.value.slice(1);
-    }
-    if (node.type === 'string' || node.type === 'literal') {
-      const val = node.value;
-      return typeof val === 'string' && val.startsWith('.') ? val.slice(1) : String(val);
-    }
-    if (node.type === 'identifier') return node.value;
-    return '';
-  };
-
-  switch (cmd.name) {
-${commandCases}
-
-    default:
-      console.warn(\`${name} bundle: Unknown command '\${cmd.name}'\`);
-      return null;
-  }
-}
-${hasBlocks
-        ? `
-// =============================================================================
-// BLOCK EXECUTOR
-// =============================================================================
-
-async function executeBlock(block: BlockNode, ctx: Context): Promise<any> {
-  switch (block.type) {
-${blockCases}
-
-    default:
-      console.warn(\`${name} bundle: Unknown block '\${block.type}'\`);
-      return null;
-  }
-}
-`
-        : ''}
-// =============================================================================
-// SEQUENCE EXECUTOR
-// =============================================================================
-
-async function executeSequence(nodes: ASTNode[], ctx: Context): Promise<any> {
-  let result: any;
-  for (const node of nodes) {
-    if (node.type === 'command') {
-      result = await executeCommand(node as CommandNode, ctx);
-    }${hasBlocks
-        ? ` else if (['if', 'repeat', 'for', 'while', 'fetch'].includes(node.type)) {
-      result = await executeBlock(node as BlockNode, ctx);
-    }`
-        : ''}
-  }
-  return result;
-}
-${hasBlocks
-        ? `
-async function executeSequenceWithBlocks(nodes: ASTNode[], ctx: Context): Promise<any> {
-  try {
-    return await executeSequence(nodes, ctx);
-  } catch (e: any) {
-    if (e?.type === 'return') throw e;
-    throw e;
-  }
-}
-`
-        : ''}
-async function executeAST(ast: ASTNode, me: Element, event?: Event): Promise<any> {
-  const ctx: Context = { me, event, locals: new Map() };
-
-  if (ast.type === 'sequence') {
-    ${hasReturn || hasBlocks ? "try { return await executeSequence(ast.commands, ctx); } catch (e: any) { if (e?.type === 'return') return e.value; throw e; }" : 'return executeSequence(ast.commands, ctx);'}
-  }
-
-  if (ast.type === 'event') {
-    const eventNode = ast as EventNode;
-    const eventName = eventNode.event;
-
-    if (eventName === 'init') {
-      ${hasReturn || hasBlocks ? "try { await executeSequence(eventNode.body, ctx); } catch (e: any) { if (e?.type !== 'return') throw e; }" : 'await executeSequence(eventNode.body, ctx);'}
-      return;
-    }
-
-    const target = eventNode.filter ? await evaluate(eventNode.filter, ctx) : me;
-    const targetEl = target instanceof Element ? target : me;
-    const mods = eventNode.modifiers;
-
-    let handler = async (e: Event) => {
-      if (mods.prevent) e.preventDefault();
-      if (mods.stop) e.stopPropagation();
-
-      const handlerCtx: Context = {
-        me, event: e,
-        you: e.target instanceof Element ? e.target : undefined,
-        locals: new Map(),
-      };
-      ${hasReturn || hasBlocks ? "try { await executeSequence(eventNode.body, handlerCtx); } catch (err: any) { if (err?.type !== 'return') throw err; }" : 'await executeSequence(eventNode.body, handlerCtx);'}
-    };
-
-    if (mods.debounce) {
-      let timeout: any;
-      const orig = handler;
-      handler = async (e: Event) => {
-        clearTimeout(timeout);
-        timeout = setTimeout(() => orig(e), mods.debounce);
-      };
-    }
-
-    if (mods.throttle) {
-      let lastCall = 0;
-      const orig = handler;
-      handler = async (e: Event) => {
-        const now = Date.now();
-        if (now - lastCall >= mods.throttle!) {
-          lastCall = now;
-          await orig(e);
-        }
-      };
-    }
-
-    targetEl.addEventListener(eventName, handler, { once: !!mods.once });
-    return;
-  }
-
-  return null;
-}
-
-// =============================================================================
-// DOM PROCESSOR
-// =============================================================================
-
-function processElement(el: Element): void {
-  const code = el.getAttribute('_');
-  if (!code) return;
-
-  try {
-    const parser = new HybridParser(code);
-    const ast = parser.parse();
-    executeAST(ast, el);
-  } catch (err) {
-    console.error('HyperFixi ${name} error:', err, 'Code:', code);
-  }
-}
-
-function processElements(root: Element | Document = document): void {
-  const elements = root.querySelectorAll('[_]');
-  elements.forEach(processElement);
-}
-
-// =============================================================================
-// PUBLIC API
-// =============================================================================
-// Shape mirrors \`compatibility/bundle-shell.ts\` (BundleShellApi). The two are
-// separate copies on purpose \u2014 a generated bundle is self-contained and must
-// not import from @hyperfixi/core \u2014 so \`bundle-shell.test.ts\` asserts the
-// emitted key set matches the handwritten one, the way Oracle 2 pins the two
-// cmdMaps. \`run\`/\`eval\`/\`parserName\` are generated-only extras; see the
-// witnessed-extras table in bundle-shell.ts for why they stay here and are not
-// added to the shipped handwritten bundles.
-
-const api = {
-  version: '1.0.0-${name.toLowerCase().replace(/\s+/g, '-')}',
-
-  parse(code: string): ASTNode {
-    const parser = new HybridParser(code);
-    return parser.parse();
-  },
-
-  async execute(code: string, element?: Element): Promise<any> {
-    const me = element || document.body;
-    const parser = new HybridParser(code);
-    const ast = parser.parse();
-    return executeAST(ast, me);
-  },
-
-  run: async (code: string, element?: Element) => api.execute(code, element),
-  eval: async (code: string, element?: Element) => api.execute(code, element),
-
-  init: processElements,
-  process: processElements,
-
-  commands: ${JSON.stringify(commands)},
-  ${blocks.length > 0 ? `blocks: ${JSON.stringify(blocks)},` : ''}
-  parserName: 'hybrid',
-};
-
-// =============================================================================
-// AUTO-INITIALIZE
-// =============================================================================
-${autoInit
-        ? `
-if (typeof window !== 'undefined') {
-  (window as any).${globalName} = api;
-
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', () => processElements());
-  } else {
-    processElements();
-  }
-${htmxIntegration
-            ? `
-  // HTMX integration
-  document.addEventListener('htmx:afterSettle', (e: Event) => {
-    const target = (e as CustomEvent).detail?.target;
-    if (target) processElements(target);
-  });
-`
-            : ''}
-}
-`
-        : ''}
-${esModule
-        ? `
-export default api;
-export { api, processElements };
-`
-        : ''}`;
-}
-function generateBundle(config) {
-    const warnings = [];
-    const errors = [];
-    const strict = config.validation?.strict ?? false;
-    const unknownCommands = config.commands.filter(cmd => !COMMAND_IMPLEMENTATIONS[resolveCommandKey(cmd)]);
-    for (const cmd of unknownCommands) {
-        const error = {
-            type: 'unknown-command',
-            message: `Unknown command '${cmd}' will not be included`,
-            name: cmd,
-        };
-        errors.push(error);
-        warnings.push(error.message);
-    }
-    const unknownBlocks = (config.blocks || []).filter(block => !BLOCK_IMPLEMENTATIONS[block]);
-    for (const block of unknownBlocks) {
-        const error = {
-            type: 'unknown-block',
-            message: `Unknown block '${block}' will not be included`,
-            name: block,
-        };
-        errors.push(error);
-        warnings.push(error.message);
-    }
-    if (strict && errors.length > 0) {
-        const errorMessages = errors.map(e => e.message).join('; ');
-        throw new Error(`Bundle generation failed (strict mode): ${errorMessages}`);
-    }
-    const code = generateBundleCode(config);
-    return {
-        code,
-        commands: config.commands.filter(cmd => COMMAND_IMPLEMENTATIONS[resolveCommandKey(cmd)]),
-        blocks: (config.blocks || []).filter(block => BLOCK_IMPLEMENTATIONS[block]),
-        positional: config.positionalExpressions || false,
-        warnings,
-        errors,
-    };
-}
-
-const LITE_PARSER_TEMPLATE = `
-// Lite Parser - Regex-based for minimal bundle size
-
-function parseLite(code) {
-  const trimmed = code.trim();
-
-  // Handle event handlers: "on click toggle .active"
-  const onMatch = trimmed.match(/^on\\s+(\\w+)(?:\\s+from\\s+([^\\s]+))?\\s+(.+)$/i);
-  if (onMatch) {
-    return {
-      type: 'event',
-      event: onMatch[1],
-      filter: onMatch[2] ? { type: 'selector', value: onMatch[2] } : undefined,
-      modifiers: {},
-      body: parseCommands(onMatch[3]),
-    };
-  }
-
-  // Handle "every Nms" event pattern
-  const everyMatch = trimmed.match(/^every\\s+(\\d+)(ms|s)?\\s+(.+)$/i);
-  if (everyMatch) {
-    const ms = everyMatch[2] === 's' ? parseInt(everyMatch[1]) * 1000 : parseInt(everyMatch[1]);
-    return {
-      type: 'event',
-      event: 'interval:' + ms,
-      modifiers: {},
-      body: parseCommands(everyMatch[3]),
-    };
-  }
-
-  // Handle "init" pattern
-  const initMatch = trimmed.match(/^init\\s+(.+)$/i);
-  if (initMatch) {
-    return {
-      type: 'event',
-      event: 'init',
-      modifiers: {},
-      body: parseCommands(initMatch[1]),
-    };
-  }
-
-  return { type: 'sequence', commands: parseCommands(trimmed) };
-}
-
-function parseCommands(code) {
-  const parts = code.split(/\\s+(?:then|and)\\s+/i);
-  return parts.map(parseCommand).filter(Boolean);
-}
-
-function parseCommand(code) {
-  const trimmed = code.trim();
-  if (!trimmed) return null;
-
-  let match;
-
-  // toggle .class [on target]
-  match = trimmed.match(/^toggle\\s+(\\.\\w+|\\w+)(?:\\s+on\\s+(.+))?$/i);
-  if (match) {
-    return {
-      type: 'command',
-      name: 'toggle',
-      args: [{ type: 'selector', value: match[1] }],
-      target: match[2] ? parseTarget(match[2]) : undefined,
-    };
-  }
-
-  // add .class [to target]
-  match = trimmed.match(/^add\\s+(\\.\\w+|\\w+)(?:\\s+to\\s+(.+))?$/i);
-  if (match) {
-    return {
-      type: 'command',
-      name: 'add',
-      args: [{ type: 'selector', value: match[1] }],
-      target: match[2] ? parseTarget(match[2]) : undefined,
-    };
-  }
-
-  // remove .class [from target] | remove [target]
-  match = trimmed.match(/^remove\\s+(\\.\\w+)(?:\\s+from\\s+(.+))?$/i);
-  if (match) {
-    return {
-      type: 'command',
-      name: 'removeClass',
-      args: [{ type: 'selector', value: match[1] }],
-      target: match[2] ? parseTarget(match[2]) : undefined,
-    };
-  }
-  match = trimmed.match(/^remove\\s+(.+)$/i);
-  if (match) {
-    return {
-      type: 'command',
-      name: 'remove',
-      args: [],
-      target: parseTarget(match[1]),
-    };
-  }
-
-  // put "content" into target
-  match = trimmed.match(/^put\\s+(?:"([^"]+)"|'([^']+)'|(\\S+))\\s+(into|before|after)\\s+(.+)$/i);
-  if (match) {
-    const content = match[1] || match[2] || match[3];
-    return {
-      type: 'command',
-      name: 'put',
-      args: [{ type: 'literal', value: content }],
-      modifier: match[4],
-      target: parseTarget(match[5]),
-    };
-  }
-
-  // set target to value | set :var to value
-  match = trimmed.match(/^set\\s+(.+?)\\s+to\\s+(.+)$/i);
-  if (match) {
-    return {
-      type: 'command',
-      name: 'set',
-      args: [parseTarget(match[1]), parseLiteValue(match[2])],
-    };
-  }
-
-  // log message
-  match = trimmed.match(/^log\\s+(.+)$/i);
-  if (match) {
-    return {
-      type: 'command',
-      name: 'log',
-      args: [parseLiteValue(match[1])],
-    };
-  }
-
-  // send event [to target]
-  match = trimmed.match(/^send\\s+(\\w+)(?:\\s+to\\s+(.+))?$/i);
-  if (match) {
-    return {
-      type: 'command',
-      name: 'send',
-      args: [{ type: 'literal', value: match[1] }],
-      target: match[2] ? parseTarget(match[2]) : undefined,
-    };
-  }
-
-  // wait Nms | wait Ns
-  match = trimmed.match(/^wait\\s+(\\d+)(ms|s)?$/i);
-  if (match) {
-    const ms = match[2] === 's' ? parseInt(match[1]) * 1000 : parseInt(match[1]);
-    return {
-      type: 'command',
-      name: 'wait',
-      args: [{ type: 'literal', value: ms }],
-    };
-  }
-
-  // show/hide shortcuts
-  match = trimmed.match(/^(show|hide)(?:\\s+(.+))?$/i);
-  if (match) {
-    return {
-      type: 'command',
-      name: match[1].toLowerCase(),
-      args: [],
-      target: match[2] ? parseTarget(match[2]) : undefined,
-    };
-  }
-
-  // Unknown command - try generic parsing
-  const parts = trimmed.split(/\\s+/);
-  if (parts.length > 0) {
-    return {
-      type: 'command',
-      name: parts[0],
-      args: parts.slice(1).map(p => ({ type: 'literal', value: p })),
-    };
-  }
-
-  return null;
-}
-
-function parseTarget(str) {
-  const s = str.trim();
-  if (s === 'me') return { type: 'identifier', value: 'me' };
-  if (s === 'body') return { type: 'identifier', value: 'body' };
-  if (s.startsWith('#') || s.startsWith('.') || s.startsWith('[')) {
-    return { type: 'selector', value: s };
-  }
-  if (s.startsWith(':')) {
-    return { type: 'variable', name: s, scope: 'local' };
-  }
-  return { type: 'identifier', value: s };
-}
-
-function parseLiteValue(str) {
-  const s = str.trim();
-  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
-    return { type: 'literal', value: s.slice(1, -1) };
-  }
-  if (/^-?\\d+(\\.\\d+)?$/.test(s)) {
-    return { type: 'literal', value: parseFloat(s) };
-  }
-  if (s === 'true') return { type: 'literal', value: true };
-  if (s === 'false') return { type: 'literal', value: false };
-  if (s === 'null') return { type: 'literal', value: null };
-  if (s.startsWith(':')) return { type: 'variable', name: s, scope: 'local' };
-  if (s === 'me') return { type: 'identifier', value: 'me' };
-  return { type: 'identifier', value: s };
-}
-`;
-const HYBRID_PARSER_TEMPLATE = `
-// #region generated:hybrid-parser \u2014 DO NOT EDIT (npm run generate:bundles)
-// Hybrid Parser \u2014 generated from parser/hybrid/{aliases,tokenizer,parser-core}.ts
-
-const COMMAND_ALIASES = {
-  flip: "toggle",
-  switch: "toggle",
-  display: "show",
-  reveal: "show",
-  conceal: "hide",
-  increase: "increment",
-  decrease: "decrement",
-  fire: "trigger",
-  dispatch: "send",
-  navigate: "go",
-  goto: "go"
-};
-const EVENT_ALIASES = {
-  clicked: "click",
-  pressed: "keydown",
-  changed: "change",
-  submitted: "submit",
-  loaded: "load"
-};
-function normalizeCommand(name) {
-  const lower = name.toLowerCase();
-  return COMMAND_ALIASES[lower] || lower;
-}
-function normalizeEvent(name) {
-  const lower = name.toLowerCase();
-  return EVENT_ALIASES[lower] || lower;
-}
-function addCommandAliases(aliases) {
-  Object.assign(COMMAND_ALIASES, aliases);
-}
-function addEventAliases(aliases) {
-  Object.assign(EVENT_ALIASES, aliases);
-}
-
-const KEYWORDS = /* @__PURE__ */ new Set([
-  "on",
-  "from",
-  "to",
-  "into",
-  "before",
-  "after",
-  "in",
-  "of",
-  "at",
-  "with",
-  "if",
-  "else",
-  "unless",
-  "end",
-  "then",
-  "and",
-  "or",
-  "not",
-  "repeat",
-  "times",
-  "for",
-  "each",
-  "while",
-  "until",
-  "toggle",
-  "add",
-  "remove",
-  "put",
-  "set",
-  "get",
-  "call",
-  "return",
-  "append",
-  "prepend",
-  "log",
-  "send",
-  "trigger",
-  "wait",
-  "settle",
-  "fetch",
-  "as",
-  "show",
-  "hide",
-  "take",
-  "increment",
-  "decrement",
-  "focus",
-  "blur",
-  "go",
-  "transition",
-  "over",
-  "the",
-  "a",
-  "an",
-  "my",
-  "its",
-  "me",
-  "it",
-  "you",
-  "first",
-  "last",
-  "next",
-  "previous",
-  "closest",
-  "parent",
-  "true",
-  "false",
-  "null",
-  "undefined",
-  "is",
-  "matches",
-  "contains",
-  "includes",
-  "exists",
-  "has",
-  "init",
-  "every",
-  "by",
-  "halt",
-  "via",
-  "values",
-  "default",
-  "event"
-]);
-function tokenize(code) {
-  const tokens = [];
-  let pos = 0;
-  while (pos < code.length) {
-    if (/\\s/.test(code[pos])) {
-      pos++;
-      continue;
-    }
-    if (code.slice(pos, pos + 2) === "--") {
-      while (pos < code.length && code[pos] !== "\\n") pos++;
-      continue;
-    }
-    const start = pos;
-    if (code[pos] === "<" && /[a-zA-Z]/.test(code[pos + 1] || "")) {
-      pos++;
-      while (pos < code.length && code[pos] !== ">") pos++;
-      if (code[pos] === ">") pos++;
-      const val = code.slice(start, pos);
-      if (val.endsWith("/>") || val.endsWith(">")) {
-        const normalized = val.slice(1).replace(/\\/?>$/, "");
-        tokens.push({ type: "selector", value: normalized, pos: start });
-        continue;
-      }
-    }
-    if (code.slice(pos, pos + 2) === "'s" && !/[a-zA-Z]/.test(code[pos + 2] || "")) {
-      tokens.push({ type: "operator", value: "'s", pos: start });
-      pos += 2;
-      continue;
-    }
-    if (code[pos] === '"' || code[pos] === "'") {
-      const quote = code[pos++];
-      while (pos < code.length && code[pos] !== quote) {
-        if (code[pos] === "\\\\") pos++;
-        pos++;
-      }
-      pos++;
-      tokens.push({ type: "string", value: code.slice(start, pos), pos: start });
-      continue;
-    }
-    if (/\\d/.test(code[pos]) || code[pos] === "-" && /\\d/.test(code[pos + 1] || "")) {
-      if (code[pos] === "-") pos++;
-      while (pos < code.length && /[\\d.]/.test(code[pos])) pos++;
-      if (code.slice(pos, pos + 2) === "ms") pos += 2;
-      else if (code[pos] === "s" && !/[a-zA-Z]/.test(code[pos + 1] || "")) pos++;
-      else if (code.slice(pos, pos + 2) === "px") pos += 2;
-      tokens.push({ type: "number", value: code.slice(start, pos), pos: start });
-      continue;
-    }
-    if (code[pos] === ":") {
-      pos++;
-      while (pos < code.length && /[\\w]/.test(code[pos])) pos++;
-      tokens.push({ type: "localVar", value: code.slice(start, pos), pos: start });
-      continue;
-    }
-    if (code[pos] === "$") {
-      pos++;
-      while (pos < code.length && /[\\w]/.test(code[pos])) pos++;
-      tokens.push({ type: "globalVar", value: code.slice(start, pos), pos: start });
-      continue;
-    }
-    if (code[pos] === "@") {
-      pos++;
-      while (pos < code.length && /[\\w-]/.test(code[pos])) pos++;
-      tokens.push({ type: "selector", value: code.slice(start, pos), pos: start });
-      continue;
-    }
-    if (code[pos] === "#" || code[pos] === ".") {
-      if (code[pos] === ".") {
-        const afterDot = code.slice(pos + 1).match(/^(once|prevent|stop|debounce|throttle)\\b/i);
-        if (afterDot) {
-          tokens.push({ type: "symbol", value: ".", pos: start });
-          pos++;
-          continue;
-        }
-      }
-      pos++;
-      while (pos < code.length && /[\\w-]/.test(code[pos])) pos++;
-      tokens.push({ type: "selector", value: code.slice(start, pos), pos: start });
-      continue;
-    }
-    if (code[pos] === "[") {
-      let lookahead = pos + 1;
-      while (lookahead < code.length && /\\s/.test(code[lookahead])) lookahead++;
-      const nextChar = code[lookahead] || "";
-      const isArrayLiteral = /['"\\d\\[\\]:\\$\\-]/.test(nextChar) || nextChar === "";
-      if (isArrayLiteral) {
-        tokens.push({ type: "symbol", value: "[", pos: start });
-        pos++;
-        continue;
-      } else {
-        pos++;
-        let depth = 1;
-        while (pos < code.length && depth > 0) {
-          if (code[pos] === "[") depth++;
-          if (code[pos] === "]") depth--;
-          pos++;
-        }
-        tokens.push({ type: "selector", value: code.slice(start, pos), pos: start });
-        continue;
-      }
-    }
-    if (code[pos] === "]") {
-      tokens.push({ type: "symbol", value: "]", pos: start });
-      pos++;
-      continue;
-    }
-    if (code.slice(pos, pos + 2) === "'s") {
-      tokens.push({ type: "operator", value: "'s", pos: start });
-      pos += 2;
-      continue;
-    }
-    const twoChar = code.slice(pos, pos + 2);
-    if (["==", "!=", "<=", ">=", "&&", "||"].includes(twoChar)) {
-      tokens.push({ type: "operator", value: twoChar, pos: start });
-      pos += 2;
-      continue;
-    }
-    if (code[pos] === "*" && /[a-zA-Z]/.test(code[pos + 1] || "")) {
-      pos++;
-      while (pos < code.length && /[\\w-]/.test(code[pos])) pos++;
-      tokens.push({ type: "styleProperty", value: code.slice(start, pos), pos: start });
-      continue;
-    }
-    if ("+-*/%<>!".includes(code[pos])) {
-      tokens.push({ type: "operator", value: code[pos], pos: start });
-      pos++;
-      continue;
-    }
-    if ("()[]{},.".includes(code[pos])) {
-      tokens.push({ type: "symbol", value: code[pos], pos: start });
-      pos++;
-      continue;
-    }
-    if (/[a-zA-Z_]/.test(code[pos])) {
-      while (pos < code.length && /[\\w-]/.test(code[pos])) pos++;
-      const value = code.slice(start, pos);
-      const type = KEYWORDS.has(value.toLowerCase()) ? "keyword" : "identifier";
-      tokens.push({ type, value, pos: start });
-      continue;
-    }
-    pos++;
-  }
-  tokens.push({ type: "eof", value: "", pos: code.length });
-  return tokens;
-}
-
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-class HybridParser {
-  constructor(code) {
-    __publicField(this, "tokens");
-    __publicField(this, "pos", 0);
-    /**
-     * The raw source. Kept because \`js \u2026 end\` must be sliced from it verbatim \u2014
-     * the tokenizer reads a JS body as hyperscript and mangles regexes, template
-     * literals and single quotes. Same approach as the full parser's
-     * \`parseJsCommand\`, which slices between token offsets for the same reason.
-     */
-    __publicField(this, "source");
-    /**
-     * Command keyword \u2192 parse rule. Built once per parse rather than once per
-     * command, and the single place the parser's command set is written down:
-     * \`isCommandKeyword()\` reads these keys instead of carrying its own copy.
-     *
-     * MUST stay in sync with \`bundle-generator/parser-templates.ts\`'s
-     * \`HYBRID_PARSER_TEMPLATE\` \u2014 core's \`generateBundle()\` imports this file
-     * while the vite-plugin's generator embeds that template, so a name in only
-     * one of them makes the reachable command set depend on which generator the
-     * user went through. Gated by \`capability-emission.test.ts\` \u00a73.
-     */
-    __publicField(this, "cmdMap", {
-      toggle: () => this.parseToggle(),
-      add: () => this.parseAdd(),
-      remove: () => this.parseRemove(),
-      put: () => this.parsePut(),
-      append: () => this.parseInsertion("append"),
-      prepend: () => this.parseInsertion("prepend"),
-      set: () => this.parseSet(),
-      get: () => this.parseGet(),
-      call: () => this.parseCall(),
-      log: () => this.parseLog(),
-      send: () => this.parseSend("to"),
-      // \`trigger <event> on <target>\` \u2014 same node as \`send\`, per the runtime,
-      // where \`trigger\` is a consolidation alias sharing \`send\`'s implementation.
-      // The target marker differs, which is why it is a parameter and not a
-      // second entry pointing at the same rule (that dropped the target).
-      trigger: () => this.parseSend("on"),
-      wait: () => this.parseWait(),
-      show: () => this.parseShow(),
-      hide: () => this.parseHide(),
-      take: () => this.parseTake(),
-      empty: () => this.parseEmpty(),
-      increment: () => this.parseIncDec("increment"),
-      decrement: () => this.parseIncDec("decrement"),
-      focus: () => this.parseFocusBlur("focus"),
-      blur: () => this.parseFocusBlur("blur"),
-      go: () => this.parseGo(),
-      return: () => this.parseReturn(),
-      transition: () => this.parseTransition(),
-      halt: () => this.parseHalt(),
-      copy: () => this.parseCopy(),
-      beep: () => this.parseBeep(),
-      push: () => this.parseUrlCommand("push"),
-      replace: () => this.parseUrlCommand("replace"),
-      morph: () => this.parseMorph(),
-      js: () => this.parseJs(),
-      throw: () => this.parseThrow(),
-      break: () => this.parseBare("break"),
-      continue: () => this.parseBare("continue"),
-      exit: () => this.parseBare("exit")
-    });
-    this.source = code;
-    this.tokens = tokenize(code);
-  }
-  peek(offset = 0) {
-    return this.tokens[Math.min(this.pos + offset, this.tokens.length - 1)];
-  }
-  advance() {
-    return this.tokens[this.pos++];
-  }
-  match(...values) {
-    const token = this.peek();
-    return values.some((v) => token.value.toLowerCase() === v.toLowerCase());
-  }
-  matchType(...types) {
-    return types.includes(this.peek().type);
-  }
-  expect(value) {
-    if (!this.match(value) && normalizeCommand(this.peek().value) !== value) {
-      throw new Error(\`Expected '\${value}', got '\${this.peek().value}'\`);
-    }
-    return this.advance();
-  }
-  isAtEnd() {
-    return this.peek().type === "eof";
-  }
-  parse() {
-    if (this.match("on")) return this.parseEventHandler();
-    if (this.match("init")) {
-      this.advance();
-      return { type: "event", event: "init", modifiers: {}, body: this.parseCommandSequence() };
-    }
-    if (this.match("every")) return this.parseEveryHandler();
-    return { type: "sequence", commands: this.parseCommandSequence() };
-  }
-  parseEventHandler() {
-    this.expect("on");
-    const eventName = this.advance().value;
-    const modifiers = {};
-    let filter;
-    while (this.peek().value === ".") {
-      this.advance();
-      const mod = this.advance().value.toLowerCase();
-      if (mod === "once") modifiers.once = true;
-      else if (mod === "prevent") modifiers.prevent = true;
-      else if (mod === "stop") modifiers.stop = true;
-      else if (mod === "debounce" || mod === "throttle") {
-        if (this.peek().value === "(") {
-          this.advance();
-          const num = this.advance().value;
-          this.expect(")");
-          if (mod === "debounce") modifiers.debounce = parseInt(num) || 100;
-          else modifiers.throttle = parseInt(num) || 100;
-        }
-      }
-    }
-    if (this.match("from")) {
-      this.advance();
-      filter = this.parseExpression();
-    }
-    return {
-      type: "event",
-      event: normalizeEvent(eventName),
-      filter,
-      modifiers,
-      body: this.parseCommandSequence()
-    };
-  }
-  parseEveryHandler() {
-    this.expect("every");
-    const interval = this.advance().value;
-    return {
-      type: "event",
-      event: \`interval:\${interval}\`,
-      modifiers: {},
-      body: this.parseCommandSequence()
-    };
-  }
-  parseCommandSequence() {
-    const commands = [];
-    while (!this.isAtEnd() && !this.match("end", "else")) {
-      const cmd = this.parseCommand();
-      if (cmd) commands.push(cmd);
-      if (this.match("then", "and")) this.advance();
-    }
-    return commands;
-  }
-  parseCommand() {
-    if (this.match("if", "unless")) return this.parseIf();
-    if (this.match("repeat")) return this.parseRepeat();
-    if (this.match("for")) return this.parseFor();
-    if (this.match("while")) return this.parseWhile();
-    if (this.match("fetch")) return this.parseFetchBlock();
-    const normalized = normalizeCommand(this.peek().value);
-    if (this.cmdMap[normalized]) {
-      return this.cmdMap[normalized]();
-    }
-    if (this.match("catch", "finally")) {
-      throw new Error(\`'\${this.peek().value}' needs the full parser (use hyperfixi.js)\`);
-    }
-    const stray = this.peek();
-    if (!this.isAtEnd() && (stray.type === "identifier" || stray.type === "keyword") && !this.match("then", "and", "end", "else")) {
-      throw new Error(\`'\${stray.value}' needs the full parser (use hyperfixi.js)\`);
-    }
-    if (!this.isAtEnd() && !this.match("then", "and", "end", "else")) {
-      this.advance();
-    }
-    return null;
-  }
-  // Control flow parsing
-  parseIf() {
-    const isUnless = this.match("unless");
-    this.advance();
-    const condition = this.parseExpression();
-    const body = this.parseCommandSequence();
-    let elseBody;
-    if (this.match("else")) {
-      this.advance();
-      elseBody = this.parseCommandSequence();
-    }
-    if (this.match("end")) this.advance();
-    return {
-      type: "if",
-      condition: isUnless ? { type: "unary", operator: "not", operand: condition } : condition,
-      body,
-      elseBody
-    };
-  }
-  parseRepeat() {
-    this.expect("repeat");
-    let count;
-    if (!this.match("until", "while", "forever")) {
-      count = this.parseExpression();
-      if (this.match("times")) this.advance();
-    }
-    const body = this.parseCommandSequence();
-    if (this.match("end")) this.advance();
-    return { type: "repeat", condition: count, body };
-  }
-  parseFor() {
-    this.expect("for");
-    if (this.match("each")) this.advance();
-    const variable = this.advance().value;
-    this.expect("in");
-    const iterable = this.parseExpression();
-    const body = this.parseCommandSequence();
-    if (this.match("end")) this.advance();
-    return { type: "for", condition: { type: "forCondition", variable, iterable }, body };
-  }
-  parseWhile() {
-    this.expect("while");
-    const condition = this.parseExpression();
-    const body = this.parseCommandSequence();
-    if (this.match("end")) this.advance();
-    return { type: "while", condition, body };
-  }
-  /**
-   * A naked URL \u2014 \`fetch /api/data \u2026\`, \`fetch https://x/y \u2026\` \u2014 the way upstream
-   * reads one: everything up to the next whitespace, verbatim. The tokenizer
-   * splits \`/api/data\` into \`/\`, \`api\`, \`/\`, \`data\`, and \`parseExpression\` used
-   * to return the first \`/\` as the URL; the skip fallback then dropped the rest
-   * silently, so every unquoted \`fetch /path\` in a hybrid bundle fetched \`/\`.
-   * Measured 2026-09-04 when the fallback stopped being silent.
-   */
-  parseNakedUrl() {
-    const tok = this.peek();
-    const isSlash = tok.type === "operator" && tok.value === "/";
-    const isScheme = (tok.value === "http" || tok.value === "https") && this.source.slice(tok.pos + tok.value.length, tok.pos + tok.value.length + 3) === "://";
-    if (!isSlash && !isScheme) return null;
-    let end = tok.pos;
-    while (end < this.source.length && !/\\s/.test(this.source[end])) end++;
-    while (!this.isAtEnd() && this.peek().pos < end) this.advance();
-    return { type: "literal", value: this.source.slice(tok.pos, end) };
-  }
-  parseFetchBlock() {
-    this.expect("fetch");
-    const url = this.parseNakedUrl() ?? this.parseExpression();
-    let responseType = { type: "literal", value: "text" };
-    let options;
-    let method;
-    if (this.match("{")) {
-      this.pos--;
-      options = this.parseExpression();
-    }
-    for (let i = 0; i < 3; i++) {
-      if (this.match("via") && !method) {
-        this.advance();
-        method = this.parseExpression();
-        continue;
-      }
-      if (this.match("as")) {
-        this.advance();
-        if (this.match("a") || this.match("an")) this.advance();
-        responseType = this.parseExpression();
-        continue;
-      }
-      if (this.match("with") && !options) {
-        this.advance();
-        options = this.parseExpression();
-        continue;
-      }
-      break;
-    }
-    if (this.match("then")) this.advance();
-    const body = this.parseCommandSequence();
-    return {
-      type: "fetch",
-      condition: { type: "fetchConfig", url, responseType, options, method },
-      body
-    };
-  }
-  // Command parsing
-  parseToggle() {
-    this.expect("toggle");
-    const what = this.parseExpression();
-    let target;
-    if (this.match("on")) {
-      this.advance();
-      target = this.parseExpression();
-    }
-    return { type: "command", name: "toggle", args: [what], target };
-  }
-  parseAdd() {
-    this.expect("add");
-    const what = this.parseExpression();
-    let target;
-    if (this.match("to")) {
-      this.advance();
-      target = this.parseExpression();
-    }
-    return { type: "command", name: "add", args: [what], target };
-  }
-  parseRemove() {
-    this.expect("remove");
-    if (this.matchType("selector") && /^[.@]/.test(this.peek().value)) {
-      const what = this.parseExpression();
-      let target2;
-      if (this.match("from")) {
-        this.advance();
-        target2 = this.parseExpression();
-      }
-      return { type: "command", name: "removeClass", args: [what], target: target2 };
-    }
-    const target = this.parseExpression();
-    return { type: "command", name: "remove", args: [], target };
-  }
-  parsePut() {
-    this.expect("put");
-    const content = this.parseExpression();
-    let modifier = "into";
-    if (this.match("into", "before", "after", "at")) {
-      modifier = this.advance().value;
-      if (modifier === "at") {
-        const pos = this.advance().value;
-        this.expect("of");
-        modifier = \`at \${pos} of\`;
-      }
-    }
-    const target = this.parseExpression();
-    return { type: "command", name: "put", args: [content], target, modifier };
-  }
-  /** \`append\`/\`prepend <content> [to <target>]\` \u2014 identical shape, both ends. */
-  parseInsertion(name) {
-    this.expect(name);
-    const content = this.parseExpression();
-    let target;
-    if (this.match("to")) {
-      this.advance();
-      target = this.parseExpression();
-    }
-    return { type: "command", name, args: [content], target };
-  }
-  parseSet() {
-    this.expect("set");
-    const target = this.parseExpression();
-    if (this.match("to")) {
-      this.advance();
-      const value = this.parseExpression();
-      return { type: "command", name: "set", args: [target, value] };
-    }
-    return { type: "command", name: "set", args: [target] };
-  }
-  parseGet() {
-    this.expect("get");
-    return { type: "command", name: "get", args: [this.parseExpression()] };
-  }
-  parseCall() {
-    this.expect("call");
-    return { type: "command", name: "call", args: [this.parseExpression()] };
-  }
-  parseLog() {
-    this.expect("log");
-    const args = [];
-    while (!this.isAtEnd() && !this.match("then", "and", "end", "else")) {
-      args.push(this.parseExpression());
-      if (this.match(",")) this.advance();
-      else break;
-    }
-    return { type: "command", name: "log", args };
-  }
-  /**
-   * \`send <event> to <target>\` / \`trigger <event> on <target>\`.
-   *
-   * Both emit a \`send\` node \u2014 the runtime registers \`trigger\` as a
-   * consolidation alias sharing \`send\`'s implementation, so the bundle
-   * generator carries one template for both. The marker is a parameter
-   * because it is the ONLY difference: \`trigger\` used to reuse this rule with
-   * \`to\` hardcoded, which parsed the event name and then silently abandoned
-   * \`on #target\`, leaving the dispatch to land on \`me\`.
-   */
-  parseSend(marker) {
-    this.advance();
-    const first = this.advance();
-    let event = first.value;
-    let end = first.pos + first.value.length;
-    while (!this.isAtEnd() && this.peek().type === "localVar" && this.peek().pos === end) {
-      const piece = this.advance();
-      event += piece.value;
-      end = piece.pos + piece.value.length;
-    }
-    let target;
-    if (this.match(marker)) {
-      this.advance();
-      target = this.parseExpression();
-    }
-    return { type: "command", name: "send", args: [{ type: "literal", value: event }], target };
-  }
-  parseWait() {
-    this.expect("wait");
-    if (this.match("for")) {
-      this.advance();
-      const event = this.advance().value;
-      let target;
-      if (this.match("from")) {
-        this.advance();
-        target = this.parseExpression();
-      }
-      return {
-        type: "command",
-        name: "waitFor",
-        args: [{ type: "literal", value: event }],
-        target
-      };
-    }
-    return { type: "command", name: "wait", args: [this.parseExpression()] };
-  }
-  parseShow() {
-    this.expect("show");
-    let target;
-    const modifiers = {};
-    if (!this.isAtEnd() && !this.match("then", "and", "end", "else", "when", "where")) {
-      target = this.parseExpression();
-    }
-    if (!this.isAtEnd() && this.match("when", "where")) {
-      const keyword = this.advance().value;
-      modifiers[keyword] = this.parseExpression();
-    }
-    return { type: "command", name: "show", args: [], target, modifiers };
-  }
-  parseHide() {
-    this.expect("hide");
-    let target;
-    const modifiers = {};
-    if (!this.isAtEnd() && !this.match("then", "and", "end", "else", "when", "where")) {
-      target = this.parseExpression();
-    }
-    if (!this.isAtEnd() && this.match("when", "where")) {
-      const keyword = this.advance().value;
-      modifiers[keyword] = this.parseExpression();
-    }
-    return { type: "command", name: "hide", args: [], target, modifiers };
-  }
-  parseTake() {
-    this.expect("take");
-    const what = this.parseExpression();
-    let from;
-    if (this.match("from")) {
-      this.advance();
-      from = this.parseExpression();
-    }
-    return { type: "command", name: "take", args: [what], target: from };
-  }
-  parseIncDec(name) {
-    this.advance();
-    const target = this.parseExpression();
-    let amount = { type: "literal", value: 1 };
-    if (this.match("by")) {
-      this.advance();
-      amount = this.parseExpression();
-    }
-    return { type: "command", name, args: [target, amount] };
-  }
-  parseFocusBlur(name) {
-    this.advance();
-    let target;
-    if (!this.isAtEnd() && !this.match("then", "and", "end", "else")) {
-      target = this.parseExpression();
-    }
-    return { type: "command", name, args: [], target };
-  }
-  parseGo() {
-    this.expect("go");
-    if (this.match("to")) this.advance();
-    if (this.match("url")) this.advance();
-    const dest = this.parseExpression();
-    return { type: "command", name: "go", args: [dest] };
-  }
-  parseReturn() {
-    this.expect("return");
-    let value;
-    if (!this.isAtEnd() && !this.match("then", "and", "end", "else")) {
-      value = this.parseExpression();
-    }
-    return { type: "command", name: "return", args: value ? [value] : [] };
-  }
-  // ---------------------------------------------------------------------------
-  // Rules restoring the commands the capability list advertised but this parser
-  // could not reach (Finding 13). Every one already had a working template in
-  // \`bundle-generator/templates.ts\`; only the parse rule was missing, so the
-  // emitted \`case\` label was dead and the user's source silently no-opped.
-  // ---------------------------------------------------------------------------
-  /** \`empty [<target>]\` \u2014 clears children. Defaults to \`me\`. */
-  parseEmpty() {
-    this.expect("empty");
-    let target;
-    if (!this.isAtEnd() && !this.match("then", "and", "end", "else")) {
-      target = this.parseExpression();
-    }
-    return { type: "command", name: "empty", args: [], target };
-  }
-  /** \`copy <value>\` \u2014 clipboard write. */
-  parseCopy() {
-    this.expect("copy");
-    return { type: "command", name: "copy", args: [this.parseExpression()] };
-  }
-  /**
-   * \`beep[!] [<value>, \u2026]\` \u2014 debug echo.
-   *
-   * Upstream spells it \`beep!\`; hyperfixi accepts both (see the tier list's
-   * note on the same nuance). The \`!\` is consumed here because the tokenizer
-   * emits it as a separate operator, and \`parseUnary\` would otherwise read it
-   * as logical negation of the first argument.
-   */
-  parseBeep() {
-    this.advance();
-    if (this.match("!")) this.advance();
-    const args = [];
-    while (!this.isAtEnd() && !this.match("then", "and", "end", "else")) {
-      args.push(this.parseExpression());
-      if (this.match(",")) this.advance();
-      else break;
-    }
-    return { type: "command", name: "beep", args };
-  }
-  /**
-   * \`push|replace url <url> [with title <title>]\` \u2014 History API navigation.
-   *
-   * The \`url\` keyword is consumed here rather than left for the executor, the
-   * way \`parseGo\` already does it. Note \`push-url\` / \`replace-url\` are NOT
-   * source spellings \u2014 the full parser rejects both \u2014 they exist only as
-   * bundle-config aliases resolving to these templates.
-   */
-  parseUrlCommand(name) {
-    this.advance();
-    if (this.match("url")) this.advance();
-    const url = this.parseExpression();
-    const modifiers = {};
-    if (this.match("with")) {
-      this.advance();
-      if (this.match("title")) {
-        this.advance();
-        modifiers.title = this.parseExpression();
-      }
-    }
-    return { type: "command", name, args: [url], modifiers };
-  }
-  /** \`morph [over] <target> to|with|into <content>\` \u2014 upstream spells it \`to\`; the full parser also takes \`with\`; \`into\` is this parser's own. */
-  parseMorph() {
-    this.expect("morph");
-    let modifier;
-    if (this.match("over")) {
-      this.advance();
-      modifier = "over";
-    }
-    const target = this.parseExpression();
-    if (this.match("with", "to", "into")) this.advance();
-    const content = this.parseExpression();
-    return { type: "command", name: "morph", args: [content], target, modifier };
-  }
-  /**
-   * \`js[(<params>)] <raw JavaScript> end\`.
-   *
-   * The body is sliced from the ORIGINAL SOURCE between token offsets, never
-   * reassembled from tokens \u2014 the tokenizer reads it as hyperscript, which
-   * mangles regexes, template literals and possessive-looking quotes. This
-   * mirrors the full parser's \`parseJsCommand\`.
-   *
-   * Known limit: the terminator scan matches the \`end\` TOKEN, so \`end\` inside a
-   * JS *string* is safe (the tokenizer keeps a string as one token, quotes
-   * included) but a bare JS identifier named \`end\` would cut the body early.
-   * The full parser's \`findJsEndBoundary\` handles that; replicating it is not
-   * worth the bytes in a bundle this size.
-   */
-  parseJs() {
-    this.advance();
-    if (this.match("(")) {
-      while (!this.isAtEnd() && !this.match(")")) this.advance();
-      if (this.match(")")) this.advance();
-    }
-    const start = this.peek().pos;
-    while (!this.isAtEnd() && !this.match("end")) this.advance();
-    const stop = this.peek().pos;
-    if (this.match("end")) this.advance();
-    const code = this.source.slice(start, stop).trim();
-    return { type: "command", name: "js", args: [{ type: "literal", value: code }] };
-  }
-  /** \`throw <value>\` */
-  parseThrow() {
-    this.expect("throw");
-    let value;
-    if (!this.isAtEnd() && !this.match("then", "and", "end", "else")) {
-      value = this.parseExpression();
-    }
-    return { type: "command", name: "throw", args: value ? [value] : [] };
-  }
-  /** \`break\` / \`continue\` / \`exit\` \u2014 bare control-flow signals, no arguments. */
-  parseBare(name) {
-    this.advance();
-    return { type: "command", name, args: [] };
-  }
-  parseHalt() {
-    this.expect("halt");
-    if (this.match("the")) this.advance();
-    if (this.match("event", "default")) this.advance();
-    return { type: "command", name: "halt", args: [] };
-  }
-  // transition <property> to <value> [over <duration>]
-  parseTransition() {
-    this.expect("transition");
-    let target;
-    if (this.match("my", "its")) {
-      const ref = this.advance().value;
-      target = { type: "identifier", value: ref === "my" ? "me" : "it" };
-    } else if (this.matchType("selector")) {
-      const expr = this.parseExpression();
-      if (expr.type === "possessive") {
-        return this.parseTransitionRest(expr.object, expr.property);
-      }
-      target = expr;
-    }
-    const propToken = this.peek();
-    let property;
-    if (propToken.type === "styleProperty") {
-      property = this.advance().value;
-    } else if (propToken.type === "identifier" || propToken.type === "keyword") {
-      property = this.advance().value;
-    } else {
-      property = "opacity";
-    }
-    return this.parseTransitionRest(target, property);
-  }
-  parseTransitionRest(target, property) {
-    let toValue = { type: "literal", value: 1 };
-    if (this.match("to")) {
-      this.advance();
-      toValue = this.parseExpression();
-    }
-    let duration = { type: "literal", value: 300 };
-    if (this.match("over")) {
-      this.advance();
-      duration = this.parseExpression();
-    }
-    return {
-      type: "command",
-      name: "transition",
-      args: [{ type: "literal", value: property }, toValue, duration],
-      target
-    };
-  }
-  // Expression parsing with operator precedence
-  parseExpression() {
-    return this.parseOr();
-  }
-  parseOr() {
-    let left = this.parseAnd();
-    while (this.match("or", "||")) {
-      this.advance();
-      left = { type: "binary", operator: "or", left, right: this.parseAnd() };
-    }
-    return left;
-  }
-  parseAnd() {
-    let left = this.parseEquality();
-    while (this.match("and", "&&") && !this.isCommandKeyword(this.peek(1))) {
-      this.advance();
-      left = { type: "binary", operator: "and", left, right: this.parseEquality() };
-    }
-    return left;
-  }
-  /**
-   * Does this token start a command rather than continue an expression?
-   *
-   * Used in two places with different stakes: terminating an \`and\` chain
-   * (\`toggle .x and add .y\`), and refusing to read a command name as a
-   * possessive property (\`my show\`).
-   *
-   * This is a deliberate SUBSET of \`cmdMap\`'s keys, not a second copy of it \u2014
-   * asserted as a subset in \`capability-emission.test.ts\` \u00a74 so it cannot
-   * name something the parser does not dispatch. It is not the full set
-   * because several of the newer keys are ordinary English or JS words
-   * (\`copy\`, \`empty\`, \`push\`, \`replace\`, \`break\`) that appear as property
-   * names and operands; promoting them here would change expression parsing,
-   * which is a separate decision from command reachability. The cost is that
-   * \`\u2026 and break\` reads \`break\` as an operand; \`then\` is the canonical
-   * separator and is handled by \`parseCommandSequence\` directly.
-   */
-  isCommandKeyword(token) {
-    const cmds = [
-      "toggle",
-      "add",
-      "remove",
-      "set",
-      "put",
-      "log",
-      "send",
-      "wait",
-      "show",
-      "hide",
-      "increment",
-      "decrement",
-      "focus",
-      "blur",
-      "go"
-    ];
-    return cmds.includes(normalizeCommand(token.value));
-  }
-  parseEquality() {
-    let left = this.parseComparison();
-    while (this.match("==", "!=", "is", "matches", "contains", "includes", "has")) {
-      const op = this.advance().value;
-      if (op.toLowerCase() === "is" && this.match("not")) {
-        this.advance();
-        left = { type: "binary", operator: "is not", left, right: this.parseComparison() };
-      } else {
-        left = { type: "binary", operator: op, left, right: this.parseComparison() };
-      }
-    }
-    return left;
-  }
-  parseComparison() {
-    let left = this.parseAdditive();
-    while (this.match("<", ">", "<=", ">=")) {
-      const op = this.advance().value;
-      left = { type: "binary", operator: op, left, right: this.parseAdditive() };
-    }
-    return left;
-  }
-  parseAdditive() {
-    let left = this.parseMultiplicative();
-    while (this.match("+", "-")) {
-      const op = this.advance().value;
-      left = { type: "binary", operator: op, left, right: this.parseMultiplicative() };
-    }
-    return left;
-  }
-  parseMultiplicative() {
-    let left = this.parseUnary();
-    while (this.match("*", "/", "%")) {
-      const op = this.advance().value;
-      left = { type: "binary", operator: op, left, right: this.parseUnary() };
-    }
-    return left;
-  }
-  parseUnary() {
-    if (this.match("beep") && this.peek(1).value === "!") {
-      throw new Error(\`'beep!' needs the full parser (use hyperfixi.js)\`);
-    }
-    if (this.match("not", "!")) {
-      this.advance();
-      return { type: "unary", operator: "not", operand: this.parseUnary() };
-    }
-    if (this.match("-") && this.peek(1).type === "number") {
-      this.advance();
-      const num = this.advance();
-      return { type: "literal", value: -parseFloat(num.value) };
-    }
-    return this.parsePostfix();
-  }
-  parsePostfix() {
-    let left = this.parsePrimary();
-    while (true) {
-      if (this.match("'s")) {
-        this.advance();
-        const next = this.peek();
-        const prop = next.type === "styleProperty" ? this.advance().value : this.advance().value;
-        left = { type: "possessive", object: left, property: prop };
-      } else if (this.peek().type === "styleProperty") {
-        const prop = this.advance().value;
-        left = { type: "possessive", object: left, property: prop };
-      } else if (this.peek().value === ".") {
-        this.advance();
-        const prop = this.advance().value;
-        left = { type: "member", object: left, property: prop };
-      } else if (this.peek().type === "selector" && this.peek().value.startsWith(".")) {
-        const prop = this.advance().value.slice(1);
-        left = { type: "member", object: left, property: prop };
-      } else if (this.peek().value === "(") {
-        this.advance();
-        const args = [];
-        while (!this.match(")")) {
-          args.push(this.parseExpression());
-          if (this.match(",")) this.advance();
-        }
-        this.expect(")");
-        left = { type: "call", callee: left, args };
-      } else if (this.peek().value === "[" && left.type !== "selector") {
-        this.advance();
-        const index = this.parseExpression();
-        this.expect("]");
-        left = { type: "member", object: left, property: index, computed: true };
-      } else {
-        break;
-      }
-    }
-    return left;
-  }
-  parsePrimary() {
-    const token = this.peek();
-    if (token.value === "(") {
-      this.advance();
-      const expr = this.parseExpression();
-      this.expect(")");
-      return expr;
-    }
-    if (token.value === "{") return this.parseObjectLiteral();
-    if (token.value === "[") return this.parseArrayLiteral();
-    if (token.type === "number") {
-      this.advance();
-      const val = token.value;
-      if (val.endsWith("ms")) return { type: "literal", value: parseInt(val), unit: "ms" };
-      if (val.endsWith("s")) return { type: "literal", value: parseFloat(val) * 1e3, unit: "ms" };
-      return { type: "literal", value: parseFloat(val) };
-    }
-    if (token.type === "string") {
-      this.advance();
-      return { type: "literal", value: token.value.slice(1, -1) };
-    }
-    if (this.match("true")) {
-      this.advance();
-      return { type: "literal", value: true };
-    }
-    if (this.match("false")) {
-      this.advance();
-      return { type: "literal", value: false };
-    }
-    if (this.match("null")) {
-      this.advance();
-      return { type: "literal", value: null };
-    }
-    if (this.match("undefined")) {
-      this.advance();
-      return { type: "literal", value: void 0 };
-    }
-    if (token.type === "localVar") {
-      this.advance();
-      return { type: "variable", name: token.value, scope: "local" };
-    }
-    if (token.type === "globalVar") {
-      this.advance();
-      return { type: "variable", name: token.value, scope: "global" };
-    }
-    if (token.type === "selector") {
-      this.advance();
-      return { type: "selector", value: token.value };
-    }
-    if (this.match("my")) {
-      this.advance();
-      const next = this.peek();
-      if ((next.type === "identifier" || next.type === "keyword") && !this.isCommandKeyword(next)) {
-        const prop = this.advance().value;
-        return { type: "possessive", object: { type: "identifier", value: "me" }, property: prop };
-      }
-      return { type: "identifier", value: "me" };
-    }
-    if (this.match("its")) {
-      this.advance();
-      const next = this.peek();
-      if ((next.type === "identifier" || next.type === "keyword") && !this.isCommandKeyword(next)) {
-        const prop = this.advance().value;
-        return { type: "possessive", object: { type: "identifier", value: "it" }, property: prop };
-      }
-      return { type: "identifier", value: "it" };
-    }
-    if (this.match("me")) {
-      this.advance();
-      return { type: "identifier", value: "me" };
-    }
-    if (this.match("it")) {
-      this.advance();
-      return { type: "identifier", value: "it" };
-    }
-    if (this.match("you")) {
-      this.advance();
-      return { type: "identifier", value: "you" };
-    }
-    if (this.match("the", "a", "an")) {
-      this.advance();
-      if (this.match("first", "last", "next", "previous", "closest", "parent")) {
-        const position = this.advance().value;
-        const target = this.parsePositionalTarget();
-        return { type: "positional", position, target };
-      }
-      return this.parsePrimary();
-    }
-    if (this.match("first", "last", "next", "previous", "closest", "parent")) {
-      const position = this.advance().value;
-      const target = this.parsePositionalTarget();
-      return { type: "positional", position, target };
-    }
-    if (this.match("values")) {
-      this.advance();
-      if (this.match("of")) {
-        this.advance();
-        const target = this.parseExpression();
-        return { type: "valuesOf", target };
-      }
-      return { type: "identifier", value: token.value };
-    }
-    if (token.type === "identifier" || token.type === "keyword") {
-      this.advance();
-      return { type: "identifier", value: token.value };
-    }
-    this.advance();
-    return { type: "identifier", value: token.value };
-  }
-  parseObjectLiteral() {
-    this.expect("{");
-    const properties = [];
-    while (!this.match("}")) {
-      const key = this.advance().value;
-      this.expect(":");
-      const value = this.parseExpression();
-      properties.push({ key, value });
-      if (this.match(",")) this.advance();
-    }
-    this.expect("}");
-    return { type: "object", properties };
-  }
-  parseArrayLiteral() {
-    this.expect("[");
-    const elements = [];
-    while (!this.match("]")) {
-      elements.push(this.parseExpression());
-      if (this.match(",")) this.advance();
-    }
-    this.expect("]");
-    return { type: "array", elements };
-  }
-  parsePositionalTarget() {
-    const token = this.peek();
-    if (token.type === "selector") {
-      return { type: "selector", value: this.advance().value };
-    }
-    if (token.type === "identifier" || token.type === "keyword") {
-      return { type: "identifier", value: this.advance().value };
-    }
-    return this.parseExpression();
-  }
-}
-// #endregion generated:hybrid-parser
-`;
-function getParserTemplate(type) {
-    return type === 'lite' ? LITE_PARSER_TEMPLATE : HYBRID_PARSER_TEMPLATE;
-}
-const LITE_PARSER_COMMANDS = [
-    'toggle',
-    'add',
-    'remove',
-    'put',
-    'set',
-    'log',
-    'send',
-    'wait',
-    'show',
-    'hide',
-];
-function canUseLiteParser(commands, blocks, positional) {
-    if (blocks.length > 0)
-        return false;
-    if (positional)
-        return false;
-    const liteCommands = new Set(LITE_PARSER_COMMANDS);
-    return commands.every(cmd => liteCommands.has(cmd));
-}
-
-exports.AVAILABLE_BLOCKS = AVAILABLE_BLOCKS;
-exports.AVAILABLE_COMMANDS = AVAILABLE_COMMANDS;
-exports.BLOCK_IMPLEMENTATIONS = BLOCK_IMPLEMENTATIONS;
-exports.COMMAND_ALIASES = COMMAND_ALIASES;
-exports.COMMAND_IMPLEMENTATIONS = COMMAND_IMPLEMENTATIONS;
-exports.ELEMENT_ARRAY_COMMANDS = ELEMENT_ARRAY_COMMANDS;
-exports.FULL_RUNTIME_ONLY_COMMANDS = FULL_RUNTIME_ONLY_COMMANDS;
-exports.HYBRID_PARSER_TEMPLATE = HYBRID_PARSER_TEMPLATE;
-exports.LITE_PARSER_COMMANDS = LITE_PARSER_COMMANDS;
-exports.LITE_PARSER_TEMPLATE = LITE_PARSER_TEMPLATE;
-exports.MORPH_COMMANDS = MORPH_COMMANDS;
-exports.STYLE_COMMANDS = STYLE_COMMANDS;
-exports.canUseLiteParser = canUseLiteParser;
-exports.generateBundle = generateBundle;
-exports.generateBundleCode = generateBundleCode;
-exports.getAvailableBlocks = getAvailableBlocks;
-exports.getAvailableCommands = getAvailableCommands;
-exports.getBlockImplementations = getBlockImplementations;
-exports.getCommandImplementations = getCommandImplementations;
-exports.getParserTemplate = getParserTemplate;
-exports.isAvailableBlock = isAvailableBlock;
-exports.isAvailableCommand = isAvailableCommand;
-exports.requiresFullRuntime = requiresFullRuntime;
-exports.resolveCommandKey = resolveCommandKey;
-//# sourceMappingURL=index.cjs.map