@openworkers/adapter-sveltekit 0.3.6 → 0.4.0

package/dist/function-worker.js

@@ -0,0 +1,66 @@
+// src/function-worker.ts
+import * as handlers from "ENDPOINT";
+var worker = {
+  async fetch(req, env, ctx) {
+    globalThis.env = env;
+    const method = req.method;
+    const handler = handlers[method];
+    if (!handler) {
+      return new Response("Method Not Allowed", {
+        status: 405,
+        headers: { Allow: Object.keys(handlers).join(", ") }
+      });
+    }
+    const url = new URL(req.url);
+    let params = {};
+    if (WITH_PARAMS) {
+      const { extractParams } = await import("lib:routing");
+      params = extractParams(url);
+    }
+    const responseHeaders = new Headers();
+    let cookiesData;
+    if (WITH_COOKIES) {
+      const { getCookies } = await import("lib:cookies");
+      cookiesData = getCookies(req, url);
+      cookiesData.set_trailing_slash("ignore");
+    }
+    const event = {
+      fetch: globalThis.fetch.bind(globalThis),
+      request: req,
+      url,
+      params,
+      cookies: WITH_COOKIES && cookiesData?.cookies || void 0,
+      locals: {},
+      platform: { env, ctx },
+      getClientAddress() {
+        return req.headers.get("x-real-ip") ?? req.headers.get("x-forwarded-for") ?? "";
+      },
+      setHeaders(headers) {
+        for (const [key, value] of Object.entries(headers)) {
+          responseHeaders.set(key, String(value));
+        }
+      }
+    };
+    try {
+      const response = await handler(event);
+      if (WITH_COOKIES && cookiesData?.new_cookies) {
+        const { addCookiesToHeaders } = await import("lib:cookies");
+        addCookiesToHeaders(response.headers, cookiesData.new_cookies.values());
+      }
+      for (const [key, value] of responseHeaders.entries()) {
+        response.headers.append(key, value);
+      }
+      return response;
+    } catch (error) {
+      console.error(`[Function] Error in ${method} handler:`, error);
+      return new Response(JSON.stringify({ error: "Internal Server Error" }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  }
+};
+var function_worker_default = worker;
+export {
+  function_worker_default as default
+};

package/dist/index.js

@@ -0,0 +1,349 @@
+// src/index.ts
+import { existsSync, writeFileSync as writeFileSync2, readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { build as build2 } from "esbuild";
+
+// src/lib/build-function.ts
+import { build } from "esbuild";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { writeFileSync, unlinkSync, mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+
+// src/lib/detect-cookies.ts
+import { readFileSync } from "node:fs";
+function detectCookiesUsage(filePath) {
+  try {
+    let code = readFileSync(filePath, "utf-8");
+    code = code.replace(/\/\/.*$/gm, "");
+    code = code.replace(/\/\*[\s\S]*?\*\//g, "");
+    code = code.replace(/`[^`]*`/g, "");
+    code = code.replace(/"[^"]*"/g, "");
+    code = code.replace(/'[^']*'/g, "");
+    const patterns = [
+      /\{\s*[^}]*\bcookies\b[^}]*\}/,
+      // Destructuring: { cookies }
+      /\bevent\.cookies\b/,
+      // Direct access: event.cookies
+      /\brequest\.cookies\b/
+      // Alternative: request.cookies
+    ];
+    return patterns.some((pattern) => pattern.test(code));
+  } catch (error) {
+    console.warn(`Could not analyze ${filePath} for cookie usage:`, error.message);
+    return true;
+  }
+}
+
+// node_modules/esm-env/browser-fallback.js
+var browser_fallback_default = typeof window !== "undefined";
+
+// node_modules/esm-env/dev-fallback.js
+var node_env = globalThis.process?.env?.NODE_ENV;
+var dev_fallback_default = node_env && !node_env.toLowerCase().startsWith("prod");
+
+// node_modules/@sveltejs/kit/src/utils/routing.js
+var param_pattern = /^(\[)?(\.\.\.)?(\w+)(?:=(\w+))?(\])?$/;
+function parse_route_id(id) {
+  const params = [];
+  const pattern = id === "/" ? /^\/$/ : new RegExp(
+    `^${get_route_segments(id).map((segment) => {
+      const rest_match = /^\[\.\.\.(\w+)(?:=(\w+))?\]$/.exec(segment);
+      if (rest_match) {
+        params.push({
+          name: rest_match[1],
+          matcher: rest_match[2],
+          optional: false,
+          rest: true,
+          chained: true
+        });
+        return "(?:/([^]*))?";
+      }
+      const optional_match = /^\[\[(\w+)(?:=(\w+))?\]\]$/.exec(segment);
+      if (optional_match) {
+        params.push({
+          name: optional_match[1],
+          matcher: optional_match[2],
+          optional: true,
+          rest: false,
+          chained: true
+        });
+        return "(?:/([^/]+))?";
+      }
+      if (!segment) {
+        return;
+      }
+      const parts = segment.split(/\[(.+?)\](?!\])/);
+      const result = parts.map((content, i) => {
+        if (i % 2) {
+          if (content.startsWith("x+")) {
+            return escape(String.fromCharCode(parseInt(content.slice(2), 16)));
+          }
+          if (content.startsWith("u+")) {
+            return escape(
+              String.fromCharCode(
+                ...content.slice(2).split("-").map((code) => parseInt(code, 16))
+              )
+            );
+          }
+          const match = (
+            /** @type {RegExpExecArray} */
+            param_pattern.exec(content)
+          );
+          if (!browser_fallback_default && !match) {
+            throw new Error(
+              `Invalid param: ${content}. Params and matcher names can only have underscores and alphanumeric characters.`
+            );
+          }
+          const [, is_optional, is_rest, name2, matcher] = match;
+          params.push({
+            name: name2,
+            matcher,
+            optional: !!is_optional,
+            rest: !!is_rest,
+            chained: is_rest ? i === 1 && parts[0] === "" : false
+          });
+          return is_rest ? "([^]*?)" : is_optional ? "([^/]*)?" : "([^/]+?)";
+        }
+        return escape(content);
+      }).join("");
+      return "/" + result;
+    }).join("")}/?$`
+  );
+  return { pattern, params };
+}
+function affects_path(segment) {
+  return segment !== "" && !/^\([^)]+\)$/.test(segment);
+}
+function get_route_segments(route) {
+  return route.slice(1).split("/").filter(affects_path);
+}
+function escape(str) {
+  return str.normalize().replace(/[[\]]/g, "\\$&").replace(/%/g, "%25").replace(/\//g, "%2[Ff]").replace(/\?/g, "%3[Ff]").replace(/#/g, "%23").replace(/[.*+?^${}()|\\]/g, "\\$&");
+}
+
+// src/lib/generate-params.ts
+function generateParamsModule(routePattern) {
+  const { pattern, params } = parse_route_id(routePattern);
+  return `import { exec } from 'sveltekit:routing';
+
+const pattern = ${pattern};
+const params = ${JSON.stringify(params)};
+
+export function extractParams(url) {
+  const match = pattern.exec(url.pathname);
+  if (!match) return {};
+  return exec(match, params, {}) || {};
+}`;
+}
+
+// src/lib/build-function.ts
+async function buildFunctionWorker(options) {
+  const {
+    endpointFile,
+    outfile,
+    routePattern,
+    minify = false
+  } = options;
+  const usesCookies = detectCookiesUsage(endpointFile);
+  const hasParams = routePattern.includes("[");
+  const tempDir = mkdtempSync(path.join(tmpdir(), "adapter-params-"));
+  const paramsModulePath = path.join(tempDir, "params.js");
+  const paramsModuleCode = generateParamsModule(routePattern);
+  writeFileSync(paramsModulePath, paramsModuleCode);
+  const urlPath = fileURLToPath(import.meta.url);
+  const adapterRoot = urlPath.includes("/dist/") ? fileURLToPath(new URL("..", import.meta.url)) : fileURLToPath(new URL("../..", import.meta.url));
+  const files = path.join(adapterRoot, "dist");
+  const functionTemplate = path.join(files, "function-worker.js");
+  const libCookies = path.join(files, "../src/lib/cookies.js");
+  const svelteKitCookie = path.join(adapterRoot, "node_modules/@sveltejs/kit/src/runtime/server/cookie.js");
+  const svelteKitRouting = path.join(adapterRoot, "node_modules/@sveltejs/kit/src/utils/routing.js");
+  const external = ["node:*"];
+  if (!usesCookies) {
+    external.push("cookie");
+  }
+  try {
+    await build({
+      entryPoints: [functionTemplate],
+      bundle: true,
+      format: "esm",
+      platform: "neutral",
+      outfile,
+      alias: {
+        ENDPOINT: endpointFile,
+        "lib:cookies": libCookies,
+        "lib:routing": paramsModulePath,
+        "sveltekit:cookie": svelteKitCookie,
+        "sveltekit:routing": svelteKitRouting
+      },
+      external,
+      minifySyntax: minify,
+      treeShaking: true,
+      define: {
+        ROUTE_PATTERN: JSON.stringify(routePattern),
+        WITH_COOKIES: JSON.stringify(usesCookies),
+        WITH_PARAMS: JSON.stringify(hasParams)
+      }
+    });
+  } finally {
+    try {
+      unlinkSync(paramsModulePath);
+      unlinkSync(tempDir);
+    } catch {
+    }
+  }
+}
+
+// src/index.ts
+var pkg = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf-8"));
+var name = "@openworkers/adapter-sveltekit";
+var version = pkg.version;
+function index_default(options = {}) {
+  return {
+    name,
+    async adapt(builder) {
+      const dest = options.out ?? "dist";
+      const assetsDir = `${dest}/assets`;
+      const functionsEnabled = options.functions ?? false;
+      const files = fileURLToPath2(new URL(".", import.meta.url).href);
+      const tmp = builder.getBuildDirectory("openworkers-tmp");
+      builder.rimraf(dest);
+      builder.mkdirp(dest);
+      builder.mkdirp(assetsDir);
+      builder.mkdirp(tmp);
+      const clientFiles = builder.writeClient(assetsDir);
+      builder.writePrerendered(assetsDir);
+      const appPath = builder.getAppPath();
+      const staticFiles = clientFiles.filter((f) => !f.startsWith(appPath));
+      const fallback = path2.join(assetsDir, "404.html");
+      if (!existsSync(fallback)) {
+        writeFileSync2(fallback, "Not Found");
+      }
+      writeFileSync2(
+        `${tmp}/manifest.js`,
+        `export const manifest = ${builder.generateManifest({ relativePath: path2.posix.relative(tmp, builder.getServerDirectory()) })};
+
+export const prerendered = new Set(${JSON.stringify(builder.prerendered.paths)});
+
+export const base_path = ${JSON.stringify(builder.config.kit.paths.base)};
+`
+      );
+      const entryPoint = `${tmp}/entry.js`;
+      const serverPath = posixify(path2.resolve(builder.getServerDirectory(), "index.js"));
+      const manifestPath = posixify(path2.resolve(tmp, "manifest.js"));
+      writeFileSync2(
+        entryPoint,
+        `import { Server } from '${serverPath}';
+import { manifest, prerendered, base_path } from '${manifestPath}';
+export { Server, manifest, prerendered, base_path };
+`
+      );
+      const workerDest = `${dest}/_worker.js`;
+      const libAsyncHooks = posixify(path2.resolve(files, "../src/lib/async-hooks.ts"));
+      await build2({
+        entryPoints: [`${files}/worker.js`],
+        bundle: true,
+        format: "esm",
+        platform: "neutral",
+        outfile: workerDest,
+        alias: {
+          SERVER: entryPoint,
+          MANIFEST: entryPoint,
+          "node:async_hooks": libAsyncHooks
+        },
+        external: ["node:*"],
+        minifySyntax: true,
+        minifyIdentifiers: true,
+        treeShaking: true,
+        banner: {
+          js: `// Generated by ${name} v${version} at ${(/* @__PURE__ */ new Date()).toISOString()}`
+        }
+      });
+      const functions = [];
+      if (functionsEnabled) {
+        builder.mkdirp(`${dest}/functions`);
+        const serverDir = builder.getServerDirectory();
+        const viteManifestPath = path2.join(serverDir, ".vite/manifest.json");
+        if (existsSync(viteManifestPath)) {
+          const viteManifest = JSON.parse(readFileSync2(viteManifestPath, "utf-8"));
+          const endpoints = extractEndpointsFromManifest(viteManifest, serverDir);
+          for (const endpoint of endpoints) {
+            const routePattern = endpoint.pattern;
+            const workerName = endpoint.route.replace(/\//g, "-").replace(/^-/, "") || "index";
+            const workerFile = `functions/${workerName}.js`;
+            await buildFunctionWorker({
+              endpointFile: posixify(endpoint.file),
+              outfile: `${dest}/${workerFile}`,
+              routePattern: endpoint.route,
+              minify: true
+            });
+            functions.push({
+              pattern: routePattern,
+              worker: workerFile
+            });
+            builder.log.minor(`  Generated function: ${routePattern} \u2192 ${workerFile}`);
+          }
+        }
+      }
+      const routes = {
+        // Immutable assets (hashed filenames, cache forever)
+        immutable: [`/${appPath}/immutable/*`],
+        // Static files from /static folder (robots.txt, favicon, etc.)
+        static: staticFiles.map((f) => `/${f}`),
+        // Prerendered pages (serve from assets, no worker needed)
+        prerendered: builder.prerendered.paths,
+        // Functions (API routes as separate workers)
+        functions,
+        // Everything else -> SSR
+        ssr: ["/*"]
+      };
+      writeFileSync2(`${dest}/_routes.json`, JSON.stringify(routes, null, 2));
+      builder.log.minor(`Wrote ${workerDest}`);
+      builder.log.minor(`Wrote ${dest}/_routes.json`);
+      if (functions.length > 0) {
+        builder.log.minor(`Wrote ${functions.length} function workers to ${dest}/functions/`);
+      }
+      builder.log.minor(`Wrote ${assetsDir} (${builder.prerendered.paths.length} prerendered pages)`);
+    }
+  };
+}
+function extractEndpointsFromManifest(manifest, serverDir) {
+  const endpoints = [];
+  for (const [key, entry] of Object.entries(manifest)) {
+    if (!key.includes("+server.ts")) continue;
+    const sourcePath = entry.src;
+    if (!sourcePath || !sourcePath.startsWith("src/routes/")) continue;
+    const routePart = sourcePath.replace(/^src\/routes/, "").replace(/\/\+server\.(ts|js)$/, "");
+    const pattern = convertRouteToPattern(routePart);
+    const file = path2.join(serverDir, entry.file);
+    endpoints.push({
+      pattern,
+      // For routing: /status/*/*
+      route: routePart,
+      // For filename: /status/[code]/[[reason]]
+      file
+    });
+  }
+  return endpoints;
+}
+function convertRouteToPattern(route) {
+  if (!route || route === "/") return "/";
+  const segments = route.split("/").filter(Boolean);
+  const patternSegments = segments.map((segment) => {
+    if (segment.startsWith("[...") && segment.endsWith("]")) {
+      return "**";
+    }
+    if (segment.startsWith("[") && segment.endsWith("]") || segment.startsWith("[[") && segment.endsWith("]]")) {
+      return "*";
+    }
+    return segment;
+  });
+  return "/" + patternSegments.join("/");
+}
+function posixify(str) {
+  return str.replace(/\\/g, "/");
+}
+export {
+  index_default as default
+};

package/{files → dist}/worker.js

@@ -1,42 +1,34 @@
-// src/worker.js
+// src/worker.ts
 import { Server, manifest, prerendered, base_path } from "SERVER";
 var server = new Server(manifest);
 var app_path = `/${manifest.appPath}`;
 var immutable = `${app_path}/immutable/`;
 var version_file = `${app_path}/version.json`;
 if (typeof caches === "undefined") {
-  const noopCache = (
-    /** @type {any} */
-    {
-      match: async () => void 0,
-      put: async () => {
-      },
-      delete: async () => false
-    }
-  );
-  globalThis.caches = /** @type {any} */
-  {
+  const noopCache = {
+    match: async () => void 0,
+    put: async () => {
+    },
+    delete: async () => false
+  };
+  globalThis.caches = {
     default: noopCache,
     open: async () => noopCache
   };
 }
 var origin;
 var initialized = server.init({
-  env: (
-    /** @type {Record<string, string>} */
-    globalThis.env ?? {}
-  ),
+  env: globalThis.env ?? {},
   read: async (file) => {
     const url = `${origin}/${file}`;
-    const response = await /** @type {Env} */
-    globalThis.env.ASSETS.fetch(url);
+    const response = await globalThis.env.ASSETS.fetch(url);
     if (!response.ok) {
       throw new Error(`read(...) failed: could not fetch ${url} (${response.status} ${response.statusText})`);
     }
     return response.body;
   }
 });
-var worker_default = {
+var worker = {
   async fetch(req, env, ctx) {
     globalThis.env = env;
     if (!origin) {
@@ -78,6 +70,7 @@ var worker_default = {
     });
   }
 };
+var worker_default = worker;
 export {
   worker_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openworkers/adapter-sveltekit",
-  "version": "0.3.6",
+  "version": "0.4.0",
   "description": "SvelteKit adapter for OpenWorkers",
   "keywords": [
     "adapter",
@@ -18,28 +18,30 @@
   "type": "module",
   "exports": {
     ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
+    "./dist/*": "./dist/*",
     "./package.json": "./package.json"
   },
-  "types": "index.d.ts",
+  "types": "dist/index.d.ts",
   "files": [
-    "files",
-    "index.js",
-    "index.d.ts"
+    "dist"
   ],
   "scripts": {
-    "build": "esbuild src/worker.js --bundle --outfile=files/worker.js --external:SERVER --external:MANIFEST --format=esm",
+    "build": "bun build.ts",
+    "test": "bun test",
     "prepublishOnly": "npm run build",
+    "check": "tsc --noEmit",
     "format": "prettier --write ."
   },
   "dependencies": {
     "esbuild": "^0.27.2"
   },
   "devDependencies": {
-    "@openworkers/workers-types": "^0.1.7",
+    "@openworkers/workers-types": "^0.1.9",
     "@sveltejs/kit": "^2.0.0",
+    "bun-types": "^1.3.8",
     "prettier": "^3.8.1"
   },
   "peerDependencies": {

package/files/function-worker.js

@@ -1,90 +0,0 @@
-/**
- * Mini-worker template for OpenWorkers Functions.
- * Wraps a SvelteKit API endpoint as a standalone worker.
- */
-
-import * as handlers from 'ENDPOINT';
-
-/**
- * Extract route params from URL pathname based on SvelteKit route pattern
- * @param {string} pathname - URL pathname (e.g., "/stream/42")
- * @param {string} pattern - SvelteKit route pattern (e.g., "/stream/[n]")
- * @returns {Record<string, string>} - Extracted params (e.g., {n: "42"})
- */
-function extractParams(pathname, pattern) {
-  const params = {};
-  const patternSegments = pattern.split('/').filter(Boolean);
-  const pathSegments = pathname.split('/').filter(Boolean);
-
-  for (let i = 0; i < patternSegments.length; i++) {
-    const patternSegment = patternSegments[i];
-
-    // Rest parameter: [...rest]
-    if (patternSegment.startsWith('[...') && patternSegment.endsWith(']')) {
-      const paramName = patternSegment.slice(4, -1);
-      params[paramName] = pathSegments.slice(i).join('/');
-      break;
-    }
-
-    // Optional parameter: [[optional]]
-    if (patternSegment.startsWith('[[') && patternSegment.endsWith(']]')) {
-      const paramName = patternSegment.slice(2, -2);
-      if (i < pathSegments.length) {
-        params[paramName] = pathSegments[i];
-      }
-      continue;
-    }
-
-    // Regular parameter: [param]
-    if (patternSegment.startsWith('[') && patternSegment.endsWith(']')) {
-      const paramName = patternSegment.slice(1, -1);
-      params[paramName] = pathSegments[i];
-      continue;
-    }
-  }
-
-  return params;
-}
-
-export default {
-  async fetch(req, env, ctx) {
-    globalThis.env = env;
-
-    const method = req.method;
-    const handler = handlers[method];
-
-    if (!handler) {
-      return new Response('Method Not Allowed', {
-        status: 405,
-        headers: { Allow: Object.keys(handlers).join(', ') }
-      });
-    }
-
-    const url = new URL(req.url);
-
-    // Extract params from URL based on route pattern
-    const params = extractParams(url.pathname, ROUTE_PATTERN);
-
-    // Build a minimal RequestEvent-like object
-    const event = {
-      request: req,
-      url,
-      params,
-      platform: { env, ctx },
-      getClientAddress() {
-        return req.headers.get('x-real-ip') ?? req.headers.get('x-forwarded-for') ?? '';
-      }
-    };
-
-    try {
-      return await handler(event);
-    } catch (error) {
-      console.error(`[Function] Error in ${method} handler:`, error);
-
-      return new Response(JSON.stringify({ error: 'Internal Server Error' }), {
-        status: 500,
-        headers: { 'Content-Type': 'application/json' }
-      });
-    }
-  }
-};

package/files/shims/async_hooks.js

@@ -1,41 +0,0 @@
-/**
- * Minimal AsyncLocalStorage shim for OpenWorkers.
- *
- * OpenWorkers creates a fresh V8 context per request.
- * Module-level state is already isolated, so no real async tracking is needed.
- */
-
-export class AsyncLocalStorage {
-  #store;
-
-  run(store, fn, ...args) {
-    this.#store = store;
-    return fn(...args);
-  }
-
-  getStore() {
-    return this.#store;
-  }
-
-  // Stubs for API completeness
-  enterWith(store) {
-    this.#store = store;
-  }
-
-  exit(fn, ...args) {
-    this.#store = undefined;
-    return fn(...args);
-  }
-
-  disable() {
-    this.#store = undefined;
-  }
-
-  static bind(fn) {
-    return fn;
-  }
-
-  static snapshot() {
-    return (fn, ...args) => fn(...args);
-  }
-}

package/index.js

@@ -1,242 +0,0 @@
-import { existsSync, writeFileSync, readdirSync, statSync, readFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { build } from 'esbuild';
-
-const pkg = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf-8'));
-const name = '@openworkers/adapter-sveltekit';
-const version = pkg.version;
-
-/** @type {import('./index.js').default} */
-export default function (options = {}) {
-  return {
-    name,
-    /** @param {import('@sveltejs/kit').Builder} builder */
-    async adapt(builder) {
-      const dest = options.out ?? 'dist';
-      const assetsDir = `${dest}/assets`;
-      const functionsEnabled = options.functions ?? false;
-
-      const files = fileURLToPath(new URL('./files', import.meta.url).href);
-      const tmp = builder.getBuildDirectory('openworkers-tmp');
-
-      builder.rimraf(dest);
-      builder.mkdirp(dest);
-      builder.mkdirp(assetsDir);
-      builder.mkdirp(tmp);
-
-      // Write client assets (returns list of files)
-      const clientFiles = builder.writeClient(assetsDir);
-
-      // Write prerendered pages
-      builder.writePrerendered(assetsDir);
-
-      // Separate static files from app files
-      const appPath = builder.getAppPath();
-      const staticFiles = clientFiles.filter((f) => !f.startsWith(appPath));
-
-      // Generate 404.html fallback
-      const fallback = path.join(assetsDir, '404.html');
-
-      if (!existsSync(fallback)) {
-        writeFileSync(fallback, 'Not Found');
-      }
-
-      // Generate manifest
-      writeFileSync(
-        `${tmp}/manifest.js`,
-        `export const manifest = ${builder.generateManifest({ relativePath: path.posix.relative(tmp, builder.getServerDirectory()) })};\n\n` +
-          `export const prerendered = new Set(${JSON.stringify(builder.prerendered.paths)});\n\n` +
-          `export const base_path = ${JSON.stringify(builder.config.kit.paths.base)};\n`
-      );
-
-      // Create entry point that imports server and manifest
-      const entryPoint = `${tmp}/entry.js`;
-      const serverPath = posixify(path.resolve(builder.getServerDirectory(), 'index.js'));
-      const manifestPath = posixify(path.resolve(tmp, 'manifest.js'));
-
-      writeFileSync(
-        entryPoint,
-        `import { Server } from '${serverPath}';\n` +
-          `import { manifest, prerendered, base_path } from '${manifestPath}';\n` +
-          `export { Server, manifest, prerendered, base_path };\n`
-      );
-
-      // Bundle main worker with esbuild
-      const workerDest = `${dest}/_worker.js`;
-      const shimAsyncHooks = posixify(path.resolve(files, 'shims/async_hooks.js'));
-
-      await build({
-        entryPoints: [`${files}/worker.js`],
-        bundle: true,
-        format: 'esm',
-        platform: 'browser',
-        outfile: workerDest,
-        alias: {
-          SERVER: entryPoint,
-          MANIFEST: entryPoint,
-          'node:async_hooks': shimAsyncHooks
-        },
-        external: ['node:*'],
-        minify: false,
-        banner: {
-          js: `// Generated by ${name} v${version}\n`
-        }
-      });
-
-      // Generate mini-workers for API routes if enabled
-      /** @type {Array<{pattern: string, worker: string}>} */
-      const functions = [];
-
-      if (functionsEnabled) {
-        builder.mkdirp(`${dest}/functions`);
-
-        const serverDir = builder.getServerDirectory();
-        const viteManifestPath = path.join(serverDir, '.vite/manifest.json');
-        const functionTemplate = posixify(path.resolve(files, 'function-worker.js'));
-
-        if (existsSync(viteManifestPath)) {
-          const viteManifest = JSON.parse(readFileSync(viteManifestPath, 'utf-8'));
-          const endpoints = extractEndpointsFromManifest(viteManifest, serverDir);
-
-          for (const endpoint of endpoints) {
-            const routePattern = endpoint.pattern;
-            // Use SvelteKit route syntax for worker filename
-            const workerName = endpoint.route.replace(/\//g, '-').replace(/^-/, '') || 'index';
-            const workerFile = `functions/${workerName}.js`;
-
-            // Bundle using the template with ENDPOINT alias
-            await build({
-              entryPoints: [functionTemplate],
-              bundle: true,
-              format: 'esm',
-              platform: 'browser',
-              outfile: `${dest}/${workerFile}`,
-              alias: {
-                ENDPOINT: posixify(endpoint.file),
-                'node:async_hooks': shimAsyncHooks
-              },
-              external: ['node:*'],
-              minify: false,
-              define: {
-                ROUTE_PATTERN: JSON.stringify(endpoint.route)
-              },
-              banner: {
-                js: `// Generated by ${name} v${version} - Function: ${routePattern}\n`
-              }
-            });
-
-            functions.push({
-              pattern: routePattern,
-              worker: workerFile
-            });
-
-            builder.log.minor(`  Generated function: ${routePattern} → ${workerFile}`);
-          }
-        }
-      }
-
-      // Generate _routes.json for edge routing
-      const routes = {
-        // Immutable assets (hashed filenames, cache forever)
-        immutable: [`/${appPath}/immutable/*`],
-        // Static files from /static folder (robots.txt, favicon, etc.)
-        static: staticFiles.map((f) => `/${f}`),
-        // Prerendered pages (serve from assets, no worker needed)
-        prerendered: builder.prerendered.paths,
-        // Functions (API routes as separate workers)
-        functions: functions,
-        // Everything else -> SSR
-        ssr: ['/*']
-      };
-
-      writeFileSync(
-        `${dest}/_routes.json`,
-        JSON.stringify(routes, null, 2)
-      );
-
-      builder.log.minor(`Wrote ${workerDest}`);
-      builder.log.minor(`Wrote ${dest}/_routes.json`);
-
-      if (functions.length > 0) {
-        builder.log.minor(`Wrote ${functions.length} function workers to ${dest}/functions/`);
-      }
-
-      builder.log.minor(`Wrote ${assetsDir} (${builder.prerendered.paths.length} prerendered pages)`);
-    }
-  };
-}
-
-/**
- * Extract endpoints from Vite manifest and convert SvelteKit routes to simple patterns
- * @param {object} manifest - Vite manifest object
- * @param {string} serverDir - Server build directory
- * @returns {Array<{pattern: string, route: string, file: string}>}
- */
-function extractEndpointsFromManifest(manifest, serverDir) {
-  const endpoints = [];
-
-  for (const [key, entry] of Object.entries(manifest)) {
-    // Only process endpoint files (+server.ts)
-    if (!key.includes('+server.ts')) continue;
-
-    const sourcePath = entry.src;
-    if (!sourcePath || !sourcePath.startsWith('src/routes/')) continue;
-
-    // Extract route from source path: src/routes/status/[code]/[[reason]]/+server.ts
-    const routePart = sourcePath
-      .replace(/^src\/routes/, '')
-      .replace(/\/\+server\.(ts|js)$/, '');
-
-    // Convert SvelteKit route syntax to simple wildcard patterns
-    const pattern = convertRouteToPattern(routePart);
-
-    // Get the built file path
-    const file = path.join(serverDir, entry.file);
-
-    endpoints.push({
-      pattern,       // For routing: /status/*/*
-      route: routePart,  // For filename: /status/[code]/[[reason]]
-      file
-    });
-  }
-
-  return endpoints;
-}
-
-/**
- * Convert SvelteKit route syntax to simple wildcard patterns
- * Examples:
- *   /status/[code]/[[reason]] becomes /status/star/star
- *   /range/[n] becomes /range/star
- *   /drip/[...params] becomes /drip/doublestar
- * @param {string} route - SvelteKit route (e.g. "/status/[code]/[[reason]]")
- * @returns {string} - Simple pattern with wildcards
- */
-function convertRouteToPattern(route) {
-  if (!route || route === '/') return '/';
-
-  const segments = route.split('/').filter(Boolean);
-  const patternSegments = segments.map(segment => {
-    // Rest parameter: [...params] -> **
-    if (segment.startsWith('[...') && segment.endsWith(']')) {
-      return '**';
-    }
-
-    // Required or optional parameter: [param] or [[param]] -> *
-    if ((segment.startsWith('[') && segment.endsWith(']')) ||
-        (segment.startsWith('[[') && segment.endsWith(']]'))) {
-      return '*';
-    }
-
-    // Static segment: keep as-is
-    return segment;
-  });
-
-  return '/' + patternSegments.join('/');
-}
-
-/** @param {string} str */
-function posixify(str) {
-  return str.replace(/\\/g, '/');
-}