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

@apex-stack/core 0.1.1

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

package/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2026 Andre Corugda
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-XB5ZYPPE.js ADDED Viewed

@@ -0,0 +1,413 @@
+// src/api/resource.ts
+function isApexResource(x) {
+  return typeof x === "object" && x !== null && x.__apexResource === true;
+}
+// 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
+  });
+  return opts.transformHtml ? opts.transformHtml(opts.url, doc) : doc;
+}
+function shell({ body, island, css, pageId }) {
+  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}
+<script type="module">
+  import Alpine from 'alpinejs'
+  import ${JSON.stringify(pageId)}
+  window.Alpine = Alpine
+  Alpine.start()
+</script>
+</body>
+</html>`;
+}
+// src/dev/server.ts
+import { createServer as createHttpServer } from "http";
+import { apex } from "@apex-stack/vite";
+import {
+  createApp,
+  defineEventHandler as defineEventHandler3,
+  fromNodeMiddleware,
+  setResponseHeader as setResponseHeader2,
+  setResponseStatus as setResponseStatus2,
+  toNodeListener
+} from "h3";
+import { createServer as createViteServer } from "vite";
+// 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 };
+}
+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;
+    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));
+    }
+  }
+  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;
+  });
+}
+// src/components/registry.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join2 } from "path";
+async function loadComponents(root, loadModule) {
+  const dir = join2(root, "components");
+  if (!existsSync2(dir)) return { registry: {}, css: "" };
+  const registry = {};
+  let css = "";
+  for (const file of readdirSync2(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 };
+}
+// 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 as existsSync3, readdirSync as readdirSync3, statSync } from "fs";
+import { join as join3, relative, sep } from "path";
+function walkAlpine(dir) {
+  const out = [];
+  for (const entry of readdirSync3(dir)) {
+    const abs = join3(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 = join3(root, "pages");
+  if (!existsSync3(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/server.ts
+async function startDevServer(options) {
+  const port = options.port ?? 3e3;
+  const pageId = options.pageId ?? "/pages/index.alpine";
+  const vite = await createViteServer({
+    root: options.root,
+    appType: "custom",
+    server: { middlewareMode: true },
+    // User apps depend on `@apex-stack/core`, so the client module imports the runtime
+    // from `@apex-stack/core/client` (a re-export) rather than the internal kit package.
+    plugins: [apex({ clientRuntime: "@apex-stack/core/client" })],
+    optimizeDeps: { include: ["alpinejs"] }
+  });
+  const app = createApp();
+  app.use(fromNodeMiddleware(vite.middlewares));
+  const apiEntries = await loadApiRoutes(options.root, (id) => vite.ssrLoadModule(id));
+  if (apiEntries.length) app.use("/api", createApiHandler(apiEntries));
+  if (hasMcpRoutes(apiEntries)) {
+    app.use("/mcp", createMcpHandler(apiEntries));
+  }
+  app.use(
+    defineEventHandler3(async (event) => {
+      const url = event.path || "/";
+      try {
+        const routes = scanPages(options.root);
+        const matched = routes.length ? matchRoute(routes, url) : { pageId, params: {} };
+        if (!matched) {
+          setResponseStatus2(event, 404);
+          setResponseHeader2(event, "Content-Type", "text/html");
+          return notFoundPage(url, routes);
+        }
+        const { registry, css: componentCss } = await loadComponents(
+          options.root,
+          (id) => vite.ssrLoadModule(id)
+        );
+        const render = options.islands ? renderIslandsPage : renderPage;
+        const html = await render({
+          loadModule: (id) => vite.ssrLoadModule(id),
+          pageId: matched.pageId,
+          params: matched.params,
+          url,
+          registry,
+          componentCss,
+          transformHtml: (u, doc) => vite.transformIndexHtml(u, doc)
+        });
+        setResponseHeader2(event, "Content-Type", "text/html");
+        return html;
+      } catch (err) {
+        const error = err;
+        vite.ssrFixStacktrace(error);
+        setResponseStatus2(event, 500);
+        setResponseHeader2(event, "Content-Type", "text/html");
+        return `<pre>${escapeHtml(error.stack ?? error.message)}</pre>`;
+      }
+    })
+  );
+  const server = createHttpServer(toNodeListener(app));
+  await new Promise((resolve) => server.listen(port, resolve));
+  return {
+    vite,
+    server,
+    port,
+    close: async () => {
+      await vite.close();
+      await new Promise(
+        (resolve, reject) => server.close((e) => e ? reject(e) : resolve())
+      );
+    }
+  };
+}
+function escapeHtml(s) {
+  return s.replace(/[&<>]/g, (c) => c === "&" ? "&amp;" : c === "<" ? "&lt;" : "&gt;");
+}
+function notFoundPage(url, routes) {
+  const list = routes.map((r) => `<li><code>${escapeHtml(r.pattern)}</code></li>`).join("");
+  return `<!DOCTYPE html><html><head><title>404 \u2014 Apex JS</title></head>
+<body style="font-family: system-ui, sans-serif; max-width: 40rem; margin: 3rem auto;">
+  <h1>404 \u2014 no route for <code>${escapeHtml(url)}</code></h1>
+  <p>Available routes:</p>
+  <ul>${list || "<li>(no pages found \u2014 add <code>pages/index.alpine</code>)</li>"}</ul>
+</body></html>`;
+}
+export {
+  isApexResource,
+  renderPage,
+  startDevServer
+};

package/dist/cli.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ import '@apex-stack/kit/client';

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,207 @@
+import {
+  startDevServer
+} from "./chunk-XB5ZYPPE.js";
+// src/cli.ts
+import { resolve as resolve3 } from "path";
+import { defineCommand as defineCommand4, runMain } from "citty";
+// src/commands/make.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { defineCommand } from "citty";
+function pageTemplate(name) {
+  return `<script server lang="ts">
+  export function loader() {
+    return { title: '${name}' }
+  }
+</script>
+<template x-data>
+  <main>
+    <h1 x-text="title"></h1>
+  </main>
+</template>
+<style scoped>
+  main { max-width: 40rem; margin: 3rem auto; font-family: system-ui, sans-serif; }
+</style>
+`;
+}
+function componentTemplate() {
+  return `<template x-data="{ count: 0 }">
+  <button @click="count++" x-text="count"></button>
+</template>
+<style scoped>
+  button { cursor: pointer; }
+</style>
+`;
+}
+function apiTemplate(name) {
+  return `import { defineApexRoute } from '@apex-stack/core'
+import { z } from 'zod'
+// GET /api/${name}  \xB7  MCP tool "${name}"
+export default defineApexRoute({
+  method: 'GET',
+  description: 'Describe what ${name} does',
+  input: { name: z.string() },
+  mcp: true,
+  handler: ({ input }) => ({ message: \`Hello, \${input.name}!\` }),
+})
+`;
+}
+function plan(kind, name, root) {
+  switch (kind) {
+    case "page":
+      return { path: join(root, "pages", `${name}.alpine`), contents: pageTemplate(name) };
+    case "component":
+      return { path: join(root, "components", `${name}.alpine`), contents: componentTemplate() };
+    case "api":
+      return { path: join(root, "server", "api", `${name}.ts`), contents: apiTemplate(name) };
+  }
+}
+var makeCommand = defineCommand({
+  meta: { name: "make", description: "Generate a page, component, or API route" },
+  args: {
+    kind: { type: "positional", required: true, description: "page | component | api" },
+    name: { type: "positional", required: true, description: "Name (about, Counter, todos, \u2026)" },
+    root: { type: "string", description: "Project root", default: "." }
+  },
+  run({ args }) {
+    const kind = args.kind;
+    if (kind !== "page" && kind !== "component" && kind !== "api") {
+      console.error(`
+  Unknown type "${args.kind}". Use: page | component | api
+`);
+      process.exit(1);
+    }
+    const root = resolve(process.cwd(), args.root);
+    const { path, contents } = plan(kind, args.name, root);
+    if (existsSync(path)) {
+      console.error(`
+  \u2717 Already exists: ${path}
+`);
+      process.exit(1);
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, contents);
+    console.log(`
+  \u2713 Created ${path.replace(`${root}/`, "")}
+`);
+  }
+});
+// src/commands/mcp.ts
+import { defineCommand as defineCommand2 } from "citty";
+var mcpCommand = defineCommand2({
+  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" },
+    call: { type: "string", description: "Name of a tool to call" },
+    args: { type: "string", description: "JSON arguments for --call", default: "{}" }
+  },
+  async run({ args }) {
+    const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
+    const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+    const client = new Client({ name: "apex-mcp-cli", version: "0.0.0" });
+    try {
+      await client.connect(new StreamableHTTPClientTransport(new URL(args.url)));
+    } catch (err) {
+      console.error(
+        `
+  Could not reach an MCP server at ${args.url}
+  Is \`apex dev\` running? ${err.message}
+`
+      );
+      process.exit(1);
+    }
+    if (args.call) {
+      const result = await client.callTool({
+        name: args.call,
+        arguments: JSON.parse(args.args)
+      });
+      console.log(`
+  \x1B[36m${args.call}\x1B[0m(${args.args}) \u2192`);
+      for (const part of result.content) {
+        console.log("  " + (part.text ?? JSON.stringify(part)));
+      }
+      console.log();
+    } else {
+      const { tools } = await client.listTools();
+      console.log(`
+  \x1B[36mMCP tools\x1B[0m at ${args.url} (${tools.length})
+`);
+      for (const t of tools) {
+        const props = t.inputSchema?.properties;
+        const sig = props ? Object.entries(props).map(([k, v]) => `${k}: ${v.type ?? "any"}`).join(", ") : "";
+        console.log(`  \u2022 \x1B[1m${t.name}\x1B[0m(${sig})`);
+        if (t.description) console.log(`    ${t.description}`);
+      }
+      console.log(`
+  Call one:  apex mcp --call <name> --args '{...}'
+`);
+    }
+    await client.close();
+  }
+});
+// src/commands/migrate.ts
+import { createRequire } from "module";
+import { join as join2, resolve as resolve2 } from "path";
+import { pathToFileURL } from "url";
+import { defineCommand as defineCommand3 } from "citty";
+var migrateCommand = defineCommand3({
+  meta: { name: "migrate", description: "Apply pending SQL migrations (db/migrations/*.sql)" },
+  args: {
+    db: { type: "string", description: "SQLite file path", default: "data.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);
+    let data;
+    try {
+      const require2 = createRequire(join2(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));
+    console.log(
+      applied.length ? `
+  \u2713 Applied ${applied.length} migration(s): ${applied.join(", ")}
+` : "\n  \u2713 Up to date \u2014 no pending migrations.\n"
+    );
+  }
+});
+// src/cli.ts
+var dev = defineCommand4({
+  meta: { name: "dev", description: "Start the Apex JS development server" },
+  args: {
+    root: { type: "positional", required: false, description: "Project root", default: "." },
+    port: { type: "string", description: "Port to listen on", default: "3000" },
+    islands: { type: "boolean", description: "Render in islands mode (static-first)", default: false }
+  },
+  async run({ args }) {
+    const root = resolve3(process.cwd(), args.root);
+    const port = Number(args.port);
+    const { port: actual } = await startDevServer({ root, port, islands: args.islands });
+    console.log(`
+  \x1B[36mApex JS\x1B[0m dev server ready
+  \u2192 http://localhost:${actual}
+`);
+  }
+});
+var main = defineCommand4({
+  meta: {
+    name: "apex",
+    description: "The full-stack meta-framework for Alpine.js"
+  },
+  subCommands: { dev, make: makeCommand, migrate: migrateCommand, mcp: mcpCommand }
+});
+runMain(main);

package/dist/client.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { registerApexComponent } from '@apex-stack/kit/client';

package/dist/client.js ADDED Viewed

@@ -0,0 +1,5 @@
+// src/client.ts
+import { registerApexComponent } from "@apex-stack/kit/client";
+export {
+  registerApexComponent
+};

package/dist/index.d.ts ADDED Viewed

@@ -0,0 +1,133 @@
+import { ZodRawShape, z } from 'zod';
+import { Server } from 'node:http';
+import { ViteDevServer } from 'vite';
+import { ComponentRegistry } from '@apex-stack/kit';
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/** Inferred, validated input object for a route's handler. */
+type InferInput<Shape extends ZodRawShape | undefined> = Shape extends ZodRawShape ? z.infer<z.ZodObject<Shape>> : Record<string, never>;
+interface ApexRouteHandlerContext<Shape extends ZodRawShape | undefined> {
+    /** The validated input (query for GET, JSON body otherwise). */
+    input: InferInput<Shape>;
+    /** The raw request URL. */
+    url: string;
+}
+interface ApexRouteConfig<Shape extends ZodRawShape | undefined, Output> {
+    /** HTTP method. Defaults to GET. */
+    method?: HttpMethod;
+    /** Human + AI-readable description. Becomes the MCP tool description. */
+    description?: string;
+    /**
+     * Input contract as a Zod raw shape (an object of Zod validators). Drives both
+     * REST validation AND the MCP tool's inputSchema — one definition, both worlds.
+     */
+    input?: Shape;
+    /** Opt in to exposing this route as an MCP tool. Defaults to false. */
+    mcp?: boolean;
+    /**
+     * Override the MCP tool name (must match ^[a-zA-Z0-9_-]{1,64}$). Defaults to a
+     * slug derived from the file path.
+     */
+    mcpName?: string;
+    /** The route implementation. Business logic should live in a service; this is the adapter. */
+    handler: (ctx: ApexRouteHandlerContext<Shape>) => Output | Promise<Output>;
+}
+/** The normalized, framework-facing route object produced by defineApexRoute. */
+interface ApexRoute {
+    method: HttpMethod;
+    description?: string;
+    inputShape?: ZodRawShape;
+    mcp: boolean;
+    mcpName?: string;
+    handler: (ctx: {
+        input: unknown;
+        url: string;
+    }) => unknown | Promise<unknown>;
+}
+/**
+ * Define a typed API route. A single definition serves as:
+ *   - a validated REST endpoint, and
+ *   - (when `mcp: true`) an MCP tool whose inputSchema is derived from `input`.
+ *
+ * The strict, schema-carrying contract is what makes "any Apex API can be MCP"
+ * possible with no extra library on the user's side.
+ */
+declare function defineApexRoute<Shape extends ZodRawShape | undefined, Output>(config: ApexRouteConfig<Shape, Output>): ApexRoute;
+/** One route within a resource, mounted at `/api/<name><pathSuffix>`. */
+interface ResourceRoute {
+    /** Path suffix after the resource name, e.g. '' or '/:id'. */
+    pathSuffix: string;
+    /** MCP tool name for this route (e.g. `todos_list`). */
+    mcpName: string;
+    route: ApexRoute;
+}
+/**
+ * A resource expands to several routes (list/get/create/…) from one definition.
+ * Built by `defineResource` in `@apex-stack/data`; recognized by the core API loader.
+ */
+interface ApexResource {
+    __apexResource: true;
+    name: string;
+    routes: ResourceRoute[];
+}
+declare function isApexResource(x: unknown): x is ApexResource;
+interface DevServerOptions {
+    root: string;
+    port?: number;
+    /** Page module rendered for every route in the spike (single-route). */
+    pageId?: string;
+    /** Render in islands mode (static-first, per-island hydration) instead of one page component. */
+    islands?: boolean;
+}
+interface DevServer {
+    vite: ViteDevServer;
+    server: Server;
+    port: number;
+    close: () => Promise<void>;
+}
+/**
+ * Start the Apex dev server: Vite in middleware mode (build/HMR/asset serving)
+ * fronted by an h3 app whose catch-all handler SSRs the page. Written as h3
+ * event handlers so the render path can migrate to Nitro unchanged.
+ */
+declare function startDevServer(options: DevServerOptions): Promise<DevServer>;
+/** The shape a compiled `.alpine` SSR module exports (see @apex-stack/vite). */
+interface PageModule {
+    loader: (ctx: {
+        params: Record<string, string>;
+        url: string;
+    }) => unknown | Promise<unknown>;
+    template: string;
+    rootXData: string | null;
+    componentId: string;
+    scopeId: string;
+    css: string;
+}
+interface RenderPageOptions {
+    /** Load a page's SSR module (dev: vite.ssrLoadModule; prod: static import). */
+    loadModule: (id: string) => Promise<PageModule>;
+    /** The page module id to render, e.g. `/pages/index.alpine`. */
+    pageId: string;
+    /** The incoming request path. */
+    url: string;
+    /** Route params captured from a dynamic segment (e.g. { slug: '...' }). */
+    params?: Record<string, string>;
+    /** Registry of embeddable components. */
+    registry?: ComponentRegistry;
+    /** Aggregated component CSS to include in the shell. */
+    componentCss?: string;
+    /** Post-process the shell HTML (dev: vite.transformIndexHtml). */
+    transformHtml?: (url: string, html: string) => string | Promise<string>;
+}
+/**
+ * The framework's render seam — deliberately dev-server-agnostic so it can move
+ * verbatim into a Nitro route handler post-spike. Loads the page module, runs
+ * its loader, renders the component to hydration-safe HTML, and assembles the
+ * document shell (SSR body + state island + client entry).
+ */
+declare function renderPage(opts: RenderPageOptions): Promise<string>;
+export { type ApexResource, type ApexRoute, type ApexRouteConfig, type ApexRouteHandlerContext, type DevServer, type DevServerOptions, type HttpMethod, type PageModule, type RenderPageOptions, type ResourceRoute, defineApexRoute, isApexResource, renderPage, startDevServer };

package/dist/index.js ADDED Viewed

@@ -0,0 +1,23 @@
+import {
+  isApexResource,
+  renderPage,
+  startDevServer
+} from "./chunk-XB5ZYPPE.js";
+// src/api/defineRoute.ts
+function defineApexRoute(config) {
+  return {
+    method: config.method ?? "GET",
+    description: config.description,
+    inputShape: config.input,
+    mcp: config.mcp ?? false,
+    mcpName: config.mcpName,
+    handler: config.handler
+  };
+}
+export {
+  defineApexRoute,
+  isApexResource,
+  renderPage,
+  startDevServer
+};

package/package.json ADDED Viewed

@@ -0,0 +1,57 @@
+{
+  "name": "@apex-stack/core",
+  "version": "0.1.1",
+  "description": "The full-stack meta-framework for Alpine.js — CLI and runtime",
+  "type": "module",
+  "license": "MIT",
+  "author": "Andre Corugda",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/andrecorugda/apexjs.git",
+    "directory": "packages/apexjs"
+  },
+  "keywords": [
+    "alpine",
+    "alpinejs",
+    "framework",
+    "ssr",
+    "apex",
+    "apexjs"
+  ],
+  "bin": {
+    "apex": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "citty": "^0.1.6",
+    "h3": "^1.13.0",
+    "vite": "^6.0.7",
+    "zod": "^4.4.3",
+    "@apex-stack/vite": "0.1.1",
+    "@apex-stack/kit": "0.1.1"
+  },
+  "peerDependencies": {
+    "alpinejs": "^3.14.0"
+  },
+  "engines": {
+    "node": ">=20.19"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}