olova 2.0.61 → 2.0.63

package/dist/vite.js

@@ -0,0 +1,2302 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { normalizePath } from 'vite';
+import { parse } from '@babel/parser';
+import generatorModule from '@babel/generator';
+import traverseModule from '@babel/traverse';
+import * as t from '@babel/types';
+import ts from 'typescript';
+
+// vite/olova-plugin.ts
+
+// compiler/parse.ts
+function isWhitespace(char) {
+  return /\s/.test(char);
+}
+function skipQuoted(source, start, quote) {
+  let index = start + 1;
+  while (index < source.length) {
+    if (source[index] === "\\" && index + 1 < source.length) {
+      index += 2;
+      continue;
+    }
+    if (source[index] === quote) {
+      return index + 1;
+    }
+    index += 1;
+  }
+  return source.length;
+}
+function findTagEnd(source, start) {
+  let index = start;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === '"' || char === "'") {
+      index = skipQuoted(source, index, char);
+      continue;
+    }
+    if (char === ">") {
+      return index;
+    }
+    index += 1;
+  }
+  return -1;
+}
+function parseAttributes(source) {
+  const attrs = {};
+  const attrRegex = /([:@A-Za-z_][-A-Za-z0-9_:.@]*)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+  let match;
+  while ((match = attrRegex.exec(source)) !== null) {
+    const [, name, doubleQuoted, singleQuoted, bare] = match;
+    const value = doubleQuoted ?? singleQuoted ?? bare ?? true;
+    attrs[name] = value;
+  }
+  return attrs;
+}
+function readOpeningTag(source, start) {
+  if (source[start] !== "<") {
+    return null;
+  }
+  const tagEnd = findTagEnd(source, start + 1);
+  if (tagEnd < 0) {
+    return null;
+  }
+  const raw = source.slice(start + 1, tagEnd).trim();
+  if (!raw || raw.startsWith("/") || raw.startsWith("!")) {
+    return null;
+  }
+  let splitIndex = 0;
+  while (splitIndex < raw.length && !isWhitespace(raw[splitIndex]) && raw[splitIndex] !== "/") {
+    splitIndex += 1;
+  }
+  const tag = raw.slice(0, splitIndex);
+  const attrsSource = raw.slice(splitIndex).replace(/\/\s*$/, "").trim();
+  return {
+    tag,
+    openEnd: tagEnd + 1,
+    attrs: parseAttributes(attrsSource)
+  };
+}
+function findMatchingTag(source, start, tagName) {
+  const opening = readOpeningTag(source, start);
+  if (!opening || opening.tag.toLowerCase() !== tagName.toLowerCase()) {
+    return null;
+  }
+  const selfClosing = /\/\s*>$/.test(source.slice(start, opening.openEnd));
+  if (selfClosing) {
+    return {
+      fullStart: start,
+      openEnd: opening.openEnd,
+      closeStart: opening.openEnd,
+      closeEnd: opening.openEnd,
+      inner: "",
+      attrs: opening.attrs
+    };
+  }
+  let depth = 1;
+  let index = opening.openEnd;
+  while (index < source.length) {
+    const next = source.indexOf("<", index);
+    if (next < 0) {
+      break;
+    }
+    if (source.startsWith("<!--", next)) {
+      const commentEnd = source.indexOf("-->", next + 4);
+      index = commentEnd >= 0 ? commentEnd + 3 : source.length;
+      continue;
+    }
+    if (source[next + 1] === "/") {
+      const closeEnd = findTagEnd(source, next + 2);
+      if (closeEnd < 0) {
+        break;
+      }
+      const closeTag = source.slice(next + 2, closeEnd).trim();
+      if (closeTag.toLowerCase() === tagName.toLowerCase()) {
+        depth -= 1;
+        if (depth === 0) {
+          return {
+            fullStart: start,
+            openEnd: opening.openEnd,
+            closeStart: next,
+            closeEnd: closeEnd + 1,
+            inner: source.slice(opening.openEnd, next),
+            attrs: opening.attrs
+          };
+        }
+      }
+      index = closeEnd + 1;
+      continue;
+    }
+    const nested = readOpeningTag(source, next);
+    if (!nested) {
+      index = next + 1;
+      continue;
+    }
+    if (nested.tag.toLowerCase() === tagName.toLowerCase()) {
+      const nestedSelfClosing = /\/\s*>$/.test(source.slice(next, nested.openEnd));
+      if (!nestedSelfClosing) {
+        depth += 1;
+      }
+    }
+    index = nested.openEnd;
+  }
+  return null;
+}
+function collectTopLevelBlocks(source, tagName) {
+  const blocks = [];
+  let index = 0;
+  while (index < source.length) {
+    const next = source.indexOf(`<${tagName}`, index);
+    if (next < 0) {
+      break;
+    }
+    const previous = next > 0 ? source[next - 1] : "";
+    if (previous && /[A-Za-z0-9_:-]/.test(previous)) {
+      index = next + tagName.length + 1;
+      continue;
+    }
+    const block = findMatchingTag(source, next, tagName);
+    if (!block) {
+      index = next + tagName.length + 1;
+      continue;
+    }
+    blocks.push(block);
+    index = block.closeEnd;
+  }
+  return blocks;
+}
+function removeRanges(source, ranges) {
+  if (ranges.length === 0) {
+    return source.trim();
+  }
+  const ordered = [...ranges].sort((a, b) => a.start - b.start);
+  let cursor = 0;
+  let output = "";
+  for (const range of ordered) {
+    output += source.slice(cursor, range.start);
+    cursor = range.end;
+  }
+  output += source.slice(cursor);
+  return output.trim();
+}
+function parseOlovaFile(source) {
+  const scriptBlock = collectTopLevelBlocks(source, "script")[0] ?? null;
+  const styleBlocks = collectTopLevelBlocks(source, "style");
+  const ranges = styleBlocks.map((block) => ({
+    start: block.fullStart,
+    end: block.closeEnd
+  }));
+  if (scriptBlock) {
+    ranges.push({ start: scriptBlock.fullStart, end: scriptBlock.closeEnd });
+  }
+  return {
+    script: scriptBlock?.inner.trim() ?? "",
+    template: removeRanges(source, ranges),
+    styles: styleBlocks.map((block) => ({
+      content: block.inner.trim(),
+      attrs: block.attrs
+    }))
+  };
+}
+
+// compiler/html-parser.ts
+function isWhitespace2(char) {
+  return /\s/.test(char);
+}
+function findTagEnd2(source, start) {
+  let index = start;
+  while (index < source.length) {
+    const char = source[index];
+    if (char === '"' || char === "'") {
+      const quoted = readQuotedValue(source, index, char);
+      index = quoted.end;
+      continue;
+    }
+    if (char === "{") {
+      const braced = readBraceValue(source, index);
+      index = braced.end;
+      continue;
+    }
+    if (char === ">") {
+      return index;
+    }
+    index += 1;
+  }
+  return -1;
+}
+function readQuotedValue(source, start, quote) {
+  let index = start + 1;
+  let value = "";
+  while (index < source.length) {
+    const char = source[index];
+    if (char === "\\" && index + 1 < source.length) {
+      value += source.slice(index, index + 2);
+      index += 2;
+      continue;
+    }
+    if (char === quote) {
+      return { value, end: index + 1 };
+    }
+    value += char;
+    index += 1;
+  }
+  return { value, end: source.length };
+}
+function readBraceValue(source, start) {
+  let index = start + 1;
+  let depth = 1;
+  let value = "{";
+  let quote = null;
+  while (index < source.length && depth > 0) {
+    const char = source[index];
+    const prev = source[index - 1];
+    value += char;
+    if (quote) {
+      if (char === quote && prev !== "\\") {
+        quote = null;
+      }
+      index += 1;
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      index += 1;
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+    }
+    index += 1;
+  }
+  return { value, end: index };
+}
+function parseAttributes2(source) {
+  const attrs = {};
+  let index = 0;
+  while (index < source.length) {
+    while (index < source.length && isWhitespace2(source[index])) {
+      index += 1;
+    }
+    if (index >= source.length) {
+      break;
+    }
+    let nameEnd = index;
+    while (nameEnd < source.length && !isWhitespace2(source[nameEnd]) && source[nameEnd] !== "=") {
+      nameEnd += 1;
+    }
+    const name = source.slice(index, nameEnd).trim();
+    index = nameEnd;
+    if (!name) {
+      index += 1;
+      continue;
+    }
+    while (index < source.length && isWhitespace2(source[index])) {
+      index += 1;
+    }
+    if (source[index] !== "=") {
+      attrs[name] = true;
+      continue;
+    }
+    index += 1;
+    while (index < source.length && isWhitespace2(source[index])) {
+      index += 1;
+    }
+    if (index >= source.length) {
+      attrs[name] = true;
+      break;
+    }
+    const start = index;
+    const char = source[index];
+    if (char === '"' || char === "'") {
+      const quoted = readQuotedValue(source, index, char);
+      attrs[name] = quoted.value;
+      index = quoted.end;
+      continue;
+    }
+    if (char === "{") {
+      const braced = readBraceValue(source, index);
+      attrs[name] = braced.value;
+      index = braced.end;
+      continue;
+    }
+    while (index < source.length && !isWhitespace2(source[index])) {
+      index += 1;
+    }
+    attrs[name] = source.slice(start, index);
+  }
+  return attrs;
+}
+function parseHTML(html) {
+  const root = [];
+  const stack = [
+    { node: null, children: root }
+  ];
+  let i = 0;
+  while (i < html.length) {
+    const textStart = i;
+    const tagStart = html.indexOf("<", i);
+    if (tagStart === -1) {
+      if (textStart < html.length) {
+        stack[stack.length - 1].children.push({
+          type: "text",
+          content: html.slice(textStart)
+        });
+      }
+      break;
+    }
+    if (tagStart > textStart) {
+      stack[stack.length - 1].children.push({
+        type: "text",
+        content: html.slice(textStart, tagStart)
+      });
+    }
+    i = tagStart;
+    if (html.startsWith("<!--", i)) {
+      const commentEnd = html.indexOf("-->", i + 4);
+      if (commentEnd === -1) {
+        stack[stack.length - 1].children.push({
+          type: "comment",
+          content: html.slice(i + 4)
+        });
+        break;
+      }
+      stack[stack.length - 1].children.push({
+        type: "comment",
+        content: html.slice(i + 4, commentEnd)
+      });
+      i = commentEnd + 3;
+      continue;
+    }
+    if (html.startsWith("</", i)) {
+      const tagEnd2 = html.indexOf(">", i + 2);
+      if (tagEnd2 === -1) {
+        i += 2;
+        continue;
+      }
+      const tag2 = html.slice(i + 2, tagEnd2).trim().toLowerCase();
+      let closeIdx = stack.length - 1;
+      while (closeIdx > 0 && stack[closeIdx].node?.tag.toLowerCase() !== tag2) {
+        closeIdx--;
+      }
+      if (closeIdx > 0) {
+        stack.length = closeIdx;
+      }
+      i = tagEnd2 + 1;
+      continue;
+    }
+    const tagEnd = findTagEnd2(html, i + 1);
+    if (tagEnd === -1) {
+      stack[stack.length - 1].children.push({ type: "text", content: "<" });
+      i++;
+      continue;
+    }
+    const rawTag = html.slice(i + 1, tagEnd).trim();
+    let tagNameEnd = 0;
+    while (tagNameEnd < rawTag.length && !isWhitespace2(rawTag[tagNameEnd]) && rawTag[tagNameEnd] !== "/") {
+      tagNameEnd += 1;
+    }
+    const tag = rawTag.slice(0, tagNameEnd);
+    if (!tag) {
+      stack[stack.length - 1].children.push({ type: "text", content: "<" });
+      i++;
+      continue;
+    }
+    const attrsStr = rawTag.slice(tagNameEnd).replace(/\/\s*$/, "").trim();
+    const selfClose = /\/\s*$/.test(rawTag);
+    const attrs = parseAttributes2(attrsStr);
+    const isSelfClosing = !!selfClose || /^(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)$/i.test(
+      tag
+    );
+    const element = {
+      type: "element",
+      tag,
+      attrs,
+      children: [],
+      isSelfClosing
+    };
+    stack[stack.length - 1].children.push(element);
+    if (!isSelfClosing) {
+      stack.push({ node: element, children: element.children });
+    }
+    i = tagEnd + 1;
+  }
+  return root;
+}
+
+// compiler/dom-generator.ts
+var SVG_NAMESPACE = "http://www.w3.org/2000/svg";
+function splitTextFragments(text) {
+  const parts = [];
+  const tokenRe = /__O_(TEXT|HTML|SLOT|COMP|IF)_([a-zA-Z0-9_]+)__/g;
+  let lastIndex = 0;
+  let match;
+  while ((match = tokenRe.exec(text)) !== null) {
+    if (match.index > lastIndex) {
+      parts.push({ type: "static", value: text.slice(lastIndex, match.index) });
+    }
+    parts.push({ type: "dynamic", tokenType: match[1], id: match[2] });
+    lastIndex = match.index + match[0].length;
+  }
+  if (lastIndex < text.length) {
+    parts.push({ type: "static", value: text.slice(lastIndex) });
+  }
+  return parts;
+}
+function isSvgContext(tag, inSvg) {
+  if (tag === "foreignObject") {
+    return false;
+  }
+  return inSvg || tag === "svg";
+}
+function processNode(node, parentVar, stateNames, transformExpr, counters, buildCtx, componentNames, inSvg = false) {
+  if (node.type === "comment") {
+    return;
+  }
+  if (node.type === "text") {
+    const parts = splitTextFragments(node.content);
+    for (const part of parts) {
+      if (part.type === "static") {
+        if (!part.value) continue;
+        const varName = `_t${buildCtx.localCount++}`;
+        buildCtx.statements.push(
+          `const ${varName} = document.createTextNode(${JSON.stringify(part.value)});`
+        );
+        buildCtx.statements.push(`${parentVar}.appendChild(${varName});`);
+      } else {
+        const varName = `_d${buildCtx.localCount++}`;
+        buildCtx.statements.push(
+          `const ${varName} = document.createTextNode('');`
+        );
+        buildCtx.nodes.push(`'${part.id}': ${varName}`);
+        buildCtx.statements.push(`${parentVar}.appendChild(${varName});`);
+      }
+    }
+    return;
+  }
+  if (node.type === "element") {
+    const tag = node.tag;
+    const varName = `_el${buildCtx.localCount++}`;
+    const useSvgNamespace = isSvgContext(tag, inSvg);
+    buildCtx.statements.push(
+      useSvgNamespace ? `const ${varName} = document.createElementNS(${JSON.stringify(SVG_NAMESPACE)}, "${tag}");` : `const ${varName} = document.createElement("${tag}");`
+    );
+    for (const [attr, val] of Object.entries(node.attrs)) {
+      if (attr.startsWith("data-o-on-")) {
+        if (typeof val === "string") {
+          buildCtx.nodes.push(`'${val}': ${varName}`);
+        }
+      } else if (typeof val === "string" && val.includes("__O_ATTR_")) {
+        const match = val.match(/__O_ATTR_([a-zA-Z0-9_]+)__/);
+        if (match) {
+          buildCtx.nodes.push(`'${match[1]}': ${varName}`);
+        }
+      } else {
+        if (val === true) {
+          buildCtx.statements.push(`${varName}.setAttribute("${attr}", "");`);
+        } else {
+          buildCtx.statements.push(
+            `${varName}.setAttribute("${attr}", ${JSON.stringify(val)});`
+          );
+        }
+      }
+    }
+    for (const child of node.children) {
+      processNode(
+        child,
+        varName,
+        stateNames,
+        transformExpr,
+        counters,
+        buildCtx,
+        componentNames,
+        useSvgNamespace
+      );
+    }
+    buildCtx.statements.push(`${parentVar}.appendChild(${varName});`);
+  }
+}
+function generateBuildFunction(html, stateNames, transformExpr, counters, componentNames) {
+  const ast = parseHTML(html);
+  const buildCtx = {
+    statements: [],
+    nodes: [],
+    localCount: 0
+  };
+  buildCtx.statements.push("const _f = document.createDocumentFragment();");
+  for (const child of ast) {
+    processNode(
+      child,
+      "_f",
+      stateNames,
+      transformExpr,
+      counters,
+      buildCtx,
+      componentNames
+    );
+  }
+  return `function() {
+    ${buildCtx.statements.join("\n    ")}
+    return { fragment: _f, nodes: { ${buildCtx.nodes.join(", ")} } };
+  }`;
+}
+
+// compiler/compile.ts
+var generate = generatorModule.default ?? generatorModule;
+var traverse = traverseModule.default ?? traverseModule;
+var CORE_KNOWN_IMPORTS = /* @__PURE__ */ new Set([
+  "Signal",
+  "computed",
+  "createApp",
+  "defineComponent",
+  "derived",
+  "effect",
+  "getContext",
+  "global",
+  "hasContext",
+  "mount",
+  "setContext",
+  "state"
+]);
+function escapeTemplate(source) {
+  return source.replace(/\\/g, "\\\\").replace(/`/g, "\\`");
+}
+function indexToLocation(source, index) {
+  const safeIndex = Math.max(0, Math.min(index, source.length));
+  const lines = source.slice(0, safeIndex).split("\n");
+  return {
+    line: lines.length,
+    column: lines[lines.length - 1]?.length ?? 0,
+    index: safeIndex
+  };
+}
+function createCodeFrame(source, line, column, contextLines = 2) {
+  const lines = source.split("\n");
+  const start = Math.max(0, line - 1 - contextLines);
+  const end = Math.min(lines.length, line + contextLines);
+  return lines.slice(start, end).map((content, offset) => {
+    const lineNumber = start + offset + 1;
+    const prefix = `${String(lineNumber).padStart(4, " ")} | `;
+    if (lineNumber !== line) {
+      return `${prefix}${content}`;
+    }
+    return `${prefix}${content}
+     | ${" ".repeat(Math.max(column, 0))}^`;
+  }).join("\n");
+}
+function createCompileError(message, source, index) {
+  const loc = indexToLocation(source, index);
+  const error = new Error(message);
+  error.loc = { start: loc };
+  error.frame = createCodeFrame(source, loc.line, loc.column);
+  return error;
+}
+function normalizeCompileError(error, source, filename = "component.olova") {
+  const compileError = error instanceof Error ? error : new Error(String(error));
+  const start = compileError.loc?.start ?? compileError.loc;
+  const line = start?.line;
+  const column = start?.column;
+  const locationSuffix = line === void 0 || column === void 0 ? "" : ` (${filename}:${line}:${column + 1})`;
+  compileError.message = `[olova] ${compileError.message.replace(/^\[olova\]\s*/, "")}${locationSuffix}`;
+  if (line !== void 0 && column !== void 0 && !compileError.frame) {
+    compileError.frame = createCodeFrame(source, line, column);
+  }
+  throw compileError;
+}
+function parseModule(code) {
+  return parse(code, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx"]
+  });
+}
+function transpileTypeScript(code, filename = "component.ts") {
+  const result = ts.transpileModule(code, {
+    fileName: filename,
+    compilerOptions: {
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.ESNext,
+      jsx: ts.JsxEmit.Preserve,
+      importsNotUsedAsValues: ts.ImportsNotUsedAsValues.Remove,
+      verbatimModuleSyntax: false,
+      sourceMap: true,
+      inlineSources: true
+    }
+  });
+  return {
+    code: result.outputText.trim(),
+    map: result.sourceMapText ? JSON.parse(result.sourceMapText) : null
+  };
+}
+function compileModuleScript(script, filename = "module.olova.ts") {
+  const ast = parseModule(script || "");
+  return transpileTypeScript(
+    ast.program.body.map((node) => generate(node).code).join("\n"),
+    filename
+  );
+}
+function isModuleOnlyScript(script) {
+  if (!script.trim()) {
+    return false;
+  }
+  const ast = parseModule(script);
+  return ast.program.body.every(
+    (node) => t.isImportDeclaration(node) || t.isExportNamedDeclaration(node) || t.isExportAllDeclaration(node) || t.isExportDefaultDeclaration(node)
+  );
+}
+function isStateInit(node) {
+  return !!(node && t.isCallExpression(node) && (t.isIdentifier(node.callee) && node.callee.name === "state" || t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.object) && node.callee.object.name === "__olovaGlobal" && t.isIdentifier(node.callee.property) && (node.callee.property.name === "state" || node.callee.property.name === "get")));
+}
+function isComputedInit(node) {
+  return !!(node && t.isCallExpression(node) && t.isIdentifier(node.callee) && (node.callee.name === "computed" || node.callee.name === "derived"));
+}
+function appendHmrStateKey(node, key) {
+  if (!node) {
+    return;
+  }
+  if (t.isCallExpression(node) && t.isIdentifier(node.callee) && node.callee.name === "state") {
+    const existingKey = node.arguments[1];
+    if (!existingKey || !t.isStringLiteral(existingKey)) {
+      node.arguments = [node.arguments[0] ?? t.identifier("undefined"), t.stringLiteral(key)];
+    }
+    return;
+  }
+  if (t.isConditionalExpression(node)) {
+    appendHmrStateKey(node.consequent, `${key}:then`);
+    appendHmrStateKey(node.alternate, `${key}:else`);
+    return;
+  }
+  if (t.isLogicalExpression(node)) {
+    appendHmrStateKey(node.left, `${key}:left`);
+    appendHmrStateKey(node.right, `${key}:right`);
+  }
+}
+function containsStateInit(node) {
+  if (!node) {
+    return false;
+  }
+  if (isStateInit(node)) {
+    return true;
+  }
+  if (t.isConditionalExpression(node)) {
+    return containsStateInit(node.consequent) || containsStateInit(node.alternate);
+  }
+  if (t.isLogicalExpression(node)) {
+    return containsStateInit(node.left) || containsStateInit(node.right);
+  }
+  return false;
+}
+function containsSignalInit(node) {
+  if (!node) {
+    return false;
+  }
+  if (isStateInit(node) || isComputedInit(node)) {
+    return true;
+  }
+  if (t.isConditionalExpression(node)) {
+    return containsSignalInit(node.consequent) || containsSignalInit(node.alternate);
+  }
+  if (t.isLogicalExpression(node)) {
+    return containsSignalInit(node.left) || containsSignalInit(node.right);
+  }
+  return false;
+}
+function isGlobalStateCall(node) {
+  return t.isMemberExpression(node.callee) && t.isIdentifier(node.callee.object) && (node.callee.object.name === "global" || node.callee.object.name === "__olovaGlobal") && t.isIdentifier(node.callee.property) && node.callee.property.name === "state";
+}
+function shouldSkipIdentifierTransform(path2) {
+  if (path2.parentPath?.isVariableDeclarator() && path2.parentPath.node.id === path2.node) {
+    return true;
+  }
+  if (path2.parentPath?.isAssignmentExpression() && path2.parentPath.node.left === path2.node) {
+    return true;
+  }
+  if (path2.parentPath?.isUpdateExpression()) {
+    return true;
+  }
+  if (path2.parentPath?.isCallExpression() && t.isIdentifier(path2.parentPath.node.callee) && path2.parentPath.node.callee.name === "setContext" && path2.parentPath.node.arguments.includes(path2.node)) {
+    return true;
+  }
+  if (path2.parentPath?.isMemberExpression() && path2.parentPath.node.property === path2.node && !path2.parentPath.node.computed) {
+    return true;
+  }
+  if (path2.parentPath?.isMemberExpression() && path2.parentPath.node.object === path2.node && t.isIdentifier(path2.parentPath.node.property) && (path2.parentPath.node.property.name === "value" || path2.parentPath.node.property.name === "notify")) {
+    return true;
+  }
+  if (path2.parentPath?.isImportSpecifier() || path2.parentPath?.isExportSpecifier()) {
+    return true;
+  }
+  if (path2.parentPath?.isObjectProperty() && path2.parentPath.node.key === path2.node && !path2.parentPath.node.computed && !path2.parentPath.node.shorthand) {
+    return true;
+  }
+  if (path2.parentPath?.isFunctionDeclaration() && path2.parentPath.node.id === path2.node) {
+    return true;
+  }
+  if (path2.parentPath?.isClassDeclaration() && path2.parentPath.node.id === path2.node) {
+    return true;
+  }
+  return false;
+}
+function addNestedMutationNotify(ast, stateNames) {
+  traverse(ast, {
+    AssignmentExpression(path2) {
+      const left = path2.node.left;
+      if (!t.isMemberExpression(left)) {
+        return;
+      }
+      let root = left;
+      while (t.isMemberExpression(root.object)) {
+        root = root.object;
+      }
+      if (!t.isIdentifier(root.object)) {
+        return;
+      }
+      if (!t.isIdentifier(root.property) || root.property.name !== "value") {
+        return;
+      }
+      const stateName = root.object.name;
+      if (!stateNames.has(stateName)) {
+        return;
+      }
+      if (left === root) {
+        return;
+      }
+      if (path2.parentPath?.isSequenceExpression()) {
+        return;
+      }
+      path2.replaceWith(
+        t.sequenceExpression([
+          path2.node,
+          t.callExpression(
+            t.memberExpression(t.identifier(stateName), t.identifier("notify")),
+            []
+          )
+        ])
+      );
+      path2.skip();
+    }
+  });
+}
+function collectScriptInfo(script) {
+  const ast = parseModule(script || "");
+  const stateNames = /* @__PURE__ */ new Set();
+  const allSignalNames = /* @__PURE__ */ new Set();
+  const componentNames = /* @__PURE__ */ new Set();
+  const jsxFunctionNames = /* @__PURE__ */ new Set();
+  let needsGlobalRuntime = false;
+  for (const node of ast.program.body) {
+    if (!t.isImportDeclaration(node)) {
+      continue;
+    }
+    for (const specifier of node.specifiers) {
+      componentNames.add(specifier.local.name);
+    }
+  }
+  const rewrittenBody = [];
+  for (const node of ast.program.body) {
+    if (t.isImportDeclaration(node) && t.isStringLiteral(node.source) && (node.source.value === "olova/global" || node.source.value === "olova/core")) {
+      if (node.source.value === "olova/global") {
+        needsGlobalRuntime = true;
+        const declarators = [];
+        for (const specifier of node.specifiers) {
+          if (!t.isImportSpecifier(specifier)) {
+            throw new Error(
+              "[olova] Use named imports with 'olova/global' (e.g. import { user } from 'olova/global')."
+            );
+          }
+          const imported = t.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value;
+          declarators.push(
+            t.variableDeclarator(
+              t.identifier(specifier.local.name),
+              t.callExpression(
+                t.memberExpression(
+                  t.identifier("__olovaGlobal"),
+                  t.identifier("get")
+                ),
+                [t.stringLiteral(imported)]
+              )
+            )
+          );
+        }
+        if (declarators.length > 0) {
+          rewrittenBody.push(t.variableDeclaration("const", declarators));
+        }
+        continue;
+      }
+      const keptSpecifiers = [];
+      const globalDeclarators = [];
+      for (const specifier of node.specifiers) {
+        if (!t.isImportSpecifier(specifier)) {
+          keptSpecifiers.push(specifier);
+          continue;
+        }
+        const imported = t.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value;
+        if (CORE_KNOWN_IMPORTS.has(imported)) {
+          keptSpecifiers.push(specifier);
+          continue;
+        }
+        needsGlobalRuntime = true;
+        globalDeclarators.push(
+          t.variableDeclarator(
+            t.identifier(specifier.local.name),
+            t.callExpression(
+              t.memberExpression(
+                t.identifier("__olovaGlobal"),
+                t.identifier("get")
+              ),
+              [t.stringLiteral(imported)]
+            )
+          )
+        );
+      }
+      if (keptSpecifiers.length > 0) {
+        rewrittenBody.push(
+          t.importDeclaration(keptSpecifiers, t.stringLiteral("olova/core"))
+        );
+      }
+      if (globalDeclarators.length > 0) {
+        rewrittenBody.push(t.variableDeclaration("const", globalDeclarators));
+      }
+      continue;
+    }
+    rewrittenBody.push(node);
+  }
+  ast.program.body = rewrittenBody;
+  traverse(ast, {
+    CallExpression(path2) {
+      if (!isGlobalStateCall(path2.node)) {
+        return;
+      }
+      needsGlobalRuntime = true;
+      path2.node.callee = t.memberExpression(
+        t.identifier("__olovaGlobal"),
+        t.identifier("state")
+      );
+      if (path2.parentPath && path2.parentPath.isVariableDeclarator() && t.isIdentifier(path2.parentPath.node.id)) {
+        const firstArg = path2.node.arguments[0];
+        const alreadyNamed = !!firstArg && t.isStringLiteral(firstArg) && firstArg.value.length > 0;
+        if (!alreadyNamed) {
+          path2.node.arguments = [
+            t.stringLiteral(path2.parentPath.node.id.name),
+            ...path2.node.arguments
+          ];
+        }
+      }
+    }
+  });
+  traverse(ast, {
+    VariableDeclarator(path2) {
+      if (!t.isIdentifier(path2.node.id)) {
+        return;
+      }
+      if (containsStateInit(path2.node.init)) {
+        stateNames.add(path2.node.id.name);
+        appendHmrStateKey(path2.node.init, path2.node.id.name);
+      }
+      if (containsSignalInit(path2.node.init)) {
+        allSignalNames.add(path2.node.id.name);
+      }
+    }
+  });
+  traverse(ast, {
+    AssignmentExpression(path2) {
+      if (!t.isIdentifier(path2.node.left)) {
+        return;
+      }
+      const name = path2.node.left.name;
+      if (!stateNames.has(name)) {
+        return;
+      }
+      const binding = path2.scope.getBinding(name);
+      if (!binding || !t.isVariableDeclarator(binding.path.node)) {
+        return;
+      }
+      if (!t.isIdentifier(binding.path.node.id) || !containsStateInit(binding.path.node.init)) {
+        return;
+      }
+      path2.node.left = t.memberExpression(
+        t.identifier(name),
+        t.identifier("value")
+      );
+    },
+    UpdateExpression(path2) {
+      if (!t.isIdentifier(path2.node.argument)) {
+        return;
+      }
+      const name = path2.node.argument.name;
+      if (!stateNames.has(name)) {
+        return;
+      }
+      const binding = path2.scope.getBinding(name);
+      if (!binding || !t.isVariableDeclarator(binding.path.node)) {
+        return;
+      }
+      if (!t.isIdentifier(binding.path.node.id) || !containsStateInit(binding.path.node.init)) {
+        return;
+      }
+      path2.node.argument = t.memberExpression(
+        t.identifier(name),
+        t.identifier("value")
+      );
+    }
+  });
+  traverse(ast, {
+    Identifier(path2) {
+      const name = path2.node.name;
+      if (!allSignalNames.has(name)) {
+        return;
+      }
+      if (shouldSkipIdentifierTransform(path2)) {
+        return;
+      }
+      const binding = path2.scope.getBinding(name);
+      if (!binding || !t.isVariableDeclarator(binding.path.node)) {
+        return;
+      }
+      if (!t.isIdentifier(binding.path.node.id) || !containsSignalInit(binding.path.node.init)) {
+        return;
+      }
+      path2.replaceWith(
+        t.memberExpression(t.identifier(name), t.identifier("value"))
+      );
+      path2.skip();
+    }
+  });
+  addNestedMutationNotify(ast, stateNames);
+  const nodeContainsJsx = (node) => {
+    if (!node) {
+      return false;
+    }
+    let found = false;
+    traverse(parseModule(`(${generate(node).code})`), {
+      JSXElement() {
+        found = true;
+      },
+      JSXFragment() {
+        found = true;
+      }
+    });
+    return found;
+  };
+  traverse(ast, {
+    FunctionDeclaration(path2) {
+      if (path2.node.id && nodeContainsJsx(path2.node.body)) {
+        jsxFunctionNames.add(path2.node.id.name);
+      }
+    },
+    VariableDeclarator(path2) {
+      if (t.isIdentifier(path2.node.id) && nodeContainsJsx(path2.node.init)) {
+        jsxFunctionNames.add(path2.node.id.name);
+      }
+    }
+  });
+  traverse(ast, {
+    JSXElement(path2) {
+      const transformed = transformExpression(
+        generate(path2.node).code,
+        stateNames,
+        allSignalNames,
+        jsxFunctionNames
+      );
+      const parsed = parseModule(`(${transformed.code})`);
+      const statement = parsed.program.body[0];
+      if (statement && t.isExpressionStatement(statement)) {
+        path2.replaceWith(statement.expression);
+        path2.skip();
+      }
+    },
+    JSXFragment(path2) {
+      const transformed = transformExpression(
+        generate(path2.node).code,
+        stateNames,
+        allSignalNames,
+        jsxFunctionNames
+      );
+      const parsed = parseModule(`(${transformed.code})`);
+      const statement = parsed.program.body[0];
+      if (statement && t.isExpressionStatement(statement)) {
+        path2.replaceWith(statement.expression);
+        path2.skip();
+      }
+    }
+  });
+  if (needsGlobalRuntime) {
+    ast.program.body.unshift(
+      t.importDeclaration(
+        [
+          t.importSpecifier(
+            t.identifier("__olovaGlobal"),
+            t.identifier("global")
+          )
+        ],
+        t.stringLiteral("olova/global")
+      )
+    );
+  }
+  const importNodes = ast.program.body.filter(
+    (node) => t.isImportDeclaration(node)
+  );
+  const bodyNodes = ast.program.body.filter(
+    (node) => !t.isImportDeclaration(node)
+  );
+  const importsCode = importNodes.map((node) => generate(node).code).join("\n");
+  const scriptBodyCode = bodyNodes.map((node) => generate(node).code).join("\n");
+  return {
+    importsCode,
+    scriptBodyCode,
+    stateNames,
+    allSignalNames,
+    componentNames,
+    jsxFunctionNames
+  };
+}
+function transformExpression(expr, stateNames, allSignalNames, jsxFunctionNames = /* @__PURE__ */ new Set(), scopeId) {
+  const ast = parseModule(`(${expr})`);
+  let containsJsx = false;
+  const jsxScopeAttr = createScopeAttr(scopeId);
+  traverse(ast, {
+    AssignmentExpression(path2) {
+      if (!t.isIdentifier(path2.node.left)) {
+        return;
+      }
+      const name = path2.node.left.name;
+      if (!stateNames.has(name)) {
+        return;
+      }
+      const binding = path2.scope.getBinding(name);
+      if (binding) {
+        return;
+      }
+      path2.node.left = t.memberExpression(
+        t.identifier(name),
+        t.identifier("value")
+      );
+    },
+    UpdateExpression(path2) {
+      if (!t.isIdentifier(path2.node.argument)) {
+        return;
+      }
+      const name = path2.node.argument.name;
+      if (!stateNames.has(name)) {
+        return;
+      }
+      const binding = path2.scope.getBinding(name);
+      if (binding) {
+        return;
+      }
+      path2.node.argument = t.memberExpression(
+        t.identifier(name),
+        t.identifier("value")
+      );
+    }
+  });
+  traverse(ast, {
+    Identifier(path2) {
+      const name = path2.node.name;
+      if (!allSignalNames.has(name)) {
+        return;
+      }
+      if (shouldSkipIdentifierTransform(path2)) {
+        return;
+      }
+      const binding = path2.scope.getBinding(name);
+      if (binding) {
+        return;
+      }
+      path2.replaceWith(
+        t.memberExpression(t.identifier(name), t.identifier("value"))
+      );
+      path2.skip();
+    }
+  });
+  addNestedMutationNotify(ast, stateNames);
+  const toStringCall = (input) => t.callExpression(t.identifier("__olovaToString"), [input]);
+  const escapeCall = (input) => t.callExpression(t.identifier("__olovaEscape"), [input]);
+  const expressionContainsJsx = (input) => {
+    let found = false;
+    traverse(parseModule(`(${generate(input).code})`), {
+      JSXElement() {
+        found = true;
+      },
+      JSXFragment() {
+        found = true;
+      }
+    });
+    return found;
+  };
+  const expressionProducesHtml = (input) => {
+    if (!input) {
+      return false;
+    }
+    if (expressionContainsJsx(input)) {
+      return true;
+    }
+    let found = false;
+    traverse(parseModule(`(${generate(input).code})`), {
+      CallExpression(path2) {
+        if (t.isIdentifier(path2.node.callee) && jsxFunctionNames.has(path2.node.callee.name)) {
+          found = true;
+          path2.stop();
+          return;
+        }
+        if (t.isMemberExpression(path2.node.callee) && t.isIdentifier(path2.node.callee.property) && (path2.node.callee.property.name === "map" || path2.node.callee.property.name === "flatMap")) {
+          const [firstArg] = path2.node.arguments;
+          if (t.isIdentifier(firstArg) && jsxFunctionNames.has(firstArg.name) || nodeContainsRenderableFunction(firstArg, jsxFunctionNames)) {
+            found = true;
+            path2.stop();
+          }
+        }
+      }
+    });
+    return found;
+  };
+  const nodeContainsRenderableFunction = (node, knownJsxFunctions) => {
+    if (!node) {
+      return false;
+    }
+    if (t.isArrowFunctionExpression(node) || t.isFunctionExpression(node)) {
+      return expressionContainsJsx(node.body) || expressionProducesHtml(node.body);
+    }
+    if (t.isIdentifier(node)) {
+      return knownJsxFunctions.has(node.name);
+    }
+    return false;
+  };
+  const concatExpressions = (parts) => {
+    if (parts.length === 0) {
+      return t.stringLiteral("");
+    }
+    return parts.slice(1).reduce(
+      (acc, current) => t.binaryExpression("+", acc, current),
+      parts[0]
+    );
+  };
+  const jsxNameToString = (name) => {
+    if (t.isJSXIdentifier(name)) {
+      return name.name;
+    }
+    if (t.isJSXNamespacedName(name)) {
+      return `${name.namespace.name}:${name.name.name}`;
+    }
+    const walkMember = (node) => {
+      if (t.isJSXIdentifier(node)) {
+        return node.name;
+      }
+      return `${walkMember(node.object)}.${node.property.name}`;
+    };
+    return walkMember(name);
+  };
+  const transformEmbeddedJsxExpression = (input) => {
+    const wrapped = parseModule(`(${generate(input).code})`);
+    let containsNestedJsx = false;
+    traverse(wrapped, {
+      JSXElement(path2) {
+        containsNestedJsx = true;
+        path2.replaceWith(jsxElementToExpression(path2.node));
+        path2.skip();
+      },
+      JSXFragment(path2) {
+        containsNestedJsx = true;
+        path2.replaceWith(jsxFragmentToExpression(path2.node));
+        path2.skip();
+      }
+    });
+    const statement2 = wrapped.program.body[0];
+    if (!statement2 || !t.isExpressionStatement(statement2)) {
+      return { expression: input, containsJsx: containsNestedJsx };
+    }
+    return {
+      expression: statement2.expression,
+      containsJsx: containsNestedJsx
+    };
+  };
+  const jsxAttrToExpression = (attr) => {
+    if (t.isJSXSpreadAttribute(attr)) {
+      const transformed = transformEmbeddedJsxExpression(
+        attr.argument
+      );
+      return t.callExpression(t.identifier("__olovaSpreadAttrs"), [
+        transformed.expression
+      ]);
+    }
+    const name = jsxNameToString(attr.name);
+    if (name === "key") {
+      return t.stringLiteral("");
+    }
+    const normalizedName = name === "className" ? "class" : name;
+    const eventMatch = name.match(/^(?:on:|on)([A-Za-z]+)$/);
+    if (!attr.value) {
+      return t.stringLiteral(` ${normalizedName}`);
+    }
+    if (t.isStringLiteral(attr.value)) {
+      return t.stringLiteral(` ${normalizedName}="${attr.value.value}"`);
+    }
+    if (t.isJSXExpressionContainer(attr.value)) {
+      const transformed = transformEmbeddedJsxExpression(
+        attr.value.expression ?? t.stringLiteral("")
+      );
+      if (eventMatch) {
+        return t.callExpression(t.identifier("__olovaRegisterJsxEvent"), [
+          t.stringLiteral(eventMatch[1].toLowerCase()),
+          transformed.expression
+        ]);
+      }
+      const valueExpression = normalizedName === "class" ? t.callExpression(t.identifier("__olovaNormalizeClassValue"), [
+        transformed.expression
+      ]) : transformed.expression;
+      return concatExpressions([
+        t.stringLiteral(` ${normalizedName}="`),
+        escapeCall(valueExpression),
+        t.stringLiteral('"')
+      ]);
+    }
+    return t.stringLiteral("");
+  };
+  const jsxChildToExpression = (child) => {
+    if (t.isJSXText(child)) {
+      return t.stringLiteral(child.value);
+    }
+    if (t.isJSXExpressionContainer(child)) {
+      if (t.isJSXEmptyExpression(child.expression)) {
+        return t.stringLiteral("");
+      }
+      const rawExpression = child.expression;
+      const transformed = transformEmbeddedJsxExpression(rawExpression);
+      return transformed.containsJsx || expressionProducesHtml(rawExpression) ? toStringCall(transformed.expression) : escapeCall(transformed.expression);
+    }
+    if (t.isJSXSpreadChild(child)) {
+      const transformed = transformEmbeddedJsxExpression(child.expression);
+      return transformed.containsJsx || expressionProducesHtml(child.expression) ? toStringCall(transformed.expression) : escapeCall(transformed.expression);
+    }
+    if (t.isJSXElement(child)) {
+      return jsxElementToExpression(child);
+    }
+    return jsxFragmentToExpression(child);
+  };
+  const jsxFragmentToExpression = (fragment) => {
+    const parts = fragment.children.map((child) => jsxChildToExpression(child));
+    return concatExpressions(parts);
+  };
+  const jsxElementToExpression = (element) => {
+    const opening = element.openingElement;
+    const tag = jsxNameToString(opening.name);
+    if (tag === "For") {
+      let eachExpr = t.arrayExpression([]);
+      for (const attr of opening.attributes) {
+        if (t.isJSXAttribute(attr) && jsxNameToString(attr.name) === "each" && attr.value && t.isJSXExpressionContainer(attr.value) && !t.isJSXEmptyExpression(attr.value.expression)) {
+          eachExpr = transformEmbeddedJsxExpression(
+            attr.value.expression
+          ).expression;
+        }
+      }
+      const childRenderer = element.children.find(
+        (child) => t.isJSXExpressionContainer(child) && !t.isJSXEmptyExpression(child.expression)
+      );
+      if (!childRenderer) {
+        return t.stringLiteral("");
+      }
+      return t.callExpression(t.identifier("__olovaFor"), [
+        eachExpr,
+        transformEmbeddedJsxExpression(
+          childRenderer.expression
+        ).expression
+      ]);
+    }
+    if (tag === "Show") {
+      let whenExpr = t.booleanLiteral(false);
+      let fallbackExpr = t.stringLiteral("");
+      for (const attr of opening.attributes) {
+        if (!t.isJSXAttribute(attr)) {
+          continue;
+        }
+        const attrName = jsxNameToString(attr.name);
+        if (attrName === "when" && attr.value && t.isJSXExpressionContainer(attr.value) && !t.isJSXEmptyExpression(attr.value.expression)) {
+          whenExpr = transformEmbeddedJsxExpression(
+            attr.value.expression
+          ).expression;
+        }
+        if (attrName === "fallback" && attr.value && t.isJSXExpressionContainer(attr.value) && !t.isJSXEmptyExpression(attr.value.expression)) {
+          fallbackExpr = transformEmbeddedJsxExpression(
+            attr.value.expression
+          ).expression;
+        }
+      }
+      const childExpr2 = concatExpressions(
+        element.children.map((child) => jsxChildToExpression(child)).filter(Boolean)
+      );
+      return t.callExpression(t.identifier("__olovaShow"), [
+        whenExpr,
+        t.arrowFunctionExpression(
+          [t.identifier("__value")],
+          childExpr2
+        ),
+        fallbackExpr
+      ]);
+    }
+    const attrExpr = concatExpressions(
+      [
+        ...jsxScopeAttr ? [t.stringLiteral(` ${jsxScopeAttr}`)] : [],
+        ...opening.attributes.map((attr) => jsxAttrToExpression(attr))
+      ]
+    );
+    const childExpr = concatExpressions(
+      element.children.map((child) => jsxChildToExpression(child)).filter(Boolean)
+    );
+    if (opening.selfClosing) {
+      return concatExpressions([
+        t.stringLiteral(`<${tag}`),
+        attrExpr,
+        t.stringLiteral("/>")
+      ]);
+    }
+    return concatExpressions([
+      t.stringLiteral(`<${tag}`),
+      attrExpr,
+      t.stringLiteral(">"),
+      childExpr,
+      t.stringLiteral(`</${tag}>`)
+    ]);
+  };
+  traverse(ast, {
+    JSXElement(path2) {
+      containsJsx = true;
+      path2.replaceWith(jsxElementToExpression(path2.node));
+      path2.skip();
+    },
+    JSXFragment(path2) {
+      containsJsx = true;
+      path2.replaceWith(jsxFragmentToExpression(path2.node));
+      path2.skip();
+    }
+  });
+  const statement = ast.program.body[0];
+  if (!statement || !t.isExpressionStatement(statement)) {
+    return { code: expr.trim(), containsJsx };
+  }
+  containsJsx = containsJsx || expressionProducesHtml(statement.expression);
+  return { code: generate(statement.expression).code, containsJsx };
+}
+function jsxToTemplateHtml(node) {
+  if (t.isJSXElement(node)) {
+    const opening = node.openingElement;
+    let tag = "";
+    if (t.isJSXIdentifier(opening.name)) {
+      tag = opening.name.name;
+    } else if (t.isJSXMemberExpression(opening.name)) {
+      const walk = (n) => t.isJSXIdentifier(n) ? n.name : `${walk(n.object)}.${n.property.name}`;
+      tag = walk(opening.name);
+    } else if (t.isJSXNamespacedName(opening.name)) {
+      tag = `${opening.name.namespace.name}:${opening.name.name.name}`;
+    }
+    let attrsStr = "";
+    for (const attr of opening.attributes) {
+      if (t.isJSXSpreadAttribute(attr)) {
+        attrsStr += ` {...${generate(attr.argument).code}}`;
+      } else {
+        let attrName = "";
+        if (t.isJSXIdentifier(attr.name)) attrName = attr.name.name;
+        else attrName = `${attr.name.namespace.name}:${attr.name.name.name}`;
+        if (!attr.value) attrsStr += ` ${attrName}`;
+        else if (t.isStringLiteral(attr.value))
+          attrsStr += ` ${attrName}="${attr.value.value}"`;
+        else if (t.isJSXExpressionContainer(attr.value)) {
+          if (!t.isJSXEmptyExpression(attr.value.expression)) {
+            attrsStr += ` ${attrName}={${generate(attr.value.expression).code}}`;
+          }
+        }
+      }
+    }
+    const childrenStr = node.children.map(jsxToTemplateHtml).join("");
+    if (opening.selfClosing) {
+      return `<${tag}${attrsStr} />`;
+    }
+    return `<${tag}${attrsStr}>${childrenStr}</${tag}>`;
+  }
+  if (t.isJSXText(node)) {
+    return node.value;
+  }
+  if (t.isJSXExpressionContainer(node)) {
+    if (t.isJSXEmptyExpression(node.expression)) return "";
+    return `{${generate(node.expression).code}}`;
+  }
+  if (t.isJSXFragment(node)) {
+    return node.children.map(jsxToTemplateHtml).join("");
+  }
+  return "";
+}
+function replaceTemplateExpressions(input, replacer) {
+  let output = "";
+  let index = 0;
+  while (index < input.length) {
+    const start = input.indexOf("{", index);
+    if (start < 0) {
+      output += input.slice(index);
+      break;
+    }
+    let prevIndex = start - 1;
+    while (prevIndex >= 0 && /\s/.test(input[prevIndex])) {
+      prevIndex -= 1;
+    }
+    if (prevIndex >= 0 && input[prevIndex] === "=") {
+      output += input.slice(index, start + 1);
+      index = start + 1;
+      continue;
+    }
+    if (start > 0 && input[start - 1] === "$") {
+      output += input.slice(index, start + 1);
+      index = start + 1;
+      continue;
+    }
+    output += input.slice(index, start);
+    let depth = 1;
+    let cursor = start + 1;
+    let quote = null;
+    while (cursor < input.length && depth > 0) {
+      const char = input[cursor];
+      const prev = input[cursor - 1];
+      if (quote) {
+        if (char === quote && prev !== "\\") {
+          quote = null;
+        }
+        cursor += 1;
+        continue;
+      }
+      if (char === "'" || char === '"' || char === "`") {
+        quote = char;
+        cursor += 1;
+        continue;
+      }
+      if (char === "{") {
+        depth += 1;
+      } else if (char === "}") {
+        depth -= 1;
+      }
+      cursor += 1;
+    }
+    if (depth !== 0) {
+      throw createCompileError("[olova] Unclosed template expression block.", input, start);
+    }
+    const expression = input.slice(start + 1, cursor - 1);
+    output += replacer(expression);
+    index = cursor;
+  }
+  return output;
+}
+function parsePropsFromAttrs(attrs, stateNames, allSignalNames, jsxFunctionNames) {
+  const props = [];
+  for (const [key, rawValue] of Object.entries(attrs)) {
+    if (key === "slot" || key === "key") {
+      continue;
+    }
+    const propName = key === "className" ? "class" : key;
+    if (rawValue === true) {
+      props.push(`${JSON.stringify(propName)}: true`);
+      continue;
+    }
+    if (rawValue.startsWith("{") && rawValue.endsWith("}")) {
+      const expr = rawValue.slice(1, -1);
+      const valueExpr = transformExpression(
+        expr,
+        stateNames,
+        allSignalNames,
+        jsxFunctionNames
+      ).code;
+      props.push(
+        `${JSON.stringify(propName)}: (${propName === "class" ? `__olovaNormalizeClassValue(${valueExpr})` : valueExpr})`
+      );
+      continue;
+    }
+    props.push(`${JSON.stringify(propName)}: ${JSON.stringify(rawValue)}`);
+  }
+  return props.length === 0 ? "{}" : `{ ${props.join(", ")} }`;
+}
+function transformTemplate(template, stateNames, allSignalNames, jsxFunctionNames, componentNames, counters, scopeId) {
+  let html = template;
+  const textBindings = [];
+  const htmlBindings = [];
+  const attrBindings = [];
+  const eventBindings = [];
+  const slotBindings = [];
+  const componentBindings = [];
+  const ifBindings = [];
+  html = replaceTemplateExpressions(html, (expr) => {
+    try {
+      const ast = parseModule(`(${expr})`);
+      const exprNode = ast.program.body[0];
+      if (t.isExpressionStatement(exprNode)) {
+        const node = exprNode.expression;
+        const containsJsxNode = (n) => {
+          let found = false;
+          traverse(parseModule(`(${generate(n).code})`), {
+            JSXElement() {
+              found = true;
+            },
+            JSXFragment() {
+              found = true;
+            }
+          });
+          return found;
+        };
+        if (t.isLogicalExpression(node) && node.operator === "&&") {
+          if (containsJsxNode(node.right)) {
+            const id = `i${counters.if++}`;
+            const condition = generate(node.left).code;
+            const trueBranchHtml = jsxToTemplateHtml(node.right);
+            ifBindings.push({
+              id,
+              expr: transformExpression(
+                condition,
+                stateNames,
+                allSignalNames,
+                jsxFunctionNames,
+                scopeId
+              ).code,
+              trueBranch: transformTemplate(
+                trueBranchHtml,
+                stateNames,
+                allSignalNames,
+                jsxFunctionNames,
+                componentNames,
+                counters,
+                scopeId
+              )
+            });
+            return `__O_IF_${id}__`;
+          }
+        } else if (t.isConditionalExpression(node)) {
+          if (containsJsxNode(node.consequent) || containsJsxNode(node.alternate)) {
+            const id = `i${counters.if++}`;
+            const condition = generate(node.test).code;
+            const trueBranchHtml = containsJsxNode(node.consequent) ? jsxToTemplateHtml(node.consequent) : `{${generate(node.consequent).code}}`;
+            const falseBranchHtml = containsJsxNode(node.alternate) ? jsxToTemplateHtml(node.alternate) : `{${generate(node.alternate).code}}`;
+            ifBindings.push({
+              id,
+              expr: transformExpression(
+                condition,
+                stateNames,
+                allSignalNames,
+                jsxFunctionNames,
+                scopeId
+              ).code,
+              trueBranch: transformTemplate(
+                trueBranchHtml,
+                stateNames,
+                allSignalNames,
+                jsxFunctionNames,
+                componentNames,
+                counters,
+                scopeId
+              ),
+              falseBranch: transformTemplate(
+                falseBranchHtml,
+                stateNames,
+                allSignalNames,
+                jsxFunctionNames,
+                componentNames,
+                counters,
+                scopeId
+              )
+            });
+            return `__O_IF_${id}__`;
+          }
+        }
+      }
+    } catch {
+    }
+    return `{${expr}}`;
+  });
+  const rawExpressions = [];
+  html = replaceTemplateExpressions(html, (expr) => {
+    const id = `raw_${rawExpressions.length}`;
+    rawExpressions.push({ id, expression: expr });
+    return `__O_RAW_EXPR_${id}__`;
+  });
+  const renderTextContent = (content) => {
+    return content.replace(
+      /__O_RAW_EXPR_([a-zA-Z0-9_]+)__/g,
+      (_full, exprId) => {
+        const found = rawExpressions.find((entry) => entry.id === exprId);
+        const expr = found ? found.expression : "";
+        const transformed = transformExpression(
+          expr,
+          stateNames,
+          allSignalNames,
+          jsxFunctionNames,
+          scopeId
+        );
+        if (transformed.containsJsx) {
+          const id2 = `h${counters.text++}`;
+          htmlBindings.push({
+            id: id2,
+            expr: `__olovaDangerouslySetHtml(${transformed.code})`
+          });
+          return `__O_HTML_${id2}__`;
+        }
+        const id = `t${counters.text++}`;
+        textBindings.push({ id, expr: transformed.code });
+        return `__O_TEXT_${id}__`;
+      }
+    );
+  };
+  const renderAttrs = (element) => {
+    let output = "";
+    const scopeAttr = createScopeAttr(scopeId);
+    if (scopeAttr) {
+      output += ` ${scopeAttr}`;
+    }
+    for (const [attrName, rawValue] of Object.entries(element.attrs)) {
+      if (attrName === "key") {
+        continue;
+      }
+      const normalizedAttrName = attrName === "className" ? "class" : attrName;
+      if (rawValue === true) {
+        output += ` ${normalizedAttrName}`;
+        continue;
+      }
+      if (rawValue.startsWith("{") && rawValue.endsWith("}")) {
+        const expr = rawValue.slice(1, -1);
+        const eventMatch = normalizedAttrName.match(/^(?:on:|on)([A-Za-z]+)$/);
+        if (eventMatch) {
+          const id2 = `e${counters.event++}`;
+          const event = eventMatch[1].toLowerCase();
+          eventBindings.push({
+            id: id2,
+            event,
+            expr: transformExpression(
+              expr,
+              stateNames,
+              allSignalNames,
+              jsxFunctionNames
+            ).code
+          });
+          output += ` data-o-on-${event}="${id2}"`;
+          continue;
+        }
+        const id = `a${counters.attr++}`;
+        attrBindings.push({
+          id,
+          attr: normalizedAttrName,
+          expr: normalizedAttrName === "class" ? `__olovaNormalizeClassValue(${transformExpression(expr, stateNames, allSignalNames, jsxFunctionNames).code})` : transformExpression(expr, stateNames, allSignalNames, jsxFunctionNames).code
+        });
+        output += ` ${normalizedAttrName}="__O_ATTR_${id}__"`;
+        continue;
+      }
+      output += ` ${normalizedAttrName}="${rawValue.replace(/"/g, "&quot;")}"`;
+    }
+    return output;
+  };
+  const serializeRawNodes = (nodes) => nodes.map((node) => {
+    if (node.type === "comment") {
+      return `<!--${node.content}-->`;
+    }
+    if (node.type === "text") {
+      return node.content;
+    }
+    const attrs = Object.entries(node.attrs).map(([name, value]) => {
+      if (value === true) {
+        return ` ${name}`;
+      }
+      return ` ${name}="${String(value).replace(/"/g, "&quot;")}"`;
+    }).join("");
+    const children = serializeRawNodes(node.children);
+    if (node.isSelfClosing) {
+      return `<${node.tag}${attrs} />`;
+    }
+    return `<${node.tag}${attrs}>${children}</${node.tag}>`;
+  }).join("");
+  const renderNodes = (nodes) => nodes.map((node) => {
+    if (node.type === "comment") {
+      return `<!--${node.content}-->`;
+    }
+    if (node.type === "text") {
+      return renderTextContent(node.content);
+    }
+    if (node.tag === "slot") {
+      const id = `s${counters.slot++}`;
+      const slotName = typeof node.attrs.name === "string" ? node.attrs.name : "default";
+      slotBindings.push({ id, name: slotName });
+      return `__O_SLOT_${id}__`;
+    }
+    if (componentNames.has(node.tag)) {
+      const id = `c${counters.comp++}`;
+      const namedSlotNodes = /* @__PURE__ */ new Map();
+      const defaultNodes = [];
+      for (const child of node.children) {
+        if (child.type === "element" && child.tag === "template" && typeof child.attrs.slot === "string") {
+          namedSlotNodes.set(child.attrs.slot, child.children);
+          continue;
+        }
+        defaultNodes.push(child);
+      }
+      const slotFactories = [];
+      if (defaultNodes.length > 0) {
+        slotFactories.push({
+          varName: `__slot_${id}_default`,
+          name: "default",
+          descriptor: transformTemplate(
+            serializeRawNodes(defaultNodes),
+            stateNames,
+            allSignalNames,
+            jsxFunctionNames,
+            componentNames,
+            counters,
+            scopeId
+          )
+        });
+      }
+      for (const [slotName, slotChildren] of namedSlotNodes.entries()) {
+        slotFactories.push({
+          varName: `__slot_${id}_${slotName.replace(/[^A-Za-z0-9_$]/g, "_")}`,
+          name: slotName,
+          descriptor: transformTemplate(
+            serializeRawNodes(slotChildren),
+            stateNames,
+            allSignalNames,
+            jsxFunctionNames,
+            componentNames,
+            counters,
+            scopeId
+          )
+        });
+      }
+      componentBindings.push({
+        id,
+        component: node.tag,
+        propsExpr: parsePropsFromAttrs(
+          node.attrs,
+          stateNames,
+          allSignalNames,
+          jsxFunctionNames
+        ),
+        slotFactories
+      });
+      return `__O_COMP_${id}__`;
+    }
+    const attrs = renderAttrs(node);
+    const children = renderNodes(node.children);
+    if (node.isSelfClosing) {
+      return `<${node.tag}${attrs} />`;
+    }
+    return `<${node.tag}${attrs}>${children}</${node.tag}>`;
+  }).join("");
+  html = renderNodes(parseHTML(html));
+  const resolveExpr = (expr) => transformExpression(
+    expr,
+    stateNames,
+    allSignalNames,
+    jsxFunctionNames,
+    scopeId
+  );
+  const buildFnStr = generateBuildFunction(
+    escapeTemplate(html),
+    stateNames,
+    resolveExpr,
+    counters,
+    componentNames
+  );
+  return {
+    html: escapeTemplate(html),
+    textBindings,
+    htmlBindings,
+    attrBindings,
+    eventBindings,
+    slotBindings,
+    componentBindings,
+    ifBindings,
+    buildFnStr
+  };
+}
+function indentBlock(code, spaces = 2) {
+  const pad = " ".repeat(spaces);
+  if (!code.trim()) {
+    return "";
+  }
+  return code.split("\n").map((line) => `${pad}${line}`).join("\n");
+}
+function renderDescriptorLiteral(descriptor, indent = "      ") {
+  const slotFactoryDecls = descriptor.componentBindings.flatMap(
+    (binding) => binding.slotFactories.map(
+      (slot) => `${indent}const ${slot.varName} = () => (${renderDescriptorLiteral(slot.descriptor, indent + "  ")});`
+    )
+  );
+  const componentBindingsCode = descriptor.componentBindings.map((binding) => {
+    const slotsObject = binding.slotFactories.length === 0 ? "{}" : `{ ${binding.slotFactories.map((slot) => `${JSON.stringify(slot.name)}: ${slot.varName}`).join(", ")} }`;
+    return `${indent}  { id: ${JSON.stringify(binding.id)}, getComponent: () => ${binding.component}, getProps: () => (${binding.propsExpr}), getSlots: () => (${slotsObject}) }`;
+  }).join(",\n");
+  const buildLines = descriptor.buildFnStr ? `${indent}build: ${descriptor.buildFnStr.replace(/\n      /g, "\n" + indent)},` : "";
+  const objectLiteral = `{
+${buildLines}
+${indent}textBindings: [
+${descriptor.textBindings.map((binding) => `${indent}  { id: ${JSON.stringify(binding.id)}, get: () => (${binding.expr}) }`).join(",\n")}
+${indent}],
+${indent}htmlBindings: [
+${descriptor.htmlBindings.map((binding) => `${indent}  { id: ${JSON.stringify(binding.id)}, get: () => (${binding.expr}) }`).join(",\n")}
+${indent}],
+${indent}attrBindings: [
+${descriptor.attrBindings.map((binding) => `${indent}  { id: ${JSON.stringify(binding.id)}, attr: ${JSON.stringify(binding.attr)}, get: () => (${binding.expr}) }`).join(",\n")}
+${indent}],
+${indent}eventBindings: [
+${descriptor.eventBindings.map((binding) => `${indent}  { id: ${JSON.stringify(binding.id)}, event: ${JSON.stringify(binding.event)}, get: () => (${binding.expr}) }`).join(",\n")}
+${indent}],
+${indent}slotBindings: [
+${descriptor.slotBindings.map((binding) => `${indent}  { id: ${JSON.stringify(binding.id)}, name: ${JSON.stringify(binding.name)} }`).join(",\n")}
+${indent}],
+${indent}componentBindings: [
+${componentBindingsCode}
+${indent}],
+${indent}ifBindings: [
+${descriptor.ifBindings.map((binding) => {
+    const trueFactory = `() => (${renderDescriptorLiteral(binding.trueBranch, indent + "  ")})`;
+    const falseFactory = binding.falseBranch ? `() => (${renderDescriptorLiteral(binding.falseBranch, indent + "  ")})` : "undefined";
+    return `${indent}  { id: ${JSON.stringify(binding.id)}, get: () => (${binding.expr}), trueBranch: ${trueFactory}, falseBranch: ${falseFactory} }`;
+  }).join(",\n")}
+${indent}]
+${indent}}`;
+  if (slotFactoryDecls.length === 0) {
+    return objectLiteral;
+  }
+  const outerIndent = indent.length >= 2 ? indent.slice(2) : "";
+  return `(() => {
+${slotFactoryDecls.join("\n")}
+${indent}return ${objectLiteral};
+${outerIndent}})()`;
+}
+function buildComponentCode(parsed, options) {
+  const scriptInfo = collectScriptInfo(parsed.script);
+  const counters = {
+    text: 0,
+    attr: 0,
+    event: 0,
+    comp: 0,
+    slot: 0,
+    if: 0
+  };
+  const transformed = transformTemplate(
+    parsed.template,
+    scriptInfo.stateNames,
+    scriptInfo.allSignalNames,
+    scriptInfo.jsxFunctionNames,
+    scriptInfo.componentNames,
+    counters,
+    options?.scopeId
+  );
+  const exportHead = options?.exportName ? `export const ${options.exportName} = __defineComponent((__props, __slots) => {` : `const __olovaComponent = __defineComponent((__props, __slots) => {`;
+  const exportTail = options?.exportName ? `}, ${JSON.stringify(options?.hmrId)});` : `}, ${JSON.stringify(options?.hmrId)});
+export default __olovaComponent;`;
+  const hmrCode = options?.dev && !options?.exportName && options?.hmrId ? `
+if (import.meta.hot) {
+  import.meta.hot.accept((nextModule) => {
+    if (nextModule?.default) {
+      __replaceComponent(__olovaComponent, nextModule.default);
+    }
+  });
+}
+` : "";
+  const code = `
+${exportHead}
+  const props = __props;
+  const slots = __slots;
+  const __olovaGlobalObj = globalThis;
+  const __olovaJsxHandlers =
+    __olovaGlobalObj.__olovaJsxHandlers ?? (__olovaGlobalObj.__olovaJsxHandlers = new Map());
+  const __olovaNextJsxEventId = () => {
+    __olovaGlobalObj.__olovaJsxEventId = (__olovaGlobalObj.__olovaJsxEventId ?? 0) + 1;
+    return String(__olovaGlobalObj.__olovaJsxEventId);
+  };
+  if (typeof __olovaGlobalObj.__olovaDispatchJsxEvent !== 'function') {
+    __olovaGlobalObj.__olovaDispatchJsxEvent = (event, element) => {
+      const key = element?.getAttribute?.('data-o-jsx-' + event.type);
+      if (!key) {
+        return;
+      }
+
+      const handler = __olovaJsxHandlers.get(key);
+      if (typeof handler === 'function') {
+        handler(event);
+      }
+    };
+  }
+  const __olovaRegisterJsxEvent = (eventName, handler) => {
+    if (typeof handler !== 'function') {
+      return '';
+    }
+
+    const id = __olovaNextJsxEventId();
+    __olovaJsxHandlers.set(id, handler);
+    return ' data-o-jsx-' + eventName + '="' + id + '" on' + eventName + '="window.__olovaDispatchJsxEvent(event, this)"';
+  };
+  const __olovaToString = (value) => Array.isArray(value) ? value.map(__olovaToString).join('') : value == null ? '' : String(value);
+  const __olovaDangerouslySetHtml = (value) => ({ __dangerousHtml: true, value: __olovaToString(value) });
+  const __olovaNormalizeClassValue = (value) => {
+    if (value == null || value === false) {
+      return '';
+    }
+    if (Array.isArray(value)) {
+      return value.map(__olovaNormalizeClassValue).filter(Boolean).join(' ');
+    }
+    if (typeof value === 'object') {
+      return Object.entries(value)
+        .filter(([, enabled]) => !!enabled)
+        .map(([key]) => key)
+        .join(' ');
+    }
+    return String(value);
+  };
+  const __olovaEscape = (value) =>
+    __olovaToString(value)
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#39;');
+  const __olovaSpreadAttrs = (input) => {
+    if (input == null || input === false) {
+      return '';
+    }
+    if (Array.isArray(input)) {
+      return input.map(__olovaSpreadAttrs).join('');
+    }
+    if (typeof input !== 'object') {
+      return '';
+    }
+
+    return Object.entries(input).reduce((acc, [key, value]) => {
+      if (value == null || value === false) {
+        return acc;
+      }
+      const attrKey = key === 'className' ? 'class' : key;
+      const normalizedValue = attrKey === 'class'
+        ? __olovaNormalizeClassValue(value)
+        : value;
+      if (attrKey === 'key') {
+        return acc;
+      }
+      if (normalizedValue == null || normalizedValue === false || normalizedValue === '') {
+        return acc;
+      }
+      if (normalizedValue === true) {
+        return acc + ' ' + attrKey;
+      }
+      return acc + ' ' + attrKey + '="' + __olovaEscape(normalizedValue) + '"';
+    }, '');
+  };
+  const __olovaFor = (each, render) => {
+    if (!Array.isArray(each) || typeof render !== 'function') {
+      return '';
+    }
+    return each.map((item, index) => render(item, index));
+  };
+  const __olovaShow = (when, render, fallback = '') => {
+    if (!when) {
+      return fallback;
+    }
+    return typeof render === 'function' ? render(when) : render;
+  };
+${indentBlock(scriptInfo.scriptBodyCode, 2)}
+
+  return ${renderDescriptorLiteral(transformed, "  ")};
+${exportTail}
+${hmrCode}
+`;
+  return { importsCode: scriptInfo.importsCode, code };
+}
+function hashScopeSeed(input) {
+  let hash = 2166136261;
+  for (let index = 0; index < input.length; index += 1) {
+    hash ^= input.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return Math.abs(hash >>> 0).toString(36);
+}
+function createScopeAttr(scopeId) {
+  return scopeId ? `data-o-scope-${scopeId}` : null;
+}
+function scopeSelectorList(selectorList, scopeAttr) {
+  const applyScopeToSegment = (segment) => {
+    const trimmed = segment.trim();
+    if (!trimmed) {
+      return trimmed;
+    }
+    if (trimmed.includes(scopeAttr)) {
+      return trimmed;
+    }
+    const globalPattern = /:global\(([^()]+)\)/g;
+    const localCandidate = trimmed.replace(globalPattern, "").trim();
+    const normalized = trimmed.replace(globalPattern, "$1");
+    if (!localCandidate) {
+      return normalized;
+    }
+    if (normalized === ":root") {
+      return `[${scopeAttr}]`;
+    }
+    const pseudoIndex = normalized.search(/(?<!:):(?!:)/);
+    if (pseudoIndex === -1) {
+      return `${normalized}[${scopeAttr}]`;
+    }
+    return `${normalized.slice(0, pseudoIndex)}[${scopeAttr}]${normalized.slice(pseudoIndex)}`;
+  };
+  return selectorList.split(",").map((selector) => selector.trim()).filter(Boolean).map((selector) => {
+    if (selector.startsWith("@") || selector.includes(scopeAttr)) {
+      return selector;
+    }
+    return selector.split(/(\s+|[>+~])/).map((part) => {
+      if (!part || /^(\s+|[>+~])$/.test(part)) {
+        return part;
+      }
+      return applyScopeToSegment(part);
+    }).join("");
+  }).join(", ");
+}
+function scopeCss(css, scopeAttr) {
+  let output = "";
+  let index = 0;
+  while (index < css.length) {
+    const open = css.indexOf("{", index);
+    if (open < 0) {
+      output += css.slice(index);
+      break;
+    }
+    const selector = css.slice(index, open).trim();
+    let depth = 1;
+    let cursor = open + 1;
+    while (cursor < css.length && depth > 0) {
+      if (css[cursor] === "{") {
+        depth += 1;
+      } else if (css[cursor] === "}") {
+        depth -= 1;
+      }
+      cursor += 1;
+    }
+    const body = css.slice(open + 1, cursor - 1);
+    if (/^@(?:media|supports|container|layer)\b/i.test(selector)) {
+      output += `${selector} {${scopeCss(body, scopeAttr)}}`;
+    } else if (/^@(?:keyframes|-webkit-keyframes)\b/i.test(selector)) {
+      output += `${selector} {${body}}`;
+    } else {
+      output += `${scopeSelectorList(selector, scopeAttr)} {${body}}`;
+    }
+    index = cursor;
+  }
+  return output;
+}
+function collectCss(blocks, scopeId) {
+  const scopeAttr = createScopeAttr(scopeId);
+  return blocks.map((block) => {
+    const content = block.content.trim();
+    if (!content) {
+      return "";
+    }
+    if (!("global" in block.attrs) && scopeAttr) {
+      return scopeCss(content, scopeAttr);
+    }
+    return content;
+  }).filter(Boolean).join("\n\n");
+}
+function compileOlovaScriptModule(source, options) {
+  try {
+    const scriptInfo = collectScriptInfo(source);
+    return transpileTypeScript(
+      [scriptInfo.importsCode, scriptInfo.scriptBodyCode].filter(Boolean).join("\n"),
+      options?.filename ?? "module.ts"
+    );
+  } catch (error) {
+    return normalizeCompileError(error, source, options?.filename ?? "module.ts");
+  }
+}
+function compileOlova(source, options) {
+  try {
+    const parsed = parseOlovaFile(source);
+    if (!parsed.template.trim() && isModuleOnlyScript(parsed.script)) {
+      return {
+        ...compileModuleScript(parsed.script, options?.filename ?? "module.olova.ts"),
+        css: collectCss(parsed.styles)
+      };
+    }
+    const scopeId = parsed.styles.some((style) => !("global" in style.attrs)) ? hashScopeSeed(`${options?.filename ?? "component.olova"}:${options?.exportName ?? "default"}`) : void 0;
+    const compiled = buildComponentCode(parsed, {
+      scopeId,
+      hmrId: options?.filename ?? "component.olova",
+      dev: options?.dev
+    });
+    const runtimeImport = options?.dev ? `import { defineComponent as __defineComponent, replaceComponent as __replaceComponent } from 'olova/runtime';` : `import { defineComponent as __defineComponent } from 'olova/runtime';`;
+    const result = transpileTypeScript(`
+${runtimeImport}
+${compiled.importsCode}
+${compiled.code}
+`, options?.filename ?? "component.olova.ts");
+    return {
+      ...result,
+      css: collectCss(parsed.styles, scopeId)
+    };
+  } catch (error) {
+    return normalizeCompileError(
+      error,
+      source,
+      options?.filename ?? "component.olova"
+    );
+  }
+}
+
+// vite/olova-plugin.ts
+var RUNTIME_MODULE_ID = "\0olova:runtime";
+var CORE_MODULE_ID = "\0olova:core";
+var GLOBAL_MODULE_ID = "\0olova:global";
+var STYLE_QUERY = "?olova&type=style";
+function findPackageRoot(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    const packageJsonPath = path.join(currentDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      return currentDir;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+function readPackageJson(packageRoot) {
+  if (!packageRoot) {
+    return null;
+  }
+  const packageJsonPath = path.join(packageRoot, "package.json");
+  if (!fs.existsSync(packageJsonPath)) {
+    return null;
+  }
+  return JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+}
+function olovaPlugin() {
+  let config;
+  const cssCache = /* @__PURE__ */ new Map();
+  const pluginDir = path.dirname(fileURLToPath(import.meta.url));
+  const packageRoot = findPackageRoot(pluginDir);
+  const packageJson = readPackageJson(packageRoot);
+  const resolvePackageEntry = (exportKey, relativePath) => {
+    const exportEntry = packageJson?.exports?.[exportKey];
+    const publishedPath = typeof exportEntry === "string" ? exportEntry : exportEntry?.import ?? exportEntry?.default;
+    if (packageRoot && publishedPath) {
+      const publishedCandidate = path.resolve(packageRoot, publishedPath);
+      if (fs.existsSync(publishedCandidate)) {
+        return normalizePath(publishedCandidate);
+      }
+    }
+    const candidates = [
+      path.resolve(pluginDir, relativePath),
+      path.resolve(pluginDir, relativePath.replace(/\.ts$/, ".js"))
+    ];
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) {
+        return normalizePath(candidate);
+      }
+    }
+    return normalizePath(candidates[0]);
+  };
+  const runtimeEntry = resolvePackageEntry("./runtime", "../runtime/index.ts");
+  const coreEntry = resolvePackageEntry("./core", "../core/index.ts");
+  const globalEntry = resolvePackageEntry("./global", "../runtime/global.ts");
+  const shouldRewriteRuntimeScript = (id, code) => {
+    if (id.includes("/node_modules/") || id.endsWith(".d.ts")) {
+      return false;
+    }
+    if (!/\.(?:[cm]?[jt]sx?)$/.test(id)) {
+      return false;
+    }
+    return /from\s+['"]olova\/(?:core|global|state)['"]|import\s+['"]olova\/(?:core|global|state)['"]/.test(code);
+  };
+  return {
+    name: "vite-plugin-olova",
+    enforce: "pre",
+    configResolved(resolvedConfig) {
+      config = resolvedConfig;
+    },
+    resolveId(id) {
+      if (id === "olova/runtime") return RUNTIME_MODULE_ID;
+      if (id === "olova/core" || id === "olova/state") return CORE_MODULE_ID;
+      if (id === "olova/global") return GLOBAL_MODULE_ID;
+      if (id.includes(`.css${STYLE_QUERY}`)) return id;
+      return null;
+    },
+    load(id) {
+      if (id === RUNTIME_MODULE_ID) return `export * from ${JSON.stringify(runtimeEntry)};`;
+      if (id === CORE_MODULE_ID) return `export * from ${JSON.stringify(coreEntry)};`;
+      if (id === GLOBAL_MODULE_ID) return `export * from ${JSON.stringify(globalEntry)};`;
+      if (id.includes(`.css${STYLE_QUERY}`)) {
+        const filename = id.split("?")[0].replace(/\.css$/, "");
+        return cssCache.get(filename) || "";
+      }
+      return null;
+    },
+    transform(code, id) {
+      const [filename, query] = id.split("?", 2);
+      if (!filename.endsWith(".olova")) {
+        if (!query && shouldRewriteRuntimeScript(filename, code)) {
+          const result = compileOlovaScriptModule(code, {
+            filename,
+            dev: !config.isProduction
+          });
+          return {
+            code: result.code,
+            map: result.map ?? null
+          };
+        }
+        return null;
+      }
+      if (query && !query.includes("olova")) return null;
+      if (query && query.includes("type=style")) return null;
+      try {
+        const result = compileOlova(code, { filename, dev: !config.isProduction });
+        let jsCode = result.code;
+        if (result.css && result.css.trim()) {
+          cssCache.set(filename, result.css);
+          jsCode = `import ${JSON.stringify(filename + ".css" + STYLE_QUERY)};
+` + jsCode;
+        } else {
+          cssCache.delete(filename);
+        }
+        return {
+          code: jsCode,
+          map: result.map || null
+        };
+      } catch (err) {
+        this.error(err, err.loc?.start?.line);
+      }
+    },
+    async handleHotUpdate(ctx) {
+      if (!ctx.file.endsWith(".olova")) {
+        return;
+      }
+      const filename = normalizePath(ctx.file);
+      const previousCss = (cssCache.get(filename) ?? "").trim();
+      try {
+        const source = await ctx.read();
+        const nextCss = (compileOlova(source, { filename, dev: !config.isProduction }).css ?? "").trim();
+        if (nextCss !== previousCss) {
+          if (nextCss) {
+            cssCache.set(filename, nextCss);
+          } else {
+            cssCache.delete(filename);
+          }
+          ctx.server.ws.send({ type: "full-reload", path: "*" });
+          return [];
+        }
+      } catch {
+      }
+      const styleId = `${filename}.css${STYLE_QUERY}`;
+      const modules = [...ctx.modules];
+      const styleModule = ctx.server.moduleGraph.getModuleById(styleId);
+      if (styleModule) {
+        modules.push(styleModule);
+      }
+      for (const mod of modules) {
+        ctx.server.moduleGraph.invalidateModule(mod);
+      }
+      return modules;
+    }
+  };
+}
+
+export { olovaPlugin };
+//# sourceMappingURL=vite.js.map
+//# sourceMappingURL=vite.js.map