gorsee 0.2.3 → 0.2.5

package/dist-pkg/deploy/conformance.js

@@ -0,0 +1,98 @@
+export function validateDeployArtifactConformance(input) {
+  const missing = input.requiredTokens.filter((token) => !input.content.includes(token)), forbidden = (input.forbiddenTokens ?? []).filter((token) => input.content.includes(token)), structured = parseStructuredArtifact(input), missingPaths = structured ? (input.requiredPaths ?? []).filter((path) => getStructuredValue(structured, path) === void 0) : [], mismatchedValues = structured ? (input.requiredValues ?? []).flatMap((expectation) => {
+    const actual = getStructuredValue(structured, expectation.path);
+    return actual === expectation.value ? [] : [`${expectation.path}: expected ${String(expectation.value)}, received ${String(actual)}`];
+  }) : [];
+  return {
+    ok: missing.length === 0 && forbidden.length === 0 && missingPaths.length === 0 && mismatchedValues.length === 0,
+    missing,
+    forbidden,
+    missingPaths,
+    mismatchedValues
+  };
+}
+export function assertDeployArtifactConformance(input) {
+  const result = validateDeployArtifactConformance(input);
+  if (result.ok)
+    return;
+  const problems = [
+    ...result.missing.map((token) => `missing token: ${token}`),
+    ...result.forbidden.map((token) => `forbidden token present: ${token}`),
+    ...result.missingPaths.map((path) => `missing path: ${path}`),
+    ...result.mismatchedValues.map((entry) => `mismatched value: ${entry}`)
+  ].join("; ");
+  throw Error(`${input.name} failed deploy conformance: ${problems}`);
+}
+function parseStructuredArtifact(input) {
+  if (input.format === "json")
+    return JSON.parse(input.content);
+  if (input.format === "toml")
+    return parseToml(input.content);
+  return null;
+}
+function getStructuredValue(record, path) {
+  let current = record;
+  for (const segment of path.split(".")) {
+    if (!current || typeof current !== "object" || !(segment in current))
+      return;
+    current = current[segment];
+  }
+  return current;
+}
+function parseToml(content) {
+  const root = {};
+  let current = root;
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#"))
+      continue;
+    if (line.startsWith("[[") && line.endsWith("]]")) {
+      const segments = line.slice(2, -2).trim().split("."), key = segments.pop(), parent = ensureTomlContainer(root, segments);
+      if (!key)
+        continue;
+      const list = Array.isArray(parent[key]) ? parent[key] : [], next = {};
+      list.push(next);
+      parent[key] = list;
+      current = next;
+      continue;
+    }
+    if (line.startsWith("[") && line.endsWith("]")) {
+      const path = line.slice(1, -1).trim().split(".");
+      current = ensureTomlContainer(root, path);
+      continue;
+    }
+    const separator = line.indexOf("=");
+    if (separator === -1)
+      continue;
+    const key = line.slice(0, separator).trim(), value = line.slice(separator + 1).trim();
+    current[key] = parseTomlValue(value);
+  }
+  return root;
+}
+function ensureTomlContainer(root, segments) {
+  let current = root;
+  for (const segment of segments) {
+    const existing = current[segment];
+    if (!existing || typeof existing !== "object" || Array.isArray(existing))
+      current[segment] = {};
+    current = current[segment];
+  }
+  return current;
+}
+function parseTomlValue(value) {
+  if (value.startsWith('"') && value.endsWith('"'))
+    return value.slice(1, -1);
+  if (value === "true")
+    return !0;
+  if (value === "false")
+    return !1;
+  if (/^-?\d+$/.test(value))
+    return Number(value);
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner)
+      return [];
+    return inner.split(",").map((part) => parseTomlValue(part.trim()));
+  }
+  return value;
+}

package/dist-pkg/deploy/dockerfile.d.ts

@@ -0,0 +1,3 @@
+import type { ProcessDeployRuntime } from "./runtime.js";
+export declare function generateDockerfile(runtime?: ProcessDeployRuntime): string;
+export declare function generateDockerignore(): string;

package/{src/deploy/dockerfile.ts → dist-pkg/deploy/dockerfile.js}

@@ -1,7 +1,6 @@
-// Generate Dockerfile for production deployment
-
-export function generateDockerfile(): string {
+export function generateDockerfile(runtime = "bun") {
   return `# Gorsee.js Production Dockerfile
+# Runtime profile: ${runtime}
 FROM oven/bun:1 AS builder
 WORKDIR /app
 COPY package.json bun.lock* ./
@@ -9,24 +8,23 @@ RUN bun install --frozen-lockfile
 COPY . .
 RUN bun run build
 
-FROM oven/bun:1-slim
+FROM ${runtime === "node" ? "node:20-bookworm-slim" : "oven/bun:1-slim"}
 WORKDIR /app
 COPY --from=builder /app/package.json ./
 COPY --from=builder /app/node_modules ./node_modules
 COPY --from=builder /app/dist ./dist
-COPY --from=builder /app/routes ./routes
 COPY --from=builder /app/public ./public
 COPY --from=builder /app/.env* ./
 
 ENV NODE_ENV=production
 ENV PORT=3000
+ENV APP_ORIGIN=REPLACE_WITH_APP_ORIGIN
 EXPOSE 3000
 
-CMD ["bun", "run", "start"]
-`
+${runtime === "node" ? 'CMD ["node", "dist/prod-node.js"]' : 'CMD ["bun", "run", "start"]'}
+`;
 }
-
-export function generateDockerignore(): string {
+export function generateDockerignore() {
   return `node_modules
 .gorsee
 .git
@@ -34,5 +32,5 @@ export function generateDockerignore(): string {
 *.sqlite
 *.db
 .env.local
-`
+`;
 }

package/dist-pkg/deploy/fly.d.ts

@@ -0,0 +1,3 @@
+import type { ProcessDeployRuntime } from "./runtime.js";
+export declare function generateFlyConfig(appName: string): string;
+export declare function generateFlyDockerfile(runtime?: ProcessDeployRuntime): string;

package/{src/deploy/fly.ts → dist-pkg/deploy/fly.js}

@@ -1,7 +1,5 @@
-// Gorsee.js — Fly.io deploy adapter
-
-export function generateFlyConfig(appName: string): string {
-  return `# Gorsee.js — Fly.io configuration
+export function generateFlyConfig(appName) {
+  return `# Gorsee.js \u2014 Fly.io configuration
 # Auto-generated by \`gorsee deploy fly\`
 
 app = "${appName}"
@@ -13,6 +11,7 @@ primary_region = "iad"
 [env]
   NODE_ENV = "production"
   PORT = "3000"
+  APP_ORIGIN = "REPLACE_WITH_APP_ORIGIN"
 
 [http_service]
   internal_port = 3000
@@ -39,12 +38,12 @@ primary_region = "iad"
   processes = ["app"]
   count_min = 1
   count_max = 3
-`
+`;
 }
-
-export function generateFlyDockerfile(): string {
-  return `# Gorsee.js — Fly.io optimized Dockerfile
+export function generateFlyDockerfile(runtime = "bun") {
+  return `# Gorsee.js \u2014 Fly.io optimized Dockerfile
 # Auto-generated by \`gorsee deploy fly\`
+# Runtime profile: ${runtime}
 
 FROM oven/bun:1 AS builder
 WORKDIR /app
@@ -53,18 +52,18 @@ RUN bun install --frozen-lockfile
 COPY . .
 RUN bun run build
 
-FROM oven/bun:1-slim
+FROM ${runtime === "node" ? "node:20-bookworm-slim" : "oven/bun:1-slim"}
 WORKDIR /app
 
 COPY --from=builder /app/package.json ./
 COPY --from=builder /app/node_modules ./node_modules
 COPY --from=builder /app/dist ./dist
-COPY --from=builder /app/routes ./routes
 COPY --from=builder /app/public ./public
 COPY --from=builder /app/.env* ./
 
 ENV NODE_ENV=production
 ENV PORT=3000
+ENV APP_ORIGIN=REPLACE_WITH_APP_ORIGIN
 
 # Fly.io runtime env vars are injected automatically:
 # FLY_ALLOC_ID, FLY_APP_NAME, FLY_REGION, FLY_MACHINE_ID
@@ -74,6 +73,6 @@ EXPOSE 3000
 HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \\
   CMD curl -f http://localhost:3000/api/health || exit 1
 
-CMD ["bun", "run", "start"]
-`
+${runtime === "node" ? 'CMD ["node", "dist/prod-node.js"]' : 'CMD ["bun", "run", "start"]'}
+`;
 }

package/dist-pkg/deploy/index.d.ts

@@ -0,0 +1,6 @@
+export { generateDockerfile, generateDockerignore, } from "./dockerfile.js";
+export { generateVercelConfig, generateVercelServerlessEntry, generateVercelBuildOutput, type VercelConfig, type VercelOutputConfig, } from "./vercel.js";
+export { generateFlyConfig, generateFlyDockerfile, } from "./fly.js";
+export { generateWranglerConfig, generateCloudflareEntry, generateCloudflareStaticAssets, type CloudflareRoutesConfig, } from "./cloudflare.js";
+export { generateNetlifyConfig, generateNetlifyFunction, } from "./netlify.js";
+export { validateDeployArtifactConformance, assertDeployArtifactConformance, type DeployArtifactConformanceInput, type DeployArtifactConformanceResult, } from "./conformance.js";

package/dist-pkg/deploy/index.js

@@ -0,0 +1,26 @@
+export {
+  generateDockerfile,
+  generateDockerignore
+} from "./dockerfile.js";
+export {
+  generateVercelConfig,
+  generateVercelServerlessEntry,
+  generateVercelBuildOutput
+} from "./vercel.js";
+export {
+  generateFlyConfig,
+  generateFlyDockerfile
+} from "./fly.js";
+export {
+  generateWranglerConfig,
+  generateCloudflareEntry,
+  generateCloudflareStaticAssets
+} from "./cloudflare.js";
+export {
+  generateNetlifyConfig,
+  generateNetlifyFunction
+} from "./netlify.js";
+export {
+  validateDeployArtifactConformance,
+  assertDeployArtifactConformance
+} from "./conformance.js";

package/dist-pkg/deploy/netlify.d.ts

@@ -0,0 +1,2 @@
+export declare function generateNetlifyConfig(): string;
+export declare function generateNetlifyFunction(): string;

package/{src/deploy/netlify.ts → dist-pkg/deploy/netlify.js}

@@ -1,7 +1,5 @@
-// Gorsee.js — Netlify deploy adapter
-
-export function generateNetlifyConfig(): string {
-  return `# Gorsee.js — Netlify configuration
+export function generateNetlifyConfig() {
+  return `# Gorsee.js \u2014 Netlify configuration
 # Auto-generated by \`gorsee deploy netlify\`
 
 [build]
@@ -10,6 +8,7 @@ export function generateNetlifyConfig(): string {
 
 [build.environment]
   NODE_VERSION = "20"
+  APP_ORIGIN = "REPLACE_WITH_APP_ORIGIN"
 
 [[edge_functions]]
   function = "gorsee-handler"
@@ -36,11 +35,10 @@ export function generateNetlifyConfig(): string {
   for = "/_gorsee/*"
   [headers.values]
     Cache-Control = "public, max-age=31536000, immutable"
-`
+`;
 }
-
-export function generateNetlifyFunction(): string {
-  return `// Gorsee.js — Netlify Edge Function
+export function generateNetlifyFunction() {
+  return `// Gorsee.js \u2014 Netlify Edge Function
 // Auto-generated by \`gorsee deploy netlify\`
 // Place in: netlify/edge-functions/gorsee-handler.ts
 
@@ -51,8 +49,9 @@ export default async function handler(
   context: Context,
 ): Promise<Response> {
   const url = new URL(request.url)
+  const appOrigin = Netlify.env.get("APP_ORIGIN") ?? url.origin
 
-  // Skip static assets — handled by Netlify CDN
+  // Skip static assets \u2014 handled by Netlify CDN
   if (url.pathname.startsWith("/_gorsee/")) {
     return context.next()
   }
@@ -64,8 +63,15 @@ export default async function handler(
 
   // Forward to Gorsee server handler
   try {
+    const rpcPolicy = {
+      // Wire auth/CSRF middleware here for privileged server() calls.
+      // The server handler should prefer app.config.ts security.rpc.middlewares
+      // when no explicit runtime policy is provided.
+      middlewares: [],
+    }
     const { handleRequest } = await import("../../dist/server-handler.js")
-    return await handleRequest(request, { netlifyContext: context })
+    void appOrigin
+    return await handleRequest(request, { netlifyContext: context }, { rpcPolicy })
   } catch (err) {
     console.error("Gorsee handler error:", err)
     return new Response("Internal Server Error", { status: 500 })
@@ -73,5 +79,5 @@ export default async function handler(
 }
 
 export const config = { path: "/*" }
-`
+`;
 }

package/dist-pkg/deploy/runtime.d.ts

@@ -0,0 +1,2 @@
+export type ProcessDeployRuntime = "bun" | "node";
+export declare function isProcessDeployRuntime(value: string | undefined): value is ProcessDeployRuntime;

package/dist-pkg/deploy/runtime.js

@@ -0,0 +1,3 @@
+export function isProcessDeployRuntime(value) {
+  return value === "bun" || value === "node";
+}

package/dist-pkg/deploy/vercel.d.ts

@@ -0,0 +1,22 @@
+export interface VercelConfig {
+    version: number;
+    framework: null;
+    buildCommand: string;
+    outputDirectory: string;
+    routes: Array<{
+        src: string;
+        dest?: string;
+        headers?: Record<string, string>;
+    }>;
+}
+export declare function generateVercelConfig(): VercelConfig;
+export declare function generateVercelServerlessEntry(): string;
+export interface VercelOutputConfig {
+    version: number;
+    routes: Array<{
+        src: string;
+        dest?: string;
+        headers?: Record<string, string>;
+    }>;
+}
+export declare function generateVercelBuildOutput(routes: string[]): VercelOutputConfig;

package/dist-pkg/deploy/vercel.js

@@ -0,0 +1,53 @@
+export function generateVercelConfig() {
+  return {
+    version: 2,
+    framework: null,
+    buildCommand: "bun run build",
+    outputDirectory: ".vercel/output",
+    routes: [
+      {
+        src: "/_gorsee/(.*)",
+        headers: { "Cache-Control": "public, max-age=31536000, immutable" }
+      },
+      { src: "/(.*)", dest: "/api/index" }
+    ]
+  };
+}
+export function generateVercelServerlessEntry() {
+  return `// Gorsee.js \u2014 Vercel serverless entry
+// Auto-generated by \`gorsee deploy vercel\`
+
+import { handleRequest } from "../dist/server-handler-node.js"
+
+export default async function handler(request: Request): Promise<Response> {
+  const url = new URL(request.url)
+  // Set APP_ORIGIN in your Vercel project environment before production traffic.
+  const appOrigin = process.env.APP_ORIGIN ?? url.origin
+  void appOrigin
+
+  const rpcPolicy = {
+    // Wire auth/CSRF middleware here for privileged server() calls.
+    middlewares: [],
+  }
+
+  return handleRequest(request, { vercel: true }, { rpcPolicy })
+}
+`;
+}
+export function generateVercelBuildOutput(routes) {
+  const outputRoutes = [
+    {
+      src: "/_gorsee/(.*)",
+      dest: "/static/_gorsee/$1",
+      headers: { "Cache-Control": "public, max-age=31536000, immutable" }
+    },
+    {
+      src: "/favicon\\.ico|/robots\\.txt|/styles\\.css",
+      dest: "/static/$0"
+    }
+  ];
+  for (const route of routes)
+    outputRoutes.push({ src: route, dest: "/functions/index" });
+  outputRoutes.push({ src: "/(.*)", dest: "/functions/index" });
+  return { version: 3, routes: outputRoutes };
+}

package/dist-pkg/dev/error-overlay.d.ts

@@ -0,0 +1 @@
+export declare function renderErrorOverlay(error: Error | string, nonce: string): string;

package/{src/dev/error-overlay.ts → dist-pkg/dev/error-overlay.js}

@@ -1,25 +1,15 @@
-// Dev error overlay -- styled error page with source context
-
-import { escapeHTML } from "../runtime/html-escape.ts"
-
-export function renderErrorOverlay(error: Error | string, nonce: string): string {
-  const message = typeof error === "string" ? error : error.message
-  const stack = typeof error === "string" ? "" : error.stack ?? ""
-
-  // Parse stack to extract file:line
-  const stackLines = stack.split("\n").slice(1)
-  const frames = stackLines.map((line) => {
-    const match = line.match(/at\s+(.+?)\s+\((.+):(\d+):(\d+)\)/)
-    if (match) return { fn: match[1], file: match[2], line: match[3], col: match[4] }
-    const match2 = line.match(/at\s+(.+):(\d+):(\d+)/)
-    if (match2) return { fn: "(anonymous)", file: match2[1], line: match2[2], col: match2[3] }
-    return null
-  }).filter(Boolean)
-
-  const framesHTML = frames.map((f) =>
-    `<div class="g-frame"><span class="g-fn">${escapeHTML(f!.fn!)}</span> <span class="g-loc">${escapeHTML(f!.file!)}:${f!.line}</span></div>`
-  ).join("")
-
+import { escapeHTML } from "../runtime/html-escape.js";
+export function renderErrorOverlay(error, nonce) {
+  const message = typeof error === "string" ? error : error.message, frames = (typeof error === "string" ? "" : error.stack ?? "").split(`
+`).slice(1).map((line) => {
+    const match = line.match(/at\s+(.+?)\s+\((.+):(\d+):(\d+)\)/);
+    if (match)
+      return { fn: match[1], file: match[2], line: match[3], col: match[4] };
+    const match2 = line.match(/at\s+(.+):(\d+):(\d+)/);
+    if (match2)
+      return { fn: "(anonymous)", file: match2[1], line: match2[2], col: match2[3] };
+    return null;
+  }).filter(Boolean), framesHTML = frames.map((f) => `<div class="g-frame"><span class="g-fn">${escapeHTML(f.fn)}</span> <span class="g-loc">${escapeHTML(f.file)}:${f.line}</span></div>`).join("");
   return `<!DOCTYPE html>
 <html>
 <head><meta charset="UTF-8" /><title>Error - Gorsee Dev</title>
@@ -50,5 +40,5 @@ body{font-family:ui-monospace,SFMono-Regular,Menlo,monospace;background:#1a1a2e;
   </div>
 </div>
 </body>
-</html>`
+</html>`;
 }

package/dist-pkg/dev/hmr.d.ts

@@ -0,0 +1,30 @@
+import type { BuildResult } from "../build/client.js";
+import type { Route } from "../router/index.js";
+export type HMRUpdateKind = "full-reload" | "route-refresh" | "css-update";
+export interface HMRUpdate {
+    kind: HMRUpdateKind;
+    changedPath: string;
+    timestamp: number;
+    reason?: string;
+    routePaths?: string[];
+    entryScripts?: string[];
+    refreshCurrentRoute?: boolean;
+}
+export interface HMRUpdateContext {
+    changedPath: string;
+    routesDir: string;
+    sharedDir: string;
+    middlewareDir: string;
+    routes: Route[];
+    clientBuild: BuildResult;
+}
+export declare const HMR_CLIENT_SCRIPT = "<script data-g-hmr>\n(function(){\n  function reload() {\n    location.reload();\n  }\n  function handleMessage(raw) {\n    if (raw === \"reload\") {\n      reload();\n      return;\n    }\n    try {\n      var payload = JSON.parse(raw);\n      if (!payload || typeof payload !== \"object\") {\n        reload();\n        return;\n      }\n      if (typeof window.__gorseeHandleHMR === \"function\") {\n        window.__gorseeHandleHMR(payload);\n        return;\n      }\n    } catch {}\n    reload();\n  }\n  var ws = new WebSocket((location.protocol===\"https:\"?\"wss://\":\"ws://\") + location.host + \"/__gorsee_hmr\");\n  ws.onmessage = function(e) {\n    handleMessage(String(e.data || \"\"));\n  };\n  ws.onclose = function() {\n    setTimeout(function(){ reload(); }, 1000);\n  };\n})();\n</script>";
+export declare function addHMRClient(ws: {
+    send(data: string): void;
+}): void;
+export declare function removeHMRClient(ws: {
+    send(data: string): void;
+}): void;
+export declare function serializeHMRUpdate(update: HMRUpdate): string;
+export declare function notifyHMRUpdate(update: HMRUpdate): void;
+export declare function createHMRUpdate(context: HMRUpdateContext): HMRUpdate;

package/dist-pkg/dev/hmr.js

@@ -0,0 +1,86 @@
+import { relative } from "node:path";
+export const HMR_CLIENT_SCRIPT = `<script data-g-hmr>
+(function(){
+  function reload() {
+    location.reload();
+  }
+  function handleMessage(raw) {
+    if (raw === "reload") {
+      reload();
+      return;
+    }
+    try {
+      var payload = JSON.parse(raw);
+      if (!payload || typeof payload !== "object") {
+        reload();
+        return;
+      }
+      if (typeof window.__gorseeHandleHMR === "function") {
+        window.__gorseeHandleHMR(payload);
+        return;
+      }
+    } catch {}
+    reload();
+  }
+  var ws = new WebSocket((location.protocol==="https:"?"wss://":"ws://") + location.host + "/__gorsee_hmr");
+  ws.onmessage = function(e) {
+    handleMessage(String(e.data || ""));
+  };
+  ws.onclose = function() {
+    setTimeout(function(){ reload(); }, 1000);
+  };
+})();
+</script>`;
+const clients = new Set;
+export function addHMRClient(ws) {
+  clients.add(ws);
+}
+export function removeHMRClient(ws) {
+  clients.delete(ws);
+}
+export function serializeHMRUpdate(update) {
+  return JSON.stringify(update);
+}
+export function notifyHMRUpdate(update) {
+  const payload = serializeHMRUpdate(update);
+  for (const ws of clients)
+    try {
+      ws.send(payload);
+    } catch {}
+}
+export function createHMRUpdate(context) {
+  const normalizedChangedPath = context.changedPath.replace(/\\/g, "/"), timestamp = Date.now(), isCSS = normalizedChangedPath.endsWith(".css"), routePaths = context.routes.filter((route) => route.filePath.replace(/\\/g, "/") === normalizedChangedPath || route.layoutPaths.some((layoutPath) => layoutPath.replace(/\\/g, "/") === normalizedChangedPath) || route.middlewarePaths.some((middlewarePath) => middlewarePath.replace(/\\/g, "/") === normalizedChangedPath) || route.errorPath?.replace(/\\/g, "/") === normalizedChangedPath || route.loadingPath?.replace(/\\/g, "/") === normalizedChangedPath).map((route) => route.path), entryScripts = routePaths.map((routePath) => context.clientBuild.entryMap.get(routePath)).filter((entry) => typeof entry === "string").map((entry) => `/_gorsee/${entry}`);
+  if (normalizedChangedPath.startsWith(context.routesDir.replace(/\\/g, "/"))) {
+    if (routePaths.length === 0 && entryScripts.length === 0)
+      return {
+        kind: "full-reload",
+        changedPath: normalizedChangedPath,
+        timestamp,
+        reason: "route change could not be mapped to a stable entry",
+        refreshCurrentRoute: !0
+      };
+    return {
+      kind: isCSS ? "css-update" : "route-refresh",
+      changedPath: normalizedChangedPath,
+      timestamp,
+      routePaths,
+      entryScripts,
+      refreshCurrentRoute: !0
+    };
+  }
+  if (normalizedChangedPath.startsWith(context.sharedDir.replace(/\\/g, "/")) || normalizedChangedPath.startsWith(context.middlewareDir.replace(/\\/g, "/")))
+    return {
+      kind: isCSS ? "css-update" : "route-refresh",
+      changedPath: normalizedChangedPath,
+      timestamp,
+      reason: normalizedChangedPath.startsWith(context.sharedDir.replace(/\\/g, "/")) ? "shared dependency changed" : "middleware changed",
+      refreshCurrentRoute: !0
+    };
+  return {
+    kind: "full-reload",
+    changedPath: normalizedChangedPath,
+    timestamp,
+    reason: `unclassified dev update: ${relative(process.cwd(), normalizedChangedPath)}`,
+    refreshCurrentRoute: !0
+  };
+}

package/dist-pkg/dev/partial-handler.d.ts

@@ -0,0 +1,9 @@
+import type { MatchResult } from "../router/matcher.js";
+import type { BuildResult } from "../build/client.js";
+interface PartialRenderOptions {
+    match: MatchResult;
+    request: Request;
+    clientBuild: BuildResult;
+}
+export declare function handlePartialNavigation(opts: PartialRenderOptions): Promise<Response>;
+export {};

package/dist-pkg/dev/partial-handler.js

@@ -0,0 +1,24 @@
+import { createContext } from "../server/middleware.js";
+import {
+  createClientScriptPath,
+  resolvePageRoute
+} from "../server/page-render.js";
+import { renderRoutePartialResponse } from "../server/route-response.js";
+export async function handlePartialNavigation(opts) {
+  const { match, request, clientBuild } = opts, mod = await import(match.route.filePath), ctx = createContext(request, match.params);
+  if (typeof mod.GET === "function" || typeof mod.POST === "function")
+    return new Response("Not a page route", { status: 400 });
+  const resolved = await resolvePageRoute(mod, match, ctx);
+  if (!resolved)
+    return new Response(JSON.stringify({ error: "Route has no default export" }), {
+      status: 500,
+      headers: { "Content-Type": "application/json" }
+    });
+  const clientScript = createClientScriptPath(clientBuild.entryMap.get(match.route.path));
+  return renderRoutePartialResponse({
+    match,
+    ctx,
+    resolved,
+    clientScript
+  });
+}

package/dist-pkg/dev/request-handler.d.ts

@@ -0,0 +1,30 @@
+import type { RequestSecurityPolicy } from "../server/request-security-policy.js";
+import type { MatchResult } from "../router/matcher.js";
+import type { BuildResult } from "../build/client.js";
+interface RenderOptions {
+    match: MatchResult;
+    request: Request;
+    nonce: string;
+    start: number;
+    trace?: {
+        requestId?: string;
+        traceId?: string;
+        spanId?: string;
+        parentSpanId?: string;
+    };
+    trustedOrigin?: string;
+    trustForwardedHeaders?: boolean;
+    securityPolicy?: RequestSecurityPolicy;
+    clientBuild: BuildResult;
+    secHeaders: Record<string, string>;
+    wrapHTML: (body: string, nonce: string | undefined, opts?: {
+        title?: string;
+        clientScript?: string;
+        loaderData?: unknown;
+        params?: Record<string, string>;
+        cssFiles?: string[];
+        headElements?: string[];
+    }) => string;
+}
+export declare function handlePageRequest(opts: RenderOptions): Promise<Response>;
+export {};