@apex-stack/core 0.1.9 → 0.1.11

package/dist/build-QRHQUUZC.js

@@ -0,0 +1,235 @@
+import {
+  loadComponents
+} from "./chunk-4VG3CZ6H.js";
+import {
+  renderIslandsPage,
+  renderPage,
+  scanPages
+} from "./chunk-PAMD24NK.js";
+
+// 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
+`
+  );
+}
+export {
+  buildCommand
+};

package/dist/chunk-2L2T47AH.js

@@ -0,0 +1,93 @@
+// src/ui.ts
+var TTY = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR && process.env.TERM !== "dumb";
+var RESET = "\x1B[0m";
+function truecolor(r, g, b, s) {
+  return TTY ? `\x1B[38;2;${r};${g};${b}m${s}${RESET}` : s;
+}
+function style(code, s) {
+  return TTY ? `\x1B[${code}m${s}${RESET}` : s;
+}
+var color = {
+  cyan: (s) => truecolor(34, 211, 238, s),
+  indigo: (s) => truecolor(129, 140, 248, s),
+  green: (s) => truecolor(52, 211, 153, s),
+  red: (s) => truecolor(248, 113, 113, s),
+  gray: (s) => truecolor(154, 166, 196, s),
+  bold: (s) => style("1", s),
+  dim: (s) => style("2", s)
+};
+var LOGO = [
+  " \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u255A\u2588\u2588\u2557\u2588\u2588\u2554\u255D",
+  "\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2557   \u255A\u2588\u2588\u2588\u2554\u255D ",
+  "\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u255D   \u2588\u2588\u2554\u2588\u2588\u2557 ",
+  "\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2554\u255D \u2588\u2588\u2557",
+  "\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D     \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D"
+];
+var FROM = [99, 102, 241];
+var TO = [34, 211, 238];
+function banner(subtitle = "The full-stack, AI-native meta-framework for Alpine.js") {
+  const width = LOGO[0].length;
+  const rows = LOGO.map((line) => {
+    if (!TTY) return `  ${line}`;
+    let out = "  ";
+    for (let i = 0; i < line.length; i++) {
+      const t = width > 1 ? i / (width - 1) : 0;
+      const r = Math.round(FROM[0] + (TO[0] - FROM[0]) * t);
+      const g = Math.round(FROM[1] + (TO[1] - FROM[1]) * t);
+      const b = Math.round(FROM[2] + (TO[2] - FROM[2]) * t);
+      out += `\x1B[38;2;${r};${g};${b}m${line[i]}`;
+    }
+    return out + RESET;
+  });
+  return `
+${rows.join("\n")}
+  ${color.gray(subtitle)}
+`;
+}
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function spinner(text) {
+  if (!TTY) {
+    process.stdout.write(`  ${text}
+`);
+    return {
+      succeed: (t) => console.log(`  ${color.green("\u2713")} ${t || text}`),
+      fail: (t) => console.log(`  ${color.red("\u2717")} ${t || text}`),
+      stop: () => {
+      }
+    };
+  }
+  let i = 0;
+  process.stdout.write("\x1B[?25l");
+  const id = setInterval(() => {
+    process.stdout.write(`\r\x1B[2K  ${color.cyan(FRAMES[i++ % FRAMES.length])} ${text}`);
+  }, 80);
+  const end = (symbol, t) => {
+    clearInterval(id);
+    process.stdout.write(`\r\x1B[2K  ${symbol} ${t || text}
+\x1B[?25h`);
+  };
+  return {
+    succeed: (t) => end(color.green("\u2713"), t),
+    fail: (t) => end(color.red("\u2717"), t),
+    stop: () => {
+      clearInterval(id);
+      process.stdout.write("\r\x1B[2K\x1B[?25h");
+    }
+  };
+}
+function ready(rows) {
+  const w = Math.max(...rows.map(([l]) => l.length));
+  console.log();
+  for (const [label, value] of rows) {
+    console.log(`  ${color.cyan("\u279C")}  ${color.bold(label.padEnd(w))}   ${color.cyan(value)}`);
+  }
+  console.log();
+}
+
+export {
+  color,
+  banner,
+  spinner,
+  ready
+};

package/dist/chunk-4VG3CZ6H.js

@@ -0,0 +1,21 @@
+// src/components/registry.ts
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+async function loadComponents(root, loadModule) {
+  const dir = join(root, "components");
+  if (!existsSync(dir)) return { registry: {}, css: "" };
+  const registry = {};
+  let css = "";
+  for (const file of readdirSync(dir).filter((f) => f.endsWith(".alpine"))) {
+    const name = file.replace(/\.alpine$/, "");
+    const mod = await loadModule(`/components/${file}`);
+    registry[name] = { template: mod.template, rootXData: mod.rootXData, scopeId: mod.scopeId };
+    if (mod.css) css += `${mod.css}
+`;
+  }
+  return { registry, css };
+}
+
+export {
+  loadComponents
+};

package/dist/chunk-DSUIB3JH.js

@@ -0,0 +1,144 @@
+// src/api/resource.ts
+function isApexResource(x) {
+  return typeof x === "object" && x !== null && x.__apexResource === true;
+}
+
+// src/api/routes.ts
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+import {
+  defineEventHandler,
+  getQuery,
+  getRequestURL,
+  readBody,
+  setResponseHeader,
+  setResponseStatus
+} from "h3";
+import { z } from "zod";
+function toSegments(pattern) {
+  return pattern.split("/").filter(Boolean).map((p) => p.startsWith(":") ? { param: p.slice(1) } : { literal: p });
+}
+function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64);
+}
+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 [];
+  const entries = [];
+  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;
+    entries.push(...expandApiModule(name, def));
+  }
+  return entries;
+}
+function matchApi(entries, path, method) {
+  const segs = (path.split("?")[0] ?? "/").split("/").filter(Boolean);
+  for (const entry of entries) {
+    if (entry.method !== method) continue;
+    if (entry.segments.length !== segs.length) continue;
+    const params = {};
+    let ok = true;
+    for (let i = 0; i < entry.segments.length; i++) {
+      const s = entry.segments[i];
+      const v = segs[i];
+      if (s.param) params[s.param] = decodeURIComponent(v);
+      else if (s.literal !== v) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) return { entry, params };
+  }
+  return null;
+}
+function createApiHandler(entries) {
+  return defineEventHandler(async (event) => {
+    const url = getRequestURL(event);
+    const matched = matchApi(entries, url.pathname, event.method);
+    if (!matched) {
+      setResponseStatus(event, 404);
+      return { error: `No API route for ${event.method} ${url.pathname}` };
+    }
+    const { entry, params } = matched;
+    const raw = {
+      ...entry.method === "GET" ? getQuery(event) : await readBody(event) ?? {},
+      ...params
+    };
+    let input = raw;
+    if (entry.route.inputShape) {
+      const parsed = z.object(entry.route.inputShape).safeParse(raw);
+      if (!parsed.success) {
+        setResponseStatus(event, 400);
+        return { error: "Invalid input", issues: parsed.error.issues };
+      }
+      input = parsed.data;
+    }
+    const result = await entry.route.handler({ input, url: url.toString() });
+    setResponseHeader(event, "Content-Type", "application/json");
+    return result;
+  });
+}
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { defineEventHandler as defineEventHandler2, toWebRequest } from "h3";
+function hasMcpRoutes(entries) {
+  return entries.some((e) => e.route.mcp);
+}
+function buildServer(entries) {
+  const server = new McpServer({ name: "apexjs", version: "0.0.0" });
+  for (const entry of entries) {
+    server.registerTool(
+      entry.mcpName,
+      {
+        description: entry.route.description ?? `Apex route ${entry.mcpName}`,
+        inputSchema: entry.route.inputShape ?? {}
+      },
+      async (args) => {
+        const result = await entry.route.handler({ input: args ?? {}, url: `mcp://${entry.mcpName}` });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      }
+    );
+  }
+  return server;
+}
+function createMcpHandler(entries) {
+  const mcpEntries = entries.filter((e) => e.route.mcp);
+  return defineEventHandler2(async (event) => {
+    const server = buildServer(mcpEntries);
+    const transport = new WebStandardStreamableHTTPServerTransport({
+      sessionIdGenerator: void 0,
+      enableJsonResponse: true
+    });
+    await server.connect(transport);
+    const response = await transport.handleRequest(toWebRequest(event));
+    void server.close();
+    return response;
+  });
+}
+
+export {
+  isApexResource,
+  expandApiModule,
+  loadApiRoutes,
+  createApiHandler,
+  hasMcpRoutes,
+  createMcpHandler
+};

package/dist/chunk-PAMD24NK.js

@@ -0,0 +1,171 @@
+// src/islands/render.ts
+import { renderIslands } from "@apex-stack/kit";
+var ISLAND_LOADER = (
+  /* js */
+  `
+let __alpine
+function __ensureAlpine() {
+  return __alpine ??= import('alpinejs').then(function (m) {
+    const Alpine = m.default
+    window.Alpine = Alpine
+    Alpine.start() // islands are x-ignore'd, so this hydrates nothing on its own
+    return Alpine
+  })
+}
+async function __hydrate(el) {
+  const Alpine = await __ensureAlpine()
+  // Global Alpine.start() marked this island with the internal _x_ignore
+  // property (from the x-ignore attribute). Clear BOTH so initTree will descend
+  // and initialize the island's own x-data instead of early-returning.
+  el.removeAttribute('x-ignore')
+  delete el._x_ignore
+  Alpine.initTree(el)
+  el.setAttribute('data-apex-hydrated', '')
+}
+document.querySelectorAll('[data-apex-island]').forEach(function (el) {
+  const mode = el.getAttribute('data-apex-client')
+  if (mode === 'load') {
+    __hydrate(el)
+  } else if (mode === 'idle') {
+    (window.requestIdleCallback || function (cb) { return setTimeout(cb, 200) })(function () { __hydrate(el) })
+  } else if (mode === 'visible') {
+    const io = new IntersectionObserver(function (entries, obs) {
+      entries.forEach(function (e) { if (e.isIntersecting) { obs.unobserve(e.target); __hydrate(e.target) } })
+    })
+    io.observe(el)
+  }
+  // 'none' \u2192 do nothing; the SSR HTML is the final, static output.
+})
+`.trim()
+);
+async function renderIslandsPage(opts) {
+  const mod = await opts.loadModule(opts.pageId);
+  const loaderData = await mod.loader({ params: opts.params ?? {}, url: opts.url }) ?? {};
+  const { html, hydratingCount } = renderIslands(
+    mod.template,
+    loaderData,
+    mod.scopeId,
+    opts.registry
+  );
+  const loaderScript = hydratingCount > 0 ? `
+<script type="module">${ISLAND_LOADER}</script>` : "";
+  const doc = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Apex JS \u2014 Islands</title>
+  <style>${mod.css}${opts.componentCss ?? ""}</style>
+</head>
+<body>
+${html}${loaderScript}
+</body>
+</html>`;
+  return opts.transformHtml ? opts.transformHtml(opts.url, doc) : doc;
+}
+
+// src/routing/router.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import { join, relative, sep } from "path";
+function walkAlpine(dir) {
+  const out = [];
+  for (const entry of readdirSync(dir)) {
+    const abs = join(dir, entry);
+    if (statSync(abs).isDirectory()) out.push(...walkAlpine(abs));
+    else if (entry.endsWith(".alpine")) out.push(abs);
+  }
+  return out;
+}
+function scanPages(root) {
+  const dir = join(root, "pages");
+  if (!existsSync(dir)) return [];
+  const routes = walkAlpine(dir).map((abs) => {
+    const rel = relative(dir, abs).split(sep).join("/");
+    const pageId = `/pages/${rel}`;
+    const parts = rel.replace(/\.alpine$/, "").split("/");
+    if (parts[parts.length - 1] === "index") parts.pop();
+    const segments = parts.map((p) => {
+      const m = /^\[(.+)\]$/.exec(p);
+      return m ? { param: m[1] } : { literal: p };
+    });
+    const isDynamic = segments.some((s) => s.param !== void 0);
+    const pattern = `/${segments.map((s) => s.param ? `:${s.param}` : s.literal).join("/")}`;
+    return { pageId, pattern, segments, isDynamic };
+  });
+  return routes.sort((a, b) => Number(a.isDynamic) - Number(b.isDynamic));
+}
+function pathSegments(url) {
+  const path = url.split("?")[0] ?? "/";
+  return path.split("/").filter(Boolean);
+}
+function matchRoute(routes, url) {
+  const segs = pathSegments(url);
+  for (const route of routes) {
+    if (route.segments.length !== segs.length) continue;
+    const params = {};
+    let ok = true;
+    for (let i = 0; i < route.segments.length; i++) {
+      const rs = route.segments[i];
+      const value = segs[i];
+      if (rs.param) params[rs.param] = decodeURIComponent(value);
+      else if (rs.literal !== value) {
+        ok = false;
+        break;
+      }
+    }
+    if (ok) return { pageId: route.pageId, params };
+  }
+  return null;
+}
+
+// src/dev/renderPage.ts
+import { renderComponent, stateIsland } from "@apex-stack/kit";
+async function renderPage(opts) {
+  const mod = await opts.loadModule(opts.pageId);
+  const loaderData = await mod.loader({ params: opts.params ?? {}, url: opts.url }) ?? {};
+  const { html } = renderComponent({
+    template: mod.template,
+    rootXData: mod.rootXData,
+    componentId: mod.componentId,
+    scopeId: mod.scopeId,
+    loaderData,
+    registry: opts.registry
+  });
+  const doc = shell({
+    body: html,
+    island: stateIsland(mod.componentId, loaderData),
+    css: mod.css + (opts.componentCss ?? ""),
+    pageId: opts.pageId,
+    clientHref: opts.clientHref
+  });
+  return opts.transformHtml ? opts.transformHtml(opts.url, doc) : doc;
+}
+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>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Apex JS</title>
+  <style>${css}</style>
+</head>
+<body>
+${body}
+${island}
+${clientScript}
+</body>
+</html>`;
+}
+
+export {
+  renderIslandsPage,
+  scanPages,
+  matchRoute,
+  renderPage
+};