@weave-framework/cli 0.2.0

package/dist/cli.js

@@ -0,0 +1,3086 @@
+// packages/cli/src/build.ts
+import { build as esbuild } from "esbuild";
+import { mkdir, writeFile, readFile as readFile3, rm, cp } from "node:fs/promises";
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join2 } from "node:path";
+
+// packages/cli/src/plugin.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+// packages/compiler/src/parser.ts
+var BLOCK_KW = /^@(if|else|for|empty|switch|case|default|let|defer|placeholder|await|then|catch|snippet|render|key)\b/;
+var VOID = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var ParseError = class extends Error {
+};
+function parseTemplate(input) {
+  const p = new Parser(input);
+  const nodes = p.parseChildren(null);
+  return nodes;
+}
+var Parser = class {
+  constructor(src) {
+    this.src = src;
+  }
+  pos = 0;
+  /** Inner start offset of the most recent {@link readParen} — for block-head expr offsets. */
+  parenStart = 0;
+  /** Offset of `sub`'s first non-whitespace char within `parent` (which starts at `parentStart`). */
+  exprOffset(parentStart, parent, sub) {
+    const at = parent.indexOf(sub);
+    return parentStart + (at < 0 ? 0 : at) + (sub.length - sub.trimStart().length);
+  }
+  eof() {
+    return this.pos >= this.src.length;
+  }
+  /**
+   * Parse children until `</closeTag>` (element), `}` (block body when
+   * `stopAtBrace`), or EOF. Does not consume the terminator.
+   */
+  parseChildren(closeTag, stopAtBrace = false) {
+    const out = [];
+    while (!this.eof()) {
+      if (stopAtBrace && this.peek() === "}") return out;
+      if (this.src.startsWith("</", this.pos)) {
+        if (closeTag === null) throw new ParseError(`Unexpected closing tag at ${this.pos}`);
+        return out;
+      }
+      if (this.src.startsWith("{{", this.pos)) {
+        const it = this.readInterp();
+        out.push({ type: "interp", expr: it.expr, offset: it.offset });
+        continue;
+      }
+      if (this.src.startsWith("<!--", this.pos)) {
+        this.skipComment();
+        continue;
+      }
+      if (this.peek() === "@" && BLOCK_KW.test(this.src.slice(this.pos))) {
+        out.push(this.parseBlock());
+        continue;
+      }
+      if (this.peek() === "<") {
+        out.push(this.parseElement());
+        continue;
+      }
+      const text = this.readText(stopAtBrace);
+      if (text) {
+        const last = out[out.length - 1];
+        if (last && last.type === "text") last.value += text;
+        else out.push({ type: "text", value: text });
+      }
+    }
+    if (closeTag !== null) throw new ParseError(`Unclosed <${closeTag}>`);
+    return out;
+  }
+  /* ──────────── control-flow blocks ──────────── */
+  parseBlock() {
+    const kw = BLOCK_KW.exec(this.src.slice(this.pos))[1];
+    switch (kw) {
+      case "if":
+        return this.parseIf();
+      case "for":
+        return this.parseFor();
+      case "switch":
+        return this.parseSwitch();
+      case "let":
+        return this.parseLet();
+      case "defer":
+        return this.parseDefer();
+      case "await":
+        return this.parseAwait();
+      case "snippet":
+        return this.parseSnippet();
+      case "render":
+        return this.parseRender();
+      case "key":
+        return this.parseKey();
+      default:
+        throw new ParseError(`Unexpected @${kw} at ${this.pos} (no matching block)`);
+    }
+  }
+  parseIf() {
+    this.pos += 3;
+    this.skipWs();
+    const head = this.readParen();
+    const headStart = this.parenStart;
+    const branches = [];
+    let cond = head;
+    let alias;
+    const semi = splitTopLevel(head, ";");
+    if (semi.length === 2) {
+      cond = semi[0].trim();
+      const m = /^as\s+([A-Za-z_$][\w$]*)$/.exec(semi[1].trim());
+      if (!m) throw new ParseError(`Expected 'as <name>' in @if, got '${semi[1].trim()}'`);
+      alias = m[1];
+    }
+    const condOffset = this.exprOffset(headStart, head, cond);
+    branches.push({ cond, condOffset, alias, children: this.readBlockBody() });
+    for (; ; ) {
+      const save = this.pos;
+      this.skipWs();
+      if (this.src.startsWith("@else if", this.pos)) {
+        this.pos += "@else if".length;
+        this.skipWs();
+        const raw = this.readParen();
+        const off = this.exprOffset(this.parenStart, raw, raw.trim());
+        branches.push({ cond: raw.trim(), condOffset: off, children: this.readBlockBody() });
+      } else if (this.src.startsWith("@else", this.pos)) {
+        this.pos += "@else".length;
+        branches.push({ children: this.readBlockBody() });
+        break;
+      } else {
+        this.pos = save;
+        break;
+      }
+    }
+    return { type: "if", branches };
+  }
+  parseFor() {
+    this.pos += 4;
+    this.skipWs();
+    const head = this.readParen();
+    const headStart = this.parenStart;
+    const parts = splitTopLevel(head, ";").map((s) => s.trim());
+    const m = /^([A-Za-z_$][\w$]*)\s+of\s+([\s\S]+)$/.exec(parts[0]);
+    if (!m) throw new ParseError(`Expected '@for (item of list)', got '${parts[0]}'`);
+    const item = m[1];
+    const list = m[2].trim();
+    let track;
+    for (const extra of parts.slice(1)) {
+      const t = /^track\s+([\s\S]+)$/.exec(extra);
+      if (t) track = t[1].trim();
+    }
+    const listOffset = this.exprOffset(headStart, head, list);
+    const trackOffset = track ? this.exprOffset(headStart, head, track) : void 0;
+    const children = this.readBlockBody();
+    let empty;
+    const save = this.pos;
+    this.skipWs();
+    if (this.src.startsWith("@empty", this.pos)) {
+      this.pos += "@empty".length;
+      empty = this.readBlockBody();
+    } else {
+      this.pos = save;
+    }
+    return { type: "for", item, list, listOffset, track, trackOffset, children, empty };
+  }
+  parseSwitch() {
+    this.pos += 7;
+    this.skipWs();
+    const rawExpr = this.readParen();
+    const exprOffset = this.exprOffset(this.parenStart, rawExpr, rawExpr.trim());
+    const expr = rawExpr.trim();
+    this.skipWs();
+    if (this.peek() !== "{") throw new ParseError(`Expected '{' after @switch at ${this.pos}`);
+    this.pos++;
+    const cases = [];
+    for (; ; ) {
+      this.skipWs();
+      if (this.peek() === "}") {
+        this.pos++;
+        break;
+      }
+      if (this.src.startsWith("@case", this.pos)) {
+        this.pos += "@case".length;
+        this.skipWs();
+        const rawTest = this.readParen();
+        const testOffset = this.exprOffset(this.parenStart, rawTest, rawTest.trim());
+        cases.push({ test: rawTest.trim(), testOffset, children: this.readBlockBody() });
+      } else if (this.src.startsWith("@default", this.pos)) {
+        this.pos += "@default".length;
+        cases.push({ children: this.readBlockBody() });
+      } else {
+        throw new ParseError(`Expected @case/@default or '}' in @switch at ${this.pos}`);
+      }
+    }
+    return { type: "switch", expr, exprOffset, cases };
+  }
+  parseLet() {
+    this.pos += 4;
+    this.skipWs();
+    const name = this.readName();
+    if (!name) throw new ParseError(`Expected name after @let at ${this.pos}`);
+    this.skipWs();
+    if (this.peek() !== "=") throw new ParseError(`Expected '=' in @let ${name}`);
+    this.pos++;
+    const rawStart = this.pos;
+    const raw = this.readUntilSemicolon();
+    const expr = raw.trim();
+    const exprOffset = rawStart + (raw.length - raw.trimStart().length);
+    if (this.peek() !== ";") throw new ParseError(`Expected ';' ending @let ${name}`);
+    this.pos++;
+    return { type: "let", name, expr, exprOffset };
+  }
+  parseDefer() {
+    this.pos += 6;
+    this.skipWs();
+    const head = this.readParen();
+    const trigger = this.parseDeferTrigger(head, this.parenStart);
+    const children = this.readBlockBody();
+    let placeholder;
+    const save = this.pos;
+    this.skipWs();
+    if (this.src.startsWith("@placeholder", this.pos)) {
+      this.pos += "@placeholder".length;
+      placeholder = this.readBlockBody();
+    } else {
+      this.pos = save;
+    }
+    return { type: "defer", trigger, children, placeholder };
+  }
+  parseAwait() {
+    this.pos += 6;
+    this.skipWs();
+    const rawExpr = this.readParen();
+    const expr = rawExpr.trim();
+    const exprOffset = this.exprOffset(this.parenStart, rawExpr, expr);
+    let pending;
+    const save = this.pos;
+    this.skipWs();
+    if (this.peek() === "{") {
+      this.pos = save;
+      pending = this.readBlockBody();
+    } else {
+      this.pos = save;
+    }
+    const branch = (kw) => {
+      const s = this.pos;
+      this.skipWs();
+      if (this.src.startsWith(kw, this.pos)) {
+        this.pos += kw.length;
+        const alias = this.maybeAlias();
+        return { alias, children: this.readBlockBody() };
+      }
+      this.pos = s;
+      return void 0;
+    };
+    const thenBranch = branch("@then");
+    const catchBranch = branch("@catch");
+    return { type: "await", expr, exprOffset, pending, then: thenBranch, catch: catchBranch };
+  }
+  parseSnippet() {
+    this.pos += "@snippet".length;
+    this.skipWs();
+    const name = this.readIdent();
+    if (!name) throw new ParseError(`Expected a snippet name after @snippet at ${this.pos}`);
+    this.skipWs();
+    if (this.peek() !== "(") throw new ParseError(`Expected '(' after @snippet ${name}`);
+    const rawParams = this.readParen();
+    const params = splitTopLevel(rawParams, ",").map((s) => s.trim()).filter(Boolean);
+    for (const p of params) {
+      if (!/^[A-Za-z_$][\w$]*$/.test(p)) {
+        throw new ParseError(`Invalid @snippet parameter '${p}' (identifiers only)`);
+      }
+    }
+    const children = this.readBlockBody();
+    return { type: "snippet", name, params, children };
+  }
+  parseKey() {
+    this.pos += "@key".length;
+    this.skipWs();
+    const raw = this.readParen();
+    const expr = raw.trim();
+    if (!expr) throw new ParseError(`@key () needs an expression`);
+    const exprOffset = this.exprOffset(this.parenStart, raw, expr);
+    return { type: "key", expr, exprOffset, children: this.readBlockBody() };
+  }
+  parseRender() {
+    this.pos += "@render".length;
+    this.skipWs();
+    if (this.peek() !== "(") throw new ParseError(`Expected '(' after @render at ${this.pos}`);
+    const raw = this.readParen();
+    const expr = raw.trim();
+    if (!expr) throw new ParseError(`@render () needs an expression`);
+    return { type: "render", expr, exprOffset: this.exprOffset(this.parenStart, raw, expr) };
+  }
+  /** Read a JS identifier (`[A-Za-z_$][\w$]*`); '' if none at the cursor. */
+  readIdent() {
+    const start = this.pos;
+    if (this.eof() || !/[A-Za-z_$]/.test(this.peek())) return "";
+    this.pos++;
+    while (!this.eof() && /[\w$]/.test(this.peek())) this.pos++;
+    return this.src.slice(start, this.pos);
+  }
+  /** Optional `(name)` alias after `@then`/`@catch`. */
+  maybeAlias() {
+    const save = this.pos;
+    this.skipWs();
+    if (this.peek() === "(") {
+      const inner = this.readParen().trim();
+      if (!/^[A-Za-z_$][\w$]*$/.test(inner)) {
+        throw new ParseError(`Expected an identifier alias in @then/@catch, got '${inner}'`);
+      }
+      return inner;
+    }
+    this.pos = save;
+    return void 0;
+  }
+  parseDeferTrigger(head, headStart) {
+    const h = head.trim();
+    const whenM = /^when\s+([\s\S]+)$/.exec(h);
+    if (whenM) {
+      const expr = whenM[1].trim();
+      return { kind: "when", expr, exprOffset: this.exprOffset(headStart, head, expr) };
+    }
+    if (h === "immediate") return { kind: "immediate" };
+    const onM = /^on\s+([\s\S]+)$/.exec(h);
+    if (onM) {
+      const on = onM[1].trim();
+      const timerM = /^timer\s*\(\s*([\s\S]+?)\s*\)$/.exec(on);
+      if (timerM) {
+        const ms = timerM[1].trim();
+        return { kind: "timer", ms, msOffset: this.exprOffset(headStart, head, ms) };
+      }
+      if (on === "idle") return { kind: "idle" };
+      if (on === "viewport") return { kind: "viewport" };
+      if (on === "interaction") return { kind: "interaction" };
+      if (on === "hover") return { kind: "hover" };
+      throw new ParseError(`Unknown @defer trigger 'on ${on}'`);
+    }
+    throw new ParseError(`Invalid @defer trigger '${h}' (use 'when <expr>', 'on idle|viewport|interaction|hover', 'on timer(ms)', or 'immediate')`);
+  }
+  /** `{ children }` */
+  readBlockBody() {
+    this.skipWs();
+    if (this.peek() !== "{") throw new ParseError(`Expected '{' at ${this.pos}`);
+    this.pos++;
+    const children = this.parseChildren(null, true);
+    if (this.peek() !== "}") throw new ParseError(`Expected '}' closing block at ${this.pos}`);
+    this.pos++;
+    return children;
+  }
+  /** Read a balanced `( … )` and return the inner text (parens consumed). */
+  readParen() {
+    if (this.peek() !== "(") throw new ParseError(`Expected '(' at ${this.pos}`);
+    this.pos++;
+    const start = this.pos;
+    let depth = 1;
+    while (!this.eof()) {
+      const c = this.peek();
+      if (c === '"' || c === "'" || c === "`") {
+        this.skipString(c);
+        continue;
+      }
+      if (c === "(") depth++;
+      else if (c === ")") {
+        depth--;
+        if (depth === 0) break;
+      }
+      this.pos++;
+    }
+    if (depth !== 0) throw new ParseError("Unclosed ( in block head");
+    const inner = this.src.slice(start, this.pos);
+    this.parenStart = start;
+    this.pos++;
+    return inner;
+  }
+  /** Read an expression up to a top-level `;` (for @let). */
+  readUntilSemicolon() {
+    const start = this.pos;
+    let depth = 0;
+    while (!this.eof()) {
+      const c = this.peek();
+      if (c === '"' || c === "'" || c === "`") {
+        this.skipString(c);
+        continue;
+      }
+      if (c === "(" || c === "[" || c === "{") depth++;
+      else if (c === ")" || c === "]" || c === "}") depth--;
+      else if (c === ";" && depth === 0) break;
+      this.pos++;
+    }
+    return this.src.slice(start, this.pos);
+  }
+  peek() {
+    return this.src[this.pos];
+  }
+  readInterp() {
+    this.pos += 2;
+    const start = this.pos;
+    const end = this.src.indexOf("}}", this.pos);
+    if (end === -1) throw new ParseError("Unclosed {{ interpolation");
+    this.pos = end + 2;
+    const raw = this.src.slice(start, end);
+    return { expr: raw.trim(), offset: start + (raw.length - raw.trimStart().length) };
+  }
+  skipComment() {
+    const end = this.src.indexOf("-->", this.pos);
+    this.pos = end === -1 ? this.src.length : end + 3;
+  }
+  readText(stopAtBrace) {
+    let out = "";
+    while (!this.eof()) {
+      const c = this.peek();
+      if (c === "<" || this.src.startsWith("{{", this.pos)) break;
+      if (stopAtBrace && c === "}") break;
+      if (c === "@") {
+        if (this.src[this.pos + 1] === "@") {
+          out += "@";
+          this.pos += 2;
+          continue;
+        }
+        if (BLOCK_KW.test(this.src.slice(this.pos))) break;
+      }
+      out += c;
+      this.pos++;
+    }
+    return out;
+  }
+  parseElement() {
+    this.pos++;
+    const tagOffset = this.pos;
+    const tag = this.readName();
+    if (!tag) throw new ParseError(`Expected tag name at ${this.pos}`);
+    const attrs = this.parseAttrs();
+    this.skipWs();
+    let selfClosing = false;
+    if (this.peek() === "/") {
+      selfClosing = true;
+      this.pos++;
+    }
+    if (this.peek() !== ">") throw new ParseError(`Expected '>' for <${tag}> at ${this.pos}`);
+    this.pos++;
+    const isVoid = !/^[A-Z]/.test(tag) && VOID.has(tag.toLowerCase());
+    if (selfClosing || isVoid) {
+      return { type: "element", tag, tagOffset, attrs, children: [], selfClosing: true };
+    }
+    const children = this.parseChildren(tag);
+    if (!this.src.startsWith("</", this.pos)) throw new ParseError(`Unclosed <${tag}>`);
+    this.pos += 2;
+    const closeName = this.readName();
+    if (closeName !== tag) throw new ParseError(`Mismatched </${closeName}>, expected </${tag}>`);
+    this.skipWs();
+    if (this.peek() !== ">") throw new ParseError(`Expected '>' closing </${tag}>`);
+    this.pos++;
+    return { type: "element", tag, tagOffset, attrs, children, selfClosing: false };
+  }
+  parseAttrs() {
+    const attrs = [];
+    while (!this.eof()) {
+      this.skipWs();
+      const c = this.peek();
+      if (c === ">" || c === "/" || c === void 0) break;
+      attrs.push(this.parseAttr());
+    }
+    return attrs;
+  }
+  parseAttr() {
+    const nameStart = this.pos;
+    const rawName = this.readAttrName();
+    let value = null;
+    if (this.peek() === "=") {
+      this.pos++;
+      value = this.readAttrValue();
+    }
+    const attr = this.classifyAttr(rawName, value);
+    if (attr.type === "use") attr.nameOffset = nameStart + "use:".length;
+    if (attr.type === "transition") {
+      const prefix = attr.mode === "both" ? "transition:" : attr.mode === "in" ? "in:" : "out:";
+      attr.nameOffset = nameStart + prefix.length;
+    }
+    return attr;
+  }
+  classifyAttr(rawName, value) {
+    const exprOf = () => {
+      if (!value) throw new ParseError(`Binding '${rawName}' requires a value`);
+      if (value.kind !== "expr") throw new ParseError(`Binding '${rawName}' needs {expr}, got a string`);
+      return value.expr;
+    };
+    const offset = value && value.kind === "expr" ? value.offset : void 0;
+    if (rawName === "ref" || rawName === "bind:this") {
+      return { type: "ref", expr: exprOf(), offset };
+    }
+    if (rawName.startsWith("on:")) {
+      const [name, ...modifiers] = rawName.slice(3).split("|");
+      return { type: "event", name, modifiers, expr: exprOf(), offset };
+    }
+    if (rawName.startsWith("class:")) {
+      return { type: "class", name: rawName.slice(6), expr: exprOf(), offset };
+    }
+    if (rawName.startsWith("bind:")) {
+      return { type: "bind", name: rawName.slice(5), expr: exprOf(), offset };
+    }
+    if (rawName.startsWith("use:")) {
+      const name = rawName.slice(4);
+      if (!name) throw new ParseError(`'use:' requires an action name, e.g. use:tooltip`);
+      const expr = value && value.kind === "expr" ? value.expr : void 0;
+      if (value && value.kind === "static") {
+        throw new ParseError(`use:${name} needs {expr}, got a string`);
+      }
+      return { type: "use", name, expr, offset };
+    }
+    if (rawName === "show") {
+      return { type: "show", expr: exprOf(), offset };
+    }
+    if (rawName.startsWith("transition:") || rawName.startsWith("in:") || rawName.startsWith("out:")) {
+      const mode = rawName.startsWith("transition:") ? "both" : rawName.startsWith("in:") ? "in" : "out";
+      const prefix = mode === "both" ? "transition:" : mode === "in" ? "in:" : "out:";
+      const name = rawName.slice(prefix.length);
+      if (!name) throw new ParseError(`'${prefix}' requires a transition function, e.g. ${prefix}fade`);
+      if (value && value.kind === "static") throw new ParseError(`${rawName} needs {expr} params, got a string`);
+      const expr = value && value.kind === "expr" ? value.expr : void 0;
+      return { type: "transition", name, mode, expr, offset };
+    }
+    if (rawName.startsWith(".")) {
+      return { type: "prop", name: rawName.slice(1), expr: exprOf(), offset };
+    }
+    if (value && value.kind === "expr") {
+      return { type: "attr", name: rawName, expr: value.expr, offset };
+    }
+    return { type: "static", name: rawName, value: value ? value.text : "" };
+  }
+  readName() {
+    const start = this.pos;
+    while (!this.eof() && /[A-Za-z0-9\-:]/.test(this.peek())) this.pos++;
+    return this.src.slice(start, this.pos);
+  }
+  readAttrName() {
+    const start = this.pos;
+    while (!this.eof() && /[A-Za-z0-9_\-:.|@]/.test(this.peek())) this.pos++;
+    return this.src.slice(start, this.pos);
+  }
+  readAttrValue() {
+    const c = this.peek();
+    if (c === "{") {
+      if (!this.src.startsWith("{{", this.pos)) {
+        throw new ParseError(`Attribute bindings use double braces: write {{ expr }}, not { expr } (at ${this.pos})`);
+      }
+      const b = this.readDoubleBracedExpr();
+      return { kind: "expr", expr: b.expr, offset: b.offset };
+    }
+    if (c === '"' || c === "'") return { kind: "static", text: this.readQuoted(c) };
+    const start = this.pos;
+    while (!this.eof() && !/[\s>/]/.test(this.peek())) this.pos++;
+    return { kind: "static", text: this.src.slice(start, this.pos) };
+  }
+  readQuoted(quote) {
+    this.pos++;
+    const start = this.pos;
+    while (!this.eof() && this.peek() !== quote) this.pos++;
+    const text = this.src.slice(start, this.pos);
+    this.pos++;
+    return text;
+  }
+  /** Read a `{{ ... }}` expression, balancing inner braces and skipping string literals. */
+  readDoubleBracedExpr() {
+    this.pos += 2;
+    const start = this.pos;
+    let depth = 0;
+    while (!this.eof()) {
+      const c = this.peek();
+      if (c === '"' || c === "'" || c === "`") {
+        this.skipString(c);
+        continue;
+      }
+      if (c === "{") depth++;
+      else if (c === "}") {
+        if (depth > 0) depth--;
+        else if (this.src[this.pos + 1] === "}") break;
+      }
+      this.pos++;
+    }
+    if (this.eof()) throw new ParseError("Unclosed {{ expression");
+    const raw = this.src.slice(start, this.pos);
+    this.pos += 2;
+    return { expr: raw.trim(), offset: start + (raw.length - raw.trimStart().length) };
+  }
+  skipString(quote) {
+    this.pos++;
+    while (!this.eof()) {
+      const c = this.peek();
+      if (c === "\\") {
+        this.pos += 2;
+        continue;
+      }
+      this.pos++;
+      if (c === quote) return;
+    }
+  }
+  skipWs() {
+    while (!this.eof() && /\s/.test(this.peek())) this.pos++;
+  }
+};
+function splitTopLevel(s, sep4) {
+  const out = [];
+  let depth = 0;
+  let last = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'" || c === "`") {
+      i = skipStr(s, i);
+      continue;
+    }
+    if (c === "(" || c === "[" || c === "{") depth++;
+    else if (c === ")" || c === "]" || c === "}") depth--;
+    else if (c === sep4 && depth === 0) {
+      out.push(s.slice(last, i));
+      last = i + 1;
+    }
+  }
+  out.push(s.slice(last));
+  return out;
+}
+function skipStr(s, start) {
+  const q2 = s[start];
+  let i = start + 1;
+  while (i < s.length) {
+    if (s[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (s[i] === q2) return i;
+    i++;
+  }
+  return s.length;
+}
+
+// packages/compiler/src/scope.ts
+var ID_START = /[A-Za-z_$]/;
+var ID_CHAR = /[A-Za-z0-9_$]/;
+function rewrite(expr, scope, ctxRef = "ctx") {
+  let out = "";
+  let reactive = false;
+  let i = 0;
+  const n = expr.length;
+  const segments = [];
+  let runSrc = -1;
+  let runGen = -1;
+  let runLen = 0;
+  const flush = () => {
+    if (runLen > 0) segments.push({ src: runSrc, gen: runGen, len: runLen });
+    runLen = 0;
+  };
+  const copy = (srcPos, text) => {
+    const genPos = out.length;
+    if (runLen > 0 && runSrc + runLen === srcPos && runGen + runLen === genPos) {
+      runLen += text.length;
+    } else {
+      flush();
+      runSrc = srcPos;
+      runGen = genPos;
+      runLen = text.length;
+    }
+    out += text;
+  };
+  const insert = (text) => {
+    flush();
+    out += text;
+  };
+  while (i < n) {
+    const c = expr[i];
+    if (c === '"' || c === "'" || c === "`") {
+      const end = scanString(expr, i);
+      copy(i, expr.slice(i, end));
+      i = end;
+      continue;
+    }
+    if (ID_START.test(c)) {
+      let j = i + 1;
+      while (j < n && ID_CHAR.test(expr[j])) j++;
+      const name = expr.slice(i, j);
+      const isProperty = lastNonSpace(out) === ".";
+      const binding = scope.get(name);
+      if (binding && !isProperty) {
+        if (binding.kind === "ctx") {
+          insert(`${ctxRef}.`);
+          copy(i, name);
+        } else if (binding.kind === "local") {
+          copy(i, name);
+        } else {
+          insert(`${binding.accessor}()`);
+        }
+        reactive = true;
+      } else {
+        copy(i, name);
+      }
+      i = j;
+      continue;
+    }
+    copy(i, c);
+    i++;
+  }
+  flush();
+  return { code: out, reactive, segments };
+}
+function ctxScope(names) {
+  const scope = /* @__PURE__ */ new Map();
+  for (const name of names) scope.set(name, { kind: "ctx" });
+  return scope;
+}
+function childScope(parent, locals) {
+  const scope = new Map(parent);
+  for (const [name, accessor] of Object.entries(locals)) {
+    scope.set(name, { kind: "call", accessor });
+  }
+  return scope;
+}
+function lastNonSpace(s) {
+  for (let i = s.length - 1; i >= 0; i--) {
+    if (!/\s/.test(s[i])) return s[i];
+  }
+  return "";
+}
+var NON_CTX = /* @__PURE__ */ new Set([
+  // literals / keywords
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "this",
+  "NaN",
+  "Infinity",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "void",
+  "delete",
+  "await",
+  "yield",
+  "return",
+  "function",
+  "class",
+  "super",
+  "if",
+  "else",
+  "switch",
+  "case",
+  // built-in objects / functions
+  "Math",
+  "JSON",
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Date",
+  "RegExp",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Symbol",
+  "Promise",
+  "BigInt",
+  "Error",
+  "TypeError",
+  "Intl",
+  "console",
+  "window",
+  "document",
+  "globalThis",
+  "parseInt",
+  "parseFloat",
+  "isNaN",
+  "isFinite",
+  "structuredClone",
+  "encodeURIComponent",
+  "decodeURIComponent",
+  "encodeURI",
+  "decodeURI",
+  "navigator",
+  "location",
+  "history",
+  "localStorage",
+  "sessionStorage",
+  "fetch",
+  "URL",
+  "URLSearchParams"
+]);
+function arrowParams(expr) {
+  const params = /* @__PURE__ */ new Set();
+  const ID = /^[A-Za-z_$][\w$]*$/;
+  let at = expr.indexOf("=>");
+  while (at !== -1) {
+    let k = at - 1;
+    while (k >= 0 && /\s/.test(expr[k])) k--;
+    if (expr[k] === ")") {
+      let depth = 1;
+      let m = k - 1;
+      for (; m >= 0; m--) {
+        if (expr[m] === ")") depth++;
+        else if (expr[m] === "(") {
+          depth--;
+          if (depth === 0) break;
+        }
+      }
+      for (const raw of expr.slice(m + 1, k).split(",")) {
+        const name = raw.trim().split(/[\s=:]/)[0].replace(/[{}[\]().]/g, "");
+        if (ID.test(name)) params.add(name);
+      }
+    } else {
+      let m = k;
+      while (m >= 0 && ID_CHAR.test(expr[m])) m--;
+      const name = expr.slice(m + 1, k + 1);
+      if (ID.test(name)) params.add(name);
+    }
+    at = expr.indexOf("=>", at + 2);
+  }
+  return params;
+}
+function freeIdentifiers(expr) {
+  const out = /* @__PURE__ */ new Set();
+  const params = arrowParams(expr);
+  let i = 0;
+  const n = expr.length;
+  while (i < n) {
+    const c = expr[i];
+    if (c === '"' || c === "'" || c === "`") {
+      i = scanString(expr, i);
+      continue;
+    }
+    if (ID_START.test(c)) {
+      let j = i + 1;
+      while (j < n && ID_CHAR.test(expr[j])) j++;
+      const name = expr.slice(i, j);
+      const isProperty = lastNonSpace(expr.slice(0, i)) === ".";
+      if (!isProperty && !NON_CTX.has(name) && !params.has(name)) out.add(name);
+      i = j;
+      continue;
+    }
+    i++;
+  }
+  return [...out];
+}
+function scanString(s, start) {
+  const quote = s[start];
+  let i = start + 1;
+  while (i < s.length) {
+    const c = s[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (c === quote) return i + 1;
+    i++;
+  }
+  return s.length;
+}
+
+// packages/compiler/src/codegen.ts
+var Gen = class {
+  constructor(mode, scopeAttr2, hostAttr2) {
+    this.mode = mode;
+    this.scopeAttr = scopeAttr2;
+    this.hostAttr = hostAttr2;
+  }
+  used = /* @__PURE__ */ new Set();
+  // @weave-framework/runtime/dom helpers
+  usedCore = /* @__PURE__ */ new Set();
+  // @weave-framework/runtime primitives (computed, …)
+  templates = [];
+  tplN = 0;
+  fnN = 0;
+  H(name) {
+    this.used.add(name);
+    return this.mode === "function" ? `rt.${name}` : name;
+  }
+  Hc(name) {
+    this.usedCore.add(name);
+    return this.mode === "function" ? `rt.${name}` : name;
+  }
+  /** Reference a child component: from the `_c` map in function mode, bare (imported) in module mode. */
+  Comp(name) {
+    return this.mode === "function" ? `_c.${name}` : name;
+  }
+  tpl(html) {
+    const v = `_t${this.tplN++}`;
+    this.templates.push(`const ${v} = ${this.H("template")}(${JSON.stringify(html)});`);
+    return v;
+  }
+  fn(prefix = "_b") {
+    return `${prefix}${this.fnN++}`;
+  }
+};
+function compileTemplate(input, options = {}) {
+  const mode = options.mode ?? "module";
+  const runtimeImport = options.runtimeImport ?? "@weave-framework/runtime/dom";
+  const gen = new Gen(mode, options.scopeAttr, options.hostAttr);
+  const ast = parseTemplate(input);
+  const render = compileFragment(gen, ast, ctxScope(options.scope ?? []), "render", "ctx, slots", true);
+  if (mode === "function") {
+    const body = [...gen.templates, render, "return render(ctx, {});"].join("\n");
+    return { code: body };
+  }
+  const domImport = `import { ${[...gen.used].sort().join(", ")} } from ${JSON.stringify(runtimeImport)};`;
+  const coreImport = gen.usedCore.size ? `import { ${[...gen.usedCore].sort().join(", ")} } from "@weave-framework/runtime";
+` : "";
+  const code = [domImport + "\n" + coreImport, ...gen.templates, `export default ${render}`].join("\n");
+  return { code };
+}
+function compileFragment(gen, nodes, scope, name, param = "", isHost = false) {
+  const top = trimTop(nodes);
+  if (top.length === 0) throw new Error("Empty template fragment");
+  const sole = top.length === 1 && top[0].type === "element" ? top[0] : null;
+  const singleRoot = !!sole && !/^[A-Z]/.test(sole.tag) && sole.tag !== "slot";
+  let html = "";
+  const stmts = [];
+  const childDecls = [];
+  const nodeDecls = [];
+  const nodeVars = /* @__PURE__ */ new Map();
+  let nodeVarN = 0;
+  const nodeExpr = (path) => {
+    if (path.length === 0) return "_r";
+    const key = path.join(",");
+    let v = nodeVars.get(key);
+    if (!v) {
+      v = `_n${nodeVarN++}`;
+      nodeVars.set(key, v);
+      nodeDecls.push(`const ${v} = ${gen.H("child")}(_r, ${path.join(", ")});`);
+    }
+    return v;
+  };
+  function emitChildren(children, basePath, sc, isHost2 = false) {
+    let dom = 0;
+    let cur = sc;
+    const snippetNames = children.filter((n) => n.type === "snippet").map((n) => n.name);
+    if (snippetNames.length) {
+      cur = new Map(cur);
+      for (const nm of snippetNames) cur.set(nm, { kind: "local" });
+    }
+    for (const node of children) {
+      if (node.type === "let") {
+        html += "<!---->";
+        stmts.push(`const ${node.name} = ${gen.Hc("computed")}(() => ${rewrite(node.expr, cur).code});`);
+        cur = childScope(cur, { [node.name]: node.name });
+        dom++;
+        continue;
+      }
+      if (node.type === "snippet") {
+        emitSnippet(node, cur);
+        continue;
+      }
+      emitNode(node, [...basePath, dom], cur, isHost2);
+      dom++;
+    }
+  }
+  function emitSnippet(node, sc) {
+    const bodyScope = new Map(sc);
+    for (const p of node.params) bodyScope.set(p, { kind: "local" });
+    childDecls.push(compileFragment(gen, node.children, bodyScope, node.name, node.params.join(", ")));
+  }
+  function emitRender(node, path, sc) {
+    html += "<!---->";
+    stmts.push(`${gen.H("mountChild")}(${nodeExpr(path)}, ${rewrite(node.expr, sc).code});`);
+  }
+  function emitKey(node, path, sc) {
+    html += "<!---->";
+    const contentFn = gen.fn();
+    childDecls.push(compileFragment(gen, node.children, sc, contentFn));
+    stmts.push(`${gen.H("keyBlock")}(${nodeExpr(path)}, () => ${rewrite(node.expr, sc).code}, ${contentFn});`);
+  }
+  function emitNode(node, path, sc, isHost2 = false) {
+    switch (node.type) {
+      case "text":
+        html += escapeText(node.value);
+        return;
+      case "interp": {
+        html += "<!---->";
+        const { code, reactive } = rewrite(node.expr, sc);
+        stmts.push(
+          reactive ? `${gen.H("bindText")}(${nodeExpr(path)}, () => ${code});` : `${gen.H("setText")}(${nodeExpr(path)}, ${code});`
+        );
+        return;
+      }
+      case "element":
+        emitElement(node, path, sc, isHost2);
+        return;
+      case "if":
+        emitIf(node, path, sc);
+        return;
+      case "for":
+        emitFor(node, path, sc);
+        return;
+      case "switch":
+        emitSwitch(node, path, sc);
+        return;
+      case "defer":
+        emitDefer(node, path, sc);
+        return;
+      case "await":
+        emitAwait(node, path, sc);
+        return;
+      case "render":
+        emitRender(node, path, sc);
+        return;
+      case "key":
+        emitKey(node, path, sc);
+        return;
+      case "snippet":
+        throw new Error("@snippet is a declaration, handled in emitChildren");
+      case "let":
+        throw new Error("@let cannot be a single dynamic node here");
+    }
+  }
+  function emitElement(node, path, sc, isHost2 = false) {
+    if (node.tag === "slot") return emitSlot(node, path, sc);
+    if (node.tag === "w:element") return emitDynamicElement(node, path, sc);
+    if (/^[A-Z]/.test(node.tag)) return emitComponent(node, path, sc);
+    html += `<${node.tag}`;
+    if (gen.scopeAttr) html += ` ${gen.scopeAttr}`;
+    if (isHost2 && gen.hostAttr) html += ` ${gen.hostAttr}`;
+    for (const attr of node.attrs) {
+      if (attr.type === "static") {
+        html += attr.value === "" ? ` ${attr.name}` : ` ${attr.name}="${escapeAttr(attr.value)}"`;
+      } else {
+        emitBinding(attr, nodeExpr(path), sc);
+      }
+    }
+    html += ">";
+    if (!node.selfClosing) {
+      emitChildren(node.children, path, sc);
+      html += `</${node.tag}>`;
+    }
+  }
+  function emitDynamicElement(node, path, sc) {
+    html += "<!---->";
+    const anchor = nodeExpr(path);
+    let tagExpr = '""';
+    const build2 = [];
+    for (const attr of node.attrs) {
+      if ((attr.type === "attr" || attr.type === "static") && attr.name === "this") {
+        tagExpr = attr.type === "attr" ? rewrite(attr.expr, sc).code : q(attr.value);
+        continue;
+      }
+      if (attr.type === "static") {
+        build2.push(`${gen.H("setAttr")}(_el, ${q(attr.name)}, ${q(attr.value)});`);
+      } else {
+        emitBinding(attr, "_el", sc, build2);
+      }
+    }
+    if (trimTop(node.children).length > 0) {
+      const contentFn = gen.fn();
+      childDecls.push(compileFragment(gen, node.children, sc, contentFn));
+      build2.push(`_el.append(${contentFn}());`);
+    }
+    stmts.push(`${gen.H("dynElement")}(${anchor}, () => ${tagExpr}, (_el) => { ${build2.join(" ")} });`);
+  }
+  function emitBinding(attr, n, sc, sink = stmts) {
+    switch (attr.type) {
+      case "attr": {
+        const { code, reactive } = rewrite(attr.expr, sc);
+        sink.push(
+          reactive ? `${gen.H("bindAttr")}(${n}, ${q(attr.name)}, () => ${code});` : `${gen.H("setAttr")}(${n}, ${q(attr.name)}, ${code});`
+        );
+        break;
+      }
+      case "prop":
+        sink.push(`${gen.H("bindProp")}(${n}, ${q(attr.name)}, () => ${rewrite(attr.expr, sc).code});`);
+        break;
+      case "class":
+        sink.push(`${gen.H("bindClass")}(${n}, ${q(attr.name)}, () => ${rewrite(attr.expr, sc).code});`);
+        break;
+      case "show":
+        sink.push(`${gen.H("bindShow")}(${n}, () => ${rewrite(attr.expr, sc).code});`);
+        break;
+      case "transition": {
+        const fn = rewrite(attr.name, sc).code;
+        const params = attr.expr !== void 0 ? rewrite(attr.expr, sc).code : "undefined";
+        sink.push(`${gen.H("transition")}(${n}, ${fn}, ${params}, ${q(attr.mode)});`);
+        break;
+      }
+      case "event": {
+        const handler = wrapHandler(attr, sc);
+        const opts = eventOpts(attr.modifiers);
+        sink.push(`${gen.H("listen")}(${n}, ${q(attr.name)}, ${handler}${opts ? `, ${opts}` : ""});`);
+        break;
+      }
+      case "ref":
+        sink.push(`${gen.H("setRef")}(${rewrite(attr.expr, sc).code}, ${n});`);
+        break;
+      case "use": {
+        const action = rewrite(attr.name, sc).code;
+        sink.push(
+          attr.expr !== void 0 ? `${gen.H("applyAction")}(${n}, ${action}, ${rewrite(attr.expr, sc).code});` : `${gen.H("applyAction")}(${n}, ${action});`
+        );
+        break;
+      }
+      case "bind": {
+        const kind = attr.name === "checked" ? "checked" : attr.name === "group" ? "group" : "value";
+        sink.push(`${gen.H("bindValue")}(${n}, ${rewrite(attr.expr, sc).code}, ${q(kind)});`);
+        break;
+      }
+    }
+  }
+  function emitComponent(node, path, sc) {
+    html += "<!---->";
+    const anchorVar = nodeExpr(path);
+    const props = [];
+    for (const attr of node.attrs) {
+      switch (attr.type) {
+        case "static":
+          props.push(`${propKey(attr.name)}: ${q(attr.value)}`);
+          break;
+        case "attr":
+          props.push(`get ${propKey(attr.name)}() { return ${rewrite(attr.expr, sc).code}; }`);
+          break;
+        case "event":
+          props.push(`${propKey(onProp(attr.name))}: ${rewrite(attr.expr, sc).code}`);
+          break;
+        default:
+          throw new Error(`'${attr.type}' binding on <${node.tag}> is not supported yet (M5: props + on:event only)`);
+      }
+    }
+    const groups = /* @__PURE__ */ new Map();
+    for (const child of node.children) {
+      let target = child;
+      let slotName = "default";
+      if (child.type === "element") {
+        const i = child.attrs.findIndex((a) => a.type === "static" && a.name === "slot");
+        if (i >= 0) {
+          slotName = child.attrs[i].value;
+          target = { ...child, attrs: child.attrs.filter((_, k) => k !== i) };
+        }
+      }
+      let arr = groups.get(slotName);
+      if (!arr) {
+        arr = [];
+        groups.set(slotName, arr);
+      }
+      arr.push(target);
+    }
+    const slots = [];
+    for (const [name2, children] of groups) {
+      if (trimTop(children).length === 0) continue;
+      const slotFn = gen.fn("_s");
+      childDecls.push(compileFragment(gen, children, sc, slotFn));
+      slots.push(`${propKey(name2)}: ${slotFn}`);
+    }
+    const propsObj = props.length ? `{ ${props.join(", ")} }` : "{}";
+    const slotsObj = slots.length ? `{ ${slots.join(", ")} }` : "{}";
+    stmts.push(`${gen.H("mountChild")}(${anchorVar}, ${gen.Comp(node.tag)}(${propsObj}, ${slotsObj}));`);
+  }
+  function emitSlot(node, path, sc) {
+    html += "<!---->";
+    const anchorVar = nodeExpr(path);
+    const nameAttr = node.attrs.find((a) => a.type === "static" && a.name === "name");
+    const name2 = nameAttr ? nameAttr.value : "default";
+    let fallback = "null";
+    if (trimTop(node.children).length > 0) {
+      const fbFn = gen.fn("_f");
+      childDecls.push(compileFragment(gen, node.children, sc, fbFn));
+      fallback = `${fbFn}()`;
+    }
+    stmts.push(
+      `{ const _sf = slots[${q(name2)}]; ${gen.H("mountChild")}(${anchorVar}, _sf ? _sf() : ${fallback}); }`
+    );
+  }
+  function emitIf(node, path, sc) {
+    html += "<!---->";
+    const head = node.branches[0];
+    let aliasVar;
+    if (head.alias) {
+      aliasVar = gen.fn("_a");
+      stmts.push(`const ${aliasVar} = ${gen.Hc("computed")}(() => ${rewrite(head.cond ?? "undefined", sc).code});`);
+    }
+    const branchNames = node.branches.map(() => gen.fn());
+    node.branches.forEach((br, i) => {
+      const bScope = i === 0 && head.alias && aliasVar ? childScope(sc, { [head.alias]: aliasVar }) : sc;
+      childDecls.push(compileFragment(gen, br.children, bScope, branchNames[i]));
+    });
+    const lines = [];
+    node.branches.forEach((br, i) => {
+      if (i === 0 && aliasVar) lines.push(`if (${aliasVar}()) return ${branchNames[i]};`);
+      else if (br.cond !== void 0) lines.push(`if (${rewrite(br.cond, sc).code}) return ${branchNames[i]};`);
+      else lines.push(`return ${branchNames[i]};`);
+    });
+    const hasElse = node.branches[node.branches.length - 1].cond === void 0;
+    if (!hasElse) lines.push("return null;");
+    stmts.push(`${gen.H("ifBlock")}(${nodeExpr(path)}, () => { ${lines.join(" ")} });`);
+  }
+  function emitSwitch(node, path, sc) {
+    html += "<!---->";
+    const names = node.cases.map(() => gen.fn());
+    node.cases.forEach((c, i) => childDecls.push(compileFragment(gen, c.children, sc, names[i])));
+    const lines = [`const _v = ${rewrite(node.expr, sc).code};`];
+    node.cases.forEach((c, i) => {
+      if (c.test !== void 0) lines.push(`if (_v === ${rewrite(c.test, sc).code}) return ${names[i]};`);
+      else lines.push(`return ${names[i]};`);
+    });
+    if (!node.cases.some((c) => c.test === void 0)) lines.push("return null;");
+    stmts.push(`${gen.H("ifBlock")}(${nodeExpr(path)}, () => { ${lines.join(" ")} });`);
+  }
+  function emitDefer(node, path, sc) {
+    html += "<!---->";
+    const contentFn = gen.fn();
+    childDecls.push(compileFragment(gen, node.children, sc, contentFn));
+    let phArg = "undefined";
+    if (node.placeholder && trimTop(node.placeholder).length > 0) {
+      const phFn = gen.fn();
+      childDecls.push(compileFragment(gen, node.placeholder, sc, phFn));
+      phArg = phFn;
+    }
+    const trig = deferTriggerExpr(node.trigger, sc);
+    stmts.push(`${gen.H("deferBlock")}(${nodeExpr(path)}, ${trig}, ${contentFn}, ${phArg});`);
+  }
+  function emitAwait(node, path, sc) {
+    html += "<!---->";
+    const anchorVar = nodeExpr(path);
+    const source = `() => (${rewrite(node.expr, sc).code})`;
+    const branchFn = (children, alias) => {
+      if (!children || trimTop(children).length === 0) return "undefined";
+      const fn = gen.fn();
+      const scope2 = alias ? new Map(sc).set(alias, { kind: "local" }) : sc;
+      childDecls.push(compileFragment(gen, children, scope2, fn, alias ?? ""));
+      return fn;
+    };
+    const pendingArg = branchFn(node.pending);
+    const thenArg = branchFn(node.then?.children, node.then?.alias);
+    const catchArg = branchFn(node.catch?.children, node.catch?.alias);
+    stmts.push(`${gen.H("awaitBlock")}(${anchorVar}, ${source}, ${pendingArg}, ${thenArg}, ${catchArg});`);
+  }
+  function deferTriggerExpr(t, sc) {
+    switch (t.kind) {
+      case "when":
+        return `{ on: "when", when: () => ${rewrite(t.expr, sc).code} }`;
+      case "timer":
+        return `{ on: "timer", ms: ${rewrite(t.ms, sc).code} }`;
+      case "idle":
+      case "viewport":
+      case "interaction":
+      case "hover":
+      case "immediate":
+        return `{ on: ${q(t.kind)} }`;
+    }
+  }
+  function emitFor(node, path, sc) {
+    html += "<!---->";
+    const rowFn = gen.fn();
+    const forScope = childScope(sc, {
+      [node.item]: "_row.item",
+      $index: "_row.index",
+      $count: "_row.count",
+      $first: "_row.first",
+      $last: "_row.last",
+      $even: "_row.even",
+      $odd: "_row.odd"
+    });
+    childDecls.push(compileFragment(gen, node.children, forScope, rowFn, "_row"));
+    let emptyArg = "";
+    if (node.empty) {
+      const emptyFn = gen.fn();
+      childDecls.push(compileFragment(gen, node.empty, sc, emptyFn));
+      emptyArg = `, ${emptyFn}`;
+    }
+    const list = rewrite(node.list, sc).code;
+    const track = node.track ? rewrite(node.track, sc).code : "$index";
+    const keyFn = `(${node.item}, $index) => ${track}`;
+    stmts.push(`${gen.H("eachBlock")}(${nodeExpr(path)}, () => ${list}, ${keyFn}, ${rowFn}${emptyArg});`);
+  }
+  if (singleRoot) emitElement(sole, [], scope, isHost);
+  else emitChildren(top, [], scope, isHost);
+  const ctor = singleRoot ? gen.H("clone") : gen.H("cloneFragment");
+  const tplVar = gen.tpl(html);
+  const body = [
+    `const _r = ${ctor}(${tplVar});`,
+    ...nodeDecls,
+    ...stmts,
+    "return _r;",
+    ...childDecls
+  ];
+  return `function ${name}(${param}) {
+${body.map((l) => "  " + l).join("\n")}
+}`;
+}
+function wrapHandler(attr, scope) {
+  const expr = rewrite(attr.expr, scope).code;
+  const guards = [];
+  for (const m of attr.modifiers) {
+    if (m === "preventDefault") guards.push("$e.preventDefault();");
+    else if (m === "stopPropagation") guards.push("$e.stopPropagation();");
+    else if (m === "self") guards.push("if ($e.target !== $e.currentTarget) return;");
+  }
+  if (guards.length === 0) return expr;
+  return `($e) => { ${guards.join(" ")} (${expr})($e); }`;
+}
+function eventOpts(modifiers) {
+  const opts = [];
+  if (modifiers.includes("once")) opts.push("once: true");
+  if (modifiers.includes("capture")) opts.push("capture: true");
+  if (modifiers.includes("passive")) opts.push("passive: true");
+  return opts.length ? `{ ${opts.join(", ")} }` : "";
+}
+function trimTop(nodes) {
+  return nodes.filter((n) => !(n.type === "text" && n.value.trim() === ""));
+}
+function q(s) {
+  return JSON.stringify(s);
+}
+function propKey(name) {
+  return /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function onProp(event) {
+  return "on" + event.charAt(0).toUpperCase() + event.slice(1);
+}
+function escapeText(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+}
+function escapeAttr(s) {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+
+// packages/compiler/src/css.ts
+function scopeAttr(hash) {
+  return `data-w-${hash}`;
+}
+function hostAttr(hash) {
+  return `data-w-${hash}-h`;
+}
+function hashCss(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36).padStart(6, "0").slice(0, 6);
+}
+function scopeCss(css, hash) {
+  return transformBlock(css, scopeAttr(hash), hostAttr(hash), false);
+}
+function transformBlock(css, attr, host, keyframes) {
+  let out = "";
+  let i = 0;
+  const n = css.length;
+  while (i < n) {
+    const c = css[i];
+    if (/\s/.test(c)) {
+      out += c;
+      i++;
+      continue;
+    }
+    if (css.startsWith("/*", i)) {
+      const end = css.indexOf("*/", i + 2);
+      const stop = end === -1 ? n : end + 2;
+      out += css.slice(i, stop);
+      i = stop;
+      continue;
+    }
+    let j = i;
+    let depth = 0;
+    let kind = "";
+    while (j < n) {
+      const ch = css[j];
+      if (ch === '"' || ch === "'") {
+        j = skipString(css, j);
+        continue;
+      }
+      if (css.startsWith("/*", j)) {
+        const e = css.indexOf("*/", j + 2);
+        j = e === -1 ? n : e + 2;
+        continue;
+      }
+      if (ch === "(" || ch === "[") depth++;
+      else if (ch === ")" || ch === "]") depth--;
+      else if (depth === 0 && ch === "{") {
+        kind = "block";
+        break;
+      } else if (depth === 0 && ch === ";") {
+        kind = "decl";
+        break;
+      }
+      j++;
+    }
+    if (kind === "") {
+      out += css.slice(i);
+      break;
+    }
+    const prelude = css.slice(i, j);
+    if (kind === "decl") {
+      out += prelude + ";";
+      i = j + 1;
+      continue;
+    }
+    const bodyStart = j + 1;
+    let k = bodyStart;
+    let bd = 1;
+    while (k < n) {
+      const ch = css[k];
+      if (ch === '"' || ch === "'") {
+        k = skipString(css, k);
+        continue;
+      }
+      if (css.startsWith("/*", k)) {
+        const e = css.indexOf("*/", k + 2);
+        k = e === -1 ? n : e + 2;
+        continue;
+      }
+      if (ch === "{") bd++;
+      else if (ch === "}") {
+        bd--;
+        if (bd === 0) break;
+      }
+      k++;
+    }
+    const body = css.slice(bodyStart, k);
+    const after = k < n ? k + 1 : n;
+    const trimmed = prelude.trim();
+    if (keyframes) {
+      out += prelude + "{" + body + "}";
+    } else if (trimmed.startsWith("@")) {
+      const kw = (/^@-?\w[\w-]*/.exec(trimmed)?.[0] ?? "").toLowerCase();
+      if (kw.endsWith("keyframes")) {
+        out += prelude + "{" + transformBlock(body, attr, host, true) + "}";
+      } else if (kw === "@font-face" || kw === "@page" || kw === "@property" || kw === "@counter-style") {
+        out += prelude + "{" + body + "}";
+      } else {
+        out += prelude + "{" + transformBlock(body, attr, host, false) + "}";
+      }
+    } else {
+      out += scopeSelectorList(prelude, attr, host) + "{" + transformBlock(body, attr, host, false) + "}";
+    }
+    i = after;
+  }
+  return out;
+}
+function scopeSelectorList(prelude, attr, host) {
+  return splitTopLevel2(prelude, ",").map((s) => scopeSelector(s, attr, host)).join(", ");
+}
+function scopeSelector(raw, attr, host) {
+  const sel = raw.trim();
+  if (!sel) return sel;
+  const start = rightmostCompoundStart(sel);
+  const prefix = rewriteHost(unwrapGlobal(sel.slice(0, start)), host);
+  const right = sel.slice(start);
+  const rightTrim = right.trim();
+  if (rightTrim.startsWith(":host")) {
+    return prefix + rewriteHost(unwrapGlobal(right), host);
+  }
+  if (rightTrim.startsWith(":global(") || right.includes("&")) {
+    return prefix + unwrapGlobal(right);
+  }
+  return prefix + insertAttr(unwrapGlobal(right), attr);
+}
+function rewriteHost(s, host) {
+  let out = "";
+  let i = 0;
+  while (i < s.length) {
+    if (s.startsWith(":host", i)) {
+      const after = s[i + 5];
+      if (after === "(") {
+        let depth = 1;
+        let j = i + 6;
+        let inner = "";
+        while (j < s.length && depth > 0) {
+          const c = s[j];
+          if (c === "(") depth++;
+          else if (c === ")" && --depth === 0) {
+            j++;
+            break;
+          }
+          inner += c;
+          j++;
+        }
+        out += inner.trim() + `[${host}]`;
+        i = j;
+        continue;
+      }
+      if (after === void 0 || !/[-\w]/.test(after)) {
+        out += `[${host}]`;
+        i += 5;
+        continue;
+      }
+    }
+    out += s[i++];
+  }
+  return out;
+}
+function rightmostCompoundStart(sel) {
+  let depth = 0;
+  let start = 0;
+  let i = 0;
+  while (i < sel.length) {
+    const c = sel[i];
+    if (c === "(" || c === "[") {
+      depth++;
+      i++;
+      continue;
+    }
+    if (c === ")" || c === "]") {
+      depth--;
+      i++;
+      continue;
+    }
+    if (depth === 0) {
+      if (c === ">" || c === "+" || c === "~") {
+        i++;
+        while (i < sel.length && /\s/.test(sel[i])) i++;
+        start = i;
+        continue;
+      }
+      if (/\s/.test(c)) {
+        let j = i;
+        while (j < sel.length && /\s/.test(sel[j])) j++;
+        const next = sel[j];
+        if (j >= sel.length) {
+          i = j;
+          continue;
+        }
+        if (next === ">" || next === "+" || next === "~") {
+          i = j;
+          continue;
+        }
+        start = j;
+        i = j;
+        continue;
+      }
+    }
+    i++;
+  }
+  return start;
+}
+function insertAttr(compound, attr) {
+  let depth = 0;
+  for (let i = 0; i < compound.length; i++) {
+    const c = compound[i];
+    if (c === "(" || c === "[") depth++;
+    else if (c === ")" || c === "]") depth--;
+    else if (depth === 0 && c === ":") {
+      return compound.slice(0, i) + `[${attr}]` + compound.slice(i);
+    }
+  }
+  return compound + `[${attr}]`;
+}
+function unwrapGlobal(s) {
+  let out = "";
+  let i = 0;
+  while (i < s.length) {
+    if (s.startsWith(":global(", i)) {
+      i += ":global(".length;
+      let depth = 1;
+      while (i < s.length && depth > 0) {
+        const c = s[i];
+        if (c === "(") depth++;
+        else if (c === ")") {
+          depth--;
+          if (depth === 0) {
+            i++;
+            break;
+          }
+        }
+        out += c;
+        i++;
+      }
+    } else {
+      out += s[i++];
+    }
+  }
+  return out;
+}
+function splitTopLevel2(s, sep4) {
+  const out = [];
+  let depth = 0;
+  let last = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === '"' || c === "'") {
+      i = skipString(s, i) - 1;
+      continue;
+    }
+    if (c === "(" || c === "[") depth++;
+    else if (c === ")" || c === "]") depth--;
+    else if (c === sep4 && depth === 0) {
+      out.push(s.slice(last, i));
+      last = i + 1;
+    }
+  }
+  out.push(s.slice(last));
+  return out;
+}
+function skipString(s, start) {
+  const q2 = s[start];
+  let i = start + 1;
+  while (i < s.length) {
+    const c = s[i];
+    if (c === "\\") {
+      i += 2;
+      continue;
+    }
+    if (c === q2) return i + 1;
+    i++;
+  }
+  return s.length;
+}
+
+// packages/compiler/src/infer.ts
+var FOR_VARS = ["$index", "$count", "$first", "$last", "$even", "$odd"];
+function inferCtxNames(nodes) {
+  const used = /* @__PURE__ */ new Set();
+  const declared = /* @__PURE__ */ new Set();
+  const add = (expr) => {
+    if (expr) for (const id of freeIdentifiers(expr)) used.add(id);
+  };
+  const walk2 = (list) => {
+    for (const node of list) {
+      switch (node.type) {
+        case "text":
+          break;
+        case "interp":
+          add(node.expr);
+          break;
+        case "let":
+          add(node.expr);
+          declared.add(node.name);
+          break;
+        case "element":
+          for (const attr of node.attrs) {
+            if (attr.type === "use") add(attr.name);
+            if (attr.type === "transition") add(attr.name);
+            if (attr.type !== "static") add(attr.expr);
+          }
+          walk2(node.children);
+          break;
+        case "if":
+          for (const br of node.branches) {
+            add(br.cond);
+            if (br.alias) declared.add(br.alias);
+            walk2(br.children);
+          }
+          break;
+        case "for":
+          add(node.list);
+          add(node.track);
+          declared.add(node.item);
+          for (const v of FOR_VARS) declared.add(v);
+          walk2(node.children);
+          if (node.empty) walk2(node.empty);
+          break;
+        case "switch":
+          add(node.expr);
+          for (const c of node.cases) {
+            add(c.test);
+            walk2(c.children);
+          }
+          break;
+        case "defer":
+          if (node.trigger.kind === "when") add(node.trigger.expr);
+          if (node.trigger.kind === "timer") add(node.trigger.ms);
+          walk2(node.children);
+          if (node.placeholder) walk2(node.placeholder);
+          break;
+        case "await":
+          add(node.expr);
+          if (node.pending) walk2(node.pending);
+          if (node.then) {
+            if (node.then.alias) declared.add(node.then.alias);
+            walk2(node.then.children);
+          }
+          if (node.catch) {
+            if (node.catch.alias) declared.add(node.catch.alias);
+            walk2(node.catch.children);
+          }
+          break;
+        case "snippet":
+          declared.add(node.name);
+          for (const p of node.params) declared.add(p);
+          walk2(node.children);
+          break;
+        case "render":
+          add(node.expr);
+          break;
+        case "key":
+          add(node.expr);
+          walk2(node.children);
+          break;
+      }
+    }
+  };
+  walk2(nodes);
+  return [...used].filter((n) => !declared.has(n)).sort();
+}
+
+// packages/compiler/src/component.ts
+var HAS_SETUP = /export\s+(?:async\s+)?function\s+setup\b|export\s+(?:const|let|var)\s+setup\b/;
+function compileComponent(src, opts = {}) {
+  const hash = opts.hash ?? hashCss(opts.filename ?? src.template);
+  const attr = scopeAttr(hash);
+  const scope = inferCtxNames(parseTemplate(src.template));
+  const host = src.styles && /:host\b/.test(src.styles) ? hostAttr(hash) : void 0;
+  const compiled = compileTemplate(src.template, { mode: "module", scope, scopeAttr: attr, hostAttr: host });
+  const renderBody = compiled.code.replace("export default function render", "function render");
+  const css = src.styles ? scopeCss(src.styles, hash) : "";
+  const script = src.script ?? "";
+  const setupArg = HAS_SETUP.test(script) ? "render, setup" : "render";
+  const code = [
+    script.trim(),
+    'import { defineComponent } from "@weave-framework/runtime/dom";',
+    renderBody,
+    `export default defineComponent(${setupArg});`
+  ].filter(Boolean).join("\n\n");
+  return { code, css, hash };
+}
+function parseSfcLoc(source) {
+  const script = locateBlock(source, "script");
+  const style = locateBlock(source, "style");
+  let template = source;
+  for (const b of [script, style]) {
+    if (b) template = blankRange(template, b.rawStart, b.rawEnd);
+  }
+  return {
+    script: script?.inner || void 0,
+    scriptLine: script ? lineAt(source, script.innerStart) : 0,
+    scriptOffset: script ? script.innerStart : 0,
+    template,
+    styleOffset: style ? style.innerStart : 0,
+    styles: style?.inner || void 0
+  };
+}
+function locateBlock(source, tag) {
+  const open = source.search(new RegExp(`<${tag}(\\s[^>]*)?>`, "i"));
+  if (open === -1) return null;
+  const gt = source.indexOf(">", open);
+  const close = source.toLowerCase().indexOf(`</${tag}>`, gt);
+  if (close === -1) return null;
+  const rawInner = source.slice(gt + 1, close);
+  const lead = rawInner.length - rawInner.trimStart().length;
+  return {
+    rawStart: open,
+    rawEnd: close + `</${tag}>`.length,
+    innerStart: gt + 1 + lead,
+    inner: rawInner.trim()
+  };
+}
+function blankRange(s, start, end) {
+  let mid = "";
+  for (let i = start; i < end; i++) mid += s[i] === "\n" ? "\n" : " ";
+  return s.slice(0, start) + mid + s.slice(end);
+}
+function lineAt(s, offset) {
+  let line = 0;
+  for (let i = 0; i < offset && i < s.length; i++) if (s[i] === "\n") line++;
+  return line;
+}
+function parseSfc(source) {
+  const script = extractBlock(source, "script");
+  const style = extractBlock(source, "style");
+  const template = source.replace(script.raw, "").replace(style.raw, "").trim();
+  return {
+    script: script.inner || void 0,
+    template,
+    styles: style.inner || void 0
+  };
+}
+function extractBlock(source, tag) {
+  const open = source.search(new RegExp(`<${tag}(\\s[^>]*)?>`, "i"));
+  if (open === -1) return { raw: "", inner: "" };
+  const gt = source.indexOf(">", open);
+  const close = source.toLowerCase().indexOf(`</${tag}>`, gt);
+  if (close === -1) return { raw: "", inner: "" };
+  const end = close + `</${tag}>`.length;
+  return { raw: source.slice(open, end), inner: source.slice(gt + 1, close).trim() };
+}
+
+// packages/compiler/src/sources.ts
+var DECL = /export\s+const\s+(template|styles)\s*(?::[^=]+)?=\s*/g;
+function extractSources(script) {
+  let template;
+  let templateRange;
+  let styles;
+  const blanks = [];
+  DECL.lastIndex = 0;
+  let m;
+  while ((m = DECL.exec(script)) !== null) {
+    const kind = m[1];
+    const valueStart = m.index + m[0].length;
+    const parsed = parseLiteral(script, valueStart, kind);
+    if (kind === "template") {
+      if (Array.isArray(parsed.value)) throw new Error("weave: `template` must be a single string, not an array");
+      template = parsed.value;
+      if (parsed.innerStart !== void 0 && parsed.innerEnd !== void 0) {
+        templateRange = [parsed.innerStart, parsed.innerEnd];
+      }
+    } else {
+      styles = Array.isArray(parsed.value) ? parsed.value : [parsed.value];
+    }
+    let end = parsed.end;
+    while (end < script.length && /\s/.test(script[end]) && script[end] !== "\n") end++;
+    if (script[end] === ";") end++;
+    blanks.push([m.index, end]);
+    DECL.lastIndex = end;
+  }
+  return { template, templateRange, styles, script: blanks.length ? blank(script, blanks) : script };
+}
+function parseLiteral(src, i, kind) {
+  i = skipWs(src, i);
+  const c = src[i];
+  if (c === '"' || c === "'" || c === "`") return parseString(src, i);
+  if (c === "[") return parseArray(src, i);
+  throw new Error(`weave: \`${kind}\` must be a static string${kind === "styles" ? " or array of strings" : ""}`);
+}
+function parseString(src, i) {
+  const quote = src[i];
+  const innerStart = i + 1;
+  let out = "";
+  let j = innerStart;
+  for (; j < src.length; j++) {
+    const ch = src[j];
+    if (ch === "\\") {
+      out += src[j + 1] ?? "";
+      j++;
+      continue;
+    }
+    if (quote === "`" && ch === "$" && src[j + 1] === "{") {
+      throw new Error("weave: inline template/styles cannot use ${\u2026} \u2014 Weave binds with {expr}, not JS interpolation");
+    }
+    if (ch === quote) return { value: out, end: j + 1, innerStart, innerEnd: j };
+    out += ch;
+  }
+  throw new Error("weave: unterminated string literal in template/styles declaration");
+}
+function parseArray(src, i) {
+  const items = [];
+  let j = i + 1;
+  for (; ; ) {
+    j = skipWs(src, j);
+    if (src[j] === "]") return { value: items, end: j + 1 };
+    if (j >= src.length) throw new Error("weave: unterminated array in styles declaration");
+    if (src[j] === ",") {
+      j++;
+      continue;
+    }
+    const str = parseString(src, j);
+    items.push(str.value);
+    j = str.end;
+  }
+}
+function skipWs(src, i) {
+  while (i < src.length && /\s/.test(src[i])) i++;
+  return i;
+}
+function blank(src, ranges) {
+  let out = "";
+  let cursor = 0;
+  for (const [start, end] of ranges) {
+    out += src.slice(cursor, start);
+    for (let k = start; k < end; k++) out += src[k] === "\n" ? "\n" : " ";
+    cursor = end;
+  }
+  return out + src.slice(cursor);
+}
+function faithfulTemplate(source, range) {
+  let out = "";
+  for (let i = 0; i < source.length; i++) {
+    out += i >= range[0] && i < range[1] ? source[i] : source[i] === "\n" ? "\n" : " ";
+  }
+  return out;
+}
+function classifyTemplate(value) {
+  if (/[<{}\n]/.test(value)) return "inline";
+  if (/[\\/]/.test(value) || /\.html$/i.test(value)) return "file";
+  return "inline";
+}
+function classifyStyle(value) {
+  if (/[{}\n]/.test(value)) return "inline";
+  if (/[\\/]/.test(value) || /\.(css|scss|sass)$/i.test(value)) return "file";
+  return "inline";
+}
+
+// packages/cli/src/styles.ts
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+function langFromExt(file) {
+  if (file.endsWith(".scss")) return "scss";
+  if (file.endsWith(".sass")) return "sass";
+  return "css";
+}
+async function compileStyleFile(path) {
+  if (langFromExt(path) === "css") return readFile(path, "utf8");
+  const sass = await import("sass");
+  return sass.compile(path).css;
+}
+async function compileStyleFileTracked(path) {
+  if (langFromExt(path) === "css") return { css: await readFile(path, "utf8"), files: [path] };
+  const sass = await import("sass");
+  const result = sass.compile(path);
+  const files = result.loadedUrls.filter((u) => u.protocol === "file:").map((u) => fileURLToPath(u));
+  return { css: result.css, files };
+}
+async function compileStyleSource(source, lang, fromDir) {
+  if (lang === "css" || !source.trim()) return source;
+  const sass = await import("sass");
+  return sass.compileString(source, {
+    syntax: lang === "sass" ? "indented" : "scss",
+    loadPaths: fromDir ? [fromDir] : []
+  }).css;
+}
+
+// packages/cli/src/plugin.ts
+function cssInjector(css) {
+  if (!css) return "";
+  return `
+;(()=>{const s=document.createElement("style");s.textContent=${JSON.stringify(
+    css
+  )};document.head.appendChild(s);})();
+`;
+}
+async function resolveTemplate(decl, tsPath, siblingHtml, hasSiblingHtml) {
+  if (decl.template !== void 0) {
+    if (hasSiblingHtml) {
+      throw new Error(
+        `weave: ${tsPath} declares \`template\` and also has a sibling .html \u2014 remove one`
+      );
+    }
+    if (classifyTemplate(decl.template) === "inline") return { text: decl.template, files: [] };
+    const file = resolve(dirname(tsPath), decl.template);
+    if (!existsSync(file)) throw new Error(`weave: template file not found: ${file} (from ${tsPath})`);
+    return { text: await readFile2(file, "utf8"), files: [file] };
+  }
+  return { text: await readFile2(siblingHtml, "utf8"), files: [siblingHtml] };
+}
+async function resolveStyles(decl, tsPath, dir, styleLang) {
+  if (decl.styles !== void 0) {
+    const siblingStyle2 = tsPath.replace(/\.ts$/, "." + styleLang);
+    if (existsSync(siblingStyle2)) {
+      throw new Error(
+        `weave: ${tsPath} declares \`styles\` and also has a sibling .${styleLang} \u2014 remove one`
+      );
+    }
+    const parts = [];
+    const files = [];
+    for (const entry of decl.styles) {
+      if (classifyStyle(entry) === "inline") {
+        parts.push(await compileStyleSource(entry, styleLang, dir));
+      } else {
+        const file = resolve(dir, entry);
+        if (!existsSync(file)) throw new Error(`weave: style file not found: ${file} (from ${tsPath})`);
+        const compiled2 = await compileStyleFileTracked(file);
+        parts.push(compiled2.css);
+        files.push(...compiled2.files);
+      }
+    }
+    return { css: parts.join("\n"), files };
+  }
+  const siblingStyle = tsPath.replace(/\.ts$/, "." + styleLang);
+  if (!existsSync(siblingStyle)) return { css: void 0, files: [] };
+  const compiled = await compileStyleFileTracked(siblingStyle);
+  return { css: compiled.css, files: compiled.files };
+}
+function weave(state, options = {}) {
+  const styleLang = options.styleLang ?? "css";
+  const dev2 = options.dev ?? false;
+  const emit2 = (code, css, resolveDir) => {
+    if (dev2) return { contents: code + cssInjector(css), loader: "ts", resolveDir };
+    if (css) state.css.push(css);
+    return { contents: code, loader: "ts", resolveDir };
+  };
+  return {
+    name: "weave",
+    setup(build2) {
+      build2.onStart(() => {
+        state.css.length = 0;
+      });
+      build2.onLoad({ filter: /\.weave$/ }, async (args) => {
+        const source = await readFile2(args.path, "utf8");
+        const src = parseSfc(source);
+        const styles = src.styles ? await compileStyleSource(src.styles, styleLang, dirname(args.path)) : void 0;
+        const { code, css } = compileComponent({ ...src, styles }, { filename: args.path });
+        return emit2(code, css, dirname(args.path));
+      });
+      build2.onLoad({ filter: /\.ts$/ }, async (args) => {
+        if (args.path.includes("node_modules")) return void 0;
+        if (args.path.endsWith(".gen.ts")) return void 0;
+        const source = await readFile2(args.path, "utf8");
+        const decl = extractSources(source);
+        const siblingHtml = args.path.replace(/\.ts$/, ".html");
+        const hasSiblingHtml = existsSync(siblingHtml);
+        if (decl.template === void 0 && !hasSiblingHtml) return void 0;
+        const dir = dirname(args.path);
+        const template = await resolveTemplate(
+          decl,
+          args.path,
+          siblingHtml,
+          hasSiblingHtml
+        );
+        const styles = await resolveStyles(
+          decl,
+          args.path,
+          dir,
+          styleLang
+        );
+        const { code, css } = compileComponent(
+          { script: decl.script, template: template.text, styles: styles.css },
+          { filename: args.path }
+        );
+        return { ...emit2(code, css, dir), watchFiles: [...template.files, ...styles.files] };
+      });
+    }
+  };
+}
+
+// packages/cli/src/entry.ts
+import { readdirSync, readFileSync, statSync, existsSync as existsSync2 } from "node:fs";
+import { join, relative, sep } from "node:path";
+var VIRTUAL_ENTRY = "weave-virtual-entry";
+var SKIP = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".weave"]);
+var TAG_RE = /export\s+const\s+tag\s*(?::[^=]+)?=\s*(['"`])([^'"`]*)\1/;
+var PROPS_RE = /export\s+const\s+props\s*(?::[^=]+)?=\s*\[([^\]]*)\]/;
+var STR_RE = /(['"`])([^'"`]*)\1/g;
+function discoverCustomElements(rootDir) {
+  const found = [];
+  walk(rootDir, found);
+  const seen = /* @__PURE__ */ new Map();
+  for (const ce of found) {
+    const prev = seen.get(ce.tag);
+    if (prev) {
+      throw new Error(`weave: custom element tag "${ce.tag}" declared twice \u2014 ${prev} and ${ce.file}`);
+    }
+    seen.set(ce.tag, ce.file);
+  }
+  return found;
+}
+function walk(path, out) {
+  if (!existsSync2(path)) return;
+  const st = statSync(path);
+  if (st.isDirectory()) {
+    for (const entry of readdirSync(path)) {
+      if (!SKIP.has(entry)) walk(join(path, entry), out);
+    }
+    return;
+  }
+  if (!path.endsWith(".ts") || path.endsWith(".d.ts") || path.endsWith(".gen.ts")) return;
+  const src = readFileSync(path, "utf8");
+  const m = src.match(TAG_RE);
+  if (!m) return;
+  const tag = m[2];
+  if (!tag.includes("-")) {
+    throw new Error(
+      `weave: custom element tag "${tag}" in ${path} must contain a hyphen (Custom Elements spec)`
+    );
+  }
+  out.push({ tag, file: path, props: extractProps(src) });
+}
+function extractProps(src) {
+  const m = src.match(PROPS_RE);
+  if (!m) return [];
+  const props = [];
+  let s;
+  STR_RE.lastIndex = 0;
+  while ((s = STR_RE.exec(m[1])) !== null) props.push(s[2]);
+  return props;
+}
+function generateEntry(rootComponent, mount, rootDir, elements) {
+  const spec = (file) => {
+    const r = relative(rootDir, file).split(sep).join("/").replace(/\.ts$/, "");
+    return JSON.stringify(r.startsWith(".") ? r : "./" + r);
+  };
+  const lines = [`import Root from ${spec(rootComponent)};`];
+  elements.forEach((ce, i) => lines.push(`import __ce${i} from ${spec(ce.file)};`));
+  lines.push('import { mountComponent, defineCustomElement } from "@weave-framework/runtime/dom";');
+  elements.forEach(
+    (ce, i) => lines.push(`defineCustomElement(${JSON.stringify(ce.tag)}, __ce${i}, { props: ${JSON.stringify(ce.props)} });`)
+  );
+  lines.push(`mountComponent(Root, ${JSON.stringify(mount)});`);
+  return lines.join("\n");
+}
+function entryPlugin(code, resolveDir) {
+  return {
+    name: "weave:entry",
+    setup(build2) {
+      build2.onResolve({ filter: new RegExp(`^${VIRTUAL_ENTRY}$`) }, (args) => ({
+        path: args.path,
+        namespace: "weave-entry"
+      }));
+      build2.onLoad({ filter: /.*/, namespace: "weave-entry" }, () => ({
+        contents: code,
+        loader: "ts",
+        resolveDir
+      }));
+    }
+  };
+}
+
+// packages/cli/src/html.ts
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stripLiveReload(html) {
+  return html.replace(
+    /[ \t]*<script>(?:(?!<\/script>)[\s\S])*?EventSource\([^)]*reload[^)]*\)[\s\S]*?<\/script>\n?/gi,
+    ""
+  );
+}
+function injectHtml(html, opts) {
+  let out = stripLiveReload(html);
+  if (opts.css && !new RegExp(`<link[^>]+href=["']${escapeRe(opts.css)}["']`, "i").test(out)) {
+    out = out.replace(/<\/head>/i, `    <link rel="stylesheet" href="${opts.css}" />
+  </head>`);
+  }
+  if (!new RegExp(`<script[^>]+src=["']${escapeRe(opts.script)}["']`, "i").test(out)) {
+    out = out.replace(
+      /<\/body>/i,
+      `    <script type="module" src="${opts.script}"></script>
+  </body>`
+    );
+  }
+  if (opts.liveReload) {
+    const client = `<script>new EventSource(${JSON.stringify(
+      opts.liveReload
+    )}).addEventListener("message",()=>location.reload());</script>`;
+    out = out.replace(/<\/body>/i, `    ${client}
+  </body>`);
+  }
+  return out;
+}
+
+// packages/cli/src/build.ts
+async function build(config) {
+  const { outDir } = config;
+  if (config.clean) await rm(outDir, { recursive: true, force: true });
+  const state = { css: [] };
+  const ve = config.virtualEntry;
+  await esbuild({
+    // A virtual entry (Level C) is emitted as `main.js`; else the hand-written entry.
+    entryPoints: ve ? [{ in: VIRTUAL_ENTRY, out: "main" }] : [config.entry],
+    bundle: true,
+    format: "esm",
+    // Code-split dynamic import()s into separate chunks, so `lazy()` routes are
+    // actually their own files and <Link> prefetch (B.15) has something to warm.
+    splitting: true,
+    outdir: outDir,
+    minify: config.minify ?? true,
+    plugins: [
+      weave(state, { styleLang: config.styleLang }),
+      ...ve ? [entryPlugin(ve.code, ve.resolveDir)] : []
+    ]
+  });
+  if (config.publicDir && existsSync3(config.publicDir)) {
+    await cp(config.publicDir, outDir, { recursive: true });
+  }
+  const globalCss = (await Promise.all((config.styles ?? []).map(compileStyleFile))).join(
+    "\n"
+  );
+  await mkdir(outDir, { recursive: true });
+  await writeFile(join2(outDir, "app.css"), [globalCss, ...state.css].filter(Boolean).join("\n"));
+  if (config.index) {
+    const html = injectHtml(await readFile3(config.index, "utf8"), {
+      script: "/main.js",
+      css: "/app.css"
+    });
+    await writeFile(join2(outDir, "index.html"), html);
+  }
+}
+
+// packages/cli/src/dev.ts
+import { context } from "esbuild";
+import { createServer } from "node:http";
+import { mkdir as mkdir2, writeFile as writeFile2, readFile as readFile4 } from "node:fs/promises";
+import { join as join3, extname, relative as relative2, sep as sep2 } from "node:path";
+var RELOAD_PATH = "/__weave_reload";
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".webmanifest": "application/manifest+json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2"
+};
+function mime(path) {
+  return MIME[extname(path).toLowerCase()] ?? "application/octet-stream";
+}
+async function dev(config) {
+  return config.inMemory ?? false ? devInMemory(config) : devLegacy(config);
+}
+async function devInMemory(config) {
+  const state = { css: [] };
+  let banner;
+  if (config.styles?.length) {
+    const css = (await Promise.all(config.styles.map(compileStyleFile))).join("\n");
+    if (css)
+      banner = {
+        js: `(()=>{const s=document.createElement("style");s.textContent=${JSON.stringify(
+          css
+        )};document.head.appendChild(s);})();`
+      };
+  }
+  const outputs = /* @__PURE__ */ new Map();
+  const clients = /* @__PURE__ */ new Set();
+  const capture = {
+    name: "weave:dev-capture",
+    setup(build2) {
+      build2.onEnd((result) => {
+        outputs.clear();
+        for (const file of result.outputFiles ?? []) {
+          const rel = relative2(config.outdir, file.path).split(sep2).join("/");
+          outputs.set("/" + rel, file.contents);
+        }
+        for (const res of clients) res.write("data: reload\n\n");
+      });
+    }
+  };
+  const ve = config.virtualEntry;
+  const ctx = await context({
+    entryPoints: ve ? [{ in: VIRTUAL_ENTRY, out: "main" }] : [config.entry],
+    bundle: true,
+    format: "esm",
+    splitting: true,
+    outdir: config.outdir,
+    write: false,
+    // everything stays in memory — dev creates no dist/
+    banner,
+    plugins: [
+      weave(state, { styleLang: config.styleLang, dev: true }),
+      ...ve ? [entryPlugin(ve.code, ve.resolveDir)] : [],
+      capture
+    ]
+  });
+  await ctx.watch();
+  const server = createServer((req, res) => {
+    void handleRequest(req, res, config, outputs, clients);
+  });
+  const port = await listen(server, config.port);
+  return { ctx, url: `http://127.0.0.1:${port}` };
+}
+async function handleRequest(req, res, config, outputs, clients) {
+  const url = (req.url ?? "/").split("?")[0];
+  if (url === RELOAD_PATH) {
+    res.writeHead(200, {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      connection: "keep-alive"
+    });
+    res.write("\n");
+    clients.add(res);
+    req.on("close", () => {
+      clients.delete(res);
+    });
+    return;
+  }
+  const built = outputs.get(url);
+  if (built) {
+    res.writeHead(200, { "content-type": mime(url) });
+    res.end(Buffer.from(built));
+    return;
+  }
+  if (extname(url)) {
+    try {
+      const buf = await readFile4(join3(config.servedir, url));
+      res.writeHead(200, { "content-type": mime(url) });
+      res.end(buf);
+    } catch {
+      res.writeHead(404);
+      res.end("Not found");
+    }
+    return;
+  }
+  try {
+    const shell = config.index ?? join3(config.servedir, "index.html");
+    const html = injectHtml(await readFile4(shell, "utf8"), {
+      script: "/main.js",
+      liveReload: RELOAD_PATH
+    });
+    res.writeHead(200, { "content-type": MIME[".html"] });
+    res.end(html);
+  } catch {
+    res.writeHead(500);
+    res.end("No index.html");
+  }
+}
+function listen(server, port) {
+  return new Promise((resolve4) => {
+    server.listen(port ?? 0, "127.0.0.1", () => {
+      const addr = server.address();
+      resolve4(typeof addr === "object" && addr ? addr.port : port ?? 0);
+    });
+  });
+}
+async function devLegacy(config) {
+  const state = { css: [] };
+  const plugins = [
+    weave(state, { styleLang: config.styleLang }),
+    {
+      name: "weave:css",
+      setup(build2) {
+        build2.onEnd(async () => {
+          await mkdir2(config.outdir, { recursive: true });
+          await writeFile2(join3(config.outdir, "app.css"), state.css.join("\n"));
+        });
+      }
+    }
+  ];
+  const ctx = await context({
+    entryPoints: [config.entry],
+    // legacy mode always has a hand-written entry
+    bundle: true,
+    format: "esm",
+    splitting: true,
+    outdir: config.outdir,
+    plugins
+  });
+  await ctx.watch();
+  const { hosts, port } = await ctx.serve({
+    servedir: config.servedir,
+    fallback: join3(config.servedir, "index.html"),
+    port: config.port,
+    host: "127.0.0.1"
+  });
+  return { ctx, url: `http://${hosts[0] ?? "127.0.0.1"}:${port}` };
+}
+
+// packages/cli/src/routes.ts
+import { readdirSync as readdirSync2, writeFileSync } from "node:fs";
+import { join as join4, relative as relative3, sep as sep3 } from "node:path";
+
+// packages/router/src/files.ts
+var EXT = /\.(weave|tsx?|jsx?)$/;
+var baseName = (file) => {
+  const slash = file.lastIndexOf("/");
+  return file.slice(slash + 1).replace(EXT, "");
+};
+function segment(name) {
+  if (name === "index") return "";
+  const catchAll = /^\[\.\.\.(.+)]$/.exec(name);
+  if (catchAll) return "*";
+  const dynamic = /^\[(.+)]$/.exec(name);
+  if (dynamic) return `:${dynamic[1]}`;
+  return name;
+}
+var emptyTree = () => ({ files: {}, dirs: {} });
+function segSpecificity(seg) {
+  if (seg === "*" || seg.startsWith("*")) return 2;
+  if (seg.startsWith(":")) return 1;
+  return 0;
+}
+function compareRoutes(a, b) {
+  const as = a.split("/");
+  const bs = b.split("/");
+  const len = Math.max(as.length, bs.length);
+  for (let i = 0; i < len; i++) {
+    const sa = as[i] ?? "";
+    const sb = bs[i] ?? "";
+    const da = segSpecificity(sa);
+    const db = segSpecificity(sb);
+    if (da !== db) return da - db;
+    if (sa !== sb) return sa.localeCompare(sb);
+  }
+  return 0;
+}
+function joinPath(dir, child) {
+  return child === "" ? dir : `${dir}/${child}`;
+}
+function convert(tree) {
+  const routes = [];
+  for (const [name, file] of Object.entries(tree.files)) {
+    if (name === "_layout") continue;
+    routes.push({ path: segment(name), file });
+  }
+  for (const [dir, sub] of Object.entries(tree.dirs)) {
+    const childRoutes = convert(sub);
+    const layout = sub.files["_layout"];
+    if (layout) {
+      routes.push({ path: dir, file: layout, children: sortRoutes(childRoutes) });
+    } else {
+      for (const r of childRoutes) routes.push({ ...r, path: joinPath(dir, r.path) });
+    }
+  }
+  return sortRoutes(routes);
+}
+function sortRoutes(routes) {
+  return routes.sort((a, b) => compareRoutes(a.path, b.path));
+}
+function fileToRoutes(files) {
+  const root = emptyTree();
+  for (const file of files) {
+    const parts = file.split("/");
+    let node = root;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const dir = parts[i];
+      node = node.dirs[dir] ??= emptyTree();
+    }
+    node.files[baseName(parts[parts.length - 1])] = file;
+  }
+  return convert(root);
+}
+function emitRoutesModule(routes, opts = {}) {
+  const imports = [];
+  let n = 0;
+  const prefix = opts.importPrefix ?? "./";
+  const spec = (file) => {
+    const withPrefix = /^[./]/.test(file) ? file : prefix + file;
+    return JSON.stringify(withPrefix.replace(/\.[mc]?[jt]sx?$/, ""));
+  };
+  const componentField = (file) => {
+    if (opts.lazy) return `component: lazy(() => import(${spec(file)}))`;
+    const id = `Page${n++}`;
+    imports.push(`import ${id} from ${spec(file)};`);
+    return `component: ${id}`;
+  };
+  const serialize = (list, indent) => {
+    const inner = indent + "  ";
+    const items = list.map((r) => {
+      const fields = [`path: ${JSON.stringify(r.path)}`];
+      if (r.file) fields.push(componentField(r.file));
+      if (r.children && r.children.length) {
+        fields.push(`children: ${serialize(r.children, inner)}`);
+      }
+      return `${inner}{ ${fields.join(", ")} }`;
+    });
+    return `[
+${items.join(",\n")}
+${indent}]`;
+  };
+  const body = serialize(routes, "");
+  const header = opts.lazy ? `import { lazy } from ${JSON.stringify(opts.runtimeImport ?? "@weave-framework/runtime/dom")};
+` : "";
+  return `${header}${imports.join("\n")}${imports.length ? "\n" : ""}
+export const routes = ${body};
+`;
+}
+
+// packages/cli/src/routes.ts
+var PAGE = /\.(weave|tsx?|jsx?)$/;
+var NOT_A_PAGE = /\.(gen|d)\.[mc]?tsx?$/;
+function scanRoutes(dir) {
+  const out = [];
+  const walk2 = (cur) => {
+    for (const entry of readdirSync2(cur, { withFileTypes: true })) {
+      const full = join4(cur, entry.name);
+      if (entry.isDirectory()) walk2(full);
+      else if (PAGE.test(entry.name) && !NOT_A_PAGE.test(entry.name))
+        out.push(relative3(dir, full).split(sep3).join("/"));
+    }
+  };
+  walk2(dir);
+  return out.sort();
+}
+function generateRoutes(dir, opts = {}) {
+  const files = scanRoutes(dir);
+  const routes = fileToRoutes(files);
+  const module = emitRoutesModule(routes, { lazy: opts.lazy ?? true });
+  const out = opts.out ?? join4(dir, "routes.gen.ts");
+  writeFileSync(out, module);
+  return out;
+}
+
+// packages/cli/src/config.ts
+import { build as esbuildBuild } from "esbuild";
+import { existsSync as existsSync4 } from "node:fs";
+import { readFile as readFile5 } from "node:fs/promises";
+import { resolve as resolve2, dirname as dirname2, join as join5, isAbsolute } from "node:path";
+function defineConfig(config) {
+  return config;
+}
+var CONFIG_NAMES = ["weave.config.ts", "weave.config.js", "weave.config.mjs", "weave.config.json"];
+async function loadConfig(cwd, explicit) {
+  const file = explicit ? resolve2(cwd, explicit) : CONFIG_NAMES.map((n) => join5(cwd, n)).find((p) => existsSync4(p));
+  if (!file || !existsSync4(file)) return null;
+  const raw = file.endsWith(".json") ? JSON.parse(await readFile5(file, "utf8")) : await importConfigModule(file);
+  return resolveConfig(raw, dirname2(file));
+}
+async function importConfigModule(file) {
+  const out = await esbuildBuild({
+    entryPoints: [file],
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    write: false,
+    packages: "external",
+    // keep node_modules external (resolved at import time)
+    plugins: [
+      {
+        // `import { defineConfig } from '@weave-framework/cli'` → a tiny inline identity, so
+        // the config doesn't drag the whole CLI (and esbuild) into the bundle.
+        name: "weave-config-shim",
+        setup(b) {
+          b.onResolve({ filter: /^@weave-framework\/cli$/ }, () => ({
+            path: "@weave-framework/cli",
+            namespace: "weave-cli-shim"
+          }));
+          b.onLoad({ filter: /.*/, namespace: "weave-cli-shim" }, () => ({
+            contents: "export const defineConfig = (c) => c;",
+            loader: "js"
+          }));
+        }
+      }
+    ]
+  });
+  const code = out.outputFiles[0].text;
+  const url = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
+  const mod = await import(url);
+  return mod.default ?? mod;
+}
+function resolveConfig(raw, root) {
+  const abs = (p) => isAbsolute(p) ? p : resolve2(root, p);
+  if (!raw.root && !raw.entry) {
+    throw new Error("weave: config must declare either `root` (generated bootstrap) or `entry` (hand-written)");
+  }
+  if (raw.root && raw.entry) {
+    throw new Error("weave: config declares both `root` and `entry` \u2014 pick one");
+  }
+  return {
+    root,
+    entry: raw.entry ? abs(raw.entry) : void 0,
+    rootComponent: raw.root ? abs(raw.root) : void 0,
+    mount: raw.mount ?? "#app",
+    publicDir: raw.publicDir ? abs(raw.publicDir) : root,
+    index: raw.index ? abs(raw.index) : void 0,
+    outDir: abs(raw.outDir ?? "dist"),
+    styleLang: raw.styleLang ?? "css",
+    routesDir: raw.routesDir ? abs(raw.routesDir) : void 0,
+    styles: (raw.styles ?? []).map(abs),
+    port: raw.dev?.port,
+    minify: raw.build?.minify ?? true
+  };
+}
+
+// packages/check/src/emit.ts
+var FOR_VARS2 = ["$index", "$count", "$first", "$last", "$even", "$odd"];
+var HAS_SETUP2 = /export\s+(?:async\s+)?function\s+setup\b|export\s+(?:const|let|var)\s+setup\b/;
+var isComponentTag = (tag) => /^[A-Z]/.test(tag);
+var propKey2 = (name) => /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+function buildVirtualSfc(filePath, source) {
+  const loc = parseSfcLoc(source);
+  const nodes = parseTemplate(loc.template);
+  const body = emit(nodes, new Set(inferCtxNames(nodes)));
+  const hasSetup = HAS_SETUP2.test(loc.script ?? "");
+  const asm = assemble(loc.script, hasSetup, body, loc.scriptOffset);
+  return {
+    path: filePath + ".ts",
+    text: asm.text,
+    templateFile: filePath,
+    templateText: loc.template,
+    templateMap: asm.templateMap,
+    scriptFile: filePath,
+    scriptText: source,
+    scriptLine: loc.scriptLine,
+    scriptLineCount: asm.scriptLineCount,
+    mappings: asm.mappings
+  };
+}
+function buildVirtualSeparate(tsPath, tsSource, htmlPath, htmlSource) {
+  const nodes = parseTemplate(htmlSource);
+  const body = emit(nodes, new Set(inferCtxNames(nodes)));
+  const asm = assemble(tsSource, HAS_SETUP2.test(tsSource), body, 0);
+  return {
+    // Live at the real `.ts` path (shadowing disk) so a parent's `import Foo from
+    // './foo'` resolves to this virtual — which carries the synthesized typed
+    // default export — instead of the on-disk source (which has only `setup`).
+    path: tsPath,
+    text: asm.text,
+    templateFile: htmlPath,
+    templateText: htmlSource,
+    templateMap: asm.templateMap,
+    scriptFile: tsPath,
+    scriptText: tsSource,
+    scriptLine: 0,
+    scriptLineCount: asm.scriptLineCount,
+    mappings: asm.mappings
+  };
+}
+function emit(nodes, ctx) {
+  const lines = [];
+  let awaitN = 0;
+  let propsN = 0;
+  const push = (text, offset) => {
+    lines.push({ text, offset });
+  };
+  const scopeOf = (locals) => {
+    const s = /* @__PURE__ */ new Map();
+    for (const n of ctx) s.set(n, { kind: "ctx" });
+    for (const n of locals) s.set(n, { kind: "local" });
+    return s;
+  };
+  const mk = () => {
+    let text = "";
+    const segs = [];
+    const api = {
+      lit(s) {
+        text += s;
+        return api;
+      },
+      expr(srcOffset, exprStr, locals) {
+        const r = rewrite(exprStr, scopeOf(locals), "__ctx");
+        const code = r.code.replace(/[\r\n]/g, " ");
+        const base = text.length;
+        if (srcOffset !== void 0) {
+          for (const s of r.segments) segs.push({ col: base + s.gen, src: srcOffset + s.src, len: s.len });
+        }
+        text += code;
+        return api;
+      },
+      push(offset) {
+        lines.push({ text, offset, segs });
+      }
+    };
+    return api;
+  };
+  const emitAttr = (attr, locals) => {
+    if (attr.type === "static") return;
+    if (attr.type === "use" || attr.type === "transition") {
+      const at = attr.nameOffset ?? attr.offset;
+      const b = mk().lit("  (").expr(at, attr.name, locals);
+      if (attr.expr !== void 0) b.lit(")(null as any, ").expr(attr.offset, attr.expr, locals).lit(");");
+      else b.lit(")(null as any);");
+      b.push(at);
+      return;
+    }
+    mk().lit("  void (").expr(attr.offset, attr.expr, locals).lit(");").push(attr.offset);
+  };
+  const emitComponent = (node, locals) => {
+    const dataProps = [];
+    for (const attr of node.attrs) {
+      if (attr.type === "static") {
+        if (attr.name === "slot") continue;
+        dataProps.push({ key: attr.name, staticVal: JSON.stringify(attr.value) });
+      } else if (attr.type === "attr") {
+        dataProps.push({ key: attr.name, expr: attr.expr, srcOffset: attr.offset });
+      } else {
+        emitAttr(attr, locals);
+      }
+    }
+    const id = `__props${propsN++}`;
+    const anchor = dataProps.find((p) => p.srcOffset !== void 0)?.srcOffset;
+    mk().lit(`  const ${id}: NonNullable<Parameters<typeof `).expr(node.tagOffset, node.tag, locals).lit(`>[0]> = {`).push(anchor ?? node.tagOffset);
+    for (const p of dataProps) {
+      if (p.expr !== void 0) {
+        mk().lit(`    ${propKey2(p.key)}: (`).expr(p.srcOffset, p.expr, locals).lit("),").push(p.srcOffset);
+      } else {
+        push(`    ${propKey2(p.key)}: (${p.staticVal}),`);
+      }
+    }
+    push(`  };`);
+    push(`  void ${id};`);
+  };
+  const walk2 = (list, locals) => {
+    let scope = locals;
+    const snippets = list.filter((n) => n.type === "snippet");
+    if (snippets.length) {
+      scope = new Set(scope);
+      for (const s of snippets) scope.add(s.name);
+      for (const s of snippets) {
+        const params = s.params.map((p) => `${p}: any`).join(", ");
+        push(`  const ${s.name} = (${params}): void => {`);
+        const inner = new Set(scope);
+        for (const p of s.params) inner.add(p);
+        walk2(s.children, inner);
+        push(`  };`);
+      }
+    }
+    for (const node of list) {
+      switch (node.type) {
+        case "snippet":
+          break;
+        // already emitted above
+        case "render":
+          mk().lit("  void (").expr(node.exprOffset, node.expr, scope).lit(");").push(node.exprOffset);
+          break;
+        case "key":
+          mk().lit("  void (").expr(node.exprOffset, node.expr, scope).lit(");").push(node.exprOffset);
+          walk2(node.children, scope);
+          break;
+        case "text":
+          break;
+        case "interp":
+          mk().lit("  void (").expr(node.offset, node.expr, scope).lit(");").push(node.offset);
+          break;
+        case "let": {
+          mk().lit(`  const ${node.name} = (`).expr(node.exprOffset, node.expr, scope).lit(");").push(node.exprOffset);
+          scope = new Set(scope).add(node.name);
+          break;
+        }
+        case "element":
+          if (isComponentTag(node.tag)) {
+            emitComponent(node, scope);
+            walk2(node.children, scope);
+            break;
+          }
+          for (const attr of node.attrs) emitAttr(attr, scope);
+          walk2(node.children, scope);
+          break;
+        case "if":
+          for (const br of node.branches) {
+            if (br.cond !== void 0) {
+              mk().lit("  if (").expr(br.condOffset, br.cond, scope).lit(") {").push(br.condOffset);
+            } else {
+              push(`  {`);
+            }
+            let inner = scope;
+            if (br.alias && br.cond !== void 0) {
+              mk().lit(`    const ${br.alias} = (`).expr(br.condOffset, br.cond, scope).lit(");").push(br.condOffset);
+              inner = new Set(scope).add(br.alias);
+            }
+            walk2(br.children, inner);
+            push(`  }`);
+          }
+          break;
+        case "for": {
+          mk().lit(`  for (const ${node.item} of (`).expr(node.listOffset, node.list, scope).lit(")) {").push(node.listOffset);
+          push(
+            `    const $index: number = 0, $count: number = 0, $first: boolean = true, $last: boolean = true, $even: boolean = true, $odd: boolean = true;`
+          );
+          const inner = new Set(scope).add(node.item);
+          for (const v of FOR_VARS2) inner.add(v);
+          if (node.track) mk().lit("    void (").expr(node.trackOffset, node.track, inner).lit(");").push(node.trackOffset);
+          walk2(node.children, inner);
+          push(`  }`);
+          if (node.empty) walk2(node.empty, scope);
+          break;
+        }
+        case "switch": {
+          mk().lit("  switch (").expr(node.exprOffset, node.expr, scope).lit(") {").push(node.exprOffset);
+          for (const c of node.cases) {
+            if (c.test !== void 0) {
+              mk().lit("    case ").expr(c.testOffset, c.test, scope).lit(": {").push(c.testOffset);
+            } else {
+              push(`    default: {`);
+            }
+            walk2(c.children, scope);
+            push(`    break; }`);
+          }
+          push(`  }`);
+          break;
+        }
+        case "defer": {
+          if (node.trigger.kind === "when") {
+            mk().lit("  void (").expr(node.trigger.exprOffset, node.trigger.expr, scope).lit(");").push(node.trigger.exprOffset);
+          } else if (node.trigger.kind === "timer") {
+            mk().lit("  void (").expr(node.trigger.msOffset, node.trigger.ms, scope).lit(");").push(node.trigger.msOffset);
+          }
+          walk2(node.children, scope);
+          if (node.placeholder) walk2(node.placeholder, scope);
+          break;
+        }
+        case "await": {
+          let srcVar = "";
+          if (node.then?.alias) {
+            srcVar = `__await${awaitN++}`;
+            mk().lit(`  const ${srcVar} = (`).expr(node.exprOffset, node.expr, scope).lit(");").push(node.exprOffset);
+          } else {
+            mk().lit("  void (").expr(node.exprOffset, node.expr, scope).lit(");").push(node.exprOffset);
+          }
+          if (node.pending) walk2(node.pending, scope);
+          if (node.then) {
+            push(`  {`);
+            let inner = scope;
+            if (node.then.alias) {
+              push(
+                `    const ${node.then.alias}: __WeaveAwaited<typeof ${srcVar}> = undefined as any;`,
+                node.exprOffset
+              );
+              inner = new Set(scope).add(node.then.alias);
+            }
+            walk2(node.then.children, inner);
+            push(`  }`);
+          }
+          if (node.catch) {
+            push(`  {`);
+            let inner = scope;
+            if (node.catch.alias) {
+              push(`    const ${node.catch.alias}: unknown = undefined;`);
+              inner = new Set(scope).add(node.catch.alias);
+            }
+            walk2(node.catch.children, inner);
+            push(`  }`);
+          }
+          break;
+        }
+      }
+    }
+  };
+  walk2(nodes, /* @__PURE__ */ new Set());
+  return lines;
+}
+function assemble(script, hasSetup, body, scriptBaseOffset) {
+  const out = [];
+  const scriptLines = script ? script.split("\n") : [];
+  for (const l of scriptLines) out.push(l);
+  out.push("");
+  out.push(
+    hasSetup ? "type __WeaveCtx = ReturnType<typeof setup>;" : "type __WeaveCtx = Record<string, any>;"
+  );
+  out.push("declare const __ctx: __WeaveCtx;");
+  out.push("type __WeaveAwaited<S> = S extends { data: () => infer D } ? NonNullable<D> : Awaited<S>;");
+  out.push("type __WeavePropsOf<F> = F extends (props: infer P, ...rest: any[]) => any ? P : Record<string, never>;");
+  out.push("function __weave__(): void {");
+  const bodyBase = out.length;
+  const templateMap = /* @__PURE__ */ new Map();
+  body.forEach((ln, i) => {
+    out.push(ln.text);
+    if (ln.offset !== void 0) templateMap.set(bodyBase + i + 1, ln.offset);
+  });
+  out.push("}");
+  const propsType = hasSetup ? "__WeavePropsOf<typeof setup>" : "Record<string, never>";
+  out.push(`declare const __weaveDefault: (props: ${propsType}, slots?: Record<string, () => unknown>) => unknown;`);
+  out.push("export default __weaveDefault;");
+  const mappings = [];
+  if (script && script.length) {
+    mappings.push({ generatedOffset: 0, sourceOffset: scriptBaseOffset, length: script.length, source: "script" });
+  }
+  const lineGenOffset = new Array(out.length);
+  let acc = 0;
+  for (let k = 0; k < out.length; k++) {
+    lineGenOffset[k] = acc;
+    acc += out[k].length + 1;
+  }
+  body.forEach((ln, i) => {
+    if (!ln.segs) return;
+    const gBase = lineGenOffset[bodyBase + i];
+    for (const s of ln.segs) {
+      mappings.push({ generatedOffset: gBase + s.col, sourceOffset: s.src, length: s.len, source: "template" });
+    }
+  });
+  return { text: out.join("\n"), scriptLineCount: scriptLines.length, templateMap, mappings };
+}
+
+// packages/check/src/check.ts
+import ts from "typescript";
+var OPTIONS = {
+  target: ts.ScriptTarget.ES2022,
+  module: ts.ModuleKind.ESNext,
+  moduleResolution: ts.ModuleResolutionKind.Bundler,
+  lib: ["lib.es2022.d.ts", "lib.dom.d.ts", "lib.dom.iterable.d.ts"],
+  types: [],
+  strict: true,
+  noEmit: true,
+  skipLibCheck: true,
+  allowJs: false
+};
+var norm = (p) => p.replace(/\\/g, "/").toLowerCase();
+function runCheck(virtuals) {
+  const byPath = new Map(virtuals.map((v) => [norm(v.path), v]));
+  const host = ts.createCompilerHost(OPTIONS, true);
+  const getSourceFile = host.getSourceFile.bind(host);
+  const readFile6 = host.readFile.bind(host);
+  const fileExists = host.fileExists.bind(host);
+  host.getSourceFile = (fileName, languageVersion, onError, shouldCreate) => {
+    const v = byPath.get(norm(fileName));
+    if (v) return ts.createSourceFile(fileName, v.text, languageVersion, true);
+    return getSourceFile(fileName, languageVersion, onError, shouldCreate);
+  };
+  host.readFile = (fileName) => byPath.get(norm(fileName))?.text ?? readFile6(fileName);
+  host.fileExists = (fileName) => byPath.has(norm(fileName)) || fileExists(fileName);
+  const program = ts.createProgram(
+    virtuals.map((v) => v.path),
+    OPTIONS,
+    host
+  );
+  const raw = [];
+  for (const v of virtuals) {
+    const sf = program.getSourceFile(v.path);
+    if (!sf) continue;
+    raw.push(...program.getSyntacticDiagnostics(sf), ...program.getSemanticDiagnostics(sf));
+  }
+  return raw.map((d) => mapDiagnostic(d, byPath));
+}
+function mapDiagnostic(d, byPath) {
+  const message = ts.flattenDiagnosticMessageText(d.messageText, "\n");
+  const category = categoryName(d.category);
+  if (!d.file || d.start === void 0) {
+    return { file: "(global)", line: 0, col: 0, code: d.code, message, category };
+  }
+  const { line, character } = d.file.getLineAndCharacterOfPosition(d.start);
+  const v = byPath.get(norm(d.file.fileName));
+  if (!v) {
+    return { file: d.file.fileName, line: line + 1, col: character + 1, code: d.code, message, category };
+  }
+  const vLine = line + 1;
+  const offset = v.templateMap.get(vLine);
+  if (offset !== void 0) {
+    const { line: l, col } = offsetToLineCol(v.templateText, offset);
+    return { file: v.templateFile, line: l, col, code: d.code, message, category };
+  }
+  if (vLine <= v.scriptLineCount) {
+    return {
+      file: v.scriptFile,
+      line: v.scriptLine + (vLine - 1) + 1,
+      col: character + 1,
+      code: d.code,
+      message,
+      category
+    };
+  }
+  return { file: v.templateFile, line: 1, col: 1, code: d.code, message: `[generated] ${message}`, category };
+}
+function categoryName(c) {
+  switch (c) {
+    case ts.DiagnosticCategory.Error:
+      return "error";
+    case ts.DiagnosticCategory.Warning:
+      return "warning";
+    case ts.DiagnosticCategory.Suggestion:
+      return "suggestion";
+    default:
+      return "message";
+  }
+}
+function offsetToLineCol(text, offset) {
+  let line = 1;
+  let col = 1;
+  const end = Math.min(offset, text.length);
+  for (let i = 0; i < end; i++) {
+    if (text[i] === "\n") {
+      line++;
+      col = 1;
+    } else {
+      col++;
+    }
+  }
+  return { line, col };
+}
+
+// packages/check/src/project.ts
+import { readFileSync as readFileSync2, readdirSync as readdirSync3, existsSync as existsSync5, statSync as statSync2 } from "node:fs";
+import { join as join6, resolve as resolve3, dirname as dirname3 } from "node:path";
+var SKIP2 = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", ".weave"]);
+function checkProject(roots) {
+  const virtuals = [];
+  for (const root of roots) collect(root, virtuals);
+  return virtuals.length ? runCheck(virtuals) : [];
+}
+function collect(path, out) {
+  if (!existsSync5(path)) return;
+  const st = statSync2(path);
+  if (st.isDirectory()) {
+    for (const entry of readdirSync3(path)) {
+      if (SKIP2.has(entry)) continue;
+      collect(join6(path, entry), out);
+    }
+    return;
+  }
+  if (path.endsWith(".weave")) {
+    out.push(absolutize(buildVirtualSfc(path, readFileSync2(path, "utf8"))));
+  } else if (path.endsWith(".ts") && !path.endsWith(".d.ts")) {
+    const v = collectTs(path);
+    if (v) out.push(absolutize(v));
+  }
+}
+function absolutize(v) {
+  v.path = resolve3(v.path);
+  return v;
+}
+function collectTs(tsPath) {
+  const source = readFileSync2(tsPath, "utf8");
+  const decl = extractSources(source);
+  const siblingHtml = tsPath.replace(/\.ts$/, ".html");
+  if (decl.template !== void 0) {
+    if (classifyTemplate(decl.template) === "inline") {
+      const faithful = decl.templateRange ? faithfulTemplate(source, decl.templateRange) : decl.template;
+      return buildVirtualSeparate(tsPath, decl.script, tsPath, faithful);
+    }
+    const file = resolve3(dirname3(tsPath), decl.template);
+    if (!existsSync5(file)) return null;
+    return buildVirtualSeparate(tsPath, decl.script, file, readFileSync2(file, "utf8"));
+  }
+  if (existsSync5(siblingHtml)) {
+    return buildVirtualSeparate(tsPath, decl.script, siblingHtml, readFileSync2(siblingHtml, "utf8"));
+  }
+  return null;
+}
+
+// packages/cli/src/cli.ts
+function flag(args, name) {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : void 0;
+}
+function syncRoutes(config) {
+  if (!config.routesDir) return;
+  const written = generateRoutes(config.routesDir, { lazy: true });
+  console.log(`weave routes \u2192 ${written}`);
+}
+function virtualEntryFor(config) {
+  if (!config.rootComponent) return void 0;
+  const elements = discoverCustomElements(config.root);
+  const code = generateEntry(config.rootComponent, config.mount, config.root, elements);
+  return { code, resolveDir: config.root };
+}
+async function main(argv) {
+  const [cmd, ...rest] = argv;
+  const entry = rest.find((a) => !a.startsWith("-")) ?? "src/main.ts";
+  const outdir = flag(rest, "--out") ?? "dist";
+  const config = await loadConfig(process.cwd(), flag(rest, "--config"));
+  if (cmd === "build") {
+    if (config) {
+      syncRoutes(config);
+      await build({
+        entry: config.entry,
+        virtualEntry: virtualEntryFor(config),
+        outDir: config.outDir,
+        minify: config.minify,
+        styleLang: config.styleLang,
+        styles: config.styles,
+        publicDir: config.publicDir,
+        index: config.index,
+        clean: true
+        // a fresh, self-contained artifact each prod build
+      });
+      console.log(`weave build \u2192 ${config.outDir}/`);
+      return;
+    }
+    await build({ entry, outDir: outdir, minify: !rest.includes("--no-minify") });
+    console.log(`weave build \u2192 ${outdir}/`);
+    return;
+  }
+  if (cmd === "dev") {
+    if (config) {
+      syncRoutes(config);
+      const { url: url2 } = await dev({
+        entry: config.entry,
+        virtualEntry: virtualEntryFor(config),
+        servedir: config.publicDir,
+        outdir: config.publicDir,
+        port: config.port,
+        styleLang: config.styleLang,
+        styles: config.styles,
+        index: config.index,
+        inMemory: true
+      });
+      console.log(`weave dev \u2192 ${url2}`);
+      return;
+    }
+    const servedir = flag(rest, "--serve") ?? ".";
+    const port = Number(flag(rest, "--port")) || void 0;
+    const { url } = await dev({ entry, outdir, servedir, port });
+    console.log(`weave dev \u2192 ${url}`);
+    return;
+  }
+  if (cmd === "check") {
+    const roots = rest.filter((a) => !a.startsWith("-"));
+    const diags = checkProject(roots.length ? roots : ["src"]);
+    for (const d of diags) console.error(formatDiagnostic(d));
+    const errors = diags.filter((d) => d.category === "error").length;
+    if (errors) {
+      console.error(`
+weave check: ${errors} error${errors === 1 ? "" : "s"}`);
+      process.exit(1);
+    }
+    console.log("weave check: no type errors");
+    return;
+  }
+  if (cmd === "routes") {
+    const dir = rest.find((a) => !a.startsWith("-")) ?? "src/routes";
+    const out = flag(rest, "--out");
+    const written = generateRoutes(dir, { out, lazy: !rest.includes("--eager") });
+    console.log(`weave routes \u2192 ${written}`);
+    return;
+  }
+  console.error(
+    "usage: weave <build|dev|check|routes> [entry|paths\u2026] [--config file] [--out dir] [--serve dir] [--port n] [--no-minify] [--eager]"
+  );
+  process.exit(1);
+}
+function formatDiagnostic(d) {
+  return `${d.file}:${d.line}:${d.col} - ${d.category} TS${d.code}: ${d.message}`;
+}
+export {
+  defineConfig,
+  main
+};