@aerobuilt/core 0.2.1 → 0.2.3

package/dist/{chunk-5GK7XRII.js → chunk-4DAK56WB.js}

@@ -1,6 +1,6 @@
 import {
   Aero
-} from "./chunk-3OZCI7DL.js";
+} from "./chunk-5ZNUGZOW.js";
 
 // src/runtime/instance.ts
 var instance = globalThis.__AERO_INSTANCE__ || new Aero();

package/dist/{chunk-3OZCI7DL.js → chunk-5ZNUGZOW.js}

@@ -1,7 +1,7 @@
 import {
   pagePathToKey,
   resolvePageTarget
-} from "./chunk-7A3WBPH4.js";
+} from "./chunk-JAMYN2VX.js";
 
 // src/runtime/index.ts
 var Aero = class {

package/dist/{chunk-7A3WBPH4.js → chunk-JAMYN2VX.js}

@@ -11,6 +11,57 @@ function toPosixRelative(value, root) {
   return valuePosix;
 }
 
+// src/utils/route-pattern.ts
+var PARAM_SEGMENT_REGEX = /^\[([^.\]\[]+)\]$/;
+function parseRoutePattern(pattern) {
+  const rawSegments = pattern.split("/").filter(Boolean);
+  const segments = rawSegments.map((seg) => {
+    const paramMatch = seg.match(PARAM_SEGMENT_REGEX);
+    if (paramMatch) {
+      return { type: "param", name: paramMatch[1] };
+    }
+    return { type: "static", value: seg };
+  });
+  return { segments };
+}
+function isDynamicRoutePattern(pattern) {
+  const { segments } = parseRoutePattern(pattern);
+  return segments.some((s) => s.type === "param");
+}
+function matchRoutePattern(pattern, pageName) {
+  const { segments } = parseRoutePattern(pattern);
+  const requestedSegments = pageName.split("/").filter(Boolean);
+  if (segments.length !== requestedSegments.length) return null;
+  const params = {};
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const requestSeg = requestedSegments[i];
+    if (seg.type === "param") {
+      params[seg.name] = decodeURIComponent(requestSeg);
+    } else if (seg.value !== requestSeg) {
+      return null;
+    }
+  }
+  return params;
+}
+function expandRoutePattern(pattern, params) {
+  const { segments } = parseRoutePattern(pattern);
+  const parts = [];
+  for (const seg of segments) {
+    if (seg.type === "param") {
+      if (!(seg.name in params)) {
+        throw new Error(
+          `[aero] getStaticPaths: missing param "${seg.name}" for pattern "${pattern}". Provided params: ${JSON.stringify(params)}`
+        );
+      }
+      parts.push(params[seg.name]);
+    } else {
+      parts.push(seg.value);
+    }
+  }
+  return parts.join("/");
+}
+
 // src/utils/routing.ts
 function pagePathToKey(path) {
   const withoutExt = toPosix(path).replace(/\.html$/i, "");
@@ -35,27 +86,10 @@ function resolvePageName(url) {
   return clean || "index";
 }
 function resolveDynamicPage(pageName, pagesMap) {
-  const requestedSegments = pageName.split("/").filter(Boolean);
   for (const [key, mod] of Object.entries(pagesMap)) {
     if (!key.includes("[") || !key.includes("]") || key.includes(".")) continue;
-    const keySegments = key.split("/").filter(Boolean);
-    if (keySegments.length !== requestedSegments.length) continue;
-    const params = {};
-    let matched = true;
-    for (let i = 0; i < keySegments.length; i++) {
-      const routeSegment = keySegments[i];
-      const requestSegment = requestedSegments[i];
-      const dynamicMatch = routeSegment.match(/^\[(.+)\]$/);
-      if (dynamicMatch) {
-        params[dynamicMatch[1]] = decodeURIComponent(requestSegment);
-        continue;
-      }
-      if (routeSegment !== requestSegment) {
-        matched = false;
-        break;
-      }
-    }
-    if (matched) {
+    const params = matchRoutePattern(key, pageName);
+    if (params != null) {
       return { module: mod, pageName: key, params };
     }
   }
@@ -91,6 +125,8 @@ function resolvePageTarget(component, pagesMap) {
 export {
   toPosix,
   toPosixRelative,
+  isDynamicRoutePattern,
+  expandRoutePattern,
   pagePathToKey,
   resolvePageName,
   resolvePageTarget

package/dist/chunk-VTEG2UU3.js

@@ -0,0 +1,184 @@
+// src/compiler/tokenizer.ts
+import {
+  tokenizeCurlyInterpolation,
+  compileInterpolationFromSegments
+} from "@aerobuilt/interpolation";
+
+// src/compiler/directive-attributes.ts
+var DEFAULT_DIRECTIVE_PREFIXES = ["x-", "@", ":", "."];
+var defaultConfig = {
+  prefixes: DEFAULT_DIRECTIVE_PREFIXES,
+  exactNames: []
+};
+function isDirectiveAttr(attrName, config = defaultConfig) {
+  const prefixes = config.prefixes ?? defaultConfig.prefixes;
+  const exactNames = config.exactNames ?? defaultConfig.exactNames;
+  if (exactNames.includes(attrName)) return true;
+  return prefixes.some((p) => attrName.startsWith(p));
+}
+
+// src/compiler/build-script-analysis.ts
+import { parseSync, ImportNameKind } from "oxc-parser";
+var BUILD_SCRIPT_FILENAME = "build.ts";
+function analyzeBuildScript(script) {
+  if (!script.trim()) {
+    return {
+      imports: [],
+      getStaticPathsFn: null,
+      scriptWithoutImportsAndGetStaticPaths: script
+    };
+  }
+  const result = parseSync(BUILD_SCRIPT_FILENAME, script, {
+    sourceType: "module",
+    range: true,
+    lang: "ts"
+  });
+  const errors = result.errors;
+  if (errors.length > 0) {
+    const first = errors[0];
+    throw new Error(
+      `[aero] Build script parse error: ${first.message}${first.codeframe ? "\n" + first.codeframe : ""}`
+    );
+  }
+  const mod = result.module;
+  const program = result.program;
+  const imports = [];
+  for (const imp of mod.staticImports) {
+    const specifier = imp.moduleRequest.value;
+    let defaultBinding = null;
+    const namedBindings = [];
+    let namespaceBinding = null;
+    for (const entry of imp.entries) {
+      if (entry.isType) continue;
+      const local = entry.localName.value;
+      switch (entry.importName.kind) {
+        case ImportNameKind.Default:
+          defaultBinding = local;
+          break;
+        case ImportNameKind.NamespaceObject:
+          namespaceBinding = local;
+          break;
+        case ImportNameKind.Name: {
+          const imported = entry.importName.name ?? local;
+          namedBindings.push({ imported, local });
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    imports.push({
+      specifier,
+      defaultBinding,
+      namedBindings,
+      namespaceBinding
+    });
+  }
+  let getStaticPathsRange = null;
+  const body = program.body;
+  if (body) {
+    for (const stmt of body) {
+      if (stmt.type !== "ExportNamedDeclaration") continue;
+      const decl = stmt.declaration;
+      if (!decl || decl.type !== "FunctionDeclaration") continue;
+      const name = decl.id?.name;
+      if (name !== "getStaticPaths") continue;
+      const range = stmt.range;
+      if (range) {
+        getStaticPathsRange = range;
+        break;
+      }
+    }
+  }
+  const getStaticPathsFn = getStaticPathsRange !== null ? script.slice(getStaticPathsRange[0], getStaticPathsRange[1]) : null;
+  const rangesToRemove = [];
+  if (getStaticPathsRange) {
+    rangesToRemove.push(getStaticPathsRange);
+  }
+  for (const imp of mod.staticImports) {
+    rangesToRemove.push([imp.start, imp.end]);
+  }
+  rangesToRemove.sort((a, b) => a[0] - b[0]);
+  const parts = [];
+  let lastEnd = 0;
+  for (const [start, end] of rangesToRemove) {
+    if (start > lastEnd) {
+      parts.push(script.slice(lastEnd, start));
+    }
+    lastEnd = end;
+  }
+  if (lastEnd < script.length) {
+    parts.push(script.slice(lastEnd));
+  }
+  const scriptWithoutImportsAndGetStaticPaths = parts.join("").trim();
+  return {
+    imports,
+    getStaticPathsFn,
+    scriptWithoutImportsAndGetStaticPaths
+  };
+}
+function analyzeBuildScriptForEditor(script) {
+  if (!script.trim()) {
+    return { imports: [] };
+  }
+  const result = parseSync(BUILD_SCRIPT_FILENAME, script, {
+    sourceType: "module",
+    range: true,
+    lang: "ts"
+  });
+  const errors = result.errors;
+  if (errors.length > 0) {
+    const first = errors[0];
+    throw new Error(
+      `[aero] Build script parse error: ${first.message}${first.codeframe ? "\n" + first.codeframe : ""}`
+    );
+  }
+  const mod = result.module;
+  const imports = [];
+  for (const imp of mod.staticImports) {
+    const specifier = imp.moduleRequest.value;
+    let defaultBinding = null;
+    const namedBindings = [];
+    let namespaceBinding = null;
+    const bindingRanges = {};
+    for (const entry of imp.entries) {
+      if (entry.isType) continue;
+      const local = entry.localName.value;
+      bindingRanges[local] = [entry.localName.start, entry.localName.end];
+      switch (entry.importName.kind) {
+        case ImportNameKind.Default:
+          defaultBinding = local;
+          break;
+        case ImportNameKind.NamespaceObject:
+          namespaceBinding = local;
+          break;
+        case ImportNameKind.Name: {
+          const imported = entry.importName.name ?? local;
+          namedBindings.push({ imported, local });
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    imports.push({
+      specifier,
+      defaultBinding,
+      namedBindings,
+      namespaceBinding,
+      range: [imp.start, imp.end],
+      specifierRange: [imp.moduleRequest.start, imp.moduleRequest.end],
+      bindingRanges
+    });
+  }
+  return { imports };
+}
+
+export {
+  tokenizeCurlyInterpolation,
+  compileInterpolationFromSegments,
+  DEFAULT_DIRECTIVE_PREFIXES,
+  isDirectiveAttr,
+  analyzeBuildScript,
+  analyzeBuildScriptForEditor
+};

package/dist/entry-dev.js

@@ -1,11 +1,11 @@
 import {
   aero,
   onUpdate
-} from "./chunk-5GK7XRII.js";
-import "./chunk-3OZCI7DL.js";
+} from "./chunk-4DAK56WB.js";
+import "./chunk-5ZNUGZOW.js";
 import {
   resolvePageName
-} from "./chunk-7A3WBPH4.js";
+} from "./chunk-JAMYN2VX.js";
 
 // src/runtime/client.ts
 function extractDocumentParts(html) {

package/dist/entry-editor.d.ts

@@ -0,0 +1,72 @@
+export { InterpolationSegment, LiteralSegment, Segment, TokenizeOptions, compileInterpolationFromSegments, tokenizeCurlyInterpolation } from '@aerobuilt/interpolation';
+
+/**
+ * Classifier for directive attributes (Alpine.js, HTMX, Vue, etc.) that should
+ * skip { } interpolation in the compiler. Replaces ALPINE_ATTR_REGEX with a
+ * declarative list for clearer semantics and easier extension.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Configurable list of directive attribute prefixes and optional exact names.
+ * Prefixes are checked with attrName.startsWith(prefix); single-char prefixes
+ * like @, :, . match event and binding syntax.
+ */
+interface DirectiveAttrConfig {
+    /** Prefixes that identify directive attributes (e.g. 'x-', '@', 'hx-'). */
+    prefixes?: string[];
+    /** Exact attribute names to treat as directives. */
+    exactNames?: string[];
+}
+/** Default prefixes: Alpine.js (x-*) and shorthand (@, :, .). */
+declare const DEFAULT_DIRECTIVE_PREFIXES: string[];
+/**
+ * Returns true if the attribute name is a directive that should skip
+ * { } interpolation (e.g. Alpine x-model, :disabled, @click).
+ *
+ * @param attrName - HTML attribute name (e.g. 'x-data', ':disabled').
+ * @param config - Optional config; uses default Alpine/shorthand prefixes when omitted.
+ */
+declare function isDirectiveAttr(attrName: string, config?: DirectiveAttrConfig): boolean;
+
+/**
+ * AST-based analysis of Aero build scripts: extract imports and getStaticPaths export.
+ *
+ * @remarks
+ * Uses oxc-parser (TypeScript-capable) so the same pipeline supports JS and TS in
+ * `<script is:build>`. Returns structured data for codegen to rewrite imports and
+ * emit getStaticPaths as a named export.
+ */
+/** Single import entry for codegen: specifier and bindings. */
+interface BuildScriptImport {
+    specifier: string;
+    defaultBinding: string | null;
+    namedBindings: Array<{
+        imported: string;
+        local: string;
+    }>;
+    namespaceBinding: string | null;
+}
+/** Editor-oriented import entry: same bindings as BuildScriptImport plus source range and per-binding ranges. */
+interface BuildScriptImportForEditor extends BuildScriptImport {
+    /** Character range of the full import statement [start, end]. */
+    range: [number, number];
+    /** Character range of the specifier string (path) within the script. */
+    specifierRange: [number, number];
+    /** Per-binding character ranges: local name -> [start, end]. */
+    bindingRanges?: Record<string, [number, number]>;
+}
+/** Result of analyzeBuildScriptForEditor: imports with source ranges for editor use (e.g. definition provider). */
+interface BuildScriptAnalysisForEditorResult {
+    imports: BuildScriptImportForEditor[];
+}
+/**
+ * Analyze build script for editor use: same as analyzeBuildScript but returns imports with
+ * source ranges (full statement and per-binding) so the extension can map to vscode.Range.
+ *
+ * @param script - Raw build script content (JS or TS).
+ * @returns Imports with range and bindingRanges. On parse error, throws.
+ */
+declare function analyzeBuildScriptForEditor(script: string): BuildScriptAnalysisForEditorResult;
+
+export { type BuildScriptAnalysisForEditorResult, type BuildScriptImportForEditor, DEFAULT_DIRECTIVE_PREFIXES, type DirectiveAttrConfig, analyzeBuildScriptForEditor, isDirectiveAttr };

package/dist/entry-editor.js

@@ -0,0 +1,14 @@
+import {
+  DEFAULT_DIRECTIVE_PREFIXES,
+  analyzeBuildScriptForEditor,
+  compileInterpolationFromSegments,
+  isDirectiveAttr,
+  tokenizeCurlyInterpolation
+} from "./chunk-VTEG2UU3.js";
+export {
+  DEFAULT_DIRECTIVE_PREFIXES,
+  analyzeBuildScriptForEditor,
+  compileInterpolationFromSegments,
+  isDirectiveAttr,
+  tokenizeCurlyInterpolation
+};

package/dist/entry-prod.js

@@ -1,7 +1,7 @@
 import {
   Aero
-} from "./chunk-3OZCI7DL.js";
-import "./chunk-7A3WBPH4.js";
+} from "./chunk-5ZNUGZOW.js";
+import "./chunk-JAMYN2VX.js";
 
 // src/entry-prod.ts
 function mount(options = {}) {

package/dist/runtime/index.js

@@ -1,7 +1,7 @@
 import {
   Aero
-} from "../chunk-3OZCI7DL.js";
-import "../chunk-7A3WBPH4.js";
+} from "../chunk-5ZNUGZOW.js";
+import "../chunk-JAMYN2VX.js";
 export {
   Aero
 };

package/dist/runtime/instance.js

@@ -1,9 +1,9 @@
 import {
   aero,
   onUpdate
-} from "../chunk-5GK7XRII.js";
-import "../chunk-3OZCI7DL.js";
-import "../chunk-7A3WBPH4.js";
+} from "../chunk-4DAK56WB.js";
+import "../chunk-5ZNUGZOW.js";
+import "../chunk-JAMYN2VX.js";
 export {
   aero,
   onUpdate

package/dist/vite/index.js

@@ -1,9 +1,17 @@
 import {
+  analyzeBuildScript,
+  compileInterpolationFromSegments,
+  isDirectiveAttr,
+  tokenizeCurlyInterpolation
+} from "../chunk-VTEG2UU3.js";
+import {
+  expandRoutePattern,
+  isDynamicRoutePattern,
   pagePathToKey,
   resolvePageName,
   toPosix,
   toPosixRelative
-} from "../chunk-7A3WBPH4.js";
+} from "../chunk-JAMYN2VX.js";
 import {
   redirectsToRouteRules
 } from "../chunk-F7MXQXLM.js";
@@ -95,176 +103,6 @@ function resolveDirs(dirs) {
 
 // src/compiler/parser.ts
 import { parseHTML } from "linkedom";
-function getCommentRanges(html) {
-  const ranges = [];
-  const commentRegex = /<!--[\s\S]*?-->/g;
-  let match;
-  while ((match = commentRegex.exec(html)) !== null) {
-    ranges.push([match.index, match.index + match[0].length]);
-  }
-  return ranges;
-}
-function isInsideComment(pos, commentRanges) {
-  return commentRanges.some(([start, end]) => pos >= start && pos < end);
-}
-function isInsideForeignNamespace(html, pos) {
-  const before = html.slice(0, pos);
-  const svgOpens = (before.match(/<svg[\s>]/gi) || []).length;
-  const svgCloses = (before.match(/<\/svg\s*>/gi) || []).length;
-  if (svgOpens > svgCloses) return true;
-  const mathOpens = (before.match(/<math[\s>]/gi) || []).length;
-  const mathCloses = (before.match(/<\/math\s*>/gi) || []).length;
-  return mathOpens > mathCloses;
-}
-function parse(html) {
-  html = html.replace(/^\uFEFF/, "");
-  const commentRanges = getCommentRanges(html);
-  let buildContent = [];
-  let clientScripts = [];
-  let inlineScripts = [];
-  let blockingScripts = [];
-  const SCRIPT_REGEX = /<script\b([^>]*)>([\s\S]*?)<\/script>/gi;
-  const edits = [];
-  const scriptsToRemove = [];
-  const isInHead = (html2, scriptStart) => {
-    const beforeScript = html2.slice(0, scriptStart);
-    let headOpen = -1;
-    const headOpenRe = /<head(?=[\s>])/gi;
-    let m;
-    while ((m = headOpenRe.exec(beforeScript)) !== null) headOpen = m.index;
-    const headClose = beforeScript.lastIndexOf("</head>");
-    return headOpen > headClose;
-  };
-  let match = SCRIPT_REGEX.exec(html);
-  while (match !== null) {
-    const start = match.index;
-    const end = match.index + match[0].length;
-    const fullTag = match[0];
-    const attrsMatch = match[1] || "";
-    const content = match[2] || "";
-    if (isInsideComment(start, commentRanges)) {
-      match = SCRIPT_REGEX.exec(html);
-      continue;
-    }
-    if (isInsideForeignNamespace(html, start)) {
-      match = SCRIPT_REGEX.exec(html);
-      continue;
-    }
-    const { document } = parseHTML(fullTag);
-    const scriptEl = document.querySelector("script");
-    if (scriptEl) {
-      const passData = scriptEl.getAttribute("pass:data") || void 0;
-      let cleanedAttrs = attrsMatch.replace(/\bis:build\b/g, "").replace(/\bis:inline\b/g, "").replace(/\bis:blocking\b/g, "");
-      const inHead = isInHead(html, start);
-      if (!scriptEl.hasAttribute("is:inline") && !inHead) {
-        cleanedAttrs = cleanedAttrs.replace(/pass:data="[^"]*"/g, "").replace(/pass:data='[^']*'/g, "").replace(/pass:data=\{[^}]*\}/g, "");
-      }
-      cleanedAttrs = cleanedAttrs.replace(/\s+/g, " ").trim();
-      const openingTag = fullTag.slice(0, fullTag.indexOf(">") + 1);
-      const isPlainDefault = /^<script\s*>$/i.test(openingTag);
-      if (isPlainDefault) {
-        scriptsToRemove.push({
-          start,
-          end,
-          type: "client",
-          content: content.trim(),
-          attrs: cleanedAttrs,
-          passDataExpr: passData,
-          injectInHead: inHead
-        });
-        edits.push({ start, end });
-      } else if (scriptEl.hasAttribute("is:build")) {
-        scriptsToRemove.push({
-          start,
-          end,
-          type: "build",
-          content: content.trim(),
-          attrs: cleanedAttrs
-        });
-        edits.push({ start, end });
-      } else if (scriptEl.hasAttribute("is:inline")) {
-        inlineScripts.push({
-          attrs: cleanedAttrs,
-          content: content.trim(),
-          passDataExpr: passData
-        });
-        edits.push({
-          start,
-          end,
-          newContent: `<script${cleanedAttrs ? " " + cleanedAttrs : ""}>${content.trim()}</script>`
-        });
-      } else if (scriptEl.hasAttribute("is:blocking")) {
-        scriptsToRemove.push({
-          start,
-          end,
-          type: "blocking",
-          content: content.trim(),
-          attrs: cleanedAttrs,
-          passDataExpr: passData
-        });
-        edits.push({ start, end });
-      } else if (scriptEl.hasAttribute("src")) {
-        const src = scriptEl.getAttribute("src") || "";
-        const isLocalScript = !src.startsWith("http://") && !src.startsWith("https://");
-        const hasType = cleanedAttrs.includes("type=");
-        if (isLocalScript && !hasType) {
-          const attrsForModule = cleanedAttrs.replace(/\bdefer\s*=\s*["'][^"']*["']/gi, "").replace(/\bdefer\b/gi, "").replace(/\bsrc\s*=\s*["'][^"']*["']/gi, "").replace(/\s+/g, " ").trim();
-          const newAttrs = attrsForModule ? attrsForModule + ' type="module"' : 'type="module"';
-          edits.push({
-            start,
-            end,
-            newContent: `<script ${newAttrs} src="${src}"></script>`
-          });
-        }
-      } else if (!scriptEl.hasAttribute("is:inline") && inHead) {
-      } else {
-        scriptsToRemove.push({
-          start,
-          end,
-          type: "client",
-          content: content.trim(),
-          attrs: cleanedAttrs,
-          passDataExpr: passData
-        });
-        edits.push({ start, end });
-      }
-    }
-    match = SCRIPT_REGEX.exec(html);
-  }
-  edits.sort((a, b) => a.start - b.start);
-  let template = "";
-  let last = 0;
-  for (const e of edits) {
-    template += html.slice(last, e.start);
-    if (e.newContent !== void 0) template += e.newContent;
-    last = e.end;
-  }
-  template += html.slice(last);
-  for (const s of scriptsToRemove) {
-    if (s.type === "build") buildContent.push(s.content);
-    if (s.type === "client")
-      clientScripts.push({
-        attrs: s.attrs,
-        content: s.content,
-        passDataExpr: s.passDataExpr,
-        injectInHead: s.injectInHead
-      });
-    if (s.type === "blocking")
-      blockingScripts.push({
-        attrs: s.attrs,
-        content: s.content,
-        passDataExpr: s.passDataExpr
-      });
-  }
-  const buildScript = buildContent.length > 0 ? { content: buildContent.join("\n") } : null;
-  return {
-    buildScript,
-    clientScripts,
-    inlineScripts,
-    blockingScripts,
-    template: template.trim()
-  };
-}
 
 // src/compiler/constants.ts
 var ATTR_PREFIX = "data-";
@@ -275,17 +113,17 @@ var ATTR_ELSE_IF = "else-if";
 var ATTR_ELSE = "else";
 var ATTR_NAME = "name";
 var ATTR_SLOT = "slot";
+var ATTR_IS_BUILD = "is:build";
 var ATTR_IS_INLINE = "is:inline";
+var ATTR_IS_BLOCKING = "is:blocking";
 var ATTR_PASS_DATA = "pass:data";
+var ATTR_SRC = "src";
 var TAG_SLOT = "slot";
 var SLOT_NAME_DEFAULT = "default";
 var EACH_REGEX = /^(\w+)\s+in\s+(.+)$/;
-var CURLY_INTERPOLATION_REGEX = /{([\s\S]+?)}/g;
 var COMPONENT_SUFFIX_REGEX = /-(component|layout)$/;
-var IMPORT_REGEX = /((?:^|[\r\n;])\s*)import\s+(?:(\w+)|\{([^}]+)\}|\*\s+as\s+(\w+))\s+from\s+(['"])(.+?)\5/g;
 var SELF_CLOSING_TAG_REGEX = /<([a-z0-9-]+)([^>]*?)\/>/gi;
 var SELF_CLOSING_TAIL_REGEX = /\/>$/;
-var ALPINE_ATTR_REGEX = /^(x-|[@:.]).*/;
 var VOID_TAGS = /* @__PURE__ */ new Set([
   "area",
   "base",
@@ -303,22 +141,157 @@ var VOID_TAGS = /* @__PURE__ */ new Set([
   "wbr"
 ]);
 
+// src/compiler/parser.ts
+function getAttrsString(element, exclude) {
+  const parts = [];
+  const attrs = element.attributes;
+  if (!attrs) return "";
+  const excludeLower = new Set([...exclude].map((s) => s.toLowerCase()));
+  for (let i = 0; i < attrs.length; i++) {
+    const a = attrs[i];
+    if (!a || excludeLower.has(a.name.toLowerCase())) continue;
+    const value = a.value;
+    const escaped = value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    parts.push(`${a.name}="${escaped}"`);
+  }
+  return parts.join(" ").trim();
+}
+function isInForeignNamespace(el) {
+  let parent = el.parentElement;
+  while (parent) {
+    const tag = parent.tagName?.toLowerCase();
+    if (tag === "svg" || tag === "math") return true;
+    parent = parent.parentElement;
+  }
+  return false;
+}
+function isInHead(el) {
+  let parent = el.parentElement;
+  while (parent) {
+    if (parent.tagName?.toLowerCase() === "head") return true;
+    parent = parent.parentElement;
+  }
+  return false;
+}
+function collectScriptElements(doc) {
+  const scripts = [];
+  const walk = (node) => {
+    if (node.nodeType === 1) {
+      const el = node;
+      if (el.tagName?.toLowerCase() === "script") {
+        if (!isInForeignNamespace(el)) scripts.push(el);
+        return;
+      }
+    }
+    for (let i = 0; i < node.childNodes.length; i++) walk(node.childNodes[i]);
+  };
+  walk(doc);
+  return scripts;
+}
+function parse(html) {
+  html = html.replace(/^\uFEFF/, "");
+  html = html.replace(SELF_CLOSING_TAG_REGEX, (match, tagName, attrs) => {
+    const tag = String(tagName).toLowerCase();
+    if (VOID_TAGS.has(tag)) return match;
+    return `<${tagName}${attrs}></${tagName}>`;
+  });
+  const isFullDocument = /<\s*html[\s>]/i.test(html);
+  let doc;
+  if (isFullDocument) {
+    const parsed = parseHTML(html);
+    doc = parsed.document;
+  } else {
+    const parsed = parseHTML(`<html><head></head><body>${html}</body></html>`);
+    doc = parsed.document;
+  }
+  const buildContent = [];
+  const clientScripts = [];
+  const inlineScripts = [];
+  const blockingScripts = [];
+  const scriptElements = collectScriptElements(doc);
+  const toRemove = [];
+  for (const scriptEl of scriptElements) {
+    const inHead = isInHead(scriptEl);
+    const hasBuild = scriptEl.hasAttribute(ATTR_IS_BUILD);
+    const hasInline = scriptEl.hasAttribute(ATTR_IS_INLINE);
+    const hasBlocking = scriptEl.hasAttribute(ATTR_IS_BLOCKING);
+    const src = scriptEl.getAttribute(ATTR_SRC) ?? "";
+    const passData = scriptEl.getAttribute(ATTR_PASS_DATA) ?? void 0;
+    const attrsExcludeTaxonomy = /* @__PURE__ */ new Set([ATTR_IS_BUILD, ATTR_IS_INLINE, ATTR_IS_BLOCKING]);
+    let cleanedAttrs = getAttrsString(scriptEl, attrsExcludeTaxonomy);
+    if (!hasInline && !inHead) {
+      cleanedAttrs = getAttrsString(scriptEl, /* @__PURE__ */ new Set([...attrsExcludeTaxonomy, ATTR_PASS_DATA]));
+    }
+    cleanedAttrs = cleanedAttrs.replace(/\s+/g, " ").trim();
+    const content = (scriptEl.textContent ?? "").trim();
+    if (hasBuild) {
+      buildContent.push(content);
+      toRemove.push(scriptEl);
+      continue;
+    }
+    if (hasInline) {
+      inlineScripts.push({
+        attrs: cleanedAttrs,
+        content,
+        passDataExpr: passData
+      });
+      scriptEl.removeAttribute(ATTR_IS_INLINE);
+      continue;
+    }
+    if (hasBlocking) {
+      blockingScripts.push({
+        attrs: cleanedAttrs,
+        content,
+        passDataExpr: passData
+      });
+      toRemove.push(scriptEl);
+      continue;
+    }
+    if (src) {
+      const isLocal = !src.startsWith("http://") && !src.startsWith("https://");
+      const hasType = scriptEl.hasAttribute("type");
+      if (isLocal && !hasType) {
+        scriptEl.setAttribute("type", "module");
+        scriptEl.removeAttribute("defer");
+      }
+      continue;
+    }
+    if (inHead && scriptEl.attributes.length > 0) continue;
+    clientScripts.push({
+      attrs: cleanedAttrs,
+      content,
+      passDataExpr: passData,
+      injectInHead: inHead
+    });
+    toRemove.push(scriptEl);
+  }
+  for (const el of toRemove) el.remove();
+  const buildScript = buildContent.length > 0 ? { content: buildContent.join("\n") } : null;
+  let template;
+  if (isFullDocument) {
+    template = doc.documentElement ? doc.documentElement.outerHTML : String(doc);
+  } else {
+    template = doc.body ? doc.body.innerHTML : "";
+  }
+  return {
+    buildScript,
+    clientScripts,
+    inlineScripts,
+    blockingScripts,
+    template: template.trim()
+  };
+}
+
 // src/compiler/helpers.ts
 function compileInterpolation(text) {
   if (!text) return "";
-  let compiled = text.replace(/`/g, "\\`");
-  compiled = compiled.replace(/{([\s\S]+?)}/g, "${$1}");
-  return compiled;
+  const segments = tokenizeCurlyInterpolation(text, { attributeMode: false });
+  return compileInterpolationFromSegments(segments);
 }
 function compileAttributeInterpolation(text) {
   if (!text) return "";
-  const openSentinel = "__AERO_ESC_OPEN__";
-  const closeSentinel = "__AERO_ESC_CLOSE__";
-  let compiled = text.replace(/`/g, "\\`");
-  compiled = compiled.replace(/{{/g, openSentinel).replace(/}}/g, closeSentinel);
-  compiled = compiled.replace(/{([\s\S]+?)}/g, "${$1}");
-  compiled = compiled.replace(new RegExp(openSentinel, "g"), "{").replace(new RegExp(closeSentinel, "g"), "}");
-  return compiled;
+  const segments = tokenizeCurlyInterpolation(text, { attributeMode: true });
+  return compileInterpolationFromSegments(segments);
 }
 function isAttr(name, attr, prefix) {
   return name === attr || name === prefix + attr;
@@ -346,55 +319,6 @@ function emitSlotsObjectVars(slotsMap) {
   const entries = Object.entries(slotsMap).map(([k, varName]) => `"${k}": ${varName}`).join(", ");
   return "{ " + entries + " }";
 }
-function extractGetStaticPaths(script) {
-  const regex = /export\s+(async\s+)?function\s+getStaticPaths\s*\([^)]*\)\s*\{/;
-  const match = regex.exec(script);
-  if (!match) return { fnText: null, remaining: script };
-  const start = match.index;
-  const braceStart = start + match[0].length - 1;
-  let depth = 1;
-  let i = braceStart + 1;
-  let inString = null;
-  let inComment = null;
-  while (i < script.length && depth > 0) {
-    const char = script[i];
-    const next = script[i + 1];
-    if (inComment) {
-      if (inComment === "//" && char === "\n") inComment = null;
-      else if (inComment === "/*" && char === "*" && next === "/") {
-        inComment = null;
-        i++;
-      }
-    } else if (inString) {
-      if (char === "\\") {
-        i++;
-      } else if (char === inString) {
-        inString = null;
-      }
-    } else {
-      if (char === "/" && next === "/") {
-        inComment = "//";
-        i++;
-      } else if (char === "/" && next === "*") {
-        inComment = "/*";
-        i++;
-      } else if (char === '"' || char === "'" || char === "`") {
-        inString = char;
-      } else if (char === "{") {
-        depth++;
-      } else if (char === "}") {
-        depth--;
-      }
-    }
-    i++;
-  }
-  if (depth !== 0) {
-    return { fnText: null, remaining: script };
-  }
-  const fnText = script.slice(start, i);
-  const remaining = (script.slice(0, start) + script.slice(i)).trim();
-  return { fnText, remaining };
-}
 function emitRenderFunction(script, body, options = {}) {
   const {
     getStaticPathsFn,
@@ -762,11 +686,9 @@ var Lowerer = class {
         if (attr.name === ATTR_IS_INLINE) {
           continue;
         }
-        let val = escapeBackticks(attr.value);
-        val = this.resolver.resolveAttrValue(val);
-        const isAlpine = ALPINE_ATTR_REGEX.test(attr.name);
-        if (!isAlpine) {
-          val = val.replace(CURLY_INTERPOLATION_REGEX, "${$1}");
+        let val = this.resolver.resolveAttrValue(attr.value ?? "");
+        if (!isDirectiveAttr(attr.name)) {
+          val = compileAttributeInterpolation(val);
         }
         attributes.push(`${attr.name}="${val}"`);
       }
@@ -1018,21 +940,24 @@ function compile(parsed, options) {
   });
   const lowerer = new Lowerer(resolver);
   let script = parsed.buildScript ? parsed.buildScript.content : "";
-  const imports = [];
-  script = script.replace(IMPORT_REGEX, (m, prefix, name, names, starName, q, p) => {
-    const resolved = resolver.resolveImport(p);
-    if (name) {
-      imports.push(`const ${name} = (await import(${q}${resolved}${q})).default`);
-    } else if (names) {
-      imports.push(`const {${names}} = await import(${q}${resolved}${q})`);
-    } else if (starName) {
-      imports.push(`const ${starName} = await import(${q}${resolved}${q})`);
+  const analysis = analyzeBuildScript(script);
+  script = analysis.scriptWithoutImportsAndGetStaticPaths;
+  const getStaticPathsFn = analysis.getStaticPathsFn;
+  const importsLines = [];
+  const quote = '"';
+  for (const imp of analysis.imports) {
+    const resolved = resolver.resolveImport(imp.specifier);
+    const modExpr = `await import(${quote}${resolved}${quote})`;
+    if (imp.defaultBinding) {
+      importsLines.push(`const ${imp.defaultBinding} = (${modExpr}).default`);
+    } else if (imp.namedBindings.length > 0) {
+      const names = imp.namedBindings.map((b) => b.imported === b.local ? b.local : `${b.imported} as ${b.local}`).join(", ");
+      importsLines.push(`const {${names}} = ${modExpr}`);
+    } else if (imp.namespaceBinding) {
+      importsLines.push(`const ${imp.namespaceBinding} = ${modExpr}`);
     }
-    return prefix;
-  });
-  const importsCode = imports.join("\n");
-  const { fnText: getStaticPathsFn, remaining: scriptWithoutPaths } = extractGetStaticPaths(script);
-  script = scriptWithoutPaths;
+  }
+  const importsCode = importsLines.join("\n");
   const expandedTemplate = parsed.template.replace(
     SELF_CLOSING_TAG_REGEX,
     (match, tagName, attrs) => {
@@ -1185,17 +1110,10 @@ function registerClientScriptsToMap(parsed, baseName, target) {
   }
 }
 function isDynamicPage(page) {
-  return /\[.+?\]/.test(page.pageName);
+  return isDynamicRoutePattern(page.pageName);
 }
 function expandPattern(pattern, params) {
-  return pattern.replace(/\[(.+?)\]/g, (_, key) => {
-    if (!(key in params)) {
-      throw new Error(
-        `[aero] getStaticPaths: missing param "${key}" for pattern "${pattern}". Provided params: ${JSON.stringify(params)}`
-      );
-    }
-    return params[key];
-  });
+  return expandRoutePattern(pattern, params);
 }
 function walkHtmlFiles(dir) {
   if (!fs.existsSync(dir)) return [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aerobuilt/core",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "license": "MIT",
   "author": "Jamie Wilson",
@@ -40,6 +40,10 @@
     "./utils/redirects": {
       "types": "./dist/utils/redirects.d.ts",
       "default": "./dist/utils/redirects.js"
+    },
+    "./editor": {
+      "types": "./dist/entry-editor.d.ts",
+      "default": "./dist/entry-editor.js"
     }
   },
   "dependencies": {
@@ -47,13 +51,20 @@
     "html-minifier-next": "^5.1.1",
     "linkedom": "^0.18.12",
     "nitro": "^3.0.1-alpha.2",
+    "oxc-parser": "^0.115.0",
     "sharp": "^0.34.5",
     "svgo": "^4.0.0",
-    "vite-plugin-image-optimizer": "^2.0.3"
+    "vite-plugin-image-optimizer": "^2.0.3",
+    "@aerobuilt/interpolation": "0.2.3"
   },
   "peerDependencies": {
     "vite": "8.0.0-beta.15"
   },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@types/node": "^25.3.0",
     "tsup": "^8.5.1",
@@ -61,7 +72,7 @@
     "vitest": "^4.0.18"
   },
   "scripts": {
-    "build": "tsup src/entry-dev.ts src/entry-prod.ts src/types.ts src/vite/index.ts src/utils/redirects.ts src/runtime/index.ts src/runtime/instance.ts --format esm --dts --clean --out-dir dist --external @content/site",
+    "build": "tsup src/entry-dev.ts src/entry-prod.ts src/entry-editor.ts src/types.ts src/vite/index.ts src/utils/redirects.ts src/runtime/index.ts src/runtime/instance.ts --format esm --dts --clean --out-dir dist --external @content/site",
     "typecheck": "tsc --noEmit",
     "test": "vitest run"
   }