npm - @apex-stack/core - Versions diffs - 0.1.1 → 0.1.3 - Mend

@apex-stack/core 0.1.1 → 0.1.3

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 (5) hide show

package/dist/{chunk-XB5ZYPPE.js → chunk-SGEM3N42.js} +31 -16
package/dist/cli.js +390 -28
package/dist/index.d.ts +3 -0
package/dist/index.js +1 -1
package/package.json +3 -3

package/dist/{chunk-XB5ZYPPE.js → chunk-SGEM3N42.js} RENAMED Viewed

@@ -20,11 +20,18 @@ async function renderPage(opts) {
     body: html,
     island: stateIsland(mod.componentId, loaderData),
     css: mod.css + (opts.componentCss ?? ""),
-    pageId: opts.pageId
+    pageId: opts.pageId,
+    clientHref: opts.clientHref
   });
   return opts.transformHtml ? opts.transformHtml(opts.url, doc) : doc;
 }
-function shell({ body, island, css, pageId }) {
+function shell({ body, island, css, pageId, clientHref }) {
+  const clientScript = clientHref ? `<script type="module" src="${clientHref}"></script>` : `<script type="module">
+  import Alpine from 'alpinejs'
+  import ${JSON.stringify(pageId)}
+  window.Alpine = Alpine
+  Alpine.start()
+</script>`;
   return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -36,12 +43,7 @@ function shell({ body, island, css, pageId }) {
 <body>
 ${body}
 ${island}
-<script type="module">
-  import Alpine from 'alpinejs'
-  import ${JSON.stringify(pageId)}
-  window.Alpine = Alpine
-  Alpine.start()
-</script>
+${clientScript}
 </body>
 </html>`;
 }
@@ -80,6 +82,18 @@ function sanitizeName(name) {
 function entryFor(pattern, method, mcpName, route) {
   return { pattern, segments: toSegments(pattern), method, mcpName, route };
 }
+function expandApiModule(name, def) {
+  if (!def) return [];
+  if (isApexResource(def)) {
+    return def.routes.map(
+      (r) => entryFor(`/api/${def.name}${r.pathSuffix}`, r.route.method, r.mcpName, r.route)
+    );
+  }
+  if (typeof def.handler === "function") {
+    return [entryFor(`/api/${name}`, def.method, sanitizeName(name), def)];
+  }
+  return [];
+}
 async function loadApiRoutes(root, loadModule) {
   const dir = join(root, "server", "api");
   if (!existsSync(dir)) return [];
@@ -87,14 +101,7 @@ async function loadApiRoutes(root, loadModule) {
   for (const file of readdirSync(dir).filter((f) => /\.(ts|js|mjs)$/.test(f))) {
     const name = file.replace(/\.(ts|js|mjs)$/, "");
     const def = (await loadModule(`/server/api/${file}`)).default;
-    if (!def) continue;
-    if (isApexResource(def)) {
-      for (const r of def.routes) {
-        entries.push(entryFor(`/api/${def.name}${r.pathSuffix}`, r.route.method, r.mcpName, r.route));
-      }
-    } else if (typeof def.handler === "function") {
-      entries.push(entryFor(`/api/${name}`, def.method, sanitizeName(name), def));
-    }
+    entries.push(...expandApiModule(name, def));
   }
   return entries;
 }
@@ -408,6 +415,14 @@ function notFoundPage(url, routes) {
 export {
   isApexResource,
+  expandApiModule,
+  createApiHandler,
+  hasMcpRoutes,
+  createMcpHandler,
+  loadComponents,
+  renderIslandsPage,
+  scanPages,
+  matchRoute,
   renderPage,
   startDevServer
 };

package/dist/cli.js CHANGED Viewed

@@ -1,15 +1,248 @@
 import {
+  createApiHandler,
+  createMcpHandler,
+  expandApiModule,
+  hasMcpRoutes,
+  loadComponents,
+  matchRoute,
+  renderIslandsPage,
+  renderPage,
+  scanPages,
   startDevServer
-} from "./chunk-XB5ZYPPE.js";
+} from "./chunk-SGEM3N42.js";
 // src/cli.ts
-import { resolve as resolve3 } from "path";
-import { defineCommand as defineCommand4, runMain } from "citty";
+import { resolve as resolve5 } from "path";
+import { defineCommand as defineCommand6, runMain } from "citty";
-// src/commands/make.ts
-import { existsSync, mkdirSync, writeFileSync } from "fs";
-import { dirname, join, resolve } from "path";
+// src/commands/build.ts
+import { cpSync, existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, rmSync, writeFileSync } from "fs";
+import { dirname, join as join3, resolve } from "path";
+import { apex as apex3 } from "@apex-stack/vite";
 import { defineCommand } from "citty";
+import { createServer as createViteServer } from "vite";
+// src/build/buildClient.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { apex } from "@apex-stack/vite";
+import { build } from "vite";
+var VIRT = "virtual:apex-client:";
+function entryName(pageId) {
+  return pageId.replace(/^\/pages\//, "").replace(/\.alpine$/, "").replace(/[^a-zA-Z0-9]+/g, "_");
+}
+async function buildClient(root, routes, outDir) {
+  const input = {};
+  for (const r of routes) input[entryName(r.pageId)] = `${VIRT}${r.pageId}`;
+  const entryPlugin = {
+    name: "apex:client-entries",
+    resolveId(id) {
+      if (id.startsWith(VIRT)) return `\0${id}`;
+    },
+    load(id) {
+      if (id.startsWith(`\0${VIRT}`)) {
+        const pageId = id.slice(`\0${VIRT}`.length);
+        return [
+          `import Alpine from 'alpinejs'`,
+          `import ${JSON.stringify(pageId)}`,
+          `window.Alpine = Alpine`,
+          `Alpine.start()`
+        ].join("\n");
+      }
+    }
+  };
+  await build({
+    root,
+    logLevel: "warn",
+    plugins: [apex({ clientRuntime: "@apex-stack/core/client" }), entryPlugin],
+    build: {
+      outDir,
+      emptyOutDir: false,
+      manifest: true,
+      rollupOptions: { input }
+    }
+  });
+  const manifest = JSON.parse(readFileSync(join(outDir, ".vite", "manifest.json"), "utf8"));
+  const hrefs = /* @__PURE__ */ new Map();
+  for (const r of routes) {
+    const virt = `${VIRT}${r.pageId}`;
+    const entry = Object.values(manifest).find(
+      (m) => m.isEntry && (m.src === virt || m.src === `\0${virt}`)
+    );
+    if (entry) hrefs.set(r.pageId, `/${entry.file}`);
+  }
+  return hrefs;
+}
+// src/build/buildServer.ts
+import { existsSync, readdirSync } from "fs";
+import { isAbsolute, join as join2 } from "path";
+import { apex as apex2 } from "@apex-stack/vite";
+import { build as build2 } from "vite";
+async function buildServer(root, routes, outDir) {
+  const ids = routes.map((r) => r.pageId);
+  const compDir = join2(root, "components");
+  if (existsSync(compDir)) {
+    for (const f of readdirSync(compDir).filter((f2) => f2.endsWith(".alpine"))) {
+      ids.push(`/components/${f}`);
+    }
+  }
+  const apiDir = join2(root, "server", "api");
+  if (existsSync(apiDir)) {
+    for (const f of readdirSync(apiDir).filter((f2) => /\.(ts|js|mjs)$/.test(f2))) {
+      ids.push(`/server/api/${f}`);
+    }
+  }
+  const input = {};
+  for (const id of ids) input[entryName2(id)] = join2(root, id.slice(1));
+  const result = await build2({
+    root,
+    logLevel: "warn",
+    plugins: [apex2({ clientRuntime: "@apex-stack/core/client" })],
+    build: {
+      ssr: true,
+      target: "esnext",
+      // Node target — allow top-level await in server modules
+      outDir: join2(outDir, "server"),
+      emptyOutDir: false,
+      rollupOptions: {
+        input,
+        // Externalize every package import (bare specifier) — deps are resolved at
+        // runtime from node_modules. Only the app's own relative/absolute files are
+        // bundled. This keeps native/workspace deps (@libsql/client, drizzle, …) out.
+        external: (id) => !id.startsWith(".") && !isAbsolute(id),
+        output: { format: "esm", entryFileNames: "[name].mjs" }
+      }
+    }
+  });
+  const byFacade = /* @__PURE__ */ new Map();
+  for (const chunk of result.output) {
+    if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
+      byFacade.set(chunk.facadeModuleId, chunk.fileName);
+    }
+  }
+  const modules = {};
+  for (const id of ids) {
+    const abs = join2(root, id.slice(1));
+    const file = byFacade.get(abs);
+    if (file) modules[id] = file;
+  }
+  return { modules };
+}
+function entryName2(id) {
+  return id.replace(/^\//, "").replace(/\.(alpine|ts|js|mjs)$/, "").replace(/[^a-zA-Z0-9]+/g, "_");
+}
+// src/commands/build.ts
+function outFile(pattern) {
+  const clean = pattern.replace(/^\//, "");
+  return clean === "" ? "index.html" : `${clean}/index.html`;
+}
+var buildCommand = defineCommand({
+  meta: { name: "build", description: "Prerender pages to deployable HTML + client bundles" },
+  args: {
+    root: { type: "positional", required: false, description: "Project root", default: "." },
+    outDir: { type: "string", description: "Output directory", default: "dist" },
+    islands: { type: "boolean", description: "Static-first islands mode (zero-JS static)", default: false },
+    server: { type: "boolean", description: "Build a Node server (dynamic routes + API/MCP)", default: false }
+  },
+  async run({ args }) {
+    const root = resolve(process.cwd(), args.root);
+    const outDir = resolve(root, args.outDir);
+    rmSync(outDir, { recursive: true, force: true });
+    const routes = scanPages(root);
+    const staticRoutes = routes.filter((r) => !r.isDynamic);
+    const dynamic = routes.filter((r) => r.isDynamic);
+    if (args.server) {
+      return buildServerTarget(root, outDir, args.outDir, routes);
+    }
+    const hrefs = args.islands ? /* @__PURE__ */ new Map() : await buildClient(root, staticRoutes, outDir);
+    const vite = await createViteServer({
+      root,
+      appType: "custom",
+      server: { middlewareMode: true },
+      plugins: [apex3({ clientRuntime: "@apex-stack/core/client" })]
+    });
+    try {
+      const { registry, css: componentCss } = await loadComponents(
+        root,
+        (id) => vite.ssrLoadModule(id)
+      );
+      for (const route of staticRoutes) {
+        const common = {
+          loadModule: (id) => vite.ssrLoadModule(id),
+          pageId: route.pageId,
+          url: route.pattern,
+          registry,
+          componentCss
+        };
+        const html = args.islands ? await renderIslandsPage(common) : await renderPage({ ...common, clientHref: hrefs.get(route.pageId) });
+        const dest = join3(outDir, outFile(route.pattern));
+        mkdirSync(dirname(dest), { recursive: true });
+        writeFileSync(dest, html);
+        console.log(`  \u2713 ${route.pattern}  \u2192  ${outFile(route.pattern)}`);
+      }
+      const pub = join3(root, "public");
+      if (existsSync2(pub)) cpSync(pub, outDir, { recursive: true });
+      console.log(
+        `
+  Built ${staticRoutes.length} page(s) \u2192 ${args.outDir}/` + (args.islands ? " (islands / static-first)" : " (prerendered + hydrated)")
+      );
+      if (dynamic.length) {
+        console.log(
+          `  Skipped ${dynamic.length} dynamic route(s): ${dynamic.map((r) => r.pattern).join(", ")} (server target on the roadmap).`
+        );
+      }
+      console.log();
+    } finally {
+      await vite.close();
+    }
+  }
+});
+async function buildServerTarget(root, outDir, outLabel, routes) {
+  const clientHrefs = await buildClient(root, routes, outDir);
+  const server = await buildServer(root, routes, outDir);
+  const components = {};
+  const compDir = join3(root, "components");
+  if (existsSync2(compDir)) {
+    for (const f of readdirSync2(compDir).filter((f2) => f2.endsWith(".alpine"))) {
+      const sf = server.modules[`/components/${f}`];
+      if (sf) components[f.replace(/\.alpine$/, "")] = sf;
+    }
+  }
+  const api = [];
+  const apiDir = join3(root, "server", "api");
+  if (existsSync2(apiDir)) {
+    for (const f of readdirSync2(apiDir).filter((f2) => /\.(ts|js|mjs)$/.test(f2))) {
+      const sf = server.modules[`/server/api/${f}`];
+      if (sf) api.push({ name: f.replace(/\.(ts|js|mjs)$/, ""), serverFile: sf });
+    }
+  }
+  const manifest = {
+    islands: false,
+    routes: routes.map((r) => ({
+      ...r,
+      serverFile: server.modules[r.pageId],
+      clientHref: clientHrefs.get(r.pageId)
+    })),
+    components,
+    api
+  };
+  writeFileSync(join3(outDir, "apex-manifest.json"), JSON.stringify(manifest, null, 2));
+  const pub = join3(root, "public");
+  if (existsSync2(pub)) cpSync(pub, outDir, { recursive: true });
+  console.log(
+    `
+  Built server target \u2192 ${outLabel}/  (${routes.length} route(s), ${api.length} API module(s))
+  Run it:  apex start
+`
+  );
+}
+// src/commands/make.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join4, resolve as resolve2 } from "path";
+import { defineCommand as defineCommand2 } from "citty";
 function pageTemplate(name) {
   return `<script server lang="ts">
   export function loader() {
@@ -55,14 +288,14 @@ export default defineApexRoute({
 function plan(kind, name, root) {
   switch (kind) {
     case "page":
-      return { path: join(root, "pages", `${name}.alpine`), contents: pageTemplate(name) };
+      return { path: join4(root, "pages", `${name}.alpine`), contents: pageTemplate(name) };
     case "component":
-      return { path: join(root, "components", `${name}.alpine`), contents: componentTemplate() };
+      return { path: join4(root, "components", `${name}.alpine`), contents: componentTemplate() };
     case "api":
-      return { path: join(root, "server", "api", `${name}.ts`), contents: apiTemplate(name) };
+      return { path: join4(root, "server", "api", `${name}.ts`), contents: apiTemplate(name) };
   }
 }
-var makeCommand = defineCommand({
+var makeCommand = defineCommand2({
   meta: { name: "make", description: "Generate a page, component, or API route" },
   args: {
     kind: { type: "positional", required: true, description: "page | component | api" },
@@ -77,16 +310,16 @@ var makeCommand = defineCommand({
 `);
       process.exit(1);
     }
-    const root = resolve(process.cwd(), args.root);
+    const root = resolve2(process.cwd(), args.root);
     const { path, contents } = plan(kind, args.name, root);
-    if (existsSync(path)) {
+    if (existsSync3(path)) {
       console.error(`
   \u2717 Already exists: ${path}
 `);
       process.exit(1);
     }
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, contents);
+    mkdirSync2(dirname2(path), { recursive: true });
+    writeFileSync2(path, contents);
     console.log(`
   \u2713 Created ${path.replace(`${root}/`, "")}
 `);
@@ -94,8 +327,8 @@ var makeCommand = defineCommand({
 });
 // src/commands/mcp.ts
-import { defineCommand as defineCommand2 } from "citty";
-var mcpCommand = defineCommand2({
+import { defineCommand as defineCommand3 } from "citty";
+var mcpCommand = defineCommand3({
   meta: { name: "mcp", description: "Inspect the local MCP server (list or call tools)" },
   args: {
     url: { type: "string", description: "MCP endpoint URL", default: "http://localhost:3000/mcp" },
@@ -149,28 +382,32 @@ var mcpCommand = defineCommand2({
 // src/commands/migrate.ts
 import { createRequire } from "module";
-import { join as join2, resolve as resolve2 } from "path";
+import { join as join5, resolve as resolve3 } from "path";
 import { pathToFileURL } from "url";
-import { defineCommand as defineCommand3 } from "citty";
-var migrateCommand = defineCommand3({
+import { defineCommand as defineCommand4 } from "citty";
+var migrateCommand = defineCommand4({
   meta: { name: "migrate", description: "Apply pending SQL migrations (db/migrations/*.sql)" },
   args: {
-    db: { type: "string", description: "SQLite file path", default: "data.db" },
+    db: { type: "string", description: "SQLite file path (libSQL)", default: "data.db" },
+    driver: { type: "string", description: "sqlite | postgres | pglite", default: "sqlite" },
+    url: { type: "string", description: "Connection URL (postgres) \u2014 overrides --db" },
     dir: { type: "string", description: "Migrations directory", default: "db/migrations" },
     root: { type: "string", description: "Project root", default: "." }
   },
   async run({ args }) {
-    const root = resolve2(process.cwd(), args.root);
+    const root = resolve3(process.cwd(), args.root);
     let data;
     try {
-      const require2 = createRequire(join2(root, "package.json"));
+      const require2 = createRequire(join5(root, "package.json"));
       data = await import(pathToFileURL(require2.resolve("@apex-stack/data")).href);
     } catch {
       console.error("\n  @apex-stack/data is not installed in this project. Run: npm i @apex-stack/data\n");
       process.exit(1);
     }
-    const { sqlite } = data.createDb(resolve2(root, args.db));
-    const applied = data.applyMigrations(sqlite, resolve2(root, args.dir));
+    const config = args.driver === "postgres" ? { driver: "postgres", url: args.url } : args.driver === "pglite" ? { driver: "pglite", dir: args.url } : resolve3(root, args.db);
+    const handle = await data.createDb(config);
+    const applied = await data.applyMigrations(handle, resolve3(root, args.dir));
+    await handle.close();
     console.log(
       applied.length ? `
   \u2713 Applied ${applied.length} migration(s): ${applied.join(", ")}
@@ -179,8 +416,126 @@ var migrateCommand = defineCommand3({
   }
 });
+// src/commands/start.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join7, resolve as resolve4 } from "path";
+import { defineCommand as defineCommand5 } from "citty";
+// src/prod/server.ts
+import { createServer as createHttpServer } from "http";
+import { existsSync as existsSync4, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join6 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import {
+  createApp,
+  defineEventHandler,
+  getRequestURL,
+  setResponseHeader,
+  setResponseStatus,
+  toNodeListener
+} from "h3";
+var MIME = {
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".css": "text/css",
+  ".html": "text/html",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2"
+};
+async function startProdServer(options) {
+  const dir = options.dir;
+  const port = options.port ?? 3e3;
+  const manifest = JSON.parse(readFileSync2(join6(dir, "apex-manifest.json"), "utf8"));
+  const importServer = (relFile) => import(pathToFileURL2(join6(dir, "server", relFile)).href);
+  const registry = {};
+  let componentCss = "";
+  for (const [name, file] of Object.entries(manifest.components)) {
+    const mod = await importServer(file);
+    registry[name] = { template: mod.template, rootXData: mod.rootXData, scopeId: mod.scopeId };
+    if (mod.css) componentCss += `${mod.css}
+`;
+  }
+  const apiEntries = [];
+  for (const { name, serverFile } of manifest.api) {
+    const mod = await importServer(serverFile);
+    apiEntries.push(...expandApiModule(name, mod.default));
+  }
+  const serverFileFor = new Map(manifest.routes.map((r) => [r.pageId, r.serverFile]));
+  const loadModule = (id) => importServer(serverFileFor.get(id));
+  const app = createApp();
+  app.use(
+    defineEventHandler((event) => {
+      if (event.method !== "GET") return;
+      const path = decodeURIComponent(getRequestURL(event).pathname);
+      if (path === "/" || path.startsWith("/api") || path === "/mcp") return;
+      const file = join6(dir, path);
+      if (!file.startsWith(dir) || !existsSync4(file) || !statSync(file).isFile()) return;
+      const ext = path.slice(path.lastIndexOf("."));
+      setResponseHeader(event, "Content-Type", MIME[ext] ?? "application/octet-stream");
+      if (path.startsWith("/assets/")) setResponseHeader(event, "Cache-Control", "public, max-age=31536000, immutable");
+      return readFileSync2(file);
+    })
+  );
+  if (apiEntries.length) app.use("/api", createApiHandler(apiEntries));
+  if (hasMcpRoutes(apiEntries)) app.use("/mcp", createMcpHandler(apiEntries));
+  app.use(
+    defineEventHandler(async (event) => {
+      const url = getRequestURL(event).pathname;
+      const matched = matchRoute(manifest.routes, url);
+      if (!matched) {
+        setResponseStatus(event, 404);
+        setResponseHeader(event, "Content-Type", "text/html");
+        return `<!DOCTYPE html><h1>404 \u2014 ${url}</h1>`;
+      }
+      const route = manifest.routes.find((r) => r.pageId === matched.pageId);
+      const render = manifest.islands ? renderIslandsPage : renderPage;
+      const html = await render({
+        loadModule,
+        pageId: matched.pageId,
+        params: matched.params,
+        url,
+        registry,
+        componentCss,
+        clientHref: route?.clientHref
+      });
+      setResponseHeader(event, "Content-Type", "text/html");
+      return html;
+    })
+  );
+  const server = createHttpServer(toNodeListener(app));
+  await new Promise((resolve6) => server.listen(port, resolve6));
+  return { server, port };
+}
+// src/commands/start.ts
+var startCommand = defineCommand5({
+  meta: { name: "start", description: "Run a production build (from `apex build --server`)" },
+  args: {
+    dir: { type: "positional", required: false, description: "Build directory", default: "dist" },
+    port: { type: "string", description: "Port to listen on", default: "3000" }
+  },
+  async run({ args }) {
+    const dir = resolve4(process.cwd(), args.dir);
+    if (!existsSync5(join7(dir, "apex-manifest.json"))) {
+      console.error(`
+  No build found in ${args.dir}/. Run \`apex build --server\` first.
+`);
+      process.exit(1);
+    }
+    const { port } = await startProdServer({ dir, port: Number(args.port) });
+    console.log(`
+  \x1B[36mApex JS\x1B[0m production server
+  \u2192 http://localhost:${port}
+`);
+  }
+});
 // src/cli.ts
-var dev = defineCommand4({
+var dev = defineCommand6({
   meta: { name: "dev", description: "Start the Apex JS development server" },
   args: {
     root: { type: "positional", required: false, description: "Project root", default: "." },
@@ -188,7 +543,7 @@ var dev = defineCommand4({
     islands: { type: "boolean", description: "Render in islands mode (static-first)", default: false }
   },
   async run({ args }) {
-    const root = resolve3(process.cwd(), args.root);
+    const root = resolve5(process.cwd(), args.root);
     const port = Number(args.port);
     const { port: actual } = await startDevServer({ root, port, islands: args.islands });
     console.log(`
@@ -197,11 +552,18 @@ var dev = defineCommand4({
 `);
   }
 });
-var main = defineCommand4({
+var main = defineCommand6({
   meta: {
     name: "apex",
     description: "The full-stack meta-framework for Alpine.js"
   },
-  subCommands: { dev, make: makeCommand, migrate: migrateCommand, mcp: mcpCommand }
+  subCommands: {
+    dev,
+    build: buildCommand,
+    start: startCommand,
+    make: makeCommand,
+    migrate: migrateCommand,
+    mcp: mcpCommand
+  }
 });
 runMain(main);

package/dist/index.d.ts CHANGED Viewed

@@ -121,6 +121,9 @@ interface RenderPageOptions {
     componentCss?: string;
     /** Post-process the shell HTML (dev: vite.transformIndexHtml). */
     transformHtml?: (url: string, html: string) => string | Promise<string>;
+    /** In a production build, the href of the built client bundle for this page.
+     * When set, the shell references it instead of the inline dev module. */
+    clientHref?: string;
 }
 /**
  * The framework's render seam — deliberately dev-server-agnostic so it can move

package/dist/index.js CHANGED Viewed

@@ -2,7 +2,7 @@ import {
   isApexResource,
   renderPage,
   startDevServer
-} from "./chunk-XB5ZYPPE.js";
+} from "./chunk-SGEM3N42.js";
 // src/api/defineRoute.ts
 function defineApexRoute(config) {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@apex-stack/core",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "The full-stack meta-framework for Alpine.js — CLI and runtime",
   "type": "module",
   "license": "MIT",
@@ -40,8 +40,8 @@
     "h3": "^1.13.0",
     "vite": "^6.0.7",
     "zod": "^4.4.3",
-    "@apex-stack/vite": "0.1.1",
-    "@apex-stack/kit": "0.1.1"
+    "@apex-stack/kit": "0.1.1",
+    "@apex-stack/vite": "0.1.1"
   },
   "peerDependencies": {
     "alpinejs": "^3.14.0"