npm - @aerobuilt/core - Versions diffs - 0.1.0 - Mend

@aerobuilt/core 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (20) hide show

package/README.md +122 -0
package/dist/chunk-3OZCI7DL.js +238 -0
package/dist/chunk-5GK7XRII.js +36 -0
package/dist/chunk-7A3WBPH4.js +97 -0
package/dist/chunk-F7MXQXLM.js +15 -0
package/dist/entry-dev.d.ts +34 -0
package/dist/entry-dev.js +87 -0
package/dist/entry-prod.d.ts +19 -0
package/dist/entry-prod.js +19 -0
package/dist/runtime/index.d.ts +74 -0
package/dist/runtime/index.js +7 -0
package/dist/runtime/instance.d.ts +31 -0
package/dist/runtime/instance.js +10 -0
package/dist/types.d.ts +202 -0
package/dist/types.js +0 -0
package/dist/utils/redirects.d.ts +24 -0
package/dist/utils/redirects.js +6 -0
package/dist/vite/index.d.ts +23 -0
package/dist/vite/index.js +2049 -0
package/package.json +68 -0

package/README.md ADDED Viewed

@@ -0,0 +1,122 @@
+# @aerobuilt/core
+The core package of the Aero static site generator. It provides the compiler, runtime, and Vite plugin that power Aero’s HTML-first template engine, component system, and build pipeline.
+## Overview
+- **Compiler** — Parses Aero HTML templates, extracts script blocks, and compiles templates into async render functions (DOM → IR → JS).
+- **Runtime** — Renders pages and components with context; supports props, slots, globals, and 404 handling.
+- **Vite plugin** — Integrates templates into the Vite build: virtual client modules, HMR, static generation, optional Nitro and image optimization.
+## Exports
+| Export                             | Description                                                          |
+| ---------------------------------- | -------------------------------------------------------------------- |
+| `@aerobuilt/core`                  | Default: shared `aero` instance with `mount()` for the client entry. |
+| `aerobuilt/vite`                   | `aero()` Vite plugin for build and dev.                              |
+| `@aerobuilt/core/runtime`          | `Aero` class for programmatic rendering.                             |
+| `@aerobuilt/core/runtime/instance` | Shared `aero` instance and `onUpdate` for HMR.                       |
+| `@aerobuilt/core/types`            | Shared TypeScript types.                                             |
+## Script taxonomy
+Script blocks are classified by attributes (see [docs/script-taxonomy.md](https://github.com/jamiewilson/aero/blob/main/docs/script-taxonomy.md) in the repo):
+| Script type | Attribute              | When it runs      | Notes                                                                                     |
+| ----------- | ---------------------- | ----------------- | ----------------------------------------------------------------------------------------- |
+| Build       | `<script is:build>`    | Build time (Node) | One per template; compiles into the render module. Access `aero.props`, globals, imports. |
+| Client      | Plain `<script>`       | Browser           | Bundled as a Vite virtual module; HMR. Use `pass:data` to inject build-time data.         |
+| Inline      | `<script is:inline>`   | Browser           | Left in place; not bundled. For critical inline scripts (e.g. theme FOUC prevention).     |
+| Blocking    | `<script is:blocking>` | Browser           | Extracted and emitted in `<head>`.                                                        |
+## Features
+### Template compiler
+- Parses templates and extracts `<script is:build>`, client (plain `<script>`), `<script is:inline>`, and `<script is:blocking>` blocks.
+- Lowers template DOM to an **IR** (intermediate representation), then emits a single async render function with `{ }` interpolation.
+- Supports components, slots, `each`, `if` / `else-if` / `else`, and `pass:data` on scripts and styles.
+**Example**
+```html
+<script is:build>
+	import header from '@components/header'
+	const { title } = aero.props
+</script>
+<header-component title="{ title }" />
+```
+### Runtime
+- **Aero** class: `global()`, `registerPages()`, `render()`, `renderComponent()`.
+- Context includes globals (e.g. from content), props, slots, request, url, params.
+- Resolves pages by name with fallbacks (index, trailing slash, `getStaticPaths`); returns `null` for 404 when no static path matches.
+**Example**
+```js
+import { Aero } from '@aerobuilt/core/runtime'
+const aero = new Aero()
+aero.global('site', { title: 'My Site' })
+// … registerPages, then:
+const html = await aero.render('index', { props: { title: 'Home' } })
+```
+### Vite plugin
+- **Plugin** from `aerobuilt/vite`: `aero(options?)`. Options: `nitro`, `apiPrefix`, `dirs`, `site` (canonical URL; exposed as `import.meta.env.SITE` and `Aero.site`; when set, generates `dist/sitemap.xml` after build).
+- Sub-plugins: config resolution, virtual client modules (`\0`-prefixed), HTML transform, SSR middleware, HMR.
+- Build: page discovery, static render, optional Nitro build, optional image optimizer (sharp/svgo).
+**Example**
+```js
+import { aero } from 'aerobuilt/vite'
+export default {
+	plugins: [aero({ nitro: true })],
+}
+```
+Apps typically use `@aerobuilt/config` and `createViteConfig(aeroConfig)`, which wires the Aero plugin for them.
+### Client entry
+The default export of `@aerobuilt/core` is the shared `aero` instance with `mount(options?)` attached. Use it as the browser entry (e.g. in your main script). It does not perform an initial render; it attaches to a root element and subscribes to HMR re-renders in dev.
+```js
+import aero from 'aerobuilt'
+aero.mount({
+	target: '#app',
+	onRender: el => {
+		/* optional */
+	},
+})
+```
+### Components and layouts
+- Components: use `-component` suffix in markup; import without suffix (e.g. `@components/header` → `header.html`).
+- Layouts: use `-layout` and `<slot>` (with `name` and optional `slot` attribute).
+- Props: attributes or `props` / `props="{ ... }"`. In build script, read via `aero.props`.
+### Path aliases and client stack
+- Path aliases (e.g. `@components/*`, `@layouts/*`, `@content/*`) are resolved from the project tsconfig.
+- Alpine.js and HTMX attributes (e.g. `x-data`, `:disabled`, `hx-post`) are preserved; attributes matching `^(x-|[@:.]).*` are not interpolated.
+## File structure
+```
+src/
+  compiler/     # parser.ts, codegen.ts, ir.ts, emit.ts, resolver.ts, helpers.ts, constants.ts
+  runtime/      # index.ts (Aero), instance.ts, client.ts
+  vite/         # index.ts (plugin), build.ts, defaults.ts
+  utils/        # aliases.ts, routing.ts
+  types.ts
+  index.ts      # client entry (aero + mount)
+```
+## Tests
+Vitest in `packages/core`: `compiler/__tests__/`, `runtime/__tests__/`, `vite/__tests__/`. Run from repo root: `pnpm test`.

package/dist/chunk-3OZCI7DL.js ADDED Viewed

@@ -0,0 +1,238 @@
+import {
+  pagePathToKey,
+  resolvePageTarget
+} from "./chunk-7A3WBPH4.js";
+// src/runtime/index.ts
+var Aero = class {
+  /** Global values merged into template context (e.g. from content modules). */
+  globals = {};
+  /** Map from page name (or path) to module. Keys include both canonical name and full path for lookup. */
+  pagesMap = {};
+  /** Set by client entry when running in the browser; used to attach the app to a DOM root. */
+  mount;
+  /**
+   * Register a global value available in all templates as `name`.
+   *
+   * @param name - Key used in templates (e.g. `site`).
+   * @param value - Any value (object, string, etc.).
+   */
+  global(name, value) {
+    this.globals[name] = value;
+  }
+  /**
+   * Register page/layout modules from a Vite glob (e.g. `import.meta.glob('@pages/**\/*.html')`).
+   * Derives a lookup key from each path via pagePathToKey; also stores by full path for resolution.
+   *
+   * @param pages - Record of resolved path → module (default export is the render function).
+   */
+  registerPages(pages) {
+    for (const [path, mod] of Object.entries(pages)) {
+      const key = pagePathToKey(path);
+      this.pagesMap[key] = mod;
+      this.pagesMap[path] = mod;
+    }
+  }
+  /** Type guard: true if value looks like an `AeroRenderInput` (has at least one of props, slots, request, url, params, routePath). */
+  isRenderInput(value) {
+    if (!value || typeof value !== "object") return false;
+    return ["props", "slots", "request", "url", "params", "routePath"].some(
+      (key) => key in value
+    );
+  }
+  /** Coerce various call signatures into a single `AeroRenderInput` (e.g. plain object → `{ props }`). */
+  normalizeRenderInput(input) {
+    if (!input) return {};
+    if (this.isRenderInput(input)) return input;
+    if (typeof input === "object") return { props: input };
+    return { props: {} };
+  }
+  /** Convert a page name to a route path (e.g. `index` → `'/'`, `about` → `'/about'`). */
+  toRoutePath(pageName = "index") {
+    if (!pageName || pageName === "index" || pageName === "home") return "/";
+    if (pageName.endsWith("/index")) {
+      return "/" + pageName.slice(0, -"/index".length);
+    }
+    return pageName.startsWith("/") ? pageName : "/" + pageName;
+  }
+  /** Build a URL from route path and optional raw URL. Uses `http://localhost` as base when only a path is given. */
+  toURL(routePath, rawUrl) {
+    if (rawUrl instanceof URL) return rawUrl;
+    if (typeof rawUrl === "string" && rawUrl.length > 0) {
+      return new URL(rawUrl, "http://localhost");
+    }
+    return new URL(routePath, "http://localhost");
+  }
+  /** Build template context: globals, props, slots, request, url, params, site, and `renderComponent` / `nextPassDataId`. */
+  createContext(input) {
+    const routePath = input.routePath || "/";
+    const url = this.toURL(routePath, input.url);
+    const request = input.request || new Request(url.toString(), { method: "GET" });
+    let _passDataId = 0;
+    const context = {
+      ...this.globals,
+      props: input.props || {},
+      slots: input.slots || {},
+      request,
+      url,
+      params: input.params || {},
+      site: input.site ?? "",
+      styles: input.styles,
+      scripts: input.scripts,
+      headScripts: input.headScripts,
+      nextPassDataId: () => `__aero_${_passDataId++}`,
+      renderComponent: this.renderComponent.bind(this)
+    };
+    return context;
+  }
+  /** True if entry params and request params have the same keys and stringified values. */
+  paramsMatch(entryParams, requestParams) {
+    const entryKeys = Object.keys(entryParams);
+    if (entryKeys.length !== Object.keys(requestParams).length) return false;
+    for (const key of entryKeys) {
+      if (String(entryParams[key]) !== String(requestParams[key])) return false;
+    }
+    return true;
+  }
+  /**
+   * Render a page or layout to HTML.
+   *
+   * @remarks
+   * Resolves `component` (page name string or module) via `pagesMap`, with fallbacks: directory index
+   * (`foo` → `foo/index`), `index` → `home`, dynamic routes, and trailing-slash stripping. If the module
+   * exports `getStaticPaths` and no props are provided, finds the matching static path and uses its props.
+   * For root-level renders, injects accumulated styles and scripts into the document and fixes content
+   * that ends up after `</html>` when using layouts (moves it into `</body>`).
+   *
+   * @param component - Page name (e.g. `'index'`, `'about'`) or the module object.
+   * @param input - Render input (props, request, url, params, etc.). Can be a plain object (treated as props).
+   * @returns HTML string, or `null` if the page is not found or no static path match.
+   */
+  async render(component, input = {}) {
+    const renderInput = this.normalizeRenderInput(input);
+    const isRootRender = !renderInput.styles;
+    if (isRootRender) {
+      renderInput.styles = /* @__PURE__ */ new Set();
+      renderInput.scripts = /* @__PURE__ */ new Set();
+      renderInput.headScripts = /* @__PURE__ */ new Set();
+    }
+    const resolved = resolvePageTarget(component, this.pagesMap);
+    if (!resolved) return null;
+    let target = resolved.module;
+    const matchedPageName = resolved.pageName;
+    const dynamicParams = resolved.params;
+    if (typeof target === "function" && target.length === 0) {
+      target = await target();
+    }
+    if (typeof target.getStaticPaths === "function" && Object.keys(renderInput.props || {}).length === 0) {
+      const staticPaths = await target.getStaticPaths();
+      const combinedParams = { ...dynamicParams, ...renderInput.params || {} };
+      const match = staticPaths.find((entry) => this.paramsMatch(entry.params, combinedParams));
+      if (!match) {
+        console.warn(
+          `[aero] 404: Route params ${JSON.stringify(combinedParams)} not found in getStaticPaths for ${matchedPageName}`
+        );
+        return null;
+      }
+      if (match.props) {
+        renderInput.props = match.props;
+      }
+    }
+    const routePath = renderInput.routePath || this.toRoutePath(matchedPageName);
+    const context = this.createContext({
+      props: renderInput.props || {},
+      slots: renderInput.slots || {},
+      request: renderInput.request,
+      url: renderInput.url,
+      params: { ...dynamicParams, ...renderInput.params || {} },
+      routePath,
+      site: renderInput.site,
+      styles: renderInput.styles,
+      scripts: renderInput.scripts,
+      headScripts: renderInput.headScripts
+    });
+    let renderFn = target;
+    if (target.default) renderFn = target.default;
+    if (typeof renderFn === "function") {
+      let html = await renderFn(context);
+      if (isRootRender) {
+        if (html.includes("</html>")) {
+          const afterHtml = html.split("</html>")[1]?.trim();
+          if (afterHtml && html.includes("</body>")) {
+            html = html.split("</html>")[0] + "</html>";
+            html = html.replace("</body>", `
+${afterHtml}
+</body>`);
+          }
+        }
+        let headInjections = "";
+        if (context.styles && context.styles.size > 0) {
+          headInjections += Array.from(context.styles).join("\n") + "\n";
+        }
+        if (context.headScripts && context.headScripts.size > 0) {
+          headInjections += Array.from(context.headScripts).join("\n") + "\n";
+        }
+        if (headInjections) {
+          if (html.includes("</head>")) {
+            html = html.replace("</head>", `
+${headInjections}</head>`);
+          } else if (html.includes("<body")) {
+            html = html.replace(/(<body[^>]*>)/i, `<head>
+${headInjections}</head>
+$1`);
+          } else {
+            html = `${headInjections}${html}`;
+          }
+        }
+        if (context.scripts && context.scripts.size > 0) {
+          const scriptsHtml = Array.from(context.scripts).join("\n");
+          if (html.includes("</body>")) {
+            html = html.replace("</body>", `
+${scriptsHtml}
+</body>`);
+          } else {
+            html = `${html}
+${scriptsHtml}`;
+          }
+        }
+      }
+      return html;
+    }
+    return "";
+  }
+  /**
+   * Render a child component (layout or component) with the given props and slots.
+   * Used by compiled templates via context.renderComponent.
+   *
+   * @param component - Render function or module with `default` render function.
+   * @param props - Props object for the component.
+   * @param slots - Named slot content (key → HTML string).
+   * @param input - Optional request/url/params for context; `headScripts` is not passed through.
+   * @returns HTML string from the component's render function, or empty string if not invokable.
+   */
+  async renderComponent(component, props = {}, slots = {}, input = {}) {
+    const context = this.createContext({
+      props,
+      slots,
+      request: input.request,
+      url: input.url,
+      params: input.params,
+      routePath: input.routePath || "/",
+      site: input.site,
+      styles: input.styles,
+      scripts: input.scripts,
+      headScripts: input.headScripts
+    });
+    if (typeof component === "function") {
+      return await component(context);
+    }
+    if (component && typeof component.default === "function") {
+      return await component.default(context);
+    }
+    return "";
+  }
+};
+export {
+  Aero
+};

package/dist/chunk-5GK7XRII.js ADDED Viewed

@@ -0,0 +1,36 @@
+import {
+  Aero
+} from "./chunk-3OZCI7DL.js";
+// src/runtime/instance.ts
+var instance = globalThis.__AERO_INSTANCE__ || new Aero();
+var listeners = globalThis.__AERO_LISTENERS__ || /* @__PURE__ */ new Set();
+var aero = instance;
+var onUpdate = (cb) => {
+  listeners.add(cb);
+  return () => listeners.delete(cb);
+};
+var notify = () => {
+  listeners.forEach((cb) => cb());
+};
+if (!globalThis.__AERO_INSTANCE__) {
+  globalThis.__AERO_INSTANCE__ = instance;
+}
+if (!globalThis.__AERO_LISTENERS__) {
+  globalThis.__AERO_LISTENERS__ = listeners;
+}
+var components = import.meta.glob("@components/**/*.html", { eager: true });
+var layouts = import.meta.glob("@layouts/*.html", { eager: true });
+var pages = import.meta.glob("@pages/**/*.html", { eager: true });
+aero.registerPages(components);
+aero.registerPages(layouts);
+aero.registerPages(pages);
+notify();
+if (import.meta.hot) {
+  import.meta.hot.accept();
+}
+export {
+  aero,
+  onUpdate
+};

package/dist/chunk-7A3WBPH4.js ADDED Viewed

@@ -0,0 +1,97 @@
+// src/utils/path.ts
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+function toPosixRelative(value, root) {
+  const valuePosix = toPosix(value);
+  const rootPosix = toPosix(root);
+  if (valuePosix.startsWith(rootPosix + "/")) {
+    return valuePosix.slice(rootPosix.length + 1);
+  }
+  return valuePosix;
+}
+// src/utils/routing.ts
+function pagePathToKey(path) {
+  const withoutExt = toPosix(path).replace(/\.html$/i, "");
+  if (withoutExt.includes("pages/")) {
+    return withoutExt.split("pages/").pop();
+  }
+  const segments = withoutExt.split("/").filter(Boolean);
+  if (segments.length > 1) {
+    return segments.join("/");
+  }
+  return segments.pop() || path;
+}
+function resolvePageName(url) {
+  const [pathPart] = url.split("?");
+  let clean = pathPart || "/";
+  if (clean === "/" || clean === "") return "index";
+  if (clean.endsWith("/")) {
+    clean = clean + "index";
+  }
+  clean = clean.replace(/^\//, "");
+  clean = clean.replace(/\.html$/, "");
+  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) {
+      return { module: mod, pageName: key, params };
+    }
+  }
+  return null;
+}
+function resolvePageTarget(component, pagesMap) {
+  if (typeof component !== "string") {
+    return component != null ? { module: component, pageName: "index", params: {} } : null;
+  }
+  const pageName = component;
+  let target = pagesMap[pageName];
+  if (!target) {
+    target = pagesMap[`${pageName}/index`];
+  }
+  if (!target && pageName === "index") {
+    target = pagesMap["home"];
+  }
+  if (!target) {
+    const dynamicMatch = resolveDynamicPage(pageName, pagesMap) ?? resolveDynamicPage(`${pageName}/index`, pagesMap);
+    if (dynamicMatch) return dynamicMatch;
+  }
+  if (!target && pageName.endsWith("/index")) {
+    const stripped = pageName.slice(0, -"/index".length);
+    target = pagesMap[stripped];
+    if (target) return { module: target, pageName: stripped, params: {} };
+    const dynamicMatch = resolveDynamicPage(stripped, pagesMap);
+    if (dynamicMatch) return dynamicMatch;
+  }
+  if (!target) return null;
+  return { module: target, pageName, params: {} };
+}
+export {
+  toPosix,
+  toPosixRelative,
+  pagePathToKey,
+  resolvePageName,
+  resolvePageTarget
+};

package/dist/chunk-F7MXQXLM.js ADDED Viewed

@@ -0,0 +1,15 @@
+// src/utils/redirects.ts
+function redirectsToRouteRules(redirects) {
+  const out = {};
+  for (const rule of redirects) {
+    const status = rule.status ?? 302;
+    out[rule.from] = {
+      redirect: status === 307 ? rule.to : { to: rule.to, statusCode: status }
+    };
+  }
+  return out;
+}
+export {
+  redirectsToRouteRules
+};

package/dist/entry-dev.d.ts ADDED Viewed

@@ -0,0 +1,34 @@
+import { MountOptions } from './types.js';
+import { Aero } from './runtime/index.js';
+import 'vite';
+/**
+ * Client entry for the Aero framework.
+ *
+ * @remarks
+ * Re-exports the shared `aero` instance with a `mount()` method attached.
+ * Used as the app's client entry point (e.g. in the main script that runs in the browser).
+ * Assumes HTML was server-rendered or pre-rendered; `mount()` does not perform an initial
+ * render, only sets up the root element and (in dev) HMR re-renders.
+ */
+/**
+ * Attach the app to a DOM element and optionally set up HMR re-renders.
+ *
+ * @remarks
+ * Does not perform an initial render: we assume the document already has SSR/pre-rendered
+ * HTML. Only runs `onRender` if provided, then in dev (Vite HMR) subscribes to template
+ * updates and re-renders into the same target.
+ *
+ * @param options - Mount options. Defaults to `{ target: '#app' }`.
+ * @param options.target - CSS selector (e.g. `#app`) or the root `HTMLElement`. Defaults to `#app`.
+ * @param options.onRender - Called with the root element after mount and after each HMR re-render.
+ * @returns A promise that resolves immediately. Does not wait for any async render (no initial render).
+ * @throws When `target` is a string and no matching element is found in the document.
+ */
+declare function mount(options?: MountOptions): Promise<void>;
+declare const _default: Aero & {
+    mount: typeof mount;
+};
+export { _default as default };

package/dist/entry-dev.js ADDED Viewed

@@ -0,0 +1,87 @@
+import {
+  aero,
+  onUpdate
+} from "./chunk-5GK7XRII.js";
+import "./chunk-3OZCI7DL.js";
+import {
+  resolvePageName
+} from "./chunk-7A3WBPH4.js";
+// src/runtime/client.ts
+function extractDocumentParts(html) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(html, "text/html");
+  const head = doc.head?.innerHTML?.trim() || "";
+  const body = doc.body?.innerHTML ?? html;
+  return { head, body };
+}
+var PERSISTENT_SELECTORS = [
+  'script[src*="/@vite/client"]',
+  "[data-vite-dev-id]"
+].join(", ");
+function updateHead(headContent) {
+  const headEl = document.head;
+  const queriedNodes = headEl.querySelectorAll(PERSISTENT_SELECTORS);
+  const persistentSet = new Set(Array.from(queriedNodes));
+  for (const node of Array.from(headEl.children)) {
+    if (persistentSet.has(node)) continue;
+    headEl.removeChild(node);
+  }
+  const parser = new DOMParser();
+  const frag = parser.parseFromString(`<head>${headContent}</head>`, "text/html");
+  const nodes = Array.from(frag.head?.childNodes || []);
+  for (const node of nodes) {
+    if (node.nodeType === Node.ELEMENT_NODE) {
+      const el = node;
+      if (el.matches(PERSISTENT_SELECTORS)) {
+        const devId = el.getAttribute("data-vite-dev-id");
+        if (devId && headEl.querySelector(`[data-vite-dev-id="${devId}"]`)) continue;
+        if (el instanceof HTMLScriptElement && el.src && headEl.querySelector(`script[src="${el.src}"]`)) {
+          continue;
+        }
+      }
+    }
+    headEl.appendChild(document.importNode(node, true));
+  }
+}
+async function renderPage(appEl, renderFn) {
+  const pageName = resolvePageName(window.location.pathname);
+  try {
+    const html = await renderFn(pageName);
+    const { head, body } = extractDocumentParts(html);
+    if (head) updateHead(head);
+    appEl.innerHTML = body;
+    console.log(`[aero] Rendered: ${pageName}`);
+  } catch (err) {
+    appEl.innerHTML = `<h1>Error rendering page: ${pageName}</h1><pre>${String(err)}</pre>`;
+    console.error("[aero] Render Error:", err);
+  }
+}
+// src/entry-dev.ts
+var coreRender = aero.render.bind(aero);
+var hmrState = { lastEl: null, unsubscribe: null };
+function mount(options = {}) {
+  const { target = "#app", onRender } = options;
+  const el = typeof target === "string" ? document.querySelector(target) : target;
+  if (!el) throw new Error("Target element not found: " + target);
+  hmrState.lastEl = el;
+  if (onRender) onRender(el);
+  const done = Promise.resolve();
+  if (import.meta.hot && !hmrState.unsubscribe) {
+    hmrState.unsubscribe = onUpdate(() => {
+      const el2 = hmrState.lastEl;
+      if (el2) {
+        void renderPage(el2, coreRender).then(() => {
+          if (onRender) onRender(el2);
+        });
+      }
+    });
+  }
+  return done;
+}
+aero.mount = mount;
+var entry_dev_default = aero;
+export {
+  entry_dev_default as default
+};

package/dist/entry-prod.d.ts ADDED Viewed

@@ -0,0 +1,19 @@
+import { MountOptions } from './types.js';
+import { Aero } from './runtime/index.js';
+import 'vite';
+/**
+ * Minimal client entry for static production builds.
+ *
+ * @remarks
+ * Does not import the runtime instance (no import.meta.glob of components/layouts/pages),
+ * so the production client bundle stays small: no template chunks, only mount + onRender.
+ * Use this when building for production; dev uses the full entry (entry-dev.ts) for HMR.
+ */
+declare function mount(options?: MountOptions): Promise<void>;
+declare const _default: Aero & {
+    mount: typeof mount;
+};
+export { _default as default };

package/dist/entry-prod.js ADDED Viewed

@@ -0,0 +1,19 @@
+import {
+  Aero
+} from "./chunk-3OZCI7DL.js";
+import "./chunk-7A3WBPH4.js";
+// src/entry-prod.ts
+function mount(options = {}) {
+  const { target = "#app", onRender } = options;
+  const el = typeof target === "string" ? document.querySelector(target) : target;
+  if (!el) throw new Error("Target element not found: " + target);
+  if (onRender) onRender(el);
+  return Promise.resolve();
+}
+var aero = new Aero();
+aero.mount = mount;
+var entry_prod_default = aero;
+export {
+  entry_prod_default as default
+};