@lokascript/compilation-service 3.1.0 → 3.2.0

package/dist/index.cjs

@@ -948,6 +948,37 @@ function makeTypeCheckHandler(negated) {
     };
   };
 }
+function parseOfOperand(ctx, minBp = OF_OPERAND_BP) {
+  let right = ctx.parseExpr(minBp);
+  if (ctx.peek()?.value === "in") {
+    const inToken = ctx.advance();
+    const scope = ctx.parseExpr(minBp);
+    right = {
+      type: "binaryExpression",
+      operator: "in",
+      left: right,
+      right: scope,
+      start: right.start,
+      end: scope.end ?? inToken.end,
+      line: right.line ?? inToken.line,
+      column: right.column ?? inToken.column
+    };
+  }
+  return right;
+}
+function ofHandler(left, token, ctx) {
+  const right = parseOfOperand(ctx);
+  return {
+    type: "binaryExpression",
+    operator: token.value,
+    left,
+    right,
+    start: left.start,
+    end: right.end ?? token.end,
+    line: left.line ?? token.line,
+    column: left.column ?? token.column
+  };
+}
 function report(kind, err2) {
   if (typeof console !== "undefined") {
     console.error(`[hyperfixi] ${kind} threw:`, err2);
@@ -1458,6 +1489,48 @@ function parseMaybeNamedArgument(ctx) {
   const value = ctx.parseExpression();
   return name !== void 0 ? { name, value } : { value };
 }
+function isNakedNamedArgStart(ctx) {
+  if (ctx.check("{"))
+    return false;
+  if (!ctx.checkIdentifierLike())
+    return false;
+  const next = ctx.peekAt(1);
+  return next !== null && next.value === ":";
+}
+function parseNakedNamedArgs(ctx, parseValue, command2) {
+  const properties = [];
+  const startPos = ctx.getPosition();
+  do {
+    if (!ctx.checkIdentifierLike())
+      break;
+    const keyToken = ctx.advance();
+    const key = {
+      type: "identifier",
+      name: keyToken.value,
+      start: keyToken.start,
+      end: keyToken.end,
+      line: keyToken.line,
+      column: keyToken.column
+    };
+    ctx.consume(":", `Expected ':' after property name in ${command2} named arguments`);
+    const value = parseValue();
+    if (value) {
+      properties.push({ key, value });
+    }
+  } while (ctx.match(",") && !ctx.isAtEnd());
+  const endPos = ctx.getPosition();
+  return {
+    type: "objectLiteral",
+    properties,
+    start: startPos.start,
+    end: endPos.end,
+    line: startPos.line,
+    column: startPos.column
+  };
+}
+function isGluedBeepBang(beep, bang) {
+  return beep?.value === "beep" && bang?.value === "!" && bang.start === beep.end;
+}
 function parseTriggerCommand(ctx, identifierNode) {
   const allArgs = [];
   let eventName = "";
@@ -1528,6 +1601,8 @@ function parseTriggerCommand(ctx, identifierNode) {
   const modifiers = {};
   while (!isCommandBoundary(ctx)) {
     if (ctx.check(KEYWORDS.ON) || ctx.check(KEYWORDS.TO)) {
+      if (modifiers["on"])
+        break;
       ctx.advance();
       const target = parseOneArgument(ctx, [KEYWORDS.WITH]);
       if (target)
@@ -1659,6 +1734,8 @@ function parseRepeatCommand(ctx, commandToken) {
   } else if (ctx.check(KEYWORDS.FOREVER)) {
     ctx.advance();
     loopType = KEYWORDS.FOREVER;
+  } else if (ctx.checkIsCommand() || ctx.isCommand(ctx.peek().value)) {
+    loopType = KEYWORDS.FOREVER;
   } else {
     times = ctx.parseExpression();
     if (ctx.check(KEYWORDS.TIMES)) {
@@ -1698,10 +1775,11 @@ function parseRepeatCommand(ctx, commandToken) {
       loopType = result.terminator;
       ctx.advance();
       condition = ctx.parseExpression();
-      if (!ctx.check("end")) {
+      if (ctx.check("end")) {
+        ctx.advance();
+      } else if (!ctx.atEndOfInput()) {
         throw new Error('Expected "end" to close repeat block');
       }
-      ctx.advance();
     }
   } else {
     const result = ctx.parseCommandListUntilEndOrElse();
@@ -1908,7 +1986,7 @@ function parseIfCommand(ctx, commandToken) {
         }));
       }
     }
-    if (!consumedElseIf && !ctx.isAtEnd()) {
+    if (!consumedElseIf && !ctx.atEndOfInput()) {
       ctx.consume(KEYWORDS.END, "Expected 'end' after if block");
     }
   } else {
@@ -1928,7 +2006,6 @@ function parseIfCommand(ctx, commandToken) {
   return CommandNodeBuilder.from(commandToken).withArgs(...args).endingAt(ctx.getPosition()).build();
 }
 function parseForCommand(ctx, commandToken) {
-  const args = [];
   let variable = null;
   let collection = null;
   if (ctx.check(KEYWORDS.EACH)) {
@@ -1968,30 +2045,20 @@ function parseForCommand(ctx, commandToken) {
     }
   }
   const commands = ctx.parseCommandListUntilEnd("for");
-  args.push({
-    type: "identifier",
-    name: "for",
-    start: commandToken.start,
-    end: commandToken.end,
-    line: commandToken.line,
-    column: commandToken.column
-  });
-  const forPos = {
+  const pos2 = {
     start: commandToken.start,
     end: commandToken.end,
     line: commandToken.line,
     column: commandToken.column
   };
-  args.push(createStringLiteral(variable, forPos));
-  args.push(collection);
-  if (indexVariable) {
-    args.push(createStringLiteral(indexVariable, forPos));
-  }
-  args.push(createBlock(commands, { ...forPos, end: forPos.end || 0 }));
-  return CommandNodeBuilder.from({
-    ...commandToken,
-    value: "repeat"
-  }).withArgs(...args).endingAt(ctx.getPosition()).build();
+  const modifiers = {
+    loopType: toLegacyExpression(createStringLiteral(KEYWORDS.FOR, pos2)),
+    for: toLegacyExpression(createStringLiteral(variable, pos2)),
+    in: collection
+  };
+  if (indexVariable)
+    modifiers["index"] = toLegacyExpression(createStringLiteral(indexVariable, pos2));
+  return CommandNodeBuilder.from({ ...commandToken, value: "repeat" }).withArgs(createBlock(commands, { ...pos2, end: pos2.end || 0 })).withModifiers(modifiers).endingAt(ctx.getPosition()).build();
 }
 function parseMeasureCommand(ctx, identifierNode) {
   const args = [];
@@ -2041,73 +2108,142 @@ function parseMeasureCommand(ctx, identifierNode) {
   return builder.build();
 }
 function parseTransitionCommand(ctx, commandToken) {
-  const args = [];
-  const modifiers = {};
-  let property = null;
-  let target = null;
-  const leadToken = ctx.peek();
-  const startsTarget = ctx.checkAnySelector() || ctx.checkContextVar() || ctx.check("<") || isIdentifierLike(leadToken) && CONTEXT_POSSESSIVES.has(leadToken.value);
-  if (startsTarget) {
-    const parsed = ctx.parsePrimary();
-    if ((parsed.type === "possessiveExpression" || parsed.type === "memberExpression" && !parsed.computed) && parsed.object && parsed.property?.name) {
-      target = parsed.object;
-      property = {
-        type: "string",
-        value: parsed.property.name,
-        start: leadToken.start || 0,
-        end: ctx.getPosition().end,
-        line: leadToken.line,
-        column: leadToken.column
-      };
-    } else {
-      target = parsed;
-      if (ctx.check("'s"))
-        ctx.advance();
-    }
-  }
-  const firstToken = ctx.peek();
-  if (!property && (isIdentifierLike(firstToken) || firstToken.value === "*")) {
-    let propertyValue = "";
-    if (ctx.check("*")) {
-      propertyValue = "*";
+  const pairs = [];
+  do {
+    pairs.push(parseTransitionPair(ctx));
+  } while (startsAnotherPair(ctx));
+  const [first, ...rest] = pairs;
+  const args = first.owner ? [first.owner, first.property] : [first.property];
+  const modifiers = { to: first.to };
+  if (first.from)
+    modifiers["from"] = first.from;
+  if (rest.length > 0)
+    modifiers["pairs"] = pairsNode(rest);
+  for (let i = 0; i < 3 && !ctx.isAtEnd(); i++) {
+    if (ctx.check("over") && !modifiers["over"]) {
       ctx.advance();
-    }
-    const hyphenatedName = parseHyphenatedName(ctx);
-    if (hyphenatedName) {
-      propertyValue += hyphenatedName;
-      property = {
-        type: "string",
-        value: propertyValue,
-        start: firstToken.start || 0,
-        end: ctx.getPosition().end,
-        line: firstToken.line,
-        column: firstToken.column
-      };
+      modifiers["over"] = ctx.parseExpression();
+    } else if (ctx.check("using") && !modifiers["using"]) {
+      ctx.advance();
+      modifiers["using"] = ctx.parseExpression();
+    } else if (ctx.check(KEYWORDS.WITH) && !modifiers["with"]) {
+      ctx.advance();
+      modifiers["with"] = ctx.parsePrimary();
+    } else {
+      break;
     }
   }
-  if (!property) {
-    throw new Error("Transition command requires a CSS property");
+  return CommandNodeBuilder.from(commandToken).withArgs(...args).withModifiers(modifiers).endingAt(ctx.getPosition()).build();
+}
+function parseTransitionPair(ctx) {
+  const { owner, property } = parseTransitionProperty(ctx);
+  let from = null;
+  if (ctx.check("from")) {
+    ctx.advance();
+    from = ctx.parseExpression();
   }
-  if (target)
-    args.push(target);
-  args.push(property);
   if (!ctx.check(KEYWORDS.TO)) {
     throw new Error('Expected "to" keyword after property in transition command');
   }
   ctx.advance();
-  const value = ctx.parseExpression();
-  modifiers["to"] = value;
-  if (ctx.check("over")) {
-    ctx.advance();
-    const duration = ctx.parseExpression();
-    modifiers["over"] = duration;
+  const to = ctx.parseExpression();
+  return { owner, property, from, to };
+}
+function parseTransitionProperty(ctx) {
+  const lead = ctx.peek();
+  if (!lead || isKeyword(lead, [KEYWORDS.TO, "from"])) {
+    throw new Error("Transition command requires a CSS property");
   }
-  if (ctx.check(KEYWORDS.WITH)) {
+  const expr = ctx.parseExpression();
+  const split = splitStyleExpression(expr);
+  if (split)
+    return { owner: split.owner, property: propertyNode(split.name, lead, ctx) };
+  let name = "";
+  if (ctx.check("*")) {
+    name = "*";
     ctx.advance();
-    const timingFunction = ctx.parsePrimary();
-    modifiers["with"] = timingFunction;
   }
-  return CommandNodeBuilder.from(commandToken).withArgs(...args).withModifiers(modifiers).endingAt(ctx.getPosition()).build();
+  const hyphenated = parseHyphenatedName(ctx);
+  if (!hyphenated)
+    throw new Error("Transition command requires a CSS property");
+  return { owner: expr, property: propertyNode(name + hyphenated, lead, ctx) };
+}
+function splitStyleExpression(node) {
+  const n = node;
+  switch (n.type) {
+    case "selector":
+      return typeof n.value === "string" && n.value.startsWith("*") ? { owner: null, name: n.value } : null;
+    case "identifier":
+      return typeof n.name === "string" && !CONTEXT_REFS.has(n.name) ? { owner: null, name: n.name } : null;
+    case "possessiveExpression":
+    case "memberExpression":
+      return !n.computed && n.object && typeof n.property?.name === "string" ? { owner: n.object, name: n.property.name } : null;
+    case "binaryExpression": {
+      if (n.operator !== "of" || !n.left || !n.right)
+        return null;
+      const inner = splitStyleExpression(n.left);
+      return inner && !inner.owner ? { owner: n.right, name: inner.name } : null;
+    }
+    case "propertyOfExpression":
+      return n.target && typeof n.property?.name === "string" ? { owner: n.target, name: n.property.name } : null;
+    default:
+      return null;
+  }
+}
+function propertyNode(name, lead, ctx) {
+  return {
+    type: "string",
+    value: name,
+    start: lead.start || 0,
+    end: ctx.getPosition().end,
+    line: lead.line,
+    column: lead.column
+  };
+}
+function startsAnotherPair(ctx) {
+  if (ctx.isAtEnd() || isComment(ctx.peek()))
+    return false;
+  if (isKeyword(ctx.peek(), ["over", "using", KEYWORDS.WITH]))
+    return false;
+  return !isCommandBoundary(ctx, ["catch", "finally", "on"]);
+}
+function pairsNode(pairs) {
+  const field = (name, value) => ({
+    key: {
+      type: "identifier",
+      name,
+      start: value.start,
+      end: value.end,
+      line: value.line,
+      column: value.column
+    },
+    value
+  });
+  const elements = pairs.map((pair) => {
+    const properties = [field("property", pair.property), field("to", pair.to)];
+    if (pair.owner)
+      properties.push(field("owner", pair.owner));
+    if (pair.from)
+      properties.push(field("from", pair.from));
+    return {
+      type: "objectLiteral",
+      properties,
+      start: (pair.owner ?? pair.property).start,
+      end: pair.to.end,
+      line: (pair.owner ?? pair.property).line,
+      column: (pair.owner ?? pair.property).column
+    };
+  });
+  const firstEl = elements[0];
+  const lastEl = elements[elements.length - 1];
+  return {
+    type: "arrayLiteral",
+    elements,
+    start: firstEl.start,
+    end: lastEl.end,
+    line: firstEl.line,
+    column: firstEl.column
+  };
 }
 function parseStartCommand(ctx, identifierNode) {
   if (!ctx.match("view")) {
@@ -2354,11 +2490,15 @@ function parseSwapCommand(ctx, identifierNode) {
   const targetExpr = isDelete ? ctx.parseExpression() : parseOneArgument(ctx, [KEYWORDS.WITH]);
   if (targetExpr)
     args.push(targetExpr);
-  if (!isDelete && consumeOptionalKeyword(ctx, KEYWORDS.WITH)) {
+  const isMorph = identifierNode.name === "morph";
+  if (!isDelete && (consumeOptionalKeyword(ctx, KEYWORDS.WITH) || isMorph && consumeOptionalKeyword(ctx, KEYWORDS.TO))) {
     const contentExpr = parseOneArgument(ctx, ["using"]);
     if (contentExpr)
       modifiers["with"] = contentExpr;
   }
+  if (isMorph && modifiers["with"] === void 0) {
+    ctx.addError("Expected 'to' and the content to morph into");
+  }
   return CommandNodeBuilder.fromIdentifier(identifierNode).withArgs(...args).withModifiers({ ...modifiers, ...parseViewTransitionTail(ctx) }).endingAt(ctx.getPosition()).build();
 }
 function parseShowHideCommand(ctx, identifierNode) {
@@ -3033,6 +3173,8 @@ function atArgumentBoundary(ctx, grammar) {
   const next = ctx.peek();
   if (ctx.checkIsCommand() && ctx.peekAt(1)?.value === "(")
     return false;
+  if (isGluedBeepBang(next, ctx.peekAt(1)))
+    return false;
   if (isCommandBoundary(ctx, ["catch", "finally", "on"]))
     return true;
   return isKeyword(next, [...grammar.markers]);
@@ -3064,10 +3206,11 @@ function parseDeclaredCommand(ctx, commandToken, name, grammar) {
     }
   }
   const commaList = new Set(grammar.commaList ?? []);
+  const namedArgs = new Set(grammar.namedArgs ?? []);
   while (!ctx.isAtEnd() && isKeyword(ctx.peek(), [...grammar.markers])) {
     const keyword = ctx.advance().value;
     const key = ctx.resolveKeyword(keyword).toLowerCase();
-    let value = ctx.parseExpression();
+    let value = namedArgs.has(key) && isNakedNamedArgStart(ctx) ? parseNakedNamedArgs(ctx, () => ctx.parseExpression(), name) : ctx.parseExpression();
     if (value && commaList.has(key) && ctx.check(",")) {
       const elements = [value];
       while (ctx.match(",")) {
@@ -3193,8 +3336,8 @@ function parseFetchCommand(ctx, commandToken) {
     }
     if (ctx.check("with") && !modifiers["with"]) {
       ctx.advance();
-      if (isFetchNakedNamedArgStart(ctx)) {
-        modifiers["with"] = parseFetchNakedNamedArgs(ctx);
+      if (isNakedNamedArgStart(ctx)) {
+        modifiers["with"] = parseNakedNamedArgs(ctx, () => ctx.parsePrimary(), "fetch");
       } else {
         modifiers["with"] = ctx.parsePrimary();
       }
@@ -3226,45 +3369,6 @@ function parseFetchCommand(ctx, commandToken) {
   }
   return builder.build();
 }
-function isFetchNakedNamedArgStart(ctx) {
-  if (ctx.check("{"))
-    return false;
-  if (!ctx.checkIdentifierLike())
-    return false;
-  const next = ctx.peekAt(1);
-  return next !== null && next.value === ":";
-}
-function parseFetchNakedNamedArgs(ctx) {
-  const properties = [];
-  const startPos = ctx.getPosition();
-  do {
-    if (!ctx.checkIdentifierLike())
-      break;
-    const keyToken = ctx.advance();
-    const key = {
-      type: "identifier",
-      name: keyToken.value,
-      start: keyToken.start,
-      end: keyToken.end,
-      line: keyToken.line,
-      column: keyToken.column
-    };
-    ctx.consume(":", "Expected ':' after property name in fetch named arguments");
-    const value = ctx.parsePrimary();
-    if (value) {
-      properties.push({ key, value });
-    }
-  } while (ctx.match(",") && !ctx.isAtEnd());
-  const endPos = ctx.getPosition();
-  return {
-    type: "objectLiteral",
-    properties,
-    start: startPos.start,
-    end: endPos.end,
-    line: startPos.line,
-    column: startPos.column
-  };
-}
 function findJsEndBoundary(ctx, startPos) {
   const input = ctx.getInputSlice(startPos);
   if (!input) {
@@ -3378,6 +3482,7 @@ function parseTellCommand(ctx, identifierNode) {
   const commands = [];
   while (!ctx.isAtEnd()) {
     if (ctx.checkIsCommand()) {
+      const word = ctx.peek().value;
       try {
         ctx.advance();
         const cmd = ctx.parseCommand();
@@ -3386,7 +3491,8 @@ function parseTellCommand(ctx, identifierNode) {
         } else {
           break;
         }
-      } catch {
+      } catch (error) {
+        ctx.addError(`'${word}' in a tell body failed to parse: ${error instanceof Error ? error.message : String(error)}`);
         break;
       }
       if (ctx.match(KEYWORDS.AND) || ctx.match(KEYWORDS.THEN)) {
@@ -3606,6 +3712,84 @@ function isNodeList(value) {
 function isDocumentFragment(value) {
   return value !== null && typeof value === "object" && "nodeType" in value && value.nodeType === 11 && "childNodes" in value;
 }
+function beepValues(me, values) {
+  const outputs = values.map(describeBeepValue);
+  const shown = outputs.filter((output) => announce(me, output.value));
+  if (shown.length === 0)
+    return outputs;
+  console.group("\u{1F514} beep! Debug Output");
+  for (const output of shown) {
+    console.log(`Value:`, output.value);
+    console.log(`Type:`, output.type);
+    console.log(`Representation:`, output.representation);
+    console.log("---");
+  }
+  console.groupEnd();
+  return outputs;
+}
+function announce(me, value) {
+  const target = me;
+  if (typeof CustomEvent !== "function" || typeof target?.dispatchEvent !== "function")
+    return true;
+  return target.dispatchEvent(new CustomEvent("hyperscript:beep", {
+    bubbles: true,
+    cancelable: true,
+    detail: { element: me, value }
+  }));
+}
+function describeBeepValue(value) {
+  return { value, type: typeOf(value), representation: representationOf(value) };
+}
+function typeOf(value) {
+  if (value === null)
+    return "null";
+  if (value === void 0)
+    return "undefined";
+  if (Array.isArray(value))
+    return "array";
+  if (isHTMLElement$2(value))
+    return "HTMLElement";
+  if (typeof Element !== "undefined" && value instanceof Element)
+    return "Element";
+  if (typeof Node !== "undefined" && value instanceof Node)
+    return "Node";
+  if (value instanceof Error)
+    return "Error";
+  if (value instanceof Date)
+    return "Date";
+  if (value instanceof RegExp)
+    return "RegExp";
+  return typeof value;
+}
+function representationOf(value) {
+  if (value === null)
+    return "null";
+  if (value === void 0)
+    return "undefined";
+  if (Array.isArray(value)) {
+    return `Array(${value.length}) [${value.slice(0, 3).map((v2) => representationOf(v2)).join(", ")}${value.length > 3 ? "..." : ""}]`;
+  }
+  if (isHTMLElement$2(value)) {
+    const el = value;
+    const tag = el.tagName.toLowerCase();
+    const id = el.id ? `#${el.id}` : "";
+    const classes = el.className ? `.${el.className.split(" ").join(".")}` : "";
+    return `<${tag}${id}${classes}/>`;
+  }
+  if (value instanceof Error)
+    return `Error: ${value.message}`;
+  if (typeof value === "string")
+    return value.length > 50 ? `"${value.substring(0, 47)}..."` : `"${value}"`;
+  if (typeof value === "object") {
+    try {
+      const keys = Object.keys(value);
+      return `Object {${keys.slice(0, 3).join(", ")}${keys.length > 3 ? "..." : ""}}`;
+    } catch {
+      return "[Object]";
+    }
+  }
+  return String(value);
+}
 function convertToNumber(value) {
   if (value === null || value === void 0) {
     return 0;
@@ -3637,6 +3821,16 @@ function convertToNumber(value) {
   }
   return 0;
 }
+function counterAmount(value) {
+  return typeof value === "number" ? value : parseFloat(String(value));
+}
+function counterValue(value) {
+  if (isHTMLElement$2(value)) {
+    const element = value;
+    return counterValue(element.value || element.textContent);
+  }
+  return value ? counterAmount(value) : 0;
+}
 function getVariableValue(name, context, preferredScope) {
   if (preferredScope === "element") {
     return getElementVar(context, name);
@@ -3738,32 +3932,36 @@ function setElementPropertyValue(propertyPath, value, context) {
     element[property] = value;
   }
 }
+function isObjectOwner(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !isHTMLElement$2(value);
+}
 function getCurrentNumericValue(target, property, scope, context) {
   if (typeof target === "number") {
     return target;
   }
   if (isHTMLElement$2(target)) {
     const element = target;
+    if (property?.startsWith("@"))
+      return counterValue(element.getAttribute(property.slice(1)));
     if (property) {
       if (property.startsWith("data-") || ["id", "class", "title", "alt", "src", "href"].includes(property)) {
-        const value = element.getAttribute(property);
-        return convertToNumber(value);
+        return counterValue(element.getAttribute(property));
       } else {
-        const value = element[property];
-        return convertToNumber(value);
+        return counterValue(element[property]);
       }
     } else {
-      const value = element.value || element.textContent;
-      return convertToNumber(value);
+      return counterValue(element);
     }
   }
+  if (property && isObjectOwner(target)) {
+    return counterValue(target[property]);
+  }
   if (typeof target === "string") {
     if (scope === "element") {
-      return convertToNumber(getVariableValue(target, context, "element"));
+      return counterValue(getVariableValue(target, context, "element"));
     }
     if (scope === "global") {
-      const value2 = getVariableValue(target, context, "global");
-      return convertToNumber(value2);
+      return counterValue(getVariableValue(target, context, "global"));
     }
     if (target.includes(".")) {
       return getElementPropertyValue(target, context);
@@ -3775,14 +3973,17 @@ function getCurrentNumericValue(target, property, scope, context) {
     } else if (target === "you" && context.you) {
       return convertToNumber(context.you.value || 0);
     }
-    const value = getVariableValue(target, context);
-    return convertToNumber(value);
+    return counterValue(getVariableValue(target, context));
   }
-  return convertToNumber(target);
+  return counterValue(target);
 }
 function setTargetValue(target, property, scope, newValue, context) {
   if (isHTMLElement$2(target)) {
     const element = target;
+    if (property?.startsWith("@")) {
+      element.setAttribute(property.slice(1), String(newValue));
+      return;
+    }
     if (property) {
       if (property.startsWith("data-") || ["id", "class", "title", "alt", "src", "href"].includes(property)) {
         element.setAttribute(property, String(newValue));
@@ -3798,6 +3999,10 @@ function setTargetValue(target, property, scope, newValue, context) {
     }
     return;
   }
+  if (property && isObjectOwner(target)) {
+    target[property] = newValue;
+    return;
+  }
   if (typeof target === "string") {
     if (scope === "element") {
       setVariableValue(target, newValue, context, "element");
@@ -3886,13 +4091,6 @@ function isFunction(value) {
 function isInputElement$1(el) {
   return el !== null && typeof el === "object" && "tagName" in el && el.tagName === "INPUT";
 }
-function isFormElement$1(el) {
-  if (el === null || typeof el !== "object" || !("tagName" in el)) {
-    return false;
-  }
-  const tag = el.tagName;
-  return tag === "INPUT" || tag === "SELECT" || tag === "TEXTAREA";
-}
 function isHTMLElement$1(el) {
   return el !== null && typeof el === "object" && "nodeType" in el && el.nodeType === 1 && "style" in el;
 }
@@ -5208,11 +5406,12 @@ async function evaluateBinaryExpression(node, context) {
         }
       }
     }
-    if (leftNode?.type === "selector" && leftNode.fromQuery && typeof leftNode.value === "string") {
+    if (leftNode?.type === "selector" && typeof leftNode.value === "string" && (leftNode.fromQuery || operator === "in" && leftNode.value.startsWith("."))) {
       const root = await evaluateAST(node.right, context);
       const scope = root && typeof root.querySelectorAll === "function" ? root : null;
       if (scope) {
-        return Array.from(scope.querySelectorAll(leftNode.value));
+        const query = leftNode.fromQuery ? leftNode.value : escapeSelectorForQuery(leftNode, leftNode.value);
+        return Array.from(scope.querySelectorAll(query));
       }
     }
   }
@@ -5221,6 +5420,12 @@ async function evaluateBinaryExpression(node, context) {
     return getExpr(context, "styleRef").evaluate(context, leftNode.value.slice(1), el);
   }
   if (operator === "of") {
+    if (leftNode?.type === "attributeAccess") {
+      const target = await evaluateAST(node.right, context);
+      if (target == null)
+        return void 0;
+      return getExpr(context, "possessive").evaluate(context, target, `@${leftNode.attributeName}`);
+    }
     const path = propertyPathOf(node.left);
     if (path) {
       const target = await evaluateAST(node.right, context);
@@ -5228,6 +5433,10 @@ async function evaluateBinaryExpression(node, context) {
       for (const seg of path) {
         if (cur == null)
           return void 0;
+        if (isMappableCollection(cur) && !(seg in cur)) {
+          cur = await getExpr(context, "possessive").evaluate(context, cur, seg);
+          continue;
+        }
         cur = isElement(cur) ? getElementProperty$1(cur, seg) : cur[seg];
       }
       return typeof cur === "function" ? cur.bind(target) : cur;
@@ -5252,26 +5461,21 @@ async function evaluateBinaryExpression(node, context) {
   const R = node.ignoringCase ? applyCI(right) : right;
   switch (operator) {
     case "+": {
-      let addLeft = left;
-      let addRight = right;
       if (node.coerceNumeric) {
-        if (typeof addLeft === "string")
-          addLeft = convertToNumber(addLeft);
-        if (typeof addRight === "string")
-          addRight = convertToNumber(addRight);
+        return counterValue(left) + counterAmount(right);
       }
-      if (typeof addLeft === "string" || typeof addRight === "string") {
-        return String(addLeft ?? "") + String(addRight ?? "");
+      if (typeof left === "string" || typeof right === "string") {
+        return String(left ?? "") + String(right ?? "");
       }
-      if (Array.isArray(addLeft)) {
-        return Array.isArray(addRight) ? [...addLeft, ...addRight] : [...addLeft, addRight];
+      if (Array.isArray(left)) {
+        return Array.isArray(right) ? [...left, ...right] : [...left, right];
       }
-      return unwrapTypedResult(await getExpr(context, "addition").evaluate(context, {
-        left: addLeft,
-        right: addRight
-      }));
+      return unwrapTypedResult(await getExpr(context, "addition").evaluate(context, { left, right }));
     }
     case "-":
+      if (node.coerceNumeric) {
+        return counterValue(left) - counterAmount(right);
+      }
       return unwrapTypedResult(await getExpr(context, "subtraction").evaluate(context, { left, right }));
     case "*":
       return unwrapTypedResult(await getExpr(context, "multiplication").evaluate(context, { left, right }));
@@ -5516,15 +5720,14 @@ async function evaluateAttributeAccessNode(node, context) {
   return `@${attributeName}`;
 }
 async function evaluatePropertyOfExpressionNode(node, context) {
-  const propertyNode = node.property;
-  if (propertyNode?.type !== "identifier") {
+  const propertyNode2 = node.property;
+  if (propertyNode2?.type !== "identifier") {
     throw new Error('Property name must be an identifier in "the X of Y" pattern');
   }
-  const propertyName = propertyNode.name;
+  const propertyName = propertyNode2.name;
   const target = await evaluateAST(node.target, context);
-  if (target == null) {
-    throw new Error(`Cannot access property "${propertyName}" of ${target}`);
-  }
+  if (target == null)
+    return void 0;
   return getExpr(context, "possessive").evaluate(context, target, propertyName);
 }
 async function evaluateTemplateLiteralNode(node, context) {
@@ -5640,6 +5843,9 @@ async function evaluateUnaryExpression(node, context) {
     case "not":
     case "!":
       return logicalExpressions.not.evaluate(context, value);
+    case "beep!":
+      beepValues(context.me, [value]);
+      return value;
     case "no":
       return logicalExpressions.no.evaluate(context, value);
     case "-":
@@ -5727,6 +5933,10 @@ async function evaluateCallExpression(node, context) {
     const args = await resolveCallArgs(node.arguments, funcName, context);
     switch (funcName) {
       case "closest":
+        if (node.closestTo) {
+          const start = unwrapElement(await evaluateAST(node.closestTo, context)) ?? null;
+          return referencesExpressions.closest.evaluate(context, args[0], start);
+        }
         return referencesExpressions.closest.evaluate(context, ...args);
       case "previous":
       case "next": {
@@ -6452,6 +6662,73 @@ function parseAttributeWithValue(expression) {
   const result = parseAttribute(expression);
   return { name: result.name, value: result.value ?? "" };
 }
+function _parseDurationComponents(value) {
+  const trimmed = value.trim();
+  const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*(s|ms|sec|seconds?|milliseconds?)?$/i);
+  if (!match) {
+    return null;
+  }
+  const number = parseFloat(match[1]);
+  const unit = (match[2] || "ms").toLowerCase();
+  if (unit === "ms" || unit === "millisecond" || unit === "milliseconds") {
+    return { number, milliseconds: Math.floor(number) };
+  } else if (unit === "s" || unit === "sec" || unit === "second" || unit === "seconds") {
+    return { number, milliseconds: Math.floor(number * 1e3) };
+  }
+  return null;
+}
+function parseDuration(value, defaultMs = 300) {
+  if (typeof value === "number") {
+    return Math.max(0, Math.floor(value));
+  }
+  if (typeof value === "string") {
+    const result = _parseDurationComponents(value);
+    return result ? result.milliseconds : defaultMs;
+  }
+  return defaultMs;
+}
+function parseDurationStrict(value) {
+  if (typeof value === "number") {
+    if (value < 0)
+      throw new Error("Duration must be >= 0");
+    return Math.floor(value);
+  }
+  if (typeof value === "string") {
+    const result = _parseDurationComponents(value);
+    if (!result) {
+      throw new Error(`Invalid duration format: "${value}"`);
+    }
+    return result.milliseconds;
+  }
+  throw new Error(`Invalid duration type: ${typeof value}`);
+}
+function parseCSSDurations(durationString) {
+  if (!durationString || durationString === "none") {
+    return [0];
+  }
+  return durationString.split(",").map((duration) => {
+    const value = parseFloat(duration.trim());
+    if (isNaN(value))
+      return 0;
+    if (duration.includes("s") && !duration.includes("ms")) {
+      return value * 1e3;
+    }
+    return value;
+  });
+}
+function calculateMaxAnimationTime(durations, delays) {
+  let maxTime = 0;
+  for (let i = 0; i < durations.length; i++) {
+    const duration = durations[i] || 0;
+    const delay = delays[i] || 0;
+    const totalTime = duration + delay;
+    maxTime = Math.max(maxTime, totalTime);
+  }
+  return maxTime;
+}
+function camelToKebab(str) {
+  return str.replace(/([A-Z])/g, "-$1").toLowerCase();
+}
 function batchApply(targets, operation) {
   for (const element of targets) {
     operation(element);
@@ -6514,15 +6791,18 @@ function toggleAttribute(element, name, value) {
     }
   }
 }
+function toCssPropertyName(property) {
+  return property.startsWith("--") ? property : camelToKebab(property);
+}
 function batchSetStyles(targets, styles) {
   const entries = Object.entries(styles);
   return batchApplyItems(targets, entries, (element, [property, value]) => {
-    element.style.setProperty(property, value);
+    element.style.setProperty(toCssPropertyName(property), value);
   });
 }
 function batchRemoveStyles(targets, properties) {
   return batchApplyItems(targets, properties, (element, property) => {
-    element.style.removeProperty(property);
+    element.style.removeProperty(toCssPropertyName(property));
   });
 }
 function parseClasses(classValue) {
@@ -6870,73 +7150,6 @@ function removeElement(element) {
   }
   return false;
 }
-function _parseDurationComponents(value) {
-  const trimmed = value.trim();
-  const match = trimmed.match(/^(\d+(?:\.\d+)?)\s*(s|ms|sec|seconds?|milliseconds?)?$/i);
-  if (!match) {
-    return null;
-  }
-  const number = parseFloat(match[1]);
-  const unit = (match[2] || "ms").toLowerCase();
-  if (unit === "ms" || unit === "millisecond" || unit === "milliseconds") {
-    return { number, milliseconds: Math.floor(number) };
-  } else if (unit === "s" || unit === "sec" || unit === "second" || unit === "seconds") {
-    return { number, milliseconds: Math.floor(number * 1e3) };
-  }
-  return null;
-}
-function parseDuration(value, defaultMs = 300) {
-  if (typeof value === "number") {
-    return Math.max(0, Math.floor(value));
-  }
-  if (typeof value === "string") {
-    const result = _parseDurationComponents(value);
-    return result ? result.milliseconds : defaultMs;
-  }
-  return defaultMs;
-}
-function parseDurationStrict(value) {
-  if (typeof value === "number") {
-    if (value < 0)
-      throw new Error("Duration must be >= 0");
-    return Math.floor(value);
-  }
-  if (typeof value === "string") {
-    const result = _parseDurationComponents(value);
-    if (!result) {
-      throw new Error(`Invalid duration format: "${value}"`);
-    }
-    return result.milliseconds;
-  }
-  throw new Error(`Invalid duration type: ${typeof value}`);
-}
-function parseCSSDurations(durationString) {
-  if (!durationString || durationString === "none") {
-    return [0];
-  }
-  return durationString.split(",").map((duration) => {
-    const value = parseFloat(duration.trim());
-    if (isNaN(value))
-      return 0;
-    if (duration.includes("s") && !duration.includes("ms")) {
-      return value * 1e3;
-    }
-    return value;
-  });
-}
-function calculateMaxAnimationTime(durations, delays) {
-  let maxTime = 0;
-  for (let i = 0; i < durations.length; i++) {
-    const duration = durations[i] || 0;
-    const delay = delays[i] || 0;
-    const totalTime = duration + delay;
-    maxTime = Math.max(maxTime, totalTime);
-  }
-  return maxTime;
-}
-function camelToKebab(str) {
-  return str.replace(/([A-Z])/g, "-$1").toLowerCase();
-}
 function detectSmartElementType(elements) {
   if (elements.length === 0)
     return null;
@@ -7221,13 +7434,13 @@ async function resolveAnyPropertyTarget(node, evaluator, context) {
   const anyNode = node;
   if (anyNode?.type === "possessiveExpression" || anyNode?.type === "memberExpression") {
     const objectNode = anyNode.object;
-    const propertyNode = anyNode.property;
+    const propertyNode2 = anyNode.property;
     let element = await evaluator.evaluate(objectNode, context);
     if (Array.isArray(element))
       element = element[0];
     if (!isHTMLElement$2(element))
       return null;
-    const propertyName = propertyNode?.name || propertyNode?.value;
+    const propertyName = propertyNode2?.name || propertyNode2?.value;
     if (!propertyName)
       return null;
     return { element, property: propertyName };
@@ -7323,6 +7536,19 @@ function detectExpressionType(firstValue, firstArg) {
   }
   return { type: "class", expression: "" };
 }
+function arrayFragment(items) {
+  const fragment = document.createDocumentFragment();
+  for (const item of items) {
+    if (isInsertableNode(item)) {
+      fragment.append(item);
+      continue;
+    }
+    const template = document.createElement("template");
+    template.innerHTML = item === null ? "" : String(item);
+    fragment.append(template.content);
+  }
+  return fragment;
+}
 function escapeHtml(value) {
   return value.replace(/[&<>"']/g, (c) => HTML_ESCAPE[c]);
 }
@@ -7653,10 +7879,28 @@ function withViewTransition(callback, options) {
     drain().catch(reject);
   });
 }
+function loneRootWithTag(content, tagName) {
+  let root;
+  if (typeof content === "string") {
+    const template = document.createElement("template");
+    template.innerHTML = content;
+    root = template.content.firstElementChild;
+    if (!root || root.nextElementSibling)
+      return null;
+  } else {
+    root = content.cloneNode(true);
+  }
+  return root.tagName === tagName && isHTMLElement$2(root) ? root : null;
+}
 function executeSwap(target, content, strategy, morphOptions) {
   const contentStr = content !== null && !isHTMLElement$2(content) ? content : "";
   const contentEl = isHTMLElement$2(content) ? content : null;
   switch (strategy) {
+    case "morphMerge": {
+      const root = content !== null ? loneRootWithTag(content, target.tagName) : null;
+      executeSwap(target, root ?? content, root ? "morphOuter" : "morph", morphOptions);
+      break;
+    }
     case "morph":
       if (content !== null) {
         try {
@@ -8415,6 +8659,19 @@ async function resolveWriteTarget(node, evaluator, context, options) {
     }
     return { kind: "property", target: property };
   }
+  if (options.ofAndObjectProperty) {
+    const access = ofOrPossessiveAccess(n);
+    if (access) {
+      const owner = await evaluator.evaluate(access.owner, context);
+      const element = Array.isArray(owner) ? owner[0] : owner;
+      if (access.isOf && isHTMLElement$2(element)) {
+        return { kind: "property", target: { element, property: access.name } };
+      }
+      if (isObjectOwner(owner)) {
+        return { kind: "member", container: owner, property: access.name };
+      }
+    }
+  }
   if (options.bareReference && (nodeType === "identifier" || nodeType === "variable" || nodeType === "symbol") && typeof n.name === "string") {
     const rawScope = n.scope;
     const scope = rawScope === "element" || rawScope === "global" ? rawScope : void 0;
@@ -8422,6 +8679,13 @@ async function resolveWriteTarget(node, evaluator, context, options) {
   }
   return null;
 }
+function ofOrPossessiveAccess(n) {
+  const [owner, property, isOf] = n.type === "possessiveExpression" ? [n.object, n.property, false] : n.type === "propertyOfExpression" ? [n.target, n.property, false] : n.type === "binaryExpression" && n.operator === "of" ? [n.right, n.left, true] : [void 0, void 0, false];
+  const name = property?.name;
+  if (!owner || typeof name !== "string" || !/^[A-Za-z_$][\w$]*$/.test(name))
+    return null;
+  return { owner, name, isOf };
+}
 function toSetInput(target, value) {
   switch (target.kind) {
     case "node-write":
@@ -8442,6 +8706,13 @@ function toSetInput(target, value) {
         property: target.target.property,
         value
       };
+    case "member":
+      return {
+        type: "member-assignment",
+        container: target.container,
+        property: target.property,
+        value
+      };
     default:
       throw new Error(`set: unrequested write-target rung '${target.kind}'`);
   }
@@ -8451,12 +8722,24 @@ function getNodeType(node) {
     return "unknown";
   return node.type || "unknown";
 }
+function propertyTarget(node) {
+  const n = node;
+  const owner = n.type === "propertyOfExpression" ? n.target : n.type === "possessiveExpression" || n.type === "memberExpression" || n.type === "propertyAccess" ? n.object : void 0;
+  if (!owner || n.computed)
+    return null;
+  const p = n.property;
+  const name = typeof p === "string" ? p : typeof p?.name === "string" ? p.name : void 0;
+  if (!name || !/^[A-Za-z_$][\w$-]*$/.test(name))
+    return null;
+  return { owner, name };
+}
 async function parseNumericTargetInput(raw, evaluator, context, commandName) {
   if (!raw.args || raw.args.length === 0) {
     throw new Error(`${commandName} command requires a target`);
   }
   const targetArg = raw.args[0];
   let target;
+  let property;
   let extractedScope;
   let customWrite;
   const nodeType = getNodeType(targetArg);
@@ -8469,7 +8752,20 @@ async function parseNumericTargetInput(raw, evaluator, context, commandName) {
     target = targetArg.value;
   } else {
     const writer = getRegisteredNodeWriter(nodeType);
-    if (writer) {
+    const attribute = writer ? null : await resolveAttributeWriteTarget(targetArg, evaluator, context, async () => context.me ? [context.me] : []);
+    const prop = writer || attribute ? null : propertyTarget(targetArg);
+    const owner = prop ? await evaluator.evaluate(prop.owner, context) : void 0;
+    const ownerElement = Array.isArray(owner) ? owner[0] : owner;
+    if (attribute?.elements[0]) {
+      target = attribute.elements[0];
+      property = `@${attribute.name}`;
+    } else if (prop && isHTMLElement$2(ownerElement)) {
+      target = ownerElement;
+      property = prop.name;
+    } else if (prop && isObjectOwner(owner)) {
+      target = owner;
+      property = prop.name;
+    } else if (writer) {
       const currentRaw = await evaluator.evaluate(targetArg, context);
       const currentValue = typeof currentRaw === "number" ? currentRaw : currentRaw == null ? 0 : Number(currentRaw) || 0;
       target = currentValue;
@@ -8498,24 +8794,20 @@ async function parseNumericTargetInput(raw, evaluator, context, commandName) {
       const evaluated = await evaluator.evaluate(arg, context);
       if (typeof evaluated === "number") {
         amount = evaluated;
+      } else if (evaluated == null) {
+        amount = NaN;
       }
     }
   }
   const byModifier = raw.modifiers?.by;
   if (byModifier) {
-    const byValue = byModifier.value;
-    if (getNodeType(byModifier) === "literal" && typeof byValue === "number") {
-      amount = byValue;
-    } else if (getNodeType(byModifier) !== "literal") {
-      const evaluated = await evaluator.evaluate(byModifier, context);
-      if (typeof evaluated === "number") {
-        amount = evaluated;
-      }
-    }
+    const value = getNodeType(byModifier) === "literal" ? byModifier.value : await evaluator.evaluate(byModifier, context);
+    amount = counterAmount(value);
   }
   return {
     target,
     amount,
+    ...property && { property },
     ...scope && { scope },
     ...customWrite && { customWrite }
   };
@@ -8722,7 +9014,10 @@ function createUntilLoopConfig(conditionExpr, evaluateCondition2, context, index
   };
   const config2 = {
     type: "until",
-    shouldContinue: () => !evaluateCondition2(conditionExpr, context)
+    shouldContinue: () => {
+      const met = evaluateCondition2(conditionExpr, context);
+      return met instanceof Promise ? met.then((value) => !value) : !met;
+    }
   };
   return { config: config2, iterCtx };
 }
@@ -8757,7 +9052,7 @@ function createForeverLoopConfig(indexVariable, maxIterations = 1e4) {
   };
   return { config: config2, iterCtx };
 }
-async function slotText(node, evaluator, context) {
+async function slotText$1(node, evaluator, context) {
   if (!node)
     return void 0;
   const n = node;
@@ -8770,6 +9065,18 @@ async function slotText(node, evaluator, context) {
   const v2 = await evaluator.evaluate(node, context);
   return typeof v2 === "string" ? v2 : void 0;
 }
+function isEventTarget(value) {
+  return typeof value?.addEventListener === "function";
+}
+async function evaluateLoopCondition(condition, context) {
+  if (typeof condition === "function")
+    return Boolean(await condition());
+  return evaluateCondition(condition, context);
+}
+function loopCount(value) {
+  const count = Number(value);
+  return Number.isNaN(count) ? 0 : count;
+}
 function createPseudoCommand() {
   return new PseudoCommand();
 }
@@ -8805,6 +9112,28 @@ function namedPropertyOf(node) {
   }
   return null;
 }
+function elementsOf(value) {
+  if (Array.isArray(value) || isNodeList(value)) {
+    return Array.from(value).filter(isHTMLElement$2);
+  }
+  return isHTMLElement$2(value) ? [value] : [];
+}
+async function valueOf(node, evaluator, context) {
+  const value = await evaluator.evaluate(node, context);
+  const name = node.name;
+  if (value === void 0 && node.type === "identifier" && typeof name === "string")
+    return name;
+  return value;
+}
+function longestTransitionMs(css) {
+  let longest;
+  for (const item of css.split(",")) {
+    const times = [...item.matchAll(/(\d*\.?\d+)(ms|s)\b/g)].map((m) => parseFloat(m[1]) * (m[2] === "s" ? 1e3 : 1));
+    if (times.length > 0)
+      longest = Math.max(longest ?? 0, times[0] + (times[1] ?? 0));
+  }
+  return longest;
+}
 function scopedVariableTarget(node) {
   if (node?.["type"] !== "contextReference")
     return null;
@@ -9603,6 +9932,14 @@ function convertNode(node, infer) {
         ...pos(node)
       };
     case "identifier":
+      if (node.scope === "element" || node.scope === "local" || node.scope === "global") {
+        return {
+          type: "variable",
+          name: node.name ?? "",
+          scope: node.scope,
+          ...pos(node)
+        };
+      }
       return {
         type: "identifier",
         value: node.name ?? node.value ?? "",
@@ -9625,6 +9962,15 @@ function convertNode(node, infer) {
         operand: convertNode(node.argument ?? node.operand, infer),
         ...pos(node)
       };
+    case "typeCheckExpression":
+      return {
+        type: "typeCheck",
+        value: convertNode(node.value, infer),
+        typeName: String(node.typeName),
+        nullOk: node.nullOk !== false,
+        negated: node.negated === true,
+        ...pos(node)
+      };
     case "timeExpression":
       return { type: "literal", value: node.value, ...pos(node) };
     case "templateLiteral":
@@ -9636,6 +9982,28 @@ function convertNode(node, infer) {
         scope: node.scope ?? "local",
         ...pos(node)
       };
+    case "arrayLiteral":
+      return {
+        type: "array",
+        elements: (node.elements ?? []).map((element) => convertNode(element, infer)),
+        ...pos(node)
+      };
+    case "attributeAccess":
+      return {
+        type: "possessive",
+        object: { type: "identifier", value: "me" },
+        property: `@${node.attributeName}`,
+        ...pos(node)
+      };
+    case "propertyOfExpression": {
+      const property = node.property;
+      return {
+        type: "possessive",
+        object: convertNode(node.target, infer),
+        property: property?.name ?? property?.value ?? "",
+        ...pos(node)
+      };
+    }
     case "htmlSelector":
       return {
         type: "selector",
@@ -9686,6 +10054,18 @@ function convertCommand$1(node, infer) {
   if (name === "repeat") {
     return convertRepeatCommand(node, infer);
   }
+  const original = node.originalCommand;
+  const sum = node.modifiers?.to;
+  const counted = node.args?.[0];
+  if (name === "set" && (original === "increment" || original === "decrement") && sum?.type === "binaryExpression" && counted) {
+    return convertCommand$1({
+      ...node,
+      name: original,
+      args: [counted],
+      modifiers: { by: sum.right },
+      originalCommand: void 0
+    }, infer);
+  }
   const args = (node.args ?? []).map((arg) => convertNode(arg, infer));
   const target = node.target ? convertNode(node.target, infer) : void 0;
   const modifiers = node.modifiers ? convertModifiers(node.modifiers, infer) : void 0;
@@ -9727,6 +10107,64 @@ function convertIfCommand(node, infer) {
   };
 }
 function convertRepeatCommand(node, infer) {
+  const slots = node.modifiers ?? {};
+  const form = slotText(slots.loopType);
+  if (form === void 0)
+    return convertPositionalRepeat(node, infer);
+  const [bodyBlock, elseBlock] = node.args ?? [];
+  const body = extractBlockCommands(bodyBlock, infer);
+  const indexName = slotText(slots.index);
+  const shared = {
+    ...indexName ? { indexName } : {},
+    ...elseBlock ? { elseBody: extractBlockCommands(elseBlock, infer) } : {},
+    ...pos(node)
+  };
+  const operand = (slot) => slot ? convertNode(slot, infer) : void 0;
+  switch (form) {
+    case "for":
+      return {
+        type: "foreach",
+        itemName: slotText(slots.for) ?? "it",
+        collection: operand(slots.in) ?? { type: "literal", value: null },
+        body,
+        ...shared
+      };
+    case "times":
+      return { type: "repeat", count: operand(slots.times), body, ...shared };
+    case "while":
+    case "until": {
+      const test = operand(slots[form]) ?? { type: "literal", value: form === "until" };
+      return {
+        type: "while",
+        condition: form === "until" ? { type: "unary", operator: "not", operand: test } : test,
+        ...slots.bottomTested?.value === true ? { bottomTested: true } : {},
+        body,
+        ...shared
+      };
+    }
+    case "until-event": {
+      const event = slotText(slots.event);
+      if (!event) {
+        return { type: "error", message: "'repeat until event' has no event name", ...pos(node) };
+      }
+      const target = operand(slots.from);
+      return {
+        type: "repeat",
+        untilEvent: event,
+        ...target ? { untilEventTarget: target } : {},
+        body,
+        ...shared
+      };
+    }
+    default:
+      return { type: "repeat", body, ...shared };
+  }
+}
+function slotText(slot) {
+  const text = slot?.value ?? slot?.name;
+  return typeof text === "string" ? text : void 0;
+}
+function convertPositionalRepeat(node, infer) {
   const args = node.args ?? [];
   if (args.length === 0) {
     return { type: "repeat", body: [], ...pos(node) };
@@ -9846,13 +10284,13 @@ function buildEventModifiers(node) {
     ...node.selector && !node.from ? { from: node.selector } : {}
   };
 }
-function extractBlockCommands(block, infer) {
-  if (!block)
+function extractBlockCommands(block2, infer) {
+  if (!block2)
     return [];
-  if (block.type === "block") {
-    return (block.commands ?? []).map((cmd) => convertNode(cmd, infer));
+  if (block2.type === "block") {
+    return (block2.commands ?? []).map((cmd) => convertNode(cmd, infer));
   }
-  return [convertNode(block, infer)];
+  return [convertNode(block2, infer)];
 }
 function inferRoles(name, args, modifiers, target, infer) {
   const roles = {};
@@ -10012,6 +10450,15 @@ function toCoreAST(node) {
         prefix: true,
         ...nodePos(node)
       };
+    case "typeCheck":
+      return {
+        type: "typeCheckExpression",
+        value: toCoreAST(node.value),
+        typeName: node.typeName,
+        nullOk: node.nullOk,
+        negated: node.negated,
+        ...nodePos(node)
+      };
     case "member":
       return {
         type: "memberExpression",
@@ -10020,6 +10467,12 @@ function toCoreAST(node) {
         computed: node.computed ?? false,
         ...nodePos(node)
       };
+    case "array":
+      return {
+        type: "arrayLiteral",
+        elements: node.elements.map((element) => toCoreAST(element)),
+        ...nodePos(node)
+      };
     case "possessive":
       return {
         type: "possessiveExpression",
@@ -10079,67 +10532,79 @@ function convertCommand(node) {
   }
   return result;
 }
+function block(nodes) {
+  return { type: "block", commands: nodes.map((n) => toCoreAST(n)), ...POS };
+}
 function convertIf(node) {
-  const result = {
+  const [elseIf, ...laterElseIfs] = node.elseIfBranches ?? [];
+  const elseBranch = elseIf ? [
+    {
+      type: "if",
+      condition: elseIf.condition,
+      thenBranch: elseIf.body,
+      elseIfBranches: laterElseIfs,
+      ...node.elseBranch ? { elseBranch: node.elseBranch } : {}
+    }
+  ] : node.elseBranch;
+  return {
     type: "command",
     name: "if",
     isBlocking: true,
-    condition: toCoreAST(node.condition),
-    thenBranch: node.thenBranch.map((n) => toCoreAST(n)),
-    args: [],
+    args: [
+      toCoreAST(node.condition),
+      block(node.thenBranch),
+      ...elseBranch ? [block(elseBranch)] : []
+    ],
     ...nodePos(node)
   };
-  if (node.elseBranch) {
-    result.elseBranch = node.elseBranch.map((n) => toCoreAST(n));
-  }
-  return result;
 }
-function convertRepeat(node) {
-  const result = {
+function loopCommand(node, form, operands) {
+  const modifiers = { loopType: slotString(form) };
+  for (const [slot, value] of Object.entries(operands)) {
+    if (value)
+      modifiers[slot] = value;
+  }
+  if (node.indexName)
+    modifiers.index = slotString(node.indexName);
+  return {
     type: "command",
     name: "repeat",
     isBlocking: true,
-    body: node.body.map((n) => toCoreAST(n)),
-    args: [],
+    args: [block(node.body), ...node.elseBody ? [block(node.elseBody)] : []],
+    modifiers,
     ...nodePos(node)
   };
+}
+function slotString(value) {
+  return { type: "string", value, ...POS };
+}
+function convertRepeat(node) {
   if (node.count !== void 0) {
-    result.count = typeof node.count === "number" ? { type: "literal", value: node.count, raw: String(node.count), ...POS } : toCoreAST(node.count);
-    result.loopVariant = "times";
-  } else if (node.whileCondition !== void 0) {
-    result.condition = toCoreAST(node.whileCondition);
-    result.loopVariant = "while";
-  } else if (node.untilEvent !== void 0) {
-    result.untilEvent = node.untilEvent;
-    result.loopVariant = "until";
+    const times = typeof node.count === "number" ? { type: "literal", value: node.count, raw: String(node.count), ...POS } : toCoreAST(node.count);
+    return loopCommand(node, "times", { times });
   }
-  return result;
+  if (node.whileCondition !== void 0) {
+    return loopCommand(node, "while", { while: toCoreAST(node.whileCondition) });
+  }
+  if (node.untilEvent !== void 0) {
+    return loopCommand(node, "until-event", {
+      event: slotString(node.untilEvent),
+      from: node.untilEventTarget ? toCoreAST(node.untilEventTarget) : void 0
+    });
+  }
+  return loopCommand(node, "forever", {});
 }
 function convertForEach(node) {
-  return {
-    type: "command",
-    name: "repeat",
-    isBlocking: true,
-    loopVariant: "for",
-    itemName: node.itemName,
-    ...node.indexName ? { indexName: node.indexName } : {},
-    collection: toCoreAST(node.collection),
-    body: node.body.map((n) => toCoreAST(n)),
-    args: [],
-    ...nodePos(node)
-  };
+  return loopCommand(node, "for", {
+    for: slotString(node.itemName),
+    in: toCoreAST(node.collection)
+  });
 }
 function convertWhile(node) {
-  return {
-    type: "command",
-    name: "repeat",
-    isBlocking: true,
-    loopVariant: "while",
-    condition: toCoreAST(node.condition),
-    body: node.body.map((n) => toCoreAST(n)),
-    args: [],
-    ...nodePos(node)
-  };
+  return loopCommand(node, "while", {
+    while: toCoreAST(node.condition),
+    bottomTested: node.bottomTested ? { type: "literal", value: true, raw: "true", ...POS } : void 0
+  });
 }
 function flattenEventModifiers(modifiers) {
   if (!modifiers)
@@ -10258,7 +10723,7 @@ async function semanticNodeToRuntimeAST(node) {
   const fw = await getFramework();
   return fw.semanticNodeToRuntimeAST(node);
 }
-var COMMAND_NAMES, COMMAND_MANIFEST, KEYWORDS, COMMAND_TERMINATORS, COMMANDS, CONTROL_FLOW_COMMANDS, PUT_OPERATIONS, PUT_OPERATION_KEYWORDS, HYPERSCRIPT_KEYWORDS, CommandClassification, CSS_FUNCTIONS, CONTEXT_VARS, LOGICAL_OPERATORS, COMPARISON_OPERATORS, DOM_EVENTS, TOKENIZER_KEYWORDS, TokenKind, MATHEMATICAL_OPERATORS, TIME_UNITS, isDebugEnabled$1, DEBUG, debug, STOP_TOKENS, STOP_DELIMITERS, CORE_FRAGMENT, PARSER_COMPARISON_FRAGMENT, ASSIGNMENT_FRAGMENT, PARSER_TABLE, GLOBAL_WRITE_HOOKS, GLOBAL_READ_HOOKS, LOCAL_WRITE_HOOKS, LOCAL_READ_HOOKS, FEATURE_REGISTRY, NODE_EVALUATORS, NODE_WRITERS, ParserExtensionRegistry, SINGLETON, WINDOW_KEY, DEFAULT_BOUNDARY_KEYWORDS, CommandNodeBuilder, OPERAND_INTRODUCERS, CONTEXT_POSSESSIVES, SWAP_STRATEGY_KEYWORDS, ELEMENT_PRONOUNS, GO_POSITIONS, SCROLL_BY_SCAN_BOUNDARY, SCROLL_POSITIONS, SCROLL_DIRECTIONS, SCROLL_STOP, COMPOUND_COMMAND_PARSERS, COMPOUND_COMMAND_NAMES, GENERIC_FALLBACK_GRAMMAR, URL_HARD_STOPS, NONE, ONE_EXPR, BEEP, COMMAND_GRAMMAR, PLUGIN_COMMAND_GRAMMAR, STRING_POSTFIX_UNITS, TIME_POSTFIX_UNITS, STRING_POSTFIX_BP, Parser, HookRegistry, sharedGlobals, elementScopes, ExpressionTypeRegistry, expressionTypeRegistry, BOOLEAN_ATTRIBUTES, SPECIAL_DOM_PROPERTIES, NUMBER_WORDS, conversionConfig, defaultConversions, TYPE_ALIASES, asExpression, isExpression, asyncExpression, conversionExpressions, meExpression, youExpression, itExpression, itsExpression$1, resultExpression, querySelectorExpression, querySelectorAllExpression, idExpression, classExpression, closestExpression, parentExpression, windowExpression, documentExpression, elementWithSelectorExpression, styleRefExpression, possessiveStyleRefExpression, ofStyleRefExpression, referencesExpressions, isProduction, skipValidation, addDescribeToValidator, v, LRUCache, HyperscriptCache, globalCache, PerformanceTracker, performanceTracker, cleanupInterval, ComparisonInputSchema, PatternMatchingInputSchema, equalsExpression, strictEqualsExpression, notEqualsExpression, strictNotEqualsExpression, lessThanExpression, lessThanOrEqualExpression, greaterThanExpression, greaterThanOrEqualExpression, andExpression, orExpression, notExpression, isEmptyExpression, noExpression, isNotEmptyExpression, existsExpression, doesNotExistExpression, containsExpression, doesNotContainExpression, startsWithExpression, endsWithExpression, betweenExpression, matchesExpression, hasExpression, doesNotHaveExpression, logicalExpressions, UNSAFE_PROPS, possessiveExpression, myExpression, itsExpression, yourExpression, ofExpression, attributeExpression, attributeWithValueExpression, classReferenceExpression, idReferenceExpression, propertiesExpressions, EVALUABLE_KINDS, EVALUABLE_KIND_SET, NotSyncEvaluable, SYNC_EVALUABLE_KINDS, SYNC_EVALUABLE_KIND_SET, cachedFullRegistry, RAW_ARG_BUILTINS, CSS_PSEUDO_CLASSES, PSEUDO_CLASS_COLON_RE, BARE_REF_ESCAPE_RE, QUERY_REF_INTERP_RE, CleanupRegistry, EventSourceRegistry, canonicalEvaluator, CommandAdapterV2, CommandRegistryV2, defaultRegistry, RegistryIntegration, StrayControlFlowError, eventRecursionDepth, RuntimeBase, BaseExpressionImpl, StringLiteralInputSchema, NumberLiteralInputSchema, BooleanLiteralInputSchema, BinaryOperationInputSchema, StringLiteralExpression, NumberLiteralExpression, BooleanLiteralExpression, StringConcatenationExpression, specialExpressions, AdditionExpression, SubtractionExpression, MultiplicationExpression, DivisionExpression, ModuloExpression, PowerExpression, mathematicalExpressions, firstExpression, lastExpression, atExpression, nextExpression, previousExpression, DOCUMENT_POSITION_PRECEDING, DOCUMENT_POSITION_FOLLOWING, nextWithinExpression, previousWithinExpression, positionalExpressions, index$1, VisibilityCommandBase, HideCommand, createHideCommand, ShowCommand, createShowCommand, SMART_ELEMENT_TAGS, DOMModificationBase, AddCommand, createAddCommand, positionMap, RemoveCommand, createRemoveCommand, PATTERN, BOOL_PROPS, isPropertyOfExpressionNode, isPropertyAccessNode, ToggleCommand, createToggleCommand, PutCommand, createPutCommand, HTML_ESCAPE, MakeCommand, createMakeCommand, EmptyCommand, createEmptyCommand, OpenCommand, createOpenCommand, CloseCommand, createCloseCommand, SelectCommand, createSelectCommand, ResetCommand, createResetCommand, SUPPORTS_MOVE_BEFORE, ELEMENT_NODE_TYPE, TEXT_NODE_TYPE, IS_PARENT_NODE_TYPE, Operation, candidateNodes, candidateElements, candidateElementsWithIds, unmatchedNodes, unmatchedElements, whitespaceNodes, _idArrayMap, _idSetMap, _options, _Morph_instances, morphOneToMany_fn, morphOneToOne_fn, morphMatchingElements_fn, morphNonMatchingElements_fn, morphOtherNode_fn, visitAttributes_fn, visitTextArea_fn, replaceNode_fn, removeNode_fn, mapIdArraysForEach_fn, mapIdArrays_fn, mapIdSets_fn, Morph, morphAdapter, queue, processing, STRATEGY_KEYWORDS, SwapCommand, MorphCommand, createSwapCommand, createMorphCommand, CRITICAL_LAYOUT_ELEMENTS, STRUCTURAL_SEMANTIC_ELEMENTS, WARNING_ELEMENTS, DEFAULT_VALIDATION_CONFIG, globalConfig, STYLES, SEVERITY_ICONS, SEVERITY_LABELS, STRATEGY_MAP, ProcessPartialsCommand, createProcessPartialsCommand, WaitCommand, createWaitCommand, customResponseTypes, DEFAULT_FETCH_THROWS_ON, fetchThrowsOnPatterns, FetchCommand, createFetchCommand, SetCommand, createSetCommand, GetCommand, createGetCommand, NumericModifyCommand, createIncrementCommand, ClearCommand, createClearCommand, LogCommand, createLogCommand, EventDispatchCommand, createTriggerCommand, GoCommand, createGoCommand, HistoryCommand, createPushUrlCommand, ScrollCommand, createScrollCommand, ConditionalCommand, createConditionalCommand, createIfCommand, RepeatCommand, createRepeatCommand, ControlFlowSignalBase, BreakCommand, createBreakCommand, ContinueCommand, createContinueCommand, HaltCommand, createHaltCommand, ReturnCommand, createReturnCommand, ExitCommand, createExitCommand, ThrowCommand, createThrowCommand, CallCommand, createCallCommand, FocusCommand, createFocusCommand, BlurCommand, createBlurCommand, PseudoCommand, ContentInsertionCommand, AppendCommand, createAppendCommand, PrependCommand, createPrependCommand, TransitionCommand, createTransitionCommand, MeasureCommand, createMeasureCommand, SettleCommand, createSettleCommand, StartViewTransitionCommand, createStartViewTransitionCommand, TakeCommand, createTakeCommand, JsCommand, createJsCommand, DefaultCommand, createDefaultCommand, TellCommand, createTellCommand, CopyCommand, createCopyCommand, PickCommand, createPickCommand, BeepCommand, createBeepCommand, BreakpointCommand, createBreakpointCommand, InstallCommand, RenderCommand, COMMAND_FACTORIES, Runtime, DEFAULT_CONFIDENCE_THRESHOLD, debugEnabled, debugEventTarget, stats, VERSION, HistorySwapBehavior, BoostedBehavior, DEFAULT_LANGUAGE$1, injectedHost, LAZY_HEADER, IMMEDIATE_EVENTS, POWERED_ATTRIBUTE, SCRIPT_SELECTOR, processedElements, lazyStubs, AttributeProcessor, defaultAttributeProcessor, RingBuffer, HISTORY_CAPACITY, DebugController, DEFAULT_LANGUAGE, ASTCache, astCache, registeredFrontEnd, defaultFrontEnd, config, _defaultRuntime, _debugController, hyperscript, lokascript, POS, DiagnosticSeverity, SymbolKind, CompletionItemKind, _semanticModule, SemanticGrammarBridge, bridge, _fw, index;
+var COMMAND_NAMES, COMMAND_MANIFEST, KEYWORDS, COMMAND_TERMINATORS, COMMANDS, CONTROL_FLOW_COMMANDS, PUT_OPERATIONS, PUT_OPERATION_KEYWORDS, HYPERSCRIPT_KEYWORDS, CommandClassification, CSS_FUNCTIONS, CONTEXT_VARS, LOGICAL_OPERATORS, COMPARISON_OPERATORS, DOM_EVENTS, TOKENIZER_KEYWORDS, TokenKind, MATHEMATICAL_OPERATORS, TIME_UNITS, isDebugEnabled$1, DEBUG, debug, STOP_TOKENS, STOP_DELIMITERS, CORE_FRAGMENT, OF_OPERAND_BP, THE_OF_TARGET_BP, PARSER_COMPARISON_FRAGMENT, ASSIGNMENT_FRAGMENT, PARSER_TABLE, GLOBAL_WRITE_HOOKS, GLOBAL_READ_HOOKS, LOCAL_WRITE_HOOKS, LOCAL_READ_HOOKS, FEATURE_REGISTRY, NODE_EVALUATORS, NODE_WRITERS, ParserExtensionRegistry, SINGLETON, WINDOW_KEY, DEFAULT_BOUNDARY_KEYWORDS, CommandNodeBuilder, OPERAND_INTRODUCERS, CONTEXT_REFS, SWAP_STRATEGY_KEYWORDS, ELEMENT_PRONOUNS, GO_POSITIONS, SCROLL_BY_SCAN_BOUNDARY, SCROLL_POSITIONS, SCROLL_DIRECTIONS, SCROLL_STOP, COMPOUND_COMMAND_PARSERS, COMPOUND_COMMAND_NAMES, GENERIC_FALLBACK_GRAMMAR, URL_HARD_STOPS, NONE, ONE_EXPR, COMMAND_GRAMMAR, PLUGIN_COMMAND_GRAMMAR, STRING_POSTFIX_UNITS, TIME_POSTFIX_UNITS, STRING_POSTFIX_BP, Parser, HookRegistry, sharedGlobals, elementScopes, ExpressionTypeRegistry, expressionTypeRegistry, BOOLEAN_ATTRIBUTES, SPECIAL_DOM_PROPERTIES, NUMBER_WORDS, conversionConfig, defaultConversions, TYPE_ALIASES, asExpression, isExpression, asyncExpression, conversionExpressions, meExpression, youExpression, itExpression, itsExpression$1, resultExpression, querySelectorExpression, querySelectorAllExpression, idExpression, classExpression, closestExpression, parentExpression, windowExpression, documentExpression, elementWithSelectorExpression, styleRefExpression, possessiveStyleRefExpression, ofStyleRefExpression, referencesExpressions, isProduction, skipValidation, addDescribeToValidator, v, LRUCache, HyperscriptCache, globalCache, PerformanceTracker, performanceTracker, cleanupInterval, ComparisonInputSchema, PatternMatchingInputSchema, equalsExpression, strictEqualsExpression, notEqualsExpression, strictNotEqualsExpression, lessThanExpression, lessThanOrEqualExpression, greaterThanExpression, greaterThanOrEqualExpression, andExpression, orExpression, notExpression, isEmptyExpression, noExpression, isNotEmptyExpression, existsExpression, doesNotExistExpression, containsExpression, doesNotContainExpression, startsWithExpression, endsWithExpression, betweenExpression, matchesExpression, hasExpression, doesNotHaveExpression, logicalExpressions, UNSAFE_PROPS, possessiveExpression, myExpression, itsExpression, yourExpression, ofExpression, attributeExpression, attributeWithValueExpression, classReferenceExpression, idReferenceExpression, propertiesExpressions, EVALUABLE_KINDS, EVALUABLE_KIND_SET, NotSyncEvaluable, SYNC_EVALUABLE_KINDS, SYNC_EVALUABLE_KIND_SET, cachedFullRegistry, RAW_ARG_BUILTINS, CSS_PSEUDO_CLASSES, PSEUDO_CLASS_COLON_RE, BARE_REF_ESCAPE_RE, QUERY_REF_INTERP_RE, CleanupRegistry, EventSourceRegistry, canonicalEvaluator, CommandAdapterV2, CommandRegistryV2, defaultRegistry, RegistryIntegration, StrayControlFlowError, eventRecursionDepth, RuntimeBase, BaseExpressionImpl, StringLiteralInputSchema, NumberLiteralInputSchema, BooleanLiteralInputSchema, BinaryOperationInputSchema, StringLiteralExpression, NumberLiteralExpression, BooleanLiteralExpression, StringConcatenationExpression, specialExpressions, AdditionExpression, SubtractionExpression, MultiplicationExpression, DivisionExpression, ModuloExpression, PowerExpression, mathematicalExpressions, firstExpression, lastExpression, atExpression, nextExpression, previousExpression, DOCUMENT_POSITION_PRECEDING, DOCUMENT_POSITION_FOLLOWING, nextWithinExpression, previousWithinExpression, positionalExpressions, index$1, VisibilityCommandBase, HideCommand, createHideCommand, ShowCommand, createShowCommand, SMART_ELEMENT_TAGS, DOMModificationBase, AddCommand, createAddCommand, positionMap, RemoveCommand, createRemoveCommand, PATTERN, BOOL_PROPS, isPropertyOfExpressionNode, isPropertyAccessNode, ToggleCommand, createToggleCommand, PutCommand, createPutCommand, HTML_ESCAPE, MakeCommand, createMakeCommand, EmptyCommand, createEmptyCommand, OpenCommand, createOpenCommand, CloseCommand, createCloseCommand, SelectCommand, createSelectCommand, ResetCommand, createResetCommand, SUPPORTS_MOVE_BEFORE, ELEMENT_NODE_TYPE, TEXT_NODE_TYPE, IS_PARENT_NODE_TYPE, Operation, candidateNodes, candidateElements, candidateElementsWithIds, unmatchedNodes, unmatchedElements, whitespaceNodes, _idArrayMap, _idSetMap, _options, _Morph_instances, morphOneToMany_fn, morphOneToOne_fn, morphMatchingElements_fn, morphNonMatchingElements_fn, morphOtherNode_fn, visitAttributes_fn, visitTextArea_fn, replaceNode_fn, removeNode_fn, mapIdArraysForEach_fn, mapIdArrays_fn, mapIdSets_fn, Morph, morphAdapter, queue, processing, STRATEGY_KEYWORDS, SwapCommand, MorphCommand, createSwapCommand, createMorphCommand, CRITICAL_LAYOUT_ELEMENTS, STRUCTURAL_SEMANTIC_ELEMENTS, WARNING_ELEMENTS, DEFAULT_VALIDATION_CONFIG, globalConfig, STYLES, SEVERITY_ICONS, SEVERITY_LABELS, STRATEGY_MAP, ProcessPartialsCommand, createProcessPartialsCommand, WaitCommand, createWaitCommand, customResponseTypes, DEFAULT_FETCH_THROWS_ON, fetchThrowsOnPatterns, FetchCommand, createFetchCommand, SET_RUNGS, SetCommand, createSetCommand, GetCommand, createGetCommand, NumericModifyCommand, createIncrementCommand, ClearCommand, createClearCommand, LogCommand, createLogCommand, EventDispatchCommand, createTriggerCommand, GoCommand, createGoCommand, HistoryCommand, createPushUrlCommand, ScrollCommand, createScrollCommand, ConditionalCommand, createConditionalCommand, createIfCommand, RepeatCommand, createRepeatCommand, ControlFlowSignalBase, BreakCommand, createBreakCommand, ContinueCommand, createContinueCommand, HaltCommand, createHaltCommand, ReturnCommand, createReturnCommand, ExitCommand, createExitCommand, ThrowCommand, createThrowCommand, CallCommand, createCallCommand, FocusCommand, createFocusCommand, BlurCommand, createBlurCommand, PseudoCommand, ContentInsertionCommand, AppendCommand, createAppendCommand, PrependCommand, createPrependCommand, RESTORE_KEYWORDS, TransitionCommand, createTransitionCommand, MeasureCommand, createMeasureCommand, SettleCommand, createSettleCommand, StartViewTransitionCommand, createStartViewTransitionCommand, TakeCommand, createTakeCommand, JsCommand, createJsCommand, DefaultCommand, createDefaultCommand, TellCommand, createTellCommand, CopyCommand, createCopyCommand, PickCommand, createPickCommand, BeepCommand, createBeepCommand, BreakpointCommand, createBreakpointCommand, InstallCommand, RenderCommand, COMMAND_FACTORIES, Runtime, DEFAULT_CONFIDENCE_THRESHOLD, debugEnabled, debugEventTarget, stats, VERSION, HistorySwapBehavior, BoostedBehavior, DEFAULT_LANGUAGE$1, injectedHost, LAZY_HEADER, IMMEDIATE_EVENTS, POWERED_ATTRIBUTE, SCRIPT_SELECTOR, processedElements, lazyStubs, AttributeProcessor, defaultAttributeProcessor, RingBuffer, HISTORY_CAPACITY, DebugController, DEFAULT_LANGUAGE, ASTCache, astCache, registeredFrontEnd, defaultFrontEnd, config, _defaultRuntime, _debugController, hyperscript, lokascript, POS, DiagnosticSeverity, SymbolKind, CompletionItemKind, _semanticModule, SemanticGrammarBridge, bridge, _fw, index;
 var init_dist = __esm({
   "../core/dist/index.mjs"() {
     "use strict";
@@ -11339,6 +11804,8 @@ var init_dist = __esm({
       ["!", prefix(80)],
       ["no", prefix(27)]
     ]);
+    OF_OPERAND_BP = 70;
+    THE_OF_TARGET_BP = OF_OPERAND_BP + 1;
     PARSER_COMPARISON_FRAGMENT = /* @__PURE__ */ new Map([
       ["===", leftAssoc(30)],
       ["!==", leftAssoc(30)],
@@ -11383,7 +11850,7 @@ var init_dist = __esm({
       ["is greater than or equal to", leftAssoc(30)],
       ["is less than or equal to", leftAssoc(30)],
       ["in", leftAssoc(30)],
-      ["of", rightAssoc(30)],
+      ["of", { infix: { bp: [90, OF_OPERAND_BP], handler: ofHandler } }],
       ["really", leftAssoc(30)],
       [
         "exists",
@@ -11707,7 +12174,7 @@ var init_dist = __esm({
       "/",
       "mod"
     ]);
-    CONTEXT_POSSESSIVES = /* @__PURE__ */ new Set(["my", "its", "your"]);
+    CONTEXT_REFS = /* @__PURE__ */ new Set(["me", "it", "you", "result"]);
     SWAP_STRATEGY_KEYWORDS = [
       "afterbegin",
       "afterend",
@@ -11781,7 +12248,6 @@ var init_dist = __esm({
       markers: [],
       syntax
     });
-    BEEP = ONE_EXPR("beep! [<expression>, \u2026]");
     COMMAND_GRAMMAR = {
       append: { positional: "expression", markers: ["to"], syntax: "append <value> [to <target>]" },
       prepend: { positional: "expression", markers: ["to"], syntax: "prepend <value> [to <target>]" },
@@ -11792,8 +12258,7 @@ var init_dist = __esm({
         syntax: "make (a|an) <type> [from <args>] [called <name>]"
       },
       throw: { positional: "primary", markers: [], syntax: "throw <error>" },
-      "beep!": BEEP,
-      beep: BEEP,
+      beep: ONE_EXPR("beep! [<expression>, \u2026]"),
       blur: ONE_EXPR("blur [<target>]"),
       break: NONE,
       breakpoint: NONE,
@@ -11817,7 +12282,8 @@ var init_dist = __esm({
       render: {
         positional: "expression",
         markers: ["with"],
-        syntax: "render <template> [with <variables>]"
+        namedArgs: ["with"],
+        syntax: "render <template> [with <name>: <value>, \u2026]"
       },
       reset: ONE_EXPR("reset [<form>]"),
       return: ONE_EXPR("return [<value>]"),
@@ -12138,7 +12604,9 @@ var init_dist = __esm({
         const firstToken = this.peek();
         const prefixEntry = _Parser.PRATT_TABLE.get(firstToken.value);
         let left;
-        if (prefixEntry?.prefix) {
+        if (isGluedBeepBang(firstToken, this.tokens[this.current + 1])) {
+          left = this.parseBeepExpression();
+        } else if (prefixEntry?.prefix) {
           const token = this.advance();
           if (this.isAtEnd()) {
             this.addError(`Expected expression after '${token.value}' operator`);
@@ -12157,6 +12625,9 @@ var init_dist = __esm({
               continue;
             }
           }
+          if (nextToken.value === "*" && this.isSpacedStyleRef(this.current)) {
+            break;
+          }
           const infixEntry = _Parser.PRATT_TABLE.get(nextToken.value);
           if (!infixEntry?.infix) {
             if (STOP_TOKENS.has(nextToken.value) || STOP_DELIMITERS.has(nextToken.value)) {
@@ -12210,6 +12681,35 @@ var init_dist = __esm({
         this.prattCache.set(cacheKey, { node: left, endPos: this.current });
         return left;
       }
+      parseBeepExpression() {
+        const beepToken = this.advance();
+        this.advance();
+        if (this.isAtEnd()) {
+          this.addError("Expected expression after 'beep!'");
+          return this.createErrorNode();
+        }
+        const operand = this.parseExpressionPratt(_Parser.BEEP_OPERAND_BP);
+        return {
+          type: "unaryExpression",
+          operator: "beep!",
+          operand,
+          argument: operand,
+          prefix: true,
+          start: beepToken.start,
+          end: this.previous().end,
+          line: beepToken.line,
+          column: beepToken.column
+        };
+      }
+      isStyleRefStar(i) {
+        const star = this.tokens[i];
+        const name = this.tokens[i + 1];
+        return star?.value === "*" && !!name && name.start === star.end && isIdentifierLike(name);
+      }
+      isSpacedStyleRef(i) {
+        const prev = this.tokens[i - 1];
+        return this.isStyleRefStar(i) && !!prev && prev.end < this.tokens[i].start;
+      }
       tryParseStringPostfix(left, nextToken) {
         const v2 = nextToken.value;
         let unit = null;
@@ -12379,6 +12879,10 @@ var init_dist = __esm({
         const isStop = () => this.check("end") || extraStops.some((s) => this.check(s));
         debug.parse("\u{1F504} parseCommandListUntilTerminator: Starting (extraStops:", extraStops.join(","), ")");
         while (!this.isAtEnd() && !isStop()) {
+          if (this.checkComment()) {
+            this.advance();
+            continue;
+          }
           debug.parse("\u{1F4CD} Loop iteration, current token:", this.peek().value, "kind:", this.peek().kind);
           let parsedCommand = false;
           const isCommandToken = this.checkIsCommand();
@@ -12450,7 +12954,7 @@ var init_dist = __esm({
         if (this.check("end")) {
           debug.parse('\u2705 Found "end", consuming it');
           this.advance();
-        } else {
+        } else if (!this.atEndOfInput()) {
           debug.parse('\u274C ERROR: Expected "end" but got:', this.peek().value, "at position:", this.peek().start);
           throw new Error(`Expected "end" to close ${construct} block`);
         }
@@ -12462,7 +12966,7 @@ var init_dist = __esm({
         if (!hasElse) {
           if (this.check("end")) {
             this.advance();
-          } else {
+          } else if (!this.atEndOfInput()) {
             throw new Error('Expected "end" to close repeat block');
           }
         }
@@ -12477,7 +12981,10 @@ var init_dist = __esm({
         if (terminator === "end") {
           this.advance();
         } else if (terminator === "") {
-          throw new Error('Expected "end", "else", "until", or "while" to close repeat block');
+          if (!this.atEndOfInput()) {
+            throw new Error('Expected "end", "else", "until", or "while" to close repeat block');
+          }
+          return { commands, terminator: "end" };
         }
         return { commands, terminator };
       }
@@ -13017,7 +13524,9 @@ var init_dist = __esm({
       parseTopLevelInitBlock() {
         const pos2 = this.getPosition();
         const initCommands = this.parseCommandBlock(["end"]);
-        this.consume("end", "Expected 'end' after init block");
+        if (!this.match("end") && !this.atEndOfInput() && !this.checkFeatureStart()) {
+          this.consume("end", "Expected 'end' after init block");
+        }
         return {
           type: "initBlock",
           commands: initCommands,
@@ -13186,10 +13695,27 @@ var init_dist = __esm({
           ...sourceExpr.column !== void 0 && { column: sourceExpr.column }
         };
       }
+      isArgumentListOnly(open) {
+        let depth = 0;
+        for (let i = open; i < this.tokens.length; i++) {
+          const token = this.tokens[i];
+          if (token.kind !== "operator")
+            continue;
+          if (token.value === "(" || token.value === "[" || token.value === "{")
+            depth++;
+          else if (token.value === ")" || token.value === "]" || token.value === "}") {
+            if (--depth === 0)
+              return i === open + 1;
+          } else if (token.value === "," && depth === 1)
+            return true;
+        }
+        return false;
+      }
       tryParsePseudoCommand(callExpr, sourceExpr) {
         const methodName = callExpr.callee.name;
         const nextToken = this.peek();
-        const hasPseudoCommandPattern = _Parser.PSEUDO_COMMAND_PREPOSITIONS.includes(nextToken.value.toLowerCase()) || isIdentifier(nextToken) && !this.isCommand(nextToken.value) || isContextVar(nextToken);
+        const nextIsArticle = nextToken.value.toLowerCase() === "the";
+        const hasPseudoCommandPattern = nextIsArticle || _Parser.PSEUDO_COMMAND_PREPOSITIONS.includes(nextToken.value.toLowerCase()) || isIdentifier(nextToken) && !this.isCommand(nextToken.value) || isContextVar(nextToken);
         if (!hasPseudoCommandPattern) {
           return {
             node: this.callExprToCommandNode(callExpr, sourceExpr),
@@ -13213,7 +13739,9 @@ var init_dist = __esm({
           });
         }
         let preposition;
-        if (_Parser.PSEUDO_COMMAND_PREPOSITIONS.includes(this.peek().value.toLowerCase())) {
+        if (nextIsArticle) {
+          this.advance();
+        } else if (_Parser.PSEUDO_COMMAND_PREPOSITIONS.includes(this.peek().value.toLowerCase())) {
           preposition = this.advance().value.toLowerCase();
         }
         let targetExpr;
@@ -13366,10 +13894,18 @@ var init_dist = __esm({
           this.consume("]", "Expected ']' after event condition");
         }
         let target;
+        let targetExpression;
         if (this.match("from")) {
-          const targetToken = this.advance();
-          target = targetToken.value;
-          debug.parse(`\u{1F527} parseEventHandler: Parsed 'from' target: ${target} (kind: ${targetToken.kind})`);
+          if (this.check("the"))
+            this.advance();
+          if (_Parser.POSITIONAL_SOURCE_HEADS.has(this.peek().value.toLowerCase())) {
+            const startIndex = this.current;
+            targetExpression = this.parseExpression();
+            target = this.tokens.slice(startIndex, this.current).map((t) => t.value).join(" ");
+          } else {
+            target = this.advance().value;
+          }
+          debug.parse(`\u{1F527} parseEventHandler: Parsed 'from' target: ${target}`);
           this.parseTemporalKeywordModifiers(modifiers);
         }
         let attributeName;
@@ -13414,7 +13950,7 @@ var init_dist = __esm({
             const nextIsOpenParen = this.tokens[this.current + 1]?.value === "(";
             const commandName = this.peek().value.toLowerCase();
             const isSpecialBodyCommand = commandName === "js" || commandName === "tell";
-            if (nextIsOpenParen && !isSpecialBodyCommand) {
+            if (nextIsOpenParen && !isSpecialBodyCommand && this.isArgumentListOnly(this.current + 1)) {
               let expr;
               const savedError = this.error;
               try {
@@ -13442,7 +13978,7 @@ var init_dist = __esm({
                 this.recordDropped(`Command '${cmdToken}' failed to parse and was discarded`);
               }
             }
-          } else if (this.checkIdentifier()) {
+          } else if (this.checkIdentifier() || this.checkEventNamedCall()) {
             const token = this.peek();
             if (this.isCommand(token.value)) {
               const cmd = this.parseCommandWithErrorRecovery();
@@ -13528,6 +14064,7 @@ var init_dist = __esm({
           ...eventParams.length > 0 && { args: eventParams },
           ...condition && { condition: fromLegacyExpression(condition) },
           ...target && { target },
+          ...targetExpression && { targetExpression: fromLegacyExpression(targetExpression) },
           ...attributeName && { attributeName },
           ...watchTarget && { watchTarget: fromLegacyExpression(watchTarget) },
           ...customEventSource && { customEventSource },
@@ -13764,10 +14301,9 @@ var init_dist = __esm({
       }
       parseCommandCore() {
         const commandToken = this.previous();
-        let commandName = commandToken.value;
+        const commandName = commandToken.value;
         if (commandName === "beep" && this.check("!")) {
           this.advance();
-          commandName = "beep!";
         }
         if (commandName === "fetch") {
           return parseFetchCommand(this.getContext(), commandToken);
@@ -13860,6 +14396,9 @@ var init_dist = __esm({
           args.push(this.parsePrimary());
         }
         const callNode = this.createCallExpression(createIdentifier(funcName, namePos), args);
+        if (funcName === "closest" && args.length > 0 && this.match("to")) {
+          callNode.closestTo = this.parseExpression();
+        }
         if (funcName === "next" || funcName === "previous") {
           const relativePositional = this.parseRelativePositionalModifiers();
           if (relativePositional) {
@@ -13898,6 +14437,9 @@ var init_dist = __esm({
       }
       parseTheXofY() {
         const positionalKeywords = ["first", "last", "next", "previous", "random", "closest"];
+        if (this.isStyleRefStar(this.current)) {
+          return this.parsePrimary();
+        }
         if (!this.checkIdentifier()) {
           return this.createIdentifier("the");
         }
@@ -13913,7 +14455,7 @@ var init_dist = __esm({
           return this.createIdentifier(propertyName);
         }
         this.advance();
-        const target = this.parseCall();
+        const target = parseOfOperand(this.makePrattContext(), THE_OF_TARGET_BP);
         return {
           type: "propertyOfExpression",
           property: { type: "identifier", name: propertyName },
@@ -14108,6 +14650,13 @@ var init_dist = __esm({
       checkLiteral() {
         return this.checkPredicate(isLiteral);
       }
+      checkEventNamedCall() {
+        if (this.isAtEnd() || !this.checkIdentifierLike() || this.checkIsCommand())
+          return false;
+        const token = this.peek();
+        const next = this.tokens[this.current + 1];
+        return next?.value === "(" && next.start === token.end;
+      }
       checkIdentifierLike() {
         return this.checkPredicate(isIdentifierLike);
       }
@@ -14216,6 +14765,19 @@ var init_dist = __esm({
       isAtEnd() {
         return this.current >= this.tokens.length;
       }
+      atEndOfInput() {
+        for (let i = this.current; i < this.tokens.length; i++) {
+          if (!isComment(this.tokens[i]))
+            return false;
+        }
+        return true;
+      }
+      checkFeatureStart() {
+        if (this.isAtEnd())
+          return false;
+        const value = this.peek().value;
+        return value === "init" || value === "on" || value === "def" || getRegisteredFeature(value) !== void 0;
+      }
       peek() {
         if (this.isAtEnd()) {
           return { kind: "unknown", value: "", start: 0, end: 0, line: 1, column: 1 };
@@ -14420,6 +14982,7 @@ var init_dist = __esm({
           match: this.match.bind(this),
           matchOperator: this.matchOperator.bind(this),
           isAtEnd: this.isAtEnd.bind(this),
+          atEndOfInput: this.atEndOfInput.bind(this),
           createIdentifier: this.createIdentifier.bind(this),
           parseExpression: this.parseExpression.bind(this),
           parsePrimary: this.parsePrimary.bind(this),
@@ -14468,7 +15031,15 @@ var init_dist = __esm({
       "ignoring case"
     ]);
     Parser.PRATT_TABLE = PARSER_TABLE;
+    Parser.BEEP_OPERAND_BP = 80;
     Parser.PSEUDO_COMMAND_PREPOSITIONS = ["from", "on", "with", "into", "at", "to"];
+    Parser.POSITIONAL_SOURCE_HEADS = /* @__PURE__ */ new Set([
+      "closest",
+      "next",
+      "previous",
+      "first",
+      "last"
+    ]);
     HookRegistry = class {
       constructor() {
         this.hooks = /* @__PURE__ */ new Map();
@@ -14918,7 +15489,7 @@ var init_dist = __esm({
       innertext: (el) => el.textContent?.trim(),
       innerHTML: (el) => el.innerHTML,
       outerhtml: (el) => el.outerHTML,
-      value: (el) => isFormElement$1(el) ? el.value : void 0,
+      value: (el) => "value" in el ? el.value : void 0,
       checked: (el) => isInputElement$1(el) ? el.checked : void 0,
       disabled: (el) => "disabled" in el ? el.disabled : void 0,
       selected: (el) => isOptionElement$1(el) ? el.selected : void 0,
@@ -15360,14 +15931,15 @@ var init_dist = __esm({
         if (typeof selector !== "string") {
           throw new Error("closest requires a string selector");
         }
-        if (!context.me) {
+        const start = args.length > 1 ? args[1] : context.me;
+        if (!(start instanceof Element)) {
           return null;
         }
-        return context.me.closest(selector);
+        return start.closest(selector);
       },
       validate(args) {
-        if (args.length !== 1) {
-          return "closest requires exactly 1 argument (selector)";
+        if (args.length !== 1 && args.length !== 2) {
+          return "closest requires a selector and, optionally, the element to start from";
         }
         const arg = args[0];
         if (typeof arg === "string")
@@ -16220,7 +16792,7 @@ var init_dist = __esm({
         else if (value instanceof Node || value instanceof Element)
           result = false;
         else if (isObject(value))
-          result = Object.keys(value).length === 0;
+          result = value.length === 0;
         else
           result = false;
         return result;
@@ -17501,8 +18073,8 @@ var init_dist = __esm({
           }
           case "initBlock":
           case "block": {
-            const block = node;
-            const ops = (Array.isArray(block.commands) ? block.commands : []).map((c) => this.compile(c));
+            const block2 = node;
+            const ops = (Array.isArray(block2.commands) ? block2.commands : []).map((c) => this.compile(c));
             const consumesHalt = node.type === "initBlock";
             return async (context) => {
               for (const op of ops) {
@@ -17882,12 +18454,22 @@ var init_dist = __esm({
         debug.runtime(`BEHAVIOR: Finished installing ${behaviorName}`);
       }
       async executeEventHandler(node, context) {
-        const { event, events, commands, target, args, selector, condition, attributeName, watchTarget, modifiers, errorSymbol, errorHandler, finallyHandler } = node;
+        const { event, events, commands, target, targetExpression, args, selector, condition, attributeName, watchTarget, modifiers, errorSymbol, errorHandler, finallyHandler } = node;
         const eventNames = events && events.length > 0 ? events : [event];
         debug.runtime(`BEHAVIOR: executeEventHandler: event='${event}', target='${target}'`);
         let targets = [];
         let globalTarget = null;
-        if (target) {
+        if (targetExpression) {
+          const resolved = await this.execute(targetExpression, context);
+          if (resolved === window)
+            globalTarget = window;
+          else if (resolved === document)
+            globalTarget = document;
+          else if (this.isElement(resolved))
+            targets = [resolved];
+          else if (Array.isArray(resolved))
+            targets = resolved.filter((el) => this.isElement(el));
+        } else if (target) {
           const targetLower = typeof target === "string" ? target.toLowerCase() : "";
           if (targetLower === "window" || targetLower === "the window") {
             globalTarget = window;
@@ -19667,9 +20249,9 @@ var init_dist = __esm({
           if (!raw.args?.length)
             throw new Error("toggle command requires an argument");
           const firstArg = raw.args[0];
-          const propertyTarget = await resolveAnyPropertyTarget(firstArg, evaluator, context);
-          if (propertyTarget) {
-            return { type: "property", target: propertyTarget };
+          const propertyTarget2 = await resolveAnyPropertyTarget(firstArg, evaluator, context);
+          if (propertyTarget2) {
+            return { type: "property", target: propertyTarget2 };
           }
           if (firstArg.type === "selector" && typeof firstArg.value === "string" && firstArg.value.startsWith("*")) {
             let expression2 = firstArg.value;
@@ -19903,13 +20485,13 @@ var init_dist = __esm({
           let targetSelector = null, memberPath, variableName;
           if (targetArg) {
             const tt = nodeType(targetArg);
-            const propertyTarget = await resolveAnyPropertyTarget(targetArg, evaluator, context);
-            if (propertyTarget) {
+            const propertyTarget2 = await resolveAnyPropertyTarget(targetArg, evaluator, context);
+            if (propertyTarget2) {
               return {
                 value,
-                targets: [propertyTarget.element],
+                targets: [propertyTarget2.element],
                 position: "into",
-                memberPath: propertyTarget.property
+                memberPath: propertyTarget2.property
               };
             }
             if (tt === "memberExpression") {
@@ -20049,7 +20631,11 @@ var init_dist = __esm({
           }
           if (isInsertableNode(v2))
             return v2;
-          return v2 == null ? "" : String(v2);
+          if (v2 == null)
+            return "null";
+          if (Array.isArray(v2))
+            return arrayFragment(v2);
+          return String(v2);
         }
         looksLikeCss(s) {
           if (!s)
@@ -21132,7 +21718,7 @@ var init_dist = __esm({
           if (args.length === 0 && modifiers.with === void 0) {
             throw new Error("[HyperFixi] morph: command requires arguments");
           }
-          const strategy = literalText(modifiers.strategy)?.toLowerCase() === "over" ? "morphOuter" : "morph";
+          const strategy = literalText(modifiers.strategy)?.toLowerCase() === "over" ? "morphOuter" : "morphMerge";
           const useViewTransition = modifiers.viewTransition !== void 0;
           const targetNode = modifiers.on !== void 0 ? modifiers.on : args[0];
           const contentNode = modifiers.with !== void 0 ? modifiers.with : modifiers.on !== void 0 ? args[0] : args[1];
@@ -21768,6 +22354,7 @@ var init_dist = __esm({
       return FetchCommand2 = _classThis;
     })();
     createFetchCommand = createFactory(FetchCommand);
+    SET_RUNGS = { nodeWriters: true, styleSplit: true, ofAndObjectProperty: true };
     SetCommand = (() => {
       let _classDecorators = [command({ name: "set" })];
       let _classDescriptor;
@@ -21786,8 +22373,7 @@ var init_dist = __esm({
           const argScope = firstArg?.scope;
           const writeTarget = await resolveWriteTarget(firstArg, evaluator, context, {
             scopeElements: () => this.resolveTargets(raw.modifiers.on, evaluator, context),
-            nodeWriters: true,
-            styleSplit: true
+            ...SET_RUNGS
           });
           if (writeTarget) {
             return toSetInput(writeTarget, await this.extractValue(raw, evaluator, context));
@@ -21911,13 +22497,13 @@ var init_dist = __esm({
         }
         async tryParseMemberExpression(firstArg, raw, evaluator, context) {
           const objectNode = firstArg.object;
-          const propertyNode = firstArg.property;
-          if (objectNode?.name && propertyNode?.name) {
+          const propertyNode2 = firstArg.property;
+          if (objectNode?.name && propertyNode2?.name) {
             const objectName = objectNode.name.toLowerCase();
             if (["me", "my", "it", "its", "you", "your"].includes(objectName)) {
               const element = resolvePossessive(objectName, context);
               const value = await this.extractValue(raw, evaluator, context);
-              return { type: "property", element, property: propertyNode.name, value };
+              return { type: "property", element, property: propertyNode2.name, value };
             }
           }
           const objectAst = firstArg.object;
@@ -21933,7 +22519,7 @@ var init_dist = __esm({
               container = await evaluator.evaluate(objectAst, context);
             }
             if (container != null && typeof container === "object") {
-              const property = computed ? String(await evaluator.evaluate(firstArg.property, context)) : propertyNode?.name || "";
+              const property = computed ? String(await evaluator.evaluate(firstArg.property, context)) : propertyNode2?.name || "";
               if (property) {
                 const value = await this.extractValue(raw, evaluator, context);
                 return {
@@ -22100,7 +22686,7 @@ var init_dist = __esm({
         async execute(input, context) {
           const { target, property, scope, amount = 1, operation = "increment", customWrite } = input;
           if (customWrite) {
-            const delta = isFinite(amount) ? amount : 1;
+            const delta = amount;
             const newValue2 = operation === "increment" ? customWrite.currentValue + delta : customWrite.currentValue - delta;
             await customWrite.writer(customWrite.node, newValue2, context);
             Object.assign(context, { it: newValue2 });
@@ -22111,8 +22697,7 @@ var init_dist = __esm({
           if (isNaN(currentValue)) {
             newValue = NaN;
           } else {
-            const delta = isFinite(amount) ? amount : 1;
-            newValue = operation === "increment" ? currentValue + delta : currentValue - delta;
+            newValue = operation === "increment" ? currentValue + amount : currentValue - amount;
           }
           setTargetValue(target, property, scope, newValue, context);
           Object.assign(context, { it: newValue });
@@ -22516,9 +23101,9 @@ var init_dist = __esm({
           }
           const { target, position, offset, behavior } = input;
           if (typeof window !== "undefined") {
-            const block = this.mapVerticalPosition(position.vertical);
+            const block2 = this.mapVerticalPosition(position.vertical);
             const inline = this.mapHorizontalPosition(position.horizontal);
-            target.scrollIntoView?.({ behavior, block, inline });
+            target.scrollIntoView?.({ behavior, block: block2, inline });
             if (offset !== 0) {
               const { x, y } = this.calculateScrollPosition(target, position, offset);
               window.scrollTo?.({ left: x, top: y, behavior });
@@ -23009,7 +23594,7 @@ var init_dist = __esm({
             }
           }
           const m = raw.modifiers ?? {};
-          const text = (node) => slotText(node, evaluator, context);
+          const text = (node) => slotText$1(node, evaluator, context);
           const loopType = await text(m.loopType) ?? null;
           const bottomTested = m.bottomTested ? await evaluator.evaluate(m.bottomTested, context) : false;
           if (loopType === "for" || m.for) {
@@ -23027,17 +23612,24 @@ var init_dist = __esm({
             };
           }
           if (loopType === "times" || m.times) {
-            const countValue = m.times && await evaluator.evaluate(m.times, context);
-            const count = typeof countValue === "number" ? countValue : parseInt(String(countValue), 10);
-            if (isNaN(count))
+            if (!m.times)
               throw new Error("times loops require a count number");
+            const count = loopCount(await evaluator.evaluate(m.times, context));
             return { type: "times", count, indexVariable, commands, elseCommands };
           }
           if (loopType === "while" || m.while) {
             const condition = m.while;
             if (!condition)
               throw new Error("while loops require a condition");
-            return { type: "while", condition, indexVariable, commands, elseCommands, bottomTested };
+            const check = () => evaluator.evaluate(condition, context);
+            return {
+              type: "while",
+              condition: check,
+              indexVariable,
+              commands,
+              elseCommands,
+              bottomTested
+            };
           }
           if (loopType === "until-event" || m.event) {
             const eventName = await text(m.event);
@@ -23053,7 +23645,7 @@ var init_dist = __esm({
                 eventTarget = window;
               } else {
                 const target = await evaluator.evaluate(m.from, context);
-                if (target instanceof EventTarget)
+                if (isEventTarget(target))
                   eventTarget = target;
                 else if (target === "document")
                   eventTarget = document;
@@ -23074,7 +23666,15 @@ var init_dist = __esm({
             const condition = m.until;
             if (!condition)
               throw new Error("until loops require a condition");
-            return { type: "until", condition, indexVariable, commands, elseCommands, bottomTested };
+            const check = () => evaluator.evaluate(condition, context);
+            return {
+              type: "until",
+              condition: check,
+              indexVariable,
+              commands,
+              elseCommands,
+              bottomTested
+            };
           }
           if (loopType === "forever") {
             return { type: "forever", indexVariable, commands, elseCommands };
@@ -23092,10 +23692,10 @@ var init_dist = __esm({
               ({ config: config2, iterCtx } = createTimesLoopConfig(count, indexVariable));
               break;
             case "while":
-              ({ config: config2, iterCtx } = createWhileLoopConfig(condition, evaluateCondition, context, indexVariable));
+              ({ config: config2, iterCtx } = createWhileLoopConfig(condition, evaluateLoopCondition, context, indexVariable));
               break;
             case "until":
-              ({ config: config2, iterCtx } = createUntilLoopConfig(condition, evaluateCondition, context, indexVariable));
+              ({ config: config2, iterCtx } = createUntilLoopConfig(condition, evaluateLoopCondition, context, indexVariable));
               break;
             case "until-event":
               ({ config: config2, iterCtx } = createUntilEventLoopConfig(eventName, eventTarget, indexVariable));
@@ -24042,6 +24642,7 @@ var init_dist = __esm({
       return PrependCommand2 = _classThis;
     })();
     createPrependCommand = createFactory(PrependCommand);
+    RESTORE_KEYWORDS = /* @__PURE__ */ new Set(["initial", "inherit", "unset", "revert"]);
     TransitionCommand = (() => {
       let _classDecorators = [command({ name: "transition" })];
       let _classDescriptor;
@@ -24057,10 +24658,9 @@ var init_dist = __esm({
           let property;
           let target;
           const firstArg = await evaluator.evaluate(raw.args[0], context);
-          const asElement = (value2) => Array.isArray(value2) || isNodeList(value2) ? value2[0] : value2;
-          const firstAsElement = asElement(firstArg);
-          if (isHTMLElement$2(firstAsElement) || typeof firstArg === "string" && /^[#.]|^(?:me|it|you)$/.test(firstArg)) {
-            target = firstAsElement;
+          const owners = elementsOf(firstArg);
+          if (owners.length > 0 || typeof firstArg === "string" && /^[#.]|^(?:me|it|you)$/.test(firstArg)) {
+            target = owners.length === 1 ? owners[0] : owners.length > 1 ? owners : firstArg;
             property = String(await evaluator.evaluate(raw.args[1], context));
           } else if (raw.args.length >= 2) {
             throw new Error("transition: target element not found");
@@ -24070,9 +24670,9 @@ var init_dist = __esm({
               throw new Error("transition requires a CSS property");
             property = named.property;
             if (named.objectNode !== void 0) {
-              const owner = asElement(await evaluator.evaluate(named.objectNode, context));
-              if (isHTMLElement$2(owner))
-                target = owner;
+              const owner = elementsOf(await evaluator.evaluate(named.objectNode, context));
+              if (owner.length > 0)
+                target = owner.length === 1 ? owner[0] : owner;
             }
           } else {
             property = String(firstArg);
@@ -24082,55 +24682,126 @@ var init_dist = __esm({
           }
           if (!raw.modifiers?.to)
             throw new Error('transition requires "to <value>"');
-          let value = await evaluator.evaluate(raw.modifiers.to, context);
-          if (value === void 0 && raw.modifiers.to.type === "identifier") {
-            value = raw.modifiers.to.name;
-          }
-          const result = { property, value };
+          const result = {
+            property,
+            value: await valueOf(raw.modifiers.to, evaluator, context)
+          };
           if (target !== void 0)
             result.target = target;
+          if (raw.modifiers?.from)
+            result.from = await valueOf(raw.modifiers.from, evaluator, context);
+          if (raw.modifiers?.pairs) {
+            result.pairs = await this.laterPairs(raw.modifiers.pairs, evaluator, context);
+          }
           if (raw.modifiers?.over)
             result.duration = await evaluator.evaluate(raw.modifiers.over, context);
           if (raw.modifiers?.with)
             result.timingFunction = String(await evaluator.evaluate(raw.modifiers.with, context));
+          if (raw.modifiers?.using)
+            result.using = String(await evaluator.evaluate(raw.modifiers.using, context));
           return result;
         }
+        async laterPairs(node, evaluator, context) {
+          const pairs = [];
+          for (const pairNode of node.elements ?? []) {
+            const fields = /* @__PURE__ */ new Map();
+            const properties = pairNode.properties ?? [];
+            for (const { key, value } of properties) {
+              if (typeof key.name === "string")
+                fields.set(key.name, value);
+            }
+            const propertyNode2 = fields.get("property");
+            const toNode = fields.get("to");
+            if (!propertyNode2 || !toNode)
+              throw new Error("transition requires property and value");
+            const pair = {
+              property: String(await evaluator.evaluate(propertyNode2, context)),
+              value: await valueOf(toNode, evaluator, context)
+            };
+            const ownerNode = fields.get("owner");
+            if (ownerNode) {
+              const owners = elementsOf(await evaluator.evaluate(ownerNode, context));
+              if (owners.length === 0)
+                throw new Error("transition: target element not found");
+              pair.target = owners.length === 1 ? owners[0] : owners;
+            }
+            const fromNode = fields.get("from");
+            if (fromNode)
+              pair.from = await valueOf(fromNode, evaluator, context);
+            pairs.push(pair);
+          }
+          return pairs;
+        }
         async execute(input, context) {
-          let { property } = input;
-          const { target, value, duration: durationInput, timingFunction } = input;
-          if (property.startsWith("*"))
-            property = property.substring(1);
-          property = camelToKebab(property);
-          const targetElement = resolveElement(target, context, "transition");
-          const duration = parseDuration(durationInput, 300);
-          const fromValue = getComputedStyle(targetElement).getPropertyValue(property);
-          const originalTransition = targetElement.style.transition;
-          const transitionProp = `${property} ${duration}ms ${timingFunction || "ease"}`;
-          targetElement.style.transition = originalTransition ? `${originalTransition}, ${transitionProp}` : transitionProp;
-          let toValue = String(value);
-          let removeInlineAfter = false;
-          if (toValue === "initial" || toValue === "inherit" || toValue === "unset" || toValue === "revert") {
-            const currentInline = targetElement.style.getPropertyValue(property);
-            targetElement.style.removeProperty(property);
-            toValue = getComputedStyle(targetElement).getPropertyValue(property);
-            if (currentInline) {
-              targetElement.style.setProperty(property, currentInline);
-            }
-            removeInlineAfter = true;
-          }
-          targetElement.style.setProperty(property, toValue);
-          const result = await waitForTransitionEnd(targetElement, property, duration);
-          targetElement.style.transition = originalTransition;
-          if (removeInlineAfter) {
-            targetElement.style.removeProperty(property);
+          const duration = parseDuration(input.duration, input.using !== void 0 && longestTransitionMs(input.using) || 300);
+          const timing = input.timingFunction || "ease";
+          const jobs = [];
+          for (const pair of [input, ...input.pairs ?? []]) {
+            let property = pair.property;
+            if (property.startsWith("*"))
+              property = property.substring(1);
+            property = camelToKebab(property);
+            const elements = Array.isArray(pair.target) ? pair.target.filter(isHTMLElement$2) : [resolveElement(pair.target, context, "transition")];
+            for (const element of elements) {
+              jobs.push({
+                element,
+                property,
+                pair,
+                fromValue: getComputedStyle(element).getPropertyValue(property),
+                toValue: "",
+                removeInlineAfter: false
+              });
+            }
+          }
+          if (jobs.length === 0)
+            throw new Error("transition: target element not found");
+          for (const job of jobs) {
+            if (job.pair.from !== void 0) {
+              job.element.style.setProperty(job.property, String(job.pair.from));
+            }
+          }
+          for (const job of jobs)
+            if (job.pair.from !== void 0)
+              void job.element.offsetWidth;
+          const originals = /* @__PURE__ */ new Map();
+          for (const job of jobs) {
+            if (!originals.has(job.element))
+              originals.set(job.element, job.element.style.transition);
+          }
+          for (const [element, original] of originals) {
+            const own = jobs.filter((job) => job.element === element).map((job) => `${job.property} ${duration}ms ${timing}`);
+            element.style.transition = input.using ?? [original, ...own].filter(Boolean).join(", ");
+          }
+          for (const job of jobs) {
+            const { element, property } = job;
+            let toValue = String(job.pair.value);
+            if (RESTORE_KEYWORDS.has(toValue)) {
+              const currentInline = element.style.getPropertyValue(property);
+              element.style.removeProperty(property);
+              toValue = getComputedStyle(element).getPropertyValue(property);
+              if (currentInline) {
+                element.style.setProperty(property, currentInline);
+              }
+              job.removeInlineAfter = true;
+            }
+            job.toValue = toValue;
+            element.style.setProperty(property, toValue);
           }
+          const results = await Promise.all(jobs.map((job) => waitForTransitionEnd(job.element, job.property, duration)));
+          for (const [element, original] of originals)
+            element.style.transition = original;
+          for (const job of jobs) {
+            if (job.removeInlineAfter)
+              job.element.style.removeProperty(job.property);
+          }
+          const first = jobs[0];
           return {
-            element: targetElement,
-            property,
-            fromValue,
-            toValue,
+            element: first.element,
+            property: first.property,
+            fromValue: first.fromValue,
+            toValue: first.toValue,
             duration,
-            completed: result.completed
+            completed: results.every((result) => result.completed)
           };
         }
       };
@@ -24143,13 +24814,16 @@ var init_dist = __esm({
       })();
       _classThis.metadata = commandMeta({
         description: "Animate CSS properties using CSS transitions",
-        syntax: "transition [<target>] <property> to <value> [over <duration>] [with <timing>]",
+        syntax: "transition <property> [from <value>] to <value> [<property> \u2026 to <value>]\u2026 [over <duration>] [using <css> | with <timing>]",
         examples: [
           "transition opacity to 0.5",
           "transition my *opacity to 0 over 200ms",
           "transition #box's *opacity to 0 over 200ms",
           "transition left to 100px over 500ms",
-          "transition background-color to red over 1s with ease-in-out"
+          "transition background-color to red over 1s with ease-in-out",
+          "transition *width to 100px *height to 50px over 300ms",
+          "transition *opacity of #panel from 0 to 1 over 200ms",
+          'transition my *opacity to 0 using "opacity 1s ease-in"'
         ],
         sideEffects: ["style-change", "timing"],
         category: "animation",
@@ -25309,17 +25983,7 @@ var init_dist = __esm({
             this.debugContext(context);
             return { expressionCount: 0, debugged: true, outputs: [] };
           }
-          const outputs = [];
-          console.group("\u{1F514} beep! Debug Output");
-          for (const expression of expressions) {
-            const output = this.debugExpression(expression);
-            outputs.push(output);
-            console.log(`Value:`, expression);
-            console.log(`Type:`, output.type);
-            console.log(`Representation:`, output.representation);
-            console.log("---");
-          }
-          console.groupEnd();
+          const outputs = beepValues(context.me, expressions);
           return { expressionCount: expressions.length, debugged: true, outputs };
         }
         debugContext(context) {
@@ -25332,63 +25996,6 @@ var init_dist = __esm({
           console.log("variables:", context.variables);
           console.groupEnd();
         }
-        debugExpression(expression) {
-          return {
-            value: expression,
-            type: this.getType(expression),
-            representation: this.getRepresentation(expression)
-          };
-        }
-        getType(value) {
-          if (value === null)
-            return "null";
-          if (value === void 0)
-            return "undefined";
-          if (Array.isArray(value))
-            return "array";
-          if (isHTMLElement$2(value))
-            return "HTMLElement";
-          if (value instanceof Element)
-            return "Element";
-          if (value instanceof Node)
-            return "Node";
-          if (value instanceof Error)
-            return "Error";
-          if (value instanceof Date)
-            return "Date";
-          if (value instanceof RegExp)
-            return "RegExp";
-          return typeof value;
-        }
-        getRepresentation(value) {
-          if (value === null)
-            return "null";
-          if (value === void 0)
-            return "undefined";
-          if (Array.isArray(value)) {
-            return `Array(${value.length}) [${value.slice(0, 3).map((v2) => this.getRepresentation(v2)).join(", ")}${value.length > 3 ? "..." : ""}]`;
-          }
-          if (isHTMLElement$2(value)) {
-            const el = value;
-            const tag = el.tagName.toLowerCase();
-            const id = el.id ? `#${el.id}` : "";
-            const classes = el.className ? `.${el.className.split(" ").join(".")}` : "";
-            return `<${tag}${id}${classes}/>`;
-          }
-          if (value instanceof Error)
-            return `Error: ${value.message}`;
-          if (typeof value === "string")
-            return value.length > 50 ? `"${value.substring(0, 47)}..."` : `"${value}"`;
-          if (typeof value === "object") {
-            try {
-              const keys = Object.keys(value);
-              return `Object {${keys.slice(0, 3).join(", ")}${keys.length > 3 ? "..." : ""}}`;
-            } catch {
-              return "[Object]";
-            }
-          }
-          return String(value);
-        }
       };
       __setFunctionName(_classThis, "BeepCommand");
       (() => {
@@ -25909,16 +26516,12 @@ var init_dist = __esm({
     };
     RenderCommand.metadata = commandMeta({
       description: "Render templates with @if, @else, and @repeat directives",
-      syntax: [
-        "render <template>",
-        "render <template> with <variables>",
-        "render <template> with (key: value, ...)"
-      ],
+      syntax: ["render <template>", "render <template> with <name>: <value>, ..."],
       examples: [
         "render myTemplate",
-        'render myTemplate with (name: "Alice")',
-        'render "<template>Hello ${name}!</template>" with (name: "World")',
-        "render template with (items: data)"
+        'render myTemplate with name: "Alice"',
+        'render "<template>Hello ${name}!</template>" with name: "World"',
+        "render template with items: data"
       ],
       category: "templates",
       compatibility: "standard",
@@ -26030,7 +26633,7 @@ var init_dist = __esm({
       averageConfidence: 0,
       confidenceHistory: []
     };
-    VERSION = "3.1.0";
+    VERSION = "3.2.0";
     HistorySwapBehavior = {
       name: "HistorySwap",
       init(element, params = {}) {
@@ -27482,8 +28085,8 @@ var init_multilingual = __esm({
       if (declared && modifiers) {
         for (const [key, role] of Object.entries(declared)) {
           const value = modifiers[key];
-          const isNode2 = !!value && typeof value === "object" && "type" in value;
-          if (isNode2 && inferred[role] === void 0) {
+          const isNode3 = !!value && typeof value === "object" && "type" in value;
+          if (isNode3 && inferred[role] === void 0) {
             inferred[role] = value;
           }
         }
@@ -27870,7 +28473,7 @@ function analyze(ast) {
 function extractClassOp2(node) {
   if (node.type !== "command") return null;
   const cmd = node;
-  if (!CLASS_COMMANDS.has(cmd.name)) return null;
+  if (!TARGET_SLOTS.has(cmd.name)) return null;
   const args = cmd.args ?? [];
   if (args.length === 0) return null;
   const arg = args[0];
@@ -27879,48 +28482,32 @@ function extractClassOp2(node) {
   if (!selector.startsWith(".")) return null;
   const className = selector.slice(1);
   if (!className) return null;
-  return {
-    command: cmd.name,
-    className,
-    hasExplicitTarget: !!cmd.target
-  };
+  return { command: cmd.name, className };
 }
-function isSameTarget(a, b) {
-  if (a.type !== "command" || b.type !== "command") return false;
-  const cmdA = a;
-  const cmdB = b;
-  if (!cmdA.target && !cmdB.target) return true;
-  if (cmdA.target && cmdB.target) {
-    return getTargetKey(cmdA.target) === getTargetKey(cmdB.target);
-  }
-  return false;
+function classTarget(cmd) {
+  if (cmd.target) return cmd.target;
+  const slot = cmd.modifiers?.[TARGET_SLOTS.get(cmd.name)];
+  return slot && typeof slot === "object" && "type" in slot ? slot : void 0;
 }
-function getTargetKey(target) {
-  if (target.type === "selector") {
-    return `selector:${target.value}`;
-  }
-  if (target.type === "identifier") {
-    return `identifier:${target.value}`;
+function batchTargetKey(cmd) {
+  const target = classTarget(cmd);
+  if (!target) return "me";
+  if (target.type === "identifier" && target.value === "me") return "me";
+  if (target.type === "selector" && /^#[\w-]+$/.test(target.value)) {
+    return target.value;
   }
   return null;
 }
-function resolveTarget2(cmd) {
-  if (!cmd.target) return "_ctx.me";
-  if (cmd.target.type === "selector") {
-    const sel = cmd.target.value;
-    if (sel.startsWith("#") && !sel.includes(" ") && !sel.includes(".")) {
-      return `document.getElementById('${sel.slice(1)}')`;
-    }
-    return `document.querySelector('${sel}')`;
-  }
-  if (cmd.target.type === "identifier") {
-    const val = cmd.target.value;
-    if (val === "me") return "_ctx.me";
-    return val;
-  }
-  return "_ctx.me";
+function resolveTarget2(key) {
+  return key === "me" ? "_ctx.me" : `document.getElementById('${key.slice(1)}')`;
+}
+function reordersClass(run, op) {
+  return run.some((node) => {
+    const other = extractClassOp2(node);
+    return other.command !== op.command && other.className === op.className;
+  });
 }
-function createBatchNode(run) {
+function createBatchNode(run, targetKey2) {
   const adds = [];
   const removes = [];
   const toggles = [];
@@ -27938,10 +28525,9 @@ function createBatchNode(run) {
         break;
     }
   }
-  const target = resolveTarget2(run[0]);
   return {
     type: "batchedClassOps",
-    target,
+    target: resolveTarget2(targetKey2),
     adds,
     removes,
     toggles
@@ -27950,9 +28536,10 @@ function createBatchNode(run) {
 function batchBody(nodes) {
   const result = [];
   let currentRun = [];
+  let runKey = "";
   function flushRun() {
     if (currentRun.length >= 2) {
-      result.push(createBatchNode(currentRun));
+      result.push(createBatchNode(currentRun, runKey));
     } else if (currentRun.length === 1) {
       result.push(currentRun[0]);
     }
@@ -27960,12 +28547,14 @@ function batchBody(nodes) {
   }
   for (const node of nodes) {
     const op = extractClassOp2(node);
-    if (op) {
-      if (currentRun.length > 0 && isSameTarget(currentRun[0], node)) {
+    const key = op && batchTargetKey(node);
+    if (op && key) {
+      if (currentRun.length > 0 && key === runKey && !reordersClass(currentRun, op)) {
         currentRun.push(node);
       } else {
         flushRun();
         currentRun = [node];
+        runKey = key;
       }
     } else {
       flushRun();
@@ -28210,6 +28799,70 @@ function generateExpression(node, ctx) {
   const codegen = new ExpressionCodegen(ctx);
   return codegen.generate(node);
 }
+function commandTarget(node, ...slots) {
+  if (node.target) return node.target;
+  for (const slot of slots) {
+    const found = slot === "arg" ? node.args?.[0] : node.modifiers?.[slot];
+    if (isNode2(found)) return found;
+  }
+  return void 0;
+}
+function isScopedQuery(node) {
+  const binary = node;
+  return binary?.type === "binary" && binary.operator === "in" && binary.left.type === "selector";
+}
+function allMatches(node, ctx) {
+  if (isScopedQuery(node)) return ctx.generateExpression(node);
+  if (node?.type !== "selector") return null;
+  const selector = node.value;
+  return /^#[\w-]+$/.test(selector) ? null : `document.querySelectorAll('${sanitizeSelector(selector)}')`;
+}
+function forEachTarget(node, ctx, op) {
+  const all = allMatches(node, ctx);
+  if (all) return `${all}.forEach(el => ${op("el")})`;
+  return op(node ? ctx.generateExpression(node) : "_ctx.me");
+}
+function variableStore(node, ctx) {
+  let name;
+  let scope;
+  if (node.type === "variable") {
+    name = node.name;
+    scope = node.scope;
+  } else if (node.type === "identifier") {
+    name = node.value ?? node.name ?? "";
+    if (/^(\$|::)/.test(name)) scope = "global";
+    else if (/^[A-Za-z_]\w*$/.test(name)) scope = "local";
+    else return null;
+  } else {
+    return null;
+  }
+  const key = sanitizeIdentifier(name.replace(/^(\$|::|:)/, ""));
+  if (scope === "global") {
+    ctx.requireHelper("globals");
+    return { read: `_rt.globals.get('${key}')`, write: (v2) => `_rt.globals.set('${key}', ${v2})` };
+  }
+  if (scope === "element") {
+    ctx.requireHelper("elementVars");
+    const store = `_rt.elementVars(_ctx.me)`;
+    return { read: `${store}.get('${key}')`, write: (v2) => `${store}.set('${key}', ${v2})` };
+  }
+  return { read: `_ctx.locals.get('${key}')`, write: (v2) => `_ctx.locals.set('${key}', ${v2})` };
+}
+function scrollOptions(modifiers) {
+  const word = (slot) => {
+    const value = modifiers?.[slot]?.value;
+    return typeof value === "string" ? value : void 0;
+  };
+  const position = word("position") ?? "";
+  const options = [];
+  if (SCROLL_BLOCK[position]) options.push(`block: '${SCROLL_BLOCK[position]}'`);
+  if (SCROLL_INLINE[position]) options.push(`inline: '${SCROLL_INLINE[position]}'`);
+  const behavior = modifiers?.smooth ? "smooth" : word("behavior");
+  options.push(
+    `behavior: '${behavior === "smooth" || behavior === "instant" ? behavior : "auto"}'`
+  );
+  return `{ ${options.join(", ")} }`;
+}
 function generateIf(node, ctx, generateBody) {
   const exprCodegen = new ExpressionCodegen(ctx);
   const condition = exprCodegen.generate(node.condition);
@@ -28234,49 +28887,85 @@ ${elseBody}
   }
   return code;
 }
+function emitLoop(parts) {
+  const pass = [
+    ...parts.elseBody !== void 0 ? ["_ran = true;"] : [],
+    ...parts.enter ? [parts.enter] : [],
+    ...parts.indexName ? [`_ctx.locals.set('${sanitizeIdentifier(parts.indexName)}', _i);`] : [],
+    parts.body
+  ].join("\n");
+  const step = parts.step ? `_i++, ${parts.step}` : "_i++";
+  const loop = parts.bottomTested ? (
+    // A `continue` jumps straight to the test, so the counter moves there.
+    `let _i = 0;
+do {
+${pass}
+} while ((${step}, ${parts.test}));`
+  ) : `for (let _i = 0; ${parts.test}; ${step}) {
+${pass}
+}`;
+  if (parts.elseBody === void 0) return parts.bottomTested ? `{
+${loop}
+}` : loop;
+  return `{
+let _ran = false;
+${loop}
+if (!_ran) {
+${parts.elseBody}
+}
+}`;
+}
 function generateRepeat(node, ctx, generateBody) {
   const exprCodegen = new ExpressionCodegen(ctx);
-  const body = generateBody(node.body);
+  const shared = {
+    indexName: node.indexName,
+    body: generateBody(node.body),
+    elseBody: node.elseBody ? generateBody(node.elseBody) : void 0
+  };
   if (node.count !== void 0) {
     const count = typeof node.count === "number" ? String(node.count) : exprCodegen.generate(node.count);
-    return `for (let _i = 0; _i < ${count}; _i++) {
-  _ctx.locals.set('index', _i);
-${body}
-}`;
+    return emitLoop({ ...shared, test: `_i < ${count}`, indexName: node.indexName ?? "index" });
   }
   if (node.whileCondition) {
-    const condition = exprCodegen.generate(node.whileCondition);
-    return `while (${condition}) {
-${body}
+    return emitLoop({ ...shared, test: exprCodegen.generate(node.whileCondition) });
+  }
+  if (node.untilEvent !== void 0) {
+    ctx.requireHelper("wait");
+    const target = node.untilEventTarget ? exprCodegen.generate(node.untilEventTarget) : "_ctx.me";
+    return `{
+let _fired = false;
+${target}.addEventListener(${JSON.stringify(node.untilEvent)}, () => { _fired = true; }, { once: true });
+${emitLoop({ ...shared, test: "!_fired", step: "await _rt.wait(0)" })}
 }`;
   }
-  return `while (true) {
-${body}
-}`;
+  return emitLoop({ ...shared, test: "true" });
 }
 function generateForEach(node, ctx, generateBody) {
   const exprCodegen = new ExpressionCodegen(ctx);
-  const collection = exprCodegen.generate(node.collection);
+  const source = node.collection;
+  const collection = source.type === "selector" && !String(source.value).startsWith("#") ? `document.querySelectorAll('${sanitizeSelector(String(source.value))}')` : exprCodegen.generate(source);
   const itemName = sanitizeIdentifier(node.itemName);
-  const indexName = node.indexName ? sanitizeIdentifier(node.indexName) : "index";
-  const body = generateBody(node.body);
   return `{
   const _collection = ${collection};
-  const _arr = Array.isArray(_collection) ? _collection : Array.from(_collection);
-  for (let _i = 0; _i < _arr.length; _i++) {
-    _ctx.locals.set('${itemName}', _arr[_i]);
-    _ctx.locals.set('${indexName}', _i);
-${body}
-  }
+  const _arr = _collection == null ? [] : Array.isArray(_collection) ? _collection : Array.from(_collection);
+${emitLoop({
+    test: "_i < _arr.length",
+    enter: `_ctx.locals.set('${itemName}', _arr[_i]);`,
+    indexName: node.indexName ?? "index",
+    body: generateBody(node.body),
+    elseBody: node.elseBody ? generateBody(node.elseBody) : void 0
+  })}
 }`;
 }
 function generateWhile(node, ctx, generateBody) {
   const exprCodegen = new ExpressionCodegen(ctx);
-  const condition = exprCodegen.generate(node.condition);
-  const body = generateBody(node.body);
-  return `while (${condition}) {
-${body}
-}`;
+  return emitLoop({
+    test: exprCodegen.generate(node.condition),
+    bottomTested: node.bottomTested,
+    indexName: node.indexName,
+    body: generateBody(node.body),
+    elseBody: node.elseBody ? generateBody(node.elseBody) : void 0
+  });
 }
 function generateCommand(node, ctx) {
   const codegen = commandCodegens.get(node.name);
@@ -28351,7 +29040,7 @@ async function createMultilingualCompiler() {
   }
   return compiler;
 }
-var import_framework2, DEFAULT_OPTIONS, ELEMENT_REGEX, SCRIPT_TAG_REGEX, ID_REGEX, CLASS_REGEX, LANG_REGEX, HTMLScanner, VueScanner, SvelteScanner, JSXScanner, Analyzer, AnalysisVisitor, CLASS_COMMANDS, ClassBatchingPass, ConstantFoldingPass, SelectorCachingPass, DeadCodeEliminationPass, LoopUnrollingPass, OptimizationPipeline, ExpressionCodegen, ToggleCodegen, AddCodegen, RemoveCodegen, SetCodegen, PutCodegen, ShowCodegen, HideCodegen, FocusCodegen, BlurCodegen, LogCodegen, WaitCodegen, FetchCodegen, SendCodegen, IncrementCodegen, DecrementCodegen, HaltCodegen, ExitCodegen, ReturnCodegen, CallCodegen, ScrollCodegen, TakeCodegen, UnlessCodegen, ThrowCodegen, DefaultCodegen, GoCodegen, AppendCodegen, PickCodegen, PushUrlCodegen, ReplaceUrlCodegen, GetCodegen, BreakCodegen, ContinueCodegen, BeepCodegen, JsCodegen, CopyCodegen, MakeCodegen, SwapCodegen, MorphCodegen, TransitionCodegen, MeasureCodegen, SettleCodegen, TellCodegen, AsyncCodegen, InstallCodegen, RenderCodegen, commandCodegens, EventHandlerCodegen, DEFAULT_COMPILE_OPTIONS, DEFAULT_CODEGEN_OPTIONS, AOTCompiler, VERSION2;
+var import_framework2, DEFAULT_OPTIONS, ELEMENT_REGEX, SCRIPT_TAG_REGEX, ID_REGEX, CLASS_REGEX, LANG_REGEX, HTMLScanner, VueScanner, SvelteScanner, JSXScanner, Analyzer, AnalysisVisitor, TARGET_SLOTS, ClassBatchingPass, ConstantFoldingPass, SelectorCachingPass, DeadCodeEliminationPass, LoopUnrollingPass, OptimizationPipeline, ExpressionCodegen, isNode2, ToggleCodegen, AddCodegen, RemoveCodegen, SetCodegen, PutCodegen, ShowCodegen, HideCodegen, EmptyCodegen, FocusCodegen, BlurCodegen, LogCodegen, WaitCodegen, FetchCodegen, SendCodegen, IncrementCodegen, DecrementCodegen, HaltCodegen, ExitCodegen, ReturnCodegen, CallCodegen, SCROLL_BLOCK, SCROLL_INLINE, ScrollCodegen, TakeCodegen, UnlessCodegen, ThrowCodegen, DefaultCodegen, GoCodegen, AppendCodegen, PickCodegen, PushUrlCodegen, ReplaceUrlCodegen, GetCodegen, BreakCodegen, ContinueCodegen, BeepCodegen, JsCodegen, CopyCodegen, MakeCodegen, SwapCodegen, MorphCodegen, TransitionCodegen, MeasureCodegen, SettleCodegen, TellCodegen, AsyncCodegen, InstallCodegen, RenderCodegen, commandCodegens, EventHandlerCodegen, DEFAULT_COMPILE_OPTIONS, DEFAULT_CODEGEN_OPTIONS, AOTCompiler, VERSION2;
 var init_dist3 = __esm({
   "../aot-compiler/dist/index.js"() {
     "use strict";
@@ -28720,6 +29409,13 @@ var init_dist3 = __esm({
       }
       visitCommand(node) {
         this.commandsUsed.add(node.name);
+        if (["set", "increment", "decrement", "default"].includes(node.name)) {
+          const target = node.roles?.destination ?? node.roles?.patient ?? node.args?.[0];
+          const name = target?.type === "identifier" ? target.value : void 0;
+          if (name && /^[A-Za-z_]\w*$/.test(name)) {
+            this.registerVariable(name, "local", "write");
+          }
+        }
         switch (node.name) {
           case "fetch":
             this.hasAsync = true;
@@ -28801,32 +29497,37 @@ var init_dist3 = __esm({
         if (node.whileCondition) {
           this.visit(node.whileCondition);
         }
-        for (const child of node.body) {
-          this.visit(child);
+        if (node.untilEvent !== void 0) {
+          this.hasAsync = true;
+          this.runtimeHelpers.add("wait");
+          if (node.untilEventTarget) this.visit(node.untilEventTarget);
         }
+        this.visitLoopBody(node);
         this.exitNesting();
       }
       visitForEach(node) {
         this.hasLoops = true;
         this.enterNesting();
         this.registerVariable(node.itemName, "local", "write");
-        if (node.indexName) {
-          this.registerVariable(node.indexName, "local", "write");
-        }
         this.visit(node.collection);
-        for (const child of node.body) {
-          this.visit(child);
-        }
+        this.visitLoopBody(node);
         this.exitNesting();
       }
       visitWhile(node) {
         this.hasLoops = true;
         this.enterNesting();
         this.visit(node.condition);
-        for (const child of node.body) {
+        this.visitLoopBody(node);
+        this.exitNesting();
+      }
+      /** The parts every loop form shares: its `index` local, body, and `else`. */
+      visitLoopBody(node) {
+        if (node.indexName) {
+          this.registerVariable(node.indexName, "local", "write");
+        }
+        for (const child of [...node.body, ...node.elseBody ?? []]) {
           this.visit(child);
         }
-        this.exitNesting();
       }
       visitVariable(node, access) {
         const name = node.name.startsWith(":") || node.name.startsWith("$") ? node.name.slice(1) : node.name;
@@ -28975,7 +29676,11 @@ var init_dist3 = __esm({
         }
       }
     };
-    CLASS_COMMANDS = /* @__PURE__ */ new Set(["add", "remove", "toggle"]);
+    TARGET_SLOTS = /* @__PURE__ */ new Map([
+      ["add", "to"],
+      ["remove", "from"],
+      ["toggle", "on"]
+    ]);
     ClassBatchingPass = class {
       constructor() {
         this.name = "class-batching";
@@ -29253,6 +29958,9 @@ var init_dist3 = __esm({
         if (this.usesIndex(body)) {
           return null;
         }
+        if (repeatNode.indexName !== void 0 || repeatNode.elseBody !== void 0) {
+          return null;
+        }
         const unrolled = [];
         for (let i = 0; i < count; i++) {
           unrolled.push(...this.cloneBody(body));
@@ -29381,6 +30089,8 @@ var init_dist3 = __esm({
             return this.generateTemplate(node);
           case "unary":
             return this.generateUnary(node);
+          case "typeCheck":
+            return this.generateTypeCheck(node);
           case "conditional":
             return this.generateConditional(node);
           case "sequence":
@@ -29455,6 +30165,9 @@ var init_dist3 = __esm({
               this.ctx.requireHelper("globals");
               return `_rt.globals.get('${varName}')`;
             }
+            if (this.ctx.analysis?.variables?.locals?.get(name)?.scope === "local") {
+              return `_ctx.locals.get('${sanitizeIdentifier(name)}')`;
+            }
             return sanitizeIdentifier(name);
         }
       }
@@ -29488,7 +30201,8 @@ var init_dist3 = __esm({
             this.ctx.requireHelper("globals");
             return `_rt.globals.get('${varName}')`;
           case "element":
-            return `_ctx.me.${varName}`;
+            this.ctx.requireHelper("elementVars");
+            return `_rt.elementVars(_ctx.me).get('${varName}')`;
           default:
             return `_ctx.locals.get('${varName}')`;
         }
@@ -29501,19 +30215,40 @@ var init_dist3 = __esm({
         const right = this.generate(node.right);
         const op = node.operator;
         switch (op) {
-          // Equality
+          // Equality, with core's phrase forms of each (`n is equal to 3`).
           case "is":
           case "==":
+          case "am":
+          case "equals":
+          case "is equal":
+          case "is equal to":
             return `(${left} === ${right})`;
           case "is not":
           case "!=":
+          case "is not equal":
+          case "is not equal to":
             return `(${left} !== ${right})`;
-          // Comparison
+          case "really equals":
+          case "is really":
+          case "is really equal to":
+            return `(${left} === ${right})`;
+          case "is not really":
+          case "is not really equal to":
+            return `(${left} !== ${right})`;
+          // Comparison. Left as is, `(n is greater than 2)` is not JavaScript.
           case "<":
           case ">":
           case "<=":
           case ">=":
             return `(${left} ${op} ${right})`;
+          case "is less than":
+            return `(${left} < ${right})`;
+          case "is greater than":
+            return `(${left} > ${right})`;
+          case "is less than or equal to":
+            return `(${left} <= ${right})`;
+          case "is greater than or equal to":
+            return `(${left} >= ${right})`;
           // Arithmetic
           case "+":
           case "-":
@@ -29521,6 +30256,9 @@ var init_dist3 = __esm({
           case "/":
           case "%":
             return `(${left} ${op} ${right})`;
+          // Hyperscript's word for `%`; left as is, `(n mod 2)` is not JavaScript.
+          case "mod":
+            return `(${left} % ${right})`;
           // Logical
           case "and":
           case "&&":
@@ -29530,15 +30268,49 @@ var init_dist3 = __esm({
             return `(${left} || ${right})`;
           // String/collection operators
           case "contains":
+          case "contain":
+          case "includes":
+          case "include":
             this.ctx.requireHelper("contains");
             return `_rt.contains(${left}, ${right})`;
+          case "does not contain":
+          case "do not contain":
+          case "does not contains":
+          case "does not include":
+            this.ctx.requireHelper("contains");
+            return `!_rt.contains(${left}, ${right})`;
+          // `matches` tests a selector, so a selector operand stays a string: the
+          // element it would query is not a selector (`_rt.matches(el, el)`).
           case "matches":
+          case "match":
+            this.ctx.requireHelper("matches");
+            return `_rt.matches(${left}, ${this.selectorText(node.right, right)})`;
+          case "does not match":
+          case "do not match":
             this.ctx.requireHelper("matches");
-            return `_rt.matches(${left}, ${right})`;
+            return `!_rt.matches(${left}, ${this.selectorText(node.right, right)})`;
+          // Membership, `n is in [1, 3]`: the right side contains the left.
+          case "is in":
+          case "am in":
+            this.ctx.requireHelper("contains");
+            return `_rt.contains(${right}, ${left})`;
+          case "is not in":
+          case "am not in":
+            this.ctx.requireHelper("contains");
+            return `!_rt.contains(${right}, ${left})`;
           case "starts with":
             return `${left}.startsWith(${right})`;
           case "ends with":
             return `${left}.endsWith(${right})`;
+          // A scoped query, `<li/> in #list`: the matches inside the scope, as
+          // both engines read it. JavaScript's `in` (the default below) tests a
+          // property KEY, so `(document.querySelector('li') in …)` matched nothing.
+          case "in":
+            if (node.left.type === "selector") {
+              const query = sanitizeSelector(node.left.value);
+              return `${right}.querySelectorAll('${query}')`;
+            }
+            return `(${left} ${op} ${right})`;
           // Class check
           case "has":
             if (node.right.type === "selector") {
@@ -29566,13 +30338,18 @@ var init_dist3 = __esm({
             return `(${left} ${op} ${right})`;
         }
       }
+      /** A selector operand as its quoted text; any other operand as generated. */
+      selectorText(node, generated) {
+        return node.type === "selector" ? `'${sanitizeSelector(node.value)}'` : generated;
+      }
       // ===========================================================================
       // MEMBER EXPRESSIONS
       // ===========================================================================
       generateMember(node) {
         const object = this.generate(node.object);
-        if (typeof node.property === "string") {
-          const prop = node.property;
+        const property = node.property;
+        const prop = typeof property === "string" ? property : !node.computed && property.type === "identifier" ? property.value ?? property.name : void 0;
+        if (prop !== void 0) {
           if (prop.startsWith("*")) {
             const styleProp = prop.slice(1);
             return `${object}.style.${styleProp}`;
@@ -29754,6 +30531,12 @@ var init_dist3 = __esm({
       // ===========================================================================
       // UNARY EXPRESSIONS
       // ===========================================================================
+      /** `x is a Number`, as both engines test it: see the runtime's `typeCheck`. */
+      generateTypeCheck(node) {
+        this.ctx.requireHelper("typeCheck");
+        const test = `_rt.typeCheck(${this.generate(node.value)}, ${JSON.stringify(node.typeName)}, ${node.nullOk})`;
+        return node.negated ? `!${test}` : test;
+      }
       generateUnary(node) {
         const operand = this.generate(node.operand);
         switch (node.operator) {
@@ -29766,6 +30549,22 @@ var init_dist3 = __esm({
             return `+${operand}`;
           case "no":
             return `!${operand}`;
+          // Core's postfix tests. Left as is, `exists#d1` is not JavaScript.
+          case "exists":
+          case "some":
+            this.ctx.requireHelper("exists");
+            return `_rt.exists(${operand})`;
+          case "does not exist":
+            this.ctx.requireHelper("exists");
+            return `!_rt.exists(${operand})`;
+          case "is empty":
+            this.ctx.requireHelper("isEmpty");
+            return `_rt.isEmpty(${operand})`;
+          case "is not empty":
+            this.ctx.requireHelper("isEmpty");
+            return `!_rt.isEmpty(${operand})`;
+          case "beep!":
+            return `((v) => (console.log('%c[beep]', 'color: orange; font-weight: bold', v), v))(${operand})`;
           default:
             return `${node.operator}${operand}`;
         }
@@ -29780,6 +30579,7 @@ var init_dist3 = __esm({
         return `(${condition} ? ${consequent} : ${alternate})`;
       }
     };
+    isNode2 = (value) => typeof value === "object" && value !== null && "type" in value;
     ToggleCodegen = class {
       constructor() {
         this.command = "toggle";
@@ -29787,22 +30587,15 @@ var init_dist3 = __esm({
       generate(node, ctx) {
         const args = node.args ?? [];
         if (args.length === 0) return null;
-        const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+        const targetNode = commandTarget(node, "on");
         const arg = args[0];
         if (arg.type === "selector") {
           const selector = arg.value;
           if (selector.startsWith(".")) {
             const className = sanitizeClassName(selector.slice(1));
             if (!className) return null;
-            if (target === "_ctx.me") {
-              return {
-                code: `_ctx.me.classList.toggle('${className}')`,
-                async: false,
-                sideEffects: true
-              };
-            }
             return {
-              code: `Array.from(document.querySelectorAll('${sanitizeSelector(selector.slice(1))}')).forEach(el => el.classList.toggle('${className}'))`,
+              code: forEachTarget(targetNode, ctx, (el) => `${el}.classList.toggle('${className}')`),
               async: false,
               sideEffects: true
             };
@@ -29814,7 +30607,11 @@ var init_dist3 = __esm({
             const attrName = value.slice(1);
             ctx.requireHelper("toggleAttr");
             return {
-              code: `_rt.toggleAttr(${target}, '${sanitizeSelector(attrName)}')`,
+              code: forEachTarget(
+                targetNode,
+                ctx,
+                (el) => `_rt.toggleAttr(${el}, '${sanitizeSelector(attrName)}')`
+              ),
               async: false,
               sideEffects: true
             };
@@ -29822,7 +30619,11 @@ var init_dist3 = __esm({
         }
         ctx.requireHelper("toggle");
         return {
-          code: `_rt.toggle(${ctx.generateExpression(arg)}, ${target})`,
+          code: forEachTarget(
+            targetNode,
+            ctx,
+            (el) => `_rt.toggle(${ctx.generateExpression(arg)}, ${el})`
+          ),
           async: false,
           sideEffects: true
         };
@@ -29843,15 +30644,8 @@ var init_dist3 = __esm({
           if (selector.startsWith(".")) {
             const className = sanitizeClassName(selector.slice(1));
             if (!className) return null;
-            if (target === "_ctx.me") {
-              return {
-                code: `_ctx.me.classList.add('${className}')`,
-                async: false,
-                sideEffects: true
-              };
-            }
             return {
-              code: `${target}.classList.add('${className}')`,
+              code: forEachTarget(targetSlot, ctx, (el) => `${el}.classList.add('${className}')`),
               async: false,
               sideEffects: true
             };
@@ -29874,7 +30668,11 @@ var init_dist3 = __esm({
         }
         ctx.requireHelper("addClass");
         return {
-          code: `_rt.addClass(${target}, ${ctx.generateExpression(arg)})`,
+          code: forEachTarget(
+            targetSlot,
+            ctx,
+            (el) => `_rt.addClass(${el}, ${ctx.generateExpression(arg)})`
+          ),
           async: false,
           sideEffects: true
         };
@@ -29888,23 +30686,29 @@ var init_dist3 = __esm({
         const args = node.args ?? [];
         if (args.length === 0) {
           const targetSlot2 = node.target ?? node.modifiers?.from;
-          const target2 = targetSlot2 ? ctx.generateExpression(targetSlot2) : "_ctx.me";
           return {
-            code: `${target2}.remove()`,
+            code: forEachTarget(targetSlot2, ctx, (el) => `${el}.remove()`),
             async: false,
             sideEffects: true
           };
         }
         const targetSlot = node.target ?? node.modifiers?.from;
-        const target = targetSlot ? ctx.generateExpression(targetSlot) : "_ctx.me";
         const arg = args[0];
+        const isElement2 = arg.type === "selector" ? !/^[.@]/.test(arg.value) : arg.type === "identifier" && !String(arg.value ?? "").startsWith("@") || arg.type === "variable" || isScopedQuery(arg);
+        if (!targetSlot && isElement2) {
+          return {
+            code: forEachTarget(arg, ctx, (el) => `${el}.remove()`),
+            async: false,
+            sideEffects: true
+          };
+        }
         if (arg.type === "selector") {
           const selector = arg.value;
           if (selector.startsWith(".")) {
             const className = sanitizeClassName(selector.slice(1));
             if (!className) return null;
             return {
-              code: `${target}.classList.remove('${className}')`,
+              code: forEachTarget(targetSlot, ctx, (el) => `${el}.classList.remove('${className}')`),
               async: false,
               sideEffects: true
             };
@@ -29912,7 +30716,11 @@ var init_dist3 = __esm({
         }
         ctx.requireHelper("removeClass");
         return {
-          code: `_rt.removeClass(${target}, ${ctx.generateExpression(arg)})`,
+          code: forEachTarget(
+            targetSlot,
+            ctx,
+            (el) => `_rt.removeClass(${el}, ${ctx.generateExpression(arg)})`
+          ),
           async: false,
           sideEffects: true
         };
@@ -29930,26 +30738,8 @@ var init_dist3 = __esm({
         const valueNode = roles?.patient ?? modifiers?.to ?? args[1];
         if (!targetNode || !valueNode) return null;
         const value = ctx.generateExpression(valueNode);
-        if (targetNode.type === "variable") {
-          const varNode = targetNode;
-          const name = varNode.name.startsWith(":") ? varNode.name.slice(1) : varNode.name;
-          const safeName = sanitizeIdentifier(name);
-          if (varNode.scope === "local") {
-            return {
-              code: `_ctx.locals.set('${safeName}', ${value})`,
-              async: false,
-              sideEffects: true
-            };
-          }
-          if (varNode.scope === "global") {
-            ctx.requireHelper("globals");
-            return {
-              code: `_rt.globals.set('${safeName}', ${value})`,
-              async: false,
-              sideEffects: true
-            };
-          }
-        }
+        const store = variableStore(targetNode, ctx);
+        if (store) return { code: store.write(value), async: false, sideEffects: true };
         if (targetNode.type === "possessive") {
           const possessive = targetNode;
           const obj = ctx.generateExpression(possessive.object);
@@ -29998,20 +30788,17 @@ var init_dist3 = __esm({
         const contentNode = roles?.patient ?? args[0];
         if (!contentNode) return null;
         const content = ctx.generateExpression(contentNode);
-        let target = "_ctx.me";
-        if (roles?.destination) {
-          target = ctx.generateExpression(roles.destination);
-        } else if (modifiers) {
+        let targetNode = roles?.destination;
+        if (!targetNode && modifiers) {
           for (const key of ["into", "before", "after"]) {
             if (modifiers[key] && typeof modifiers[key] === "object") {
-              target = ctx.generateExpression(modifiers[key]);
+              targetNode = modifiers[key];
               break;
             }
           }
         }
-        if (target === "_ctx.me" && node.target) {
-          target = ctx.generateExpression(node.target);
-        }
+        targetNode ?? (targetNode = node.target);
+        const into = (op) => forEachTarget(targetNode, ctx, op);
         let modifier = "into";
         if (roles?.method && roles.method.value) {
           modifier = String(roles.method.value);
@@ -30023,39 +30810,39 @@ var init_dist3 = __esm({
         switch (modifier) {
           case "into":
             return {
-              code: `${target}.innerHTML = ${content}`,
+              code: into((el) => `${el}.innerHTML = ${content}`),
               async: false,
               sideEffects: true
             };
           case "before":
             return {
-              code: `${target}.insertAdjacentHTML('beforebegin', ${content})`,
+              code: into((el) => `${el}.insertAdjacentHTML('beforebegin', ${content})`),
               async: false,
               sideEffects: true
             };
           case "after":
             return {
-              code: `${target}.insertAdjacentHTML('afterend', ${content})`,
+              code: into((el) => `${el}.insertAdjacentHTML('afterend', ${content})`),
               async: false,
               sideEffects: true
             };
           case "at start of":
           case "start":
             return {
-              code: `${target}.insertAdjacentHTML('afterbegin', ${content})`,
+              code: into((el) => `${el}.insertAdjacentHTML('afterbegin', ${content})`),
               async: false,
               sideEffects: true
             };
           case "at end of":
           case "end":
             return {
-              code: `${target}.insertAdjacentHTML('beforeend', ${content})`,
+              code: into((el) => `${el}.insertAdjacentHTML('beforeend', ${content})`),
               async: false,
               sideEffects: true
             };
           default:
             return {
-              code: `${target}.innerHTML = ${content}`,
+              code: into((el) => `${el}.innerHTML = ${content}`),
               async: false,
               sideEffects: true
             };
@@ -30067,9 +30854,9 @@ var init_dist3 = __esm({
         this.command = "show";
       }
       generate(node, ctx) {
-        const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+        const targetNode = commandTarget(node, "arg");
         return {
-          code: `${target}.style.display = ''`,
+          code: forEachTarget(targetNode, ctx, (el) => `${el}.style.display = ''`),
           async: false,
           sideEffects: true
         };
@@ -30080,9 +30867,22 @@ var init_dist3 = __esm({
         this.command = "hide";
       }
       generate(node, ctx) {
-        const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+        const targetNode = commandTarget(node, "arg");
+        return {
+          code: forEachTarget(targetNode, ctx, (el) => `${el}.style.display = 'none'`),
+          async: false,
+          sideEffects: true
+        };
+      }
+    };
+    EmptyCodegen = class {
+      constructor() {
+        this.command = "empty";
+      }
+      generate(node, ctx) {
+        const targetNode = commandTarget(node, "arg");
         return {
-          code: `${target}.style.display = 'none'`,
+          code: forEachTarget(targetNode, ctx, (el) => `${el}.replaceChildren()`),
           async: false,
           sideEffects: true
         };
@@ -30093,7 +30893,8 @@ var init_dist3 = __esm({
         this.command = "focus";
       }
       generate(node, ctx) {
-        const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+        const targetNode = commandTarget(node, "arg");
+        const target = targetNode ? ctx.generateExpression(targetNode) : "_ctx.me";
         return {
           code: `${target}.focus()`,
           async: false,
@@ -30106,7 +30907,8 @@ var init_dist3 = __esm({
         this.command = "blur";
       }
       generate(node, ctx) {
-        const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+        const targetNode = commandTarget(node, "arg");
+        const target = targetNode ? ctx.generateExpression(targetNode) : "_ctx.me";
         return {
           code: `${target}.blur()`,
           async: false,
@@ -30227,11 +31029,11 @@ var init_dist3 = __esm({
         const args = node.args ?? [];
         if (args.length === 0) return null;
         const eventName = ctx.generateExpression(args[0]);
-        const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+        const targetNode = commandTarget(node, "on", "to");
         const detail = args.length > 1 ? ctx.generateExpression(args[1]) : "undefined";
         ctx.requireHelper("send");
         return {
-          code: `_rt.send(${target}, ${eventName}, ${detail})`,
+          code: forEachTarget(targetNode, ctx, (el) => `_rt.send(${el}, ${eventName}, ${detail})`),
           async: false,
           sideEffects: true
         };
@@ -30249,25 +31051,10 @@ var init_dist3 = __esm({
         if (!target) return null;
         const amountNode = roles?.quantity ?? modifiers?.by ?? args[1];
         const amount = amountNode ? ctx.generateExpression(amountNode) : "1";
-        if (target.type === "variable") {
-          const varNode = target;
-          const name = varNode.name.startsWith(":") ? varNode.name.slice(1) : varNode.name;
-          const safeName = sanitizeIdentifier(name);
-          if (varNode.scope === "local") {
-            return {
-              code: `_ctx.locals.set('${safeName}', (_ctx.locals.get('${safeName}') || 0) + ${amount})`,
-              async: false,
-              sideEffects: true
-            };
-          }
-          if (varNode.scope === "global") {
-            ctx.requireHelper("globals");
-            return {
-              code: `_rt.globals.set('${safeName}', (_rt.globals.get('${safeName}') || 0) + ${amount})`,
-              async: false,
-              sideEffects: true
-            };
-          }
+        const store = variableStore(target, ctx);
+        if (store) {
+          const code = store.write(`(Number(${store.read}) || 0) + ${amount}`);
+          return { code, async: false, sideEffects: true };
         }
         const targetCode = ctx.generateExpression(target);
         return {
@@ -30289,25 +31076,10 @@ var init_dist3 = __esm({
         if (!target) return null;
         const amountNode = roles?.quantity ?? modifiers?.by ?? args[1];
         const amount = amountNode ? ctx.generateExpression(amountNode) : "1";
-        if (target.type === "variable") {
-          const varNode = target;
-          const name = varNode.name.startsWith(":") ? varNode.name.slice(1) : varNode.name;
-          const safeName = sanitizeIdentifier(name);
-          if (varNode.scope === "local") {
-            return {
-              code: `_ctx.locals.set('${safeName}', (_ctx.locals.get('${safeName}') || 0) - ${amount})`,
-              async: false,
-              sideEffects: true
-            };
-          }
-          if (varNode.scope === "global") {
-            ctx.requireHelper("globals");
-            return {
-              code: `_rt.globals.set('${safeName}', (_rt.globals.get('${safeName}') || 0) - ${amount})`,
-              async: false,
-              sideEffects: true
-            };
-          }
+        const store = variableStore(target, ctx);
+        if (store) {
+          const code = store.write(`(Number(${store.read}) || 0) - ${amount}`);
+          return { code, async: false, sideEffects: true };
         }
         const targetCode = ctx.generateExpression(target);
         return {
@@ -30372,17 +31144,22 @@ var init_dist3 = __esm({
         };
       }
     };
+    SCROLL_BLOCK = {
+      top: "start",
+      middle: "center",
+      bottom: "end",
+      nearest: "nearest"
+    };
+    SCROLL_INLINE = { left: "start", center: "center", right: "end" };
     ScrollCodegen = class {
       constructor() {
         this.command = "scroll";
       }
       generate(node, ctx) {
-        const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
-        const mods = node.modifiers;
-        const smooth = mods?.smooth || mods?.behavior?.value === "smooth";
-        const behavior = smooth ? "'smooth'" : "'auto'";
+        const targetNode = commandTarget(node, "arg", "of");
+        const target = targetNode ? ctx.generateExpression(targetNode) : "_ctx.me";
         return {
-          code: `${target}.scrollIntoView({ behavior: ${behavior} })`,
+          code: `${target}.scrollIntoView(${scrollOptions(node.modifiers)})`,
           async: false,
           sideEffects: true
         };
@@ -30392,7 +31169,7 @@ var init_dist3 = __esm({
       constructor() {
         this.command = "take";
       }
-      generate(node, _ctx) {
+      generate(node, ctx) {
         const args = node.args ?? [];
         if (args.length === 0) return null;
         const arg = args[0];
@@ -30401,6 +31178,19 @@ var init_dist3 = __esm({
         if (!selector.startsWith(".")) return null;
         const className = sanitizeClassName(selector.slice(1));
         if (!className) return null;
+        const source = commandTarget(node, "from");
+        if (source) {
+          let from = allMatches(source, ctx);
+          if (!from) {
+            ctx.requireHelper("toArray");
+            from = `_rt.toArray(${ctx.generateExpression(source)})`;
+          }
+          return {
+            code: `(() => { ${from}.forEach(el => el.classList.remove('${className}')); _ctx.me.classList.add('${className}'); })()`,
+            async: false,
+            sideEffects: true
+          };
+        }
         return {
           code: `(() => { const _me = _ctx.me; _me.parentElement?.querySelectorAll('.${className}').forEach(el => el.classList.remove('${className}')); _me.classList.add('${className}'); })()`,
           async: false,
@@ -30449,25 +31239,10 @@ var init_dist3 = __esm({
         const valueNode = roles?.patient ?? modifiers?.to ?? args[1];
         if (!targetNode || !valueNode) return null;
         const value = ctx.generateExpression(valueNode);
-        if (targetNode.type === "variable") {
-          const varNode = targetNode;
-          const name = varNode.name.startsWith(":") ? varNode.name.slice(1) : varNode.name;
-          const safeName = sanitizeIdentifier(name);
-          if (varNode.scope === "local") {
-            return {
-              code: `if (_ctx.locals.get('${safeName}') == null) _ctx.locals.set('${safeName}', ${value})`,
-              async: false,
-              sideEffects: true
-            };
-          }
-          if (varNode.scope === "global") {
-            ctx.requireHelper("globals");
-            return {
-              code: `if (_rt.globals.get('${safeName}') == null) _rt.globals.set('${safeName}', ${value})`,
-              async: false,
-              sideEffects: true
-            };
-          }
+        const store = variableStore(targetNode, ctx);
+        if (store) {
+          const code = `if (${store.read} == null) ${store.write(value)}`;
+          return { code, async: false, sideEffects: true };
         }
         return null;
       }
@@ -30483,6 +31258,15 @@ var init_dist3 = __esm({
         if (mods?.back) {
           return { code: "history.back()", async: false, sideEffects: true };
         }
+        if (mods?.position || mods?.behavior) {
+          const element = roles?.destination ?? args[0];
+          if (!element) return null;
+          return {
+            code: `${ctx.generateExpression(element)}.scrollIntoView(${scrollOptions(mods)})`,
+            async: false,
+            sideEffects: true
+          };
+        }
         const target = mods?.url ?? roles?.destination ?? args[0];
         if (!target) return null;
         if (target.type === "identifier") {
@@ -30494,9 +31278,10 @@ var init_dist3 = __esm({
             return { code: "history.forward()", async: false, sideEffects: true };
           }
         }
-        const url = ctx.generateExpression(target);
+        ctx.requireHelper("go");
+        const newWindow = mods?.in !== void 0 ? ", true" : "";
         return {
-          code: `window.location.href = ${url}`,
+          code: `_rt.go(${ctx.generateExpression(target)}${newWindow})`,
           async: false,
           sideEffects: true
         };
@@ -30512,7 +31297,8 @@ var init_dist3 = __esm({
         const contentNode = roles?.patient ?? args[0];
         if (!contentNode) return null;
         const content = ctx.generateExpression(contentNode);
-        const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+        const targetNode = commandTarget(node, "to");
+        const target = targetNode ? ctx.generateExpression(targetNode) : "_ctx.me";
         return {
           code: `${target}.insertAdjacentHTML('beforeend', ${content})`,
           async: false,
@@ -30831,9 +31617,9 @@ var init_dist3 = __esm({
         const args = node.args ?? [];
         const roles = node.roles;
         const mods = node.modifiers;
-        const propertyNode = roles?.patient ?? args[0];
-        if (!propertyNode) return null;
-        const property = ctx.generateExpression(propertyNode);
+        const propertyNode2 = roles?.patient ?? args[0];
+        if (!propertyNode2) return null;
+        const property = ctx.generateExpression(propertyNode2);
         const valueNode = mods?.to ?? args[1];
         if (!valueNode) return null;
         const value = ctx.generateExpression(valueNode);
@@ -30891,7 +31677,8 @@ var init_dist3 = __esm({
         this.command = "settle";
       }
       generate(node, ctx) {
-        const target = node.target ? ctx.generateExpression(node.target) : "_ctx.me";
+        const targetNode = commandTarget(node, "arg");
+        const target = targetNode ? ctx.generateExpression(targetNode) : "_ctx.me";
         const mods = node.modifiers;
         const timeoutNode = mods?.for;
         const timeout = timeoutNode ? ctx.generateExpression(timeoutNode) : "5000";
@@ -31011,6 +31798,7 @@ var init_dist3 = __esm({
       ["put", new PutCodegen()],
       ["show", new ShowCodegen()],
       ["hide", new HideCodegen()],
+      ["empty", new EmptyCodegen()],
       ["focus", new FocusCodegen()],
       ["blur", new BlurCodegen()],
       ["log", new LogCodegen()],
@@ -31112,6 +31900,8 @@ var init_dist3 = __esm({
             return generateForEach(node, this.ctx, (nodes) => this.generateBody(nodes));
           case "while":
             return generateWhile(node, this.ctx, (nodes) => this.generateBody(nodes));
+          case "sequence":
+            return this.generateBody(node.commands);
           case "event": {
             const nested = node;
             return this.generateBody(nested.body ?? []);
@@ -31961,15 +32751,8 @@ var init_dist3 = __esm({
        * Create a codegen context.
        */
       createCodegenContext(handlerId, analysis, options) {
-        const selectorCache = /* @__PURE__ */ new Map();
         const requiredHelpers = /* @__PURE__ */ new Set();
         let idCounter = 0;
-        for (const info of analysis.expressions.selectors) {
-          if (info.canCache && info.usages.length > 1) {
-            const cacheKey = "_sel_" + sanitizeIdentifier(info.selector).slice(0, 20) + "_" + idCounter++;
-            selectorCache.set(info.selector, cacheKey);
-          }
-        }
         const exprCodegenRef = { current: null };
         const ctx = {
           handlerId,
@@ -31982,8 +32765,12 @@ var init_dist3 = __esm({
           },
           implicitTarget: "_ctx.me",
           localVarDeclarations: "",
-          canCacheSelector: (selector) => selectorCache.has(selector),
-          getCachedSelector: (selector) => selectorCache.get(selector) ?? `document.querySelector('${selector}')`,
+          // A selector is queried each time it is evaluated, as on both engines. The
+          // cache named a variable nothing declared (`_sel__d1_0`: a handler naming
+          // #d1 twice threw), and a declared one goes stale when the handler
+          // replaces the element.
+          canCacheSelector: () => false,
+          getCachedSelector: (selector) => `document.querySelector('${selector}')`,
           requireHelper: (name) => {
             requiredHelpers.add(name);
           },
@@ -32471,6 +33258,7 @@ function normalizeJSON(input) {
 
 // src/validation/inert-shapes.ts
 var QUANTIFIER = /^(all|every|each)\.(\S+)$/;
+var BARE_QUANTIFIER = /^(all|every|each)$/;
 var PREDICATE_AS_CLASS = /(^|\s)\.(has|is|contains|matches|includes)(\s|$)/;
 function valueString(v2) {
   return String(v2.value ?? v2.raw ?? "");
@@ -32497,6 +33285,15 @@ function walk(node, out) {
         });
         continue;
       }
+      if (v2.type === "expression" && BARE_QUANTIFIER.test(s) && (role === "destination" || role === "source")) {
+        out.push({
+          severity: "warning",
+          code: "INERT_QUANTIFIER_TARGET",
+          message: `${role} parsed as the identifier "${s}", which is undefined at runtime, so this ${role} will not resolve; the selector after it is not read.`,
+          suggestion: `Selectors already address every match: write the selector alone, without "${s}".`
+        });
+        continue;
+      }
       if (role === "condition" && v2.type === "expression" && PREDICATE_AS_CLASS.test(s)) {
         const word = PREDICATE_AS_CLASS.exec(s)?.[2];
         out.push({
@@ -32769,7 +33566,8 @@ function extractOperations(node) {
 }
 function extractEventHandler(n) {
   const eventRole = n.roles?.get("event");
-  const eventName = String(eventRole?.value ?? "click");
+  const named = eventRole?.value ?? eventRole?.raw;
+  const eventName = typeof named === "string" && named.length > 0 ? named : "click";
   const operations = [];
   if (n.body && Array.isArray(n.body)) {
     for (const child of n.body) {
@@ -34871,6 +35669,7 @@ function renderSvelteElement(el, analysis) {
 var CompilationService = class _CompilationService {
   constructor(options = {}) {
     this.translateFn = null;
+    this.translationCollisionsFn = null;
     this.confidenceThreshold = options.confidenceThreshold ?? 0.7;
     this.cache = new SemanticCache(options.cacheSize ?? 500);
     this.testRenderers = new Map(
@@ -34925,6 +35724,7 @@ var CompilationService = class _CompilationService {
       compiler
     );
     service.translateFn = semantic.translate;
+    service.translationCollisionsFn = semantic.findTranslationCollisions;
     return service;
   }
   // ===========================================================================
@@ -35049,7 +35849,7 @@ var CompilationService = class _CompilationService {
         ok: true,
         code: result,
         ...verification !== void 0 ? { verification } : {},
-        diagnostics: []
+        diagnostics: this.translationCollisions(request)
       };
     } catch (error) {
       return {
@@ -35064,6 +35864,20 @@ var CompilationService = class _CompilationService {
       };
     }
   }
+  /**
+   * A variable of the source that the target language reads as a value word
+   * (tl `ako` is `me`): the translation reads the value, and no spelling of
+   * the name tells them apart, so the fix is a rename before translating.
+   */
+  translationCollisions(request) {
+    const findings = this.translationCollisionsFn?.(request.code, request.from, request.to) ?? [];
+    return findings.map((finding) => ({
+      severity: "warning",
+      code: "NAME_COLLISION",
+      message: finding.message,
+      suggestion: finding.rename ? `Rename \`${finding.name}\` to \`${finding.rename}\` in the source (${finding.occurrences.length} place(s)), then translate.` : `Rename \`${finding.name}\` in the source, then translate.`
+    }));
+  }
   /**
    * Generate behavior-level tests from hyperscript.
    *
@@ -35305,7 +36119,27 @@ var CompilationService = class _CompilationService {
     if (!gateRef.pass || !gateCand.pass) {
       return { ok: false, diagnostics };
     }
-    return { ok: true, diagnostics, ...(0, import_fidelity.scoreNodes)(normRef.node, normCand.node) };
+    const truncated = (...lists) => lists.some((ds) => ds.some((d) => d.code === "UNCONSUMED_INPUT"));
+    const referenceComplete = !truncated(normRef.diagnostics, gateRef.diagnostics);
+    const candidateComplete = !truncated(normCand.diagnostics, gateCand.diagnostics);
+    if (!referenceComplete || !candidateComplete) {
+      const sides = [!referenceComplete && "reference", !candidateComplete && "candidate"].filter(Boolean).join(" and ");
+      diagnostics.push({
+        severity: "warning",
+        code: "INCOMPLETE_PARSE",
+        message: `The ${sides} parse left tokens unconsumed, so the scores compare only what parsed; not faithful.`,
+        suggestion: "The unconsumed tokens are named in the UNCONSUMED_INPUT diagnostics above. If the reference is truncated, a translation of it drops the same clause."
+      });
+    }
+    const report2 = (0, import_fidelity.scoreNodes)(normRef.node, normCand.node);
+    return {
+      ok: true,
+      diagnostics,
+      ...report2,
+      faithful: report2.faithful && referenceComplete && candidateComplete,
+      referenceComplete,
+      candidateComplete
+    };
   }
   /**
    * Generate a target-specific output from LSE (bracket syntax or protocol JSON).
@@ -35485,7 +36319,7 @@ function nodeToSemanticJSON(node) {
       const bodyJSON = nodeToSemanticJSON(n.body[0]);
       if (bodyJSON) {
         bodyJSON.trigger = {
-          event: eventRole?.value ?? "click",
+          event: eventNameOf(eventRole),
           modifiers: n.eventModifiers
         };
         return bodyJSON;
@@ -35495,13 +36329,17 @@ function nodeToSemanticJSON(node) {
       action: n.action,
       roles,
       trigger: {
-        event: eventRole?.value ?? "click",
+        event: eventNameOf(eventRole),
         modifiers: n.eventModifiers
       }
     };
   }
   return { action: n.action, roles };
 }
+function eventNameOf(eventRole) {
+  const name = eventRole?.value ?? eventRole?.raw;
+  return typeof name === "string" && name.length > 0 ? name : "click";
+}
 
 // src/input/json-schema.ts
 var import_ir = require("@lokascript/framework/ir");