@pingpolls/svelte-adapter-bun-isr 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PingPolls
+
+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/README.md

@@ -0,0 +1,60 @@
+# @pingpolls/svelte-adapter-bun-isr
+
+A SvelteKit adapter designed for Bun environments that provides built-in Incremental Static Regeneration (ISR) support.
+
+## Installation
+
+```bash
+bun add -D @pingpolls/svelte-adapter-bun-isr
+```
+
+## Usage
+
+Add the adapter to your `svelte.config.js`:
+
+```javascript
+import adapter from '@pingpolls/svelte-adapter-bun-isr';
+
+export default {
+  kit: {
+    adapter: adapter({
+      out: 'build',
+      revalidateToken: process.env.REVALIDATE_TOKEN, // Enables POST /__isr/revalidate
+    }),
+  },
+};
+```
+
+## Features
+
+*   **Automatic ISR Support:** Define `export const revalidate = <seconds>` in your SvelteKit routes (`+page.server.ts`). The adapter automatically schedules proactive re-renders for these routes.
+*   **On-Demand Revalidation:** You can manually trigger a rebuild for a specific path using a POST request to `/__isr/revalidate?path=/your/route` (requires a valid `x-revalidate-token` header).
+*   **Warm-on-Boot:** All ISR-eligible paths are rendered and cached once when the Bun server starts.
+
+## Configuration Options
+
+| Option | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `out` | `string` | `'build'` | The output directory for the generated SvelteKit files. |
+| `revalidateToken` | `string` | `undefined` | A token required to authenticate on-demand revalidation requests. |
+| `precompress` | `boolean` | `false` | Enables pre-compression of static assets. |
+
+## ISR Convention
+
+To enable ISR on a route, export `revalidate` in your `+page.server.ts` or `+layout.server.ts` files:
+
+```ts
+// src/routes/blog/[slug]/+page.server.ts
+export const revalidate = 900; // Rebuild every 900 seconds (15 minutes)
+```
+
+## V1 Limitations
+
+*   **Single-Process Cache:** The current implementation uses an in-memory `Map` for caching. Cache coordination across multiple running processes or instances is not supported.
+*   **Path-Only Caching:** The cache keys are based solely on the pathname. Queries parameters in the URL are ignored for caching purposes.
+
+## Development
+
+```bash
+bun run build && bun test
+```

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import type { Adapter } from "@sveltejs/kit";
+interface AdapterOptions {
+    out?: string;
+    port?: number;
+}
+export default function (options?: AdapterOptions): Adapter;
+export {};

package/dist/index.js

@@ -0,0 +1,162 @@
+// @bun
+import{cpSync as Q,existsSync as L,mkdirSync as X,writeFileSync as g}from"fs";import{readdir as w}from"fs/promises";import{join as q}from"path";var M="svelte-adapter-bun-isr";function N(K={}){let{out:U="build",port:Z=3000}=K;return{name:M,async adapt(z){let H=q(process.cwd(),U),G=z.getBuildDirectory("adapter-bun");z.rimraf(H),z.rimraf(G),X(G,{recursive:!0}),z.log.minor("Copying client assets"),z.writeClient(q(H,"client")),z.log.minor("Copying prerendered pages"),z.writePrerendered(q(H,"prerendered")),z.log.minor("Building server"),z.writeServer(G);let F=JSON.stringify(z.prerendered.paths);g(q(G,"manifest.js"),[`export const manifest = ${z.generateManifest({relativePath:"./"})};`,`export const prerendered = new Set(${F});`,`export const base = ${JSON.stringify(z.config.kit.paths.base)};`].join(`
+
+`));let J=q(H,"server");X(J,{recursive:!0}),Q(q(G,"manifest.js"),q(J,"manifest.js"));let B=q(G,"index.js");if(L(B))Q(B,q(J,"index.js"));let $=q(G,"chunks");if(L($)){let O=q(J,"chunks");X(O,{recursive:!0});let V=await w($);for(let R of V)Q(q($,R),q(O,R))}let T=q(G,"entries");if(L(T))await Y(T,q(J,"entries"));let W=q(G,"nodes");if(L(W))await Y(W,q(J,"nodes"));let I=["env.js","internal.js","remote-entry.js"];for(let O of I){let V=q(G,O);if(L(V))Q(V,q(J,O))}let _=q(G,".vite");if(L(_))await Y(_,q(J,".vite"));g(q(H,"index.js"),f(Z)),z.log.minor(`Adapter output written to ${H}`)},supports:{read:()=>!0}}}async function Y(K,U){X(U,{recursive:!0});let Z=await w(K,{withFileTypes:!0});for(let z of Z){let H=q(K,z.name),G=q(U,z.name);if(z.isDirectory())await Y(H,G);else Q(H,G)}}function f(K){return`
+import { Server } from './server/index.js';
+import { manifest, prerendered, base } from './server/manifest.js';
+import { Glob } from 'bun';
+import { join } from 'node:path';
+
+const ADAPTER_NAME = 'svelte-adapter-bun-isr';
+const ISR_CACHE = new Map();
+const ASSET_DIR = join(import.meta.dir, 'client', base);
+const PRERENDERED_DIR = join(import.meta.dir, 'prerendered');
+
+const server = new Server(manifest);
+
+await server.init({
+  env: Bun.env,
+  read: (file) => Bun.file(join(ASSET_DIR, file)).stream(),
+});
+
+// Pre-compute: build a Set of all client asset paths for O(1) lookups
+// instead of calling existsSync on every request
+const clientAssets = new Set();
+const assetGlob = new Glob('**/*');
+for await (const entry of assetGlob.scan({ cwd: ASSET_DIR, onlyFiles: true, absolute: false })) {
+  clientAssets.add('/' + base + '/' + entry);
+}
+
+// Pre-compute: build a Map of regex -> revalidate duration from manifest routes
+// This eliminates per-request route pattern matching and dynamic imports
+const revalidateMap = new Map();
+const routes = manifest._?.routes || [];
+for (const route of routes) {
+  if (!route.pattern) continue;
+  const page = route.page;
+  if (!page) continue;
+
+  let revalidate = null;
+
+  // Check layouts first
+  for (const leafIdx of page.layouts || []) {
+    try {
+      const mod = await manifest._.nodes[leafIdx]();
+      if (mod?.config && typeof mod.config.revalidate === 'number') {
+        revalidate = mod.config.revalidate;
+        break;
+      }
+    } catch {}
+  }
+
+  // Check leaf if no layout had revalidate
+  if (revalidate === null && typeof page.leaf === 'number') {
+    try {
+      const mod = await manifest._.nodes[page.leaf]();
+      if (mod?.config && typeof mod.config.revalidate === 'number') {
+        revalidate = mod.config.revalidate;
+      }
+    } catch {}
+  }
+
+  if (revalidate !== null) {
+    revalidateMap.set(route.pattern, revalidate);
+  }
+}
+
+function getRevalidateForPath(pathname) {
+  for (const [pattern, revalidate] of revalidateMap) {
+    if (pattern.test(pathname)) {
+      return revalidate;
+    }
+  }
+  return null;
+}
+
+function getCached(pathname) {
+  const entry = ISR_CACHE.get(pathname);
+  if (!entry) return null;
+  const age = (Date.now() - entry.timestamp) / 1000;
+  if (age < entry.revalidate) return entry.html;
+  ISR_CACHE.delete(pathname);
+  return null;
+}
+
+function setCache(pathname, html, revalidate) {
+  ISR_CACHE.set(pathname, { html, timestamp: Date.now(), revalidate });
+}
+
+// Pre-compute: build a Map of prerendered page -> pre-opened BunFile
+// for zero-allocation, zero-syscall serving
+const prerenderedFiles = new Map();
+for (const p of prerendered) {
+  const candidates = [
+    join(PRERENDERED_DIR, p),
+    join(PRERENDERED_DIR, p + '.html'),
+    join(PRERENDERED_DIR, p, 'index.html'),
+  ];
+  for (const filePath of candidates) {
+    const f = Bun.file(filePath);
+    if (await f.exists()) {
+      prerenderedFiles.set(p, f);
+      break;
+    }
+  }
+}
+
+const bunServer = Bun.serve({
+  port: ${K},
+  idleTimeout: 0,
+  reusePort: true,
+  development: false,
+
+  async fetch(request) {
+    const url = new URL(request.url);
+    let pathname = url.pathname;
+
+    // 1. Serve static client assets (O(1) Set lookup)
+    if (clientAssets.has(pathname)) {
+      const filePath = join(ASSET_DIR, pathname.slice(base.length + 1) || pathname);
+      const file = Bun.file(filePath);
+      const headers = {};
+      if (pathname.includes('/immutable/')) {
+        headers['cache-control'] = 'public,max-age=31536000,immutable';
+      }
+      return new Response(file, { headers });
+    }
+
+    // 2. Serve prerendered pages (O(1) Map lookup, pre-opened BunFile)
+    const prerenderedFile = prerenderedFiles.get(pathname);
+    if (prerenderedFile) {
+      return new Response(prerenderedFile, {
+        headers: { 'Content-Type': 'text/html' },
+      });
+    }
+
+    // 3. Try ISR cache (O(1) Map lookup)
+    const cached = getCached(pathname);
+    if (cached) {
+      return new Response(cached, { status: 200, headers: { 'Content-Type': 'text/html' } });
+    }
+
+    // 4. Forward to SvelteKit
+    const response = await server.respond(request, {
+      platform: { server: bunServer, request },
+    });
+
+    // 5. Cache 200 responses with revalidate config (pre-computed map)
+    if (response.status === 200) {
+      const revalidate = getRevalidateForPath(pathname);
+      if (revalidate && revalidate > 0) {
+        const clone = response.clone();
+        const html = await clone.text();
+        setCache(pathname, html, revalidate);
+      }
+    }
+
+    return response;
+  },
+});
+
+console.log(\`\${ADAPTER_NAME} listening on http://localhost:\${bunServer.port}\`);
+`}export{N as default};

package/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@pingpolls/svelte-adapter-bun-isr",
+	"version": "0.1.0",
+	"description": "SvelteKit adapter for Bun with Incremental Static Regeneration (ISR) support",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/pingpolls/svelte-adapter-bun-isr.git"
+	},
+	"keywords": [
+		"sveltekit",
+		"adapter",
+		"bun",
+		"ssr",
+		"isr",
+		"static",
+		"svelte"
+	],
+	"type": "module",
+	"main": "dist/index.js",
+	"module": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "rm -rf dist && bun build ./src/index.ts --outdir ./dist --target bun --minify && bun x tsc --project tsconfig.build.json",
+		"test": "bun test",
+		"release": "bun run build && bun test && bunx --bun npm publish --access public"
+	},
+	"peerDependencies": {
+		"@sveltejs/kit": ">=2.0.0"
+	},
+	"devDependencies": {
+		"@sveltejs/kit": "^2.70.1",
+		"@types/bun": "latest",
+		"typescript": "^5.0.0"
+	}
+}