@catmint/adapter-node 0.0.0-prealpha.1 → 0.0.0-prealpha.10

package/README.md

@@ -0,0 +1,45 @@
+# @catmint/adapter-node
+
+Node.js production server adapter for [Catmint](https://github.com/darylcecile/catmint).
+
+Generates a standalone Node.js server entry point that can be started with `node dist/server/index.js`.
+
+## Install
+
+```bash
+pnpm add @catmint/adapter-node
+```
+
+## Usage
+
+```ts
+// catmint.config.ts
+import { defineConfig } from "catmint/config";
+import nodeAdapter from "@catmint/adapter-node";
+
+export default defineConfig({
+  mode: "fullstack",
+  adapter: nodeAdapter({
+    port: 6468,
+    host: "0.0.0.0",
+  }),
+});
+```
+
+## Options
+
+| Option | Type     | Default     | Description       |
+| ------ | -------- | ----------- | ----------------- |
+| `port` | `number` | `3000`      | Port to listen on |
+| `host` | `string` | `"0.0.0.0"` | Host to bind to   |
+
+## Deploy
+
+```bash
+catmint build
+node dist/server/index.js
+```
+
+## License
+
+GNU General Public License v2

package/dist/index.d.ts

@@ -7,6 +7,13 @@ export interface NodeAdapterOptions {
     port?: number;
     /** Host to bind to (default: '0.0.0.0') */
     host?: string;
+    /**
+     * Maximum allowed request body size in bytes.
+     * Applies to server function RPC calls and API endpoints.
+     *
+     * @default 1_048_576 (1 MB)
+     */
+    maxBodySize?: number;
 }
 /**
  * Create a Node.js adapter for Catmint.

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAA+B,MAAM,gBAAgB,CAAC;AAIlF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,cAAc,CA0BhB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,cAAc,EAGf,MAAM,gBAAgB,CAAC;AAIxB;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,OAAO,CAAC,EAAE,kBAAkB,GAC3B,cAAc,CAgChB"}

package/dist/index.js

@@ -17,14 +17,20 @@ import { generateServerEntry } from "./server-template.js";
  * ```
  */
 export default function nodeAdapter(options) {
-    const port = options?.port ?? 3000;
+    const port = options?.port ?? 6468;
     const host = options?.host ?? "0.0.0.0";
+    const maxBodySize = options?.maxBodySize ?? 1_048_576;
     return {
         name: "@catmint/adapter-node",
         async adapt(context) {
             context.log("@catmint/adapter-node: Generating standalone Node.js server...");
             const manifest = context.manifest;
-            const entryContent = generateServerEntry(manifest, { port, host });
+            const entryContent = generateServerEntry(manifest, {
+                port,
+                host,
+                maxBodySize,
+                headerPreset: manifest.config.security.headerPreset,
+            });
             // Write to dist/server/index.js (separate from the SSR bundle at dist/ssr/)
             // so `catmint start` can still load the SSR entry for its built-in server.
             await context.writeFile("server/index.js", entryContent);

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAI5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAY3D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,OAA4B;IAE5B,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,IAAI,CAAC;IACnC,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,SAAS,CAAC;IAExC,OAAO;QACL,IAAI,EAAE,uBAAuB;QAC7B,KAAK,CAAC,KAAK,CAAC,OAAuB;YACjC,OAAO,CAAC,GAAG,CACT,gEAAgE,CACjE,CAAC;YAEF,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAuB,CAAC;YACjD,MAAM,YAAY,GAAG,mBAAmB,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;YAEnE,4EAA4E;YAC5E,2EAA2E;YAC3E,MAAM,OAAO,CAAC,SAAS,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC;YAEzD,OAAO,CAAC,GAAG,CACT,oEAAoE,CACrE,CAAC;YACF,OAAO,CAAC,GAAG,CACT,iFAAiF,IAAI,IAAI,IAAI,GAAG,CACjG,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAQ5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAmB3D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CACjC,OAA4B;IAE5B,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,IAAI,CAAC;IACnC,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,SAAS,CAAC;IACxC,MAAM,WAAW,GAAG,OAAO,EAAE,WAAW,IAAI,SAAS,CAAC;IAEtD,OAAO;QACL,IAAI,EAAE,uBAAuB;QAC7B,KAAK,CAAC,KAAK,CAAC,OAAuB;YACjC,OAAO,CAAC,GAAG,CACT,gEAAgE,CACjE,CAAC;YAEF,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAuB,CAAC;YACjD,MAAM,YAAY,GAAG,mBAAmB,CAAC,QAAQ,EAAE;gBACjD,IAAI;gBACJ,IAAI;gBACJ,WAAW;gBACX,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY;aACpD,CAAC,CAAC;YAEH,4EAA4E;YAC5E,2EAA2E;YAC3E,MAAM,OAAO,CAAC,SAAS,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC;YAEzD,OAAO,CAAC,GAAG,CACT,oEAAoE,CACrE,CAAC;YACF,OAAO,CAAC,GAAG,CACT,iFAAiF,IAAI,IAAI,IAAI,GAAG,CACjG,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/server-template.d.ts

@@ -2,6 +2,8 @@ import type { AppManifest } from "catmint/config";
 interface ServerOptions {
     port: number;
     host: string;
+    maxBodySize: number;
+    headerPreset: "baseline" | "none";
 }
 /**
  * Generate the content of the standalone Node.js server entry point.

package/dist/server-template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-template.d.ts","sourceRoot":"","sources":["../src/server-template.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,UAAU,aAAa;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,WAAW,EACtB,OAAO,EAAE,aAAa,GACrB,MAAM,CAoWR"}
+{"version":3,"file":"server-template.d.ts","sourceRoot":"","sources":["../src/server-template.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,UAAU,aAAa;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,UAAU,GAAG,MAAM,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,WAAW,EACtB,OAAO,EAAE,aAAa,GACrB,MAAM,CA8jBR"}

package/dist/server-template.js

@@ -12,6 +12,7 @@
 export function generateServerEntry(_manifest, options) {
     return `// Auto-generated by @catmint/adapter-node — do not edit
 import { createServer } from "node:http";
+import { createHash } from "node:crypto";
 import { readFile, stat } from "node:fs/promises";
 import { join, extname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -19,6 +20,7 @@ import { fileURLToPath } from "node:url";
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const CLIENT_DIR = resolve(__dirname, "../client");
 const STATIC_DIR = resolve(__dirname, "../static");
+const PRERENDERED_DIR = resolve(__dirname, "../prerendered");
 
 const PORT = process.env.PORT ? parseInt(process.env.PORT, 10) : ${options.port};
 const HOST = process.env.HOST ?? ${JSON.stringify(options.host)};
@@ -161,14 +163,58 @@ function __catmintErrorPage(statusCode, detail) {
 }
 
 function collectBody(req) {
+  const MAX_BODY_SIZE = ${options.maxBodySize};
   return new Promise((resolve, reject) => {
     const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
+    let totalLength = 0;
+    req.on("data", (chunk) => {
+      totalLength += chunk.length;
+      if (totalLength > MAX_BODY_SIZE) {
+        req.destroy();
+        reject(new Error("Request body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
     req.on("end", () => resolve(Buffer.concat(chunks)));
     req.on("error", reject);
   });
 }
 
+// ---------------------------------------------------------------------------
+// Server function error detection helpers (duck-typing)
+//
+// The adapter cannot import from \`catmint\` at runtime. Instead we detect
+// error types by checking for characteristic properties.
+// ---------------------------------------------------------------------------
+
+function __isClientSafeErrorLike(value) {
+  if (!value || typeof value !== "object") return false;
+  if (value instanceof Error && typeof value.statusCode === "number") {
+    var proto = Object.getPrototypeOf(value);
+    while (proto && proto !== Error.prototype) {
+      if (proto.constructor && proto.constructor.name === "ClientSafeError") return true;
+      proto = Object.getPrototypeOf(proto);
+    }
+  }
+  return false;
+}
+
+function __isRedirectErrorLike(value) {
+  if (!value || typeof value !== "object") return false;
+  return (
+    value instanceof Error &&
+    value.name === "RedirectError" &&
+    typeof value.url === "string" &&
+    typeof value.status === "number"
+  );
+}
+
+function __errorRef(err) {
+  var content = String(Date.now()) + ":" + (err instanceof Error ? err.message : String(err));
+  return createHash("sha256").update(content).digest("hex").slice(0, 8);
+}
+
 // Import the RSC and SSR entries for the rendering pipeline
 const rscEntry = await import("../rsc/index.js");
 const ssrEntry = await import("../ssr/index.js");
@@ -189,14 +235,52 @@ async function pipeWebStreamToResponse(webStream, res) {
   }
 }
 
+function nodeReqToWebRequest(req) {
+  const protocol = "http";
+  const host = req.headers.host || \`\${HOST}:\${PORT}\`;
+  const reqUrl = new URL(req.url || "/", \`\${protocol}://\${host}\`);
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (value) {
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          headers.append(key, v);
+        }
+      } else {
+        headers.set(key, value);
+      }
+    }
+  }
+  return new Request(reqUrl.href, {
+    method: req.method || "GET",
+    headers,
+  });
+}
+
 const server = createServer(async (req, res) => {
+${options.headerPreset === "baseline"
+        ? `  // Baseline security headers
+  res.setHeader("X-Content-Type-Options", "nosniff");
+  res.setHeader("Referrer-Policy", "strict-origin-when-cross-origin");
+  res.setHeader("X-Frame-Options", "SAMEORIGIN");
+`
+        : ""}
   const url = new URL(req.url || "/", \`http://\${HOST}:\${PORT}\`);
   const pathname = url.pathname;
   const method = (req.method || "GET").toUpperCase();
 
   try {
-    // 1. Serve static assets from dist/static/ (no cache)
+    // 1. Serve client assets from dist/client/ (immutable for hashed assets)
+    // These have hashed filenames and never conflict with app routes.
     {
+      const filePath = join(CLIENT_DIR, pathname);
+      const served = await serveStaticFile(res, filePath, pathname.includes("/assets/"));
+      if (served) return;
+    }
+
+    // 2. Pre-rendered static pages WITHOUT middleware: serve directly from
+    // dist/static/ as a fast path — no middleware execution needed.
+    if (method === "GET") {
       let staticPath = pathname;
       if (!extname(staticPath)) {
         staticPath = staticPath.endsWith("/")
@@ -208,16 +292,79 @@ const server = createServer(async (req, res) => {
       if (served) return;
     }
 
-    // 2. Serve client assets from dist/client/ (immutable for hashed assets)
-    {
-      const filePath = join(CLIENT_DIR, pathname);
-      const served = await serveStaticFile(res, filePath, pathname.includes("/assets/"));
-      if (served) return;
+    // 3. Middleware execution — runs for all remaining routes (server functions,
+    // endpoints, prerendered pages with middleware, RSC-rendered pages).
+    // For RSC flight requests, run middleware against the TARGET page path
+    // (from ?path= query param), not the literal /__catmint/rsc pathname.
+    var middlewareHeaders = null;
+    if (ssrEntry.executeMiddleware) {
+      try {
+        var middlewarePath = pathname;
+        if (pathname === "/__catmint/rsc") {
+          var rscTargetPath = url.searchParams.get("path");
+          if (rscTargetPath) middlewarePath = rscTargetPath;
+        }
+        var webRequest = nodeReqToWebRequest(req);
+        var mwResult = await ssrEntry.executeMiddleware(middlewarePath, webRequest);
+
+        if (mwResult.shortCircuit) {
+          // Middleware short-circuited — return its response directly
+          res.writeHead(mwResult.shortCircuit.status,
+            Object.fromEntries(mwResult.shortCircuit.headers));
+          var scBody = await mwResult.shortCircuit.text();
+          res.end(scBody);
+          return;
+        }
+
+        // Middleware passed — capture headers to merge into final response
+        if (mwResult.headers && typeof mwResult.headers.forEach === "function") {
+          middlewareHeaders = mwResult.headers;
+        }
+      } catch (err) {
+        console.error("Middleware error:", err);
+        if (!res.headersSent) {
+          res.writeHead(500);
+          res.end("Internal Server Error");
+        }
+        return;
+      }
     }
 
-    // 3. Handle server function RPC calls (/__catmint/fn/*)
+    // Helper: merge middleware headers into the response before sending.
+    function applyMiddlewareHeaders() {
+      if (middlewareHeaders) {
+        middlewareHeaders.forEach(function(value, key) {
+          res.setHeader(key, value);
+        });
+      }
+    }
+
+    // 4. Handle server function RPC calls (/__catmint/fn/*)
     if (pathname.startsWith("/__catmint/fn/") && ssrEntry.handleServerFn) {
       try {
+        // Enforce POST method for server function calls
+        if (method !== "POST") {
+          sendJson(res, 405, { error: "Method " + method + " not allowed, expected POST" });
+          return;
+        }
+
+        // Enforce Content-Type: application/json
+        const ct = (req.headers["content-type"] || "").toLowerCase();
+        if (ct && !ct.startsWith("application/json")) {
+          sendJson(res, 415, { error: "Unsupported Content-Type, expected application/json" });
+          return;
+        }
+
+        // Validate Origin header to mitigate cross-site invocation
+        const origin = req.headers["origin"];
+        if (origin) {
+          const expected = \`http://\${HOST}:\${PORT}\`;
+          if (origin !== expected && origin !== \`https://\${HOST}:\${PORT}\`) {
+            sendJson(res, 403, { error: "Origin not allowed" });
+            return;
+          }
+        }
+
         const body = await collectBody(req);
         let parsed;
         try {
@@ -228,18 +375,47 @@ const server = createServer(async (req, res) => {
         }
         const result = await ssrEntry.handleServerFn(pathname, parsed);
         if (result) {
+          // Check if the result IS a ClientSafeError (returned, not thrown)
+          if (__isClientSafeErrorLike(result.result)) {
+            applyMiddlewareHeaders();
+            sendJson(res, 200, {
+              __clientSafeError: true,
+              error: result.result.message,
+              statusCode: result.result.statusCode,
+              data: result.result.data,
+            });
+            return;
+          }
+          applyMiddlewareHeaders();
           sendJson(res, 200, result.result);
           return;
         }
         sendJson(res, 404, { error: "Server function not found" });
       } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        sendJson(res, 500, { error: message });
+        // Always log full error server-side
+        console.error("[catmint] Server function error:", err);
+
+        // RedirectError — send redirect envelope
+        if (__isRedirectErrorLike(err)) {
+          sendJson(res, 200, { __redirect: true, url: err.url, status: err.status });
+          return;
+        }
+
+        // ClientSafeError — developer opted in, expose to client
+        if (__isClientSafeErrorLike(err)) {
+          sendJson(res, err.statusCode, { error: err.message, data: err.data });
+          return;
+        }
+
+        // Default: sanitize — generic message with correlation hash
+        const ref = __errorRef(err);
+        console.error("[catmint] Error reference [ref: " + ref + "] — see above for full error");
+        sendJson(res, 500, { error: "Internal Server Error [ref: " + ref + "]" });
       }
       return;
     }
 
-    // 4. RSC flight stream for client-side navigation (/__catmint/rsc?path=...)
+    // 5. RSC flight stream for client-side navigation (/__catmint/rsc?path=...)
     if (pathname === "/__catmint/rsc" && method === "GET" && rscEntry.render) {
       const targetPath = url.searchParams.get("path");
       if (!targetPath) {
@@ -251,6 +427,7 @@ const server = createServer(async (req, res) => {
       try {
         const rscResult = await rscEntry.render(targetPath);
         if (rscResult) {
+          applyMiddlewareHeaders();
           res.writeHead(200, {
             "Content-Type": "text/x-component; charset=utf-8",
             "Cache-Control": "no-cache, no-store, must-revalidate",
@@ -272,7 +449,7 @@ const server = createServer(async (req, res) => {
       return;
     }
 
-    // 5. API endpoint handling
+    // 6. API endpoint handling
     if (ssrEntry.hasEndpoint && ssrEntry.hasEndpoint(pathname)) {
       try {
         const protocol = "http";
@@ -295,7 +472,10 @@ const server = createServer(async (req, res) => {
         const result = await ssrEntry.handleEndpoint(pathname, method, webRequest);
 
         if (result) {
-          res.writeHead(result.response.status, Object.fromEntries(result.response.headers));
+          // Copy response headers then merge middleware headers
+          var epHeaders = Object.fromEntries(result.response.headers);
+          res.writeHead(result.response.status, epHeaders);
+          applyMiddlewareHeaders();
           if (result.response.body) {
             await pipeWebStreamToResponse(result.response.body, res);
           } else {
@@ -317,12 +497,41 @@ const server = createServer(async (req, res) => {
       }
     }
 
-    // 6. RSC → SSR page rendering pipeline
+    // 7. Pre-rendered pages WITH middleware: serve from dist/prerendered/
+    // These are static routes that have middleware ancestors — their HTML
+    // was pre-rendered but they must go through the middleware pipeline.
+    if (method === "GET") {
+      let prerenderedPath = pathname;
+      if (!extname(prerenderedPath)) {
+        prerenderedPath = prerenderedPath.endsWith("/")
+          ? prerenderedPath + "index.html"
+          : prerenderedPath + ".html";
+      }
+      try {
+        const prFilePath = join(PRERENDERED_DIR, prerenderedPath);
+        const prStats = await stat(prFilePath);
+        if (prStats.isFile()) {
+          const content = await readFile(prFilePath);
+          applyMiddlewareHeaders();
+          res.setHeader("Content-Type", "text/html; charset=utf-8");
+          res.setHeader("Content-Length", content.byteLength);
+          res.setHeader("Cache-Control", "public, max-age=0, must-revalidate");
+          res.writeHead(200);
+          res.end(content);
+          return;
+        }
+      } catch {
+        // No prerendered file — continue to RSC rendering
+      }
+    }
+
+    // 8. RSC → SSR page rendering pipeline
     if (method === "GET" && rscEntry.render) {
       try {
         const rscResult = await rscEntry.render(pathname);
         if (rscResult) {
           const htmlStream = await ssrEntry.renderToHtml(rscResult.stream, rscResult.headConfig);
+          applyMiddlewareHeaders();
           res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
           await pipeWebStreamToResponse(htmlStream, res);
           return;
@@ -336,7 +545,14 @@ const server = createServer(async (req, res) => {
       }
     }
 
-    // 7. 404
+    // 9. Static assets fallback (dist/static/ for public files like favicon, etc.)
+    {
+      const filePath = join(STATIC_DIR, pathname);
+      const served = await serveStaticFile(res, filePath, false);
+      if (served) return;
+    }
+
+    // 10. 404
     await sendStatusPage(res, 404, pathname);
   } catch (err) {
     console.error("Request error:", err);

package/dist/server-template.js.map

@@ -1 +1 @@
-{"version":3,"file":"server-template.js","sourceRoot":"","sources":["../src/server-template.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAShE;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CACjC,SAAsB,EACtB,OAAsB;IAEtB,OAAO;;;;;;;;;;mEAU0D,OAAO,CAAC,IAAI;mCAC5C,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuV9D,CAAC;AACF,CAAC"}
+{"version":3,"file":"server-template.js","sourceRoot":"","sources":["../src/server-template.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAWhE;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CACjC,SAAsB,EACtB,OAAsB;IAEtB,OAAO;;;;;;;;;;;;mEAY0D,OAAO,CAAC,IAAI;mCAC5C,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BA4IrC,OAAO,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgG3C,OAAO,CAAC,YAAY,KAAK,UAAU;QACjC,CAAC,CAAC;;;;CAIL;QACG,CAAC,CAAC,EACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4TC,CAAC;AACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@catmint/adapter-node",
-  "version": "0.0.0-prealpha.1",
+  "version": "0.0.0-prealpha.10",
   "type": "module",
   "private": false,
   "license": "MIT",
@@ -14,7 +14,7 @@
     }
   },
   "dependencies": {
-    "catmint": "0.0.0-prealpha.1"
+    "catmint": "0.0.0-prealpha.10"
   },
   "devDependencies": {
     "typescript": "^5.7.0"