@timber-js/app 0.2.0-alpha.191 → 0.2.0-alpha.194

package/docs/more/04b-mdx.mdx

@@ -17,10 +17,10 @@ export default {
 };
 ```
 
-Install the MDX compiler and frontmatter plugins:
+Install the MDX compiler — timber.js uses [Satteri](https://satteri.bruits.org), a Rust-based Markdown/MDX compiler with a native Vite plugin:
 
 ```bash title="Terminal"
-pnpm add -D @mdx-js/rollup remark-frontmatter remark-mdx-frontmatter
+pnpm add -D vite-plugin-satteri satteri
 ```
 
 That's it. Any `page.mdx` file in your `app/` directory is now a route.
@@ -57,7 +57,7 @@ This page is a **server component** — no JavaScript shipped to the browser.
 
 ## Frontmatter
 
-timber.js automatically registers `remark-frontmatter` and `remark-mdx-frontmatter` when installed. Frontmatter is exported as a single `frontmatter` object:
+Frontmatter parsing is built in — YAML between `---` fences or TOML between `+++` fences. Frontmatter is exported as a single `frontmatter` object:
 
 ````mdx title="app/blog/hello/page.mdx"
 ---
@@ -127,33 +127,52 @@ pnpm add @timber-js/app
 
 Only the `CopyButton` ships JavaScript. The rest of the page renders as static HTML.
 
-## Remark and Rehype Plugins
+## Plugins and Features
 
-Configure remark and rehype plugins through the `mdx` key in your config:
+GFM (tables, footnotes, strikethrough, task lists) and frontmatter are on by default. Additional syntax is enabled through `features`, and custom transforms are written as Satteri visitor plugins through the `mdx` key in your config:
 
 ```ts title="timber.config.ts"
-import remarkGfm from 'remark-gfm';
-import rehypeShiki from '@shikijs/rehype';
+import { defineHastPlugin } from 'satteri';
+
+const externalLinks = defineHastPlugin({
+  name: 'external-links',
+  element: {
+    filter: ['a'],
+    visit(node, ctx) {
+      const href = node.properties.href;
+      if (typeof href === 'string' && href.startsWith('http')) {
+        ctx.setProperty(node, 'target', '_blank');
+      }
+    },
+  },
+});
 
 export default {
   pageExtensions: ['tsx', 'ts', 'jsx', 'js', 'mdx'],
   mdx: {
-    remarkPlugins: [remarkGfm],
-    rehypePlugins: [[rehypeShiki, { theme: 'monokai' }]],
+    hastPlugins: [externalLinks],
+    features: { math: true },
   },
 };
 ```
 
-The `mdx` config maps directly to `@mdx-js/rollup` options. Available fields:
+The `mdx` config maps directly to `vite-plugin-satteri` options. Available fields:
+
+| Option         | Type                 | Description                                                                     |
+| -------------- | -------------------- | ------------------------------------------------------------------------------- |
+| `mdastPlugins` | `MdastPluginInput[]` | Markdown AST visitors (created with `defineMdastPlugin`)                        |
+| `hastPlugins`  | `HastPluginInput[]`  | HTML AST visitors (created with `defineHastPlugin`)                             |
+| `features`     | `Features`           | Parser toggles — `gfm`, `frontmatter`, `math`, `directive`, `wikilinks`, …      |
 
-| Option                | Type            | Description                                |
-| --------------------- | --------------- | ------------------------------------------ |
-| `remarkPlugins`       | `PluggableList` | remark plugins for Markdown AST transforms |
-| `rehypePlugins`       | `PluggableList` | rehype plugins for HTML AST transforms     |
-| `recmaPlugins`        | `PluggableList` | recma plugins for ESTree transforms        |
-| `remarkRehypeOptions` | `object`        | Options passed to `remark-rehype`          |
+Satteri plugins are filtered visitors, not unified plugins — **remark/rehype plugins do not run** on Satteri's Rust-side AST. Visitors can be async and can replace nodes, which is enough to build things like shiki-based syntax highlighting (shiki transformers such as `@shikijs/twoslash` still work, since they run inside shiki).
 
-Plugins like `remark-gfm` and `rehype-shiki` are your choice to install — timber.js doesn't bundle them.
+If you need the unified MDX pipeline (for example, CodeHike), bypass timber's MDX support entirely: set `mdx: false` in your config and register `@mdx-js/rollup` yourself in `vite.config.ts` with `enforce: 'pre'`:
+
+```ts title="timber.config.ts"
+export default {
+  mdx: false, // disable timber's built-in MDX — bring your own compiler
+};
+```
 
 ## Dynamic MDX Loading
 
@@ -205,5 +224,6 @@ For structured content outside the route tree (blog posts, docs, changelogs), us
 | `@next/mdx` wrapper package               | Built-in — just add `'mdx'` to pageExtensions |
 | `next.config.mjs` `withMDX()` wrapper     | `timber.config.ts` `mdx` key                  |
 | MDX pages are client components by default | MDX pages are server components by default     |
-| Custom loader for `.md` files              | `@mdx-js/rollup` handles both `.mdx` and `.md` |
+| unified (remark/rehype) plugins            | Satteri visitor plugins + built-in features   |
+| Custom loader for `.md` files              | Built in — `.md` imports export an HTML string |
 | `mdx-components.tsx` at project root       | Same convention                               |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timber-js/app",
-  "version": "0.2.0-alpha.191",
+  "version": "0.2.0-alpha.194",
   "description": "Vite-native React framework built for Servers and Serverless Platforms — correct HTTP semantics, real status codes, pages that work without JavaScript",
   "keywords": [
     "cloudflare-workers",
@@ -146,28 +146,35 @@
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "copy-docs": "node scripts/copy-docs.js",
+    "build": "vite build --config vite.lib.config.ts && node scripts/build-types.js && pnpm run copy-docs",
+    "typecheck": "tsgo --noEmit",
+    "prepublishOnly": "pnpm run build"
+  },
   "dependencies": {
     "@opentelemetry/api": "^1.9.1",
-    "@opentelemetry/context-async-hooks": "^2.9.0",
-    "@opentelemetry/sdk-trace-base": "^2.9.0",
-    "cookie": "^1.1.1",
+    "@opentelemetry/context-async-hooks": "^2.10.0",
+    "@opentelemetry/sdk-trace-base": "^2.10.0",
+    "cookie": "^2.0.1",
     "jsonc-parser": "^3.3.1",
-    "magic-string": "^0.30.21",
+    "magic-string": "^1.2.0",
     "nitro": "3.0.260610-beta",
-    "srvx": "^0.12.0"
+    "srvx": "^0.12.5"
   },
   "peerDependencies": {
     "@content-collections/core": "^0.14.0 || ^0.15.0",
     "@content-collections/mdx": "^0.2.0",
     "@content-collections/vite": "^0.2.0 || ^0.3.0",
-    "@mdx-js/rollup": "^3.0.0",
     "@typescript/native-preview": "^7.0.0-dev.0",
     "@vitejs/plugin-react": "^6.0.0",
     "@vitejs/plugin-rsc": ">=0.5.28",
     "nuqs": "^2.0.0",
-    "react": "19.2.7",
-    "react-dom": "19.2.7",
-    "vite": "^8.1.0",
+    "react": "19.2.8",
+    "react-dom": "19.2.8",
+    "satteri": "^0.9.5",
+    "vite": "8.2.1",
+    "vite-plugin-satteri": "^0.2.15",
     "wrangler": "^4.0.0",
     "zod": "^3.22.0 || ^4.0.0"
   },
@@ -181,7 +188,10 @@
     "@content-collections/vite": {
       "optional": true
     },
-    "@mdx-js/rollup": {
+    "satteri": {
+      "optional": true
+    },
+    "vite-plugin-satteri": {
       "optional": true
     },
     "@typescript/native-preview": {
@@ -195,14 +205,9 @@
     }
   },
   "devDependencies": {
-    "@typescript/native-preview": "7.0.0-dev.20260707.2"
+    "@typescript/native-preview": "catalog:"
   },
   "engines": {
     "node": ">=22.18.0"
-  },
-  "scripts": {
-    "copy-docs": "node scripts/copy-docs.js",
-    "build": "vite build --config vite.lib.config.ts && node scripts/build-types.js && pnpm run copy-docs",
-    "typecheck": "tsgo --noEmit"
   }
-}
+}

package/src/adapters/build-output-helper.ts

@@ -13,7 +13,7 @@
 
 import { writeFile, mkdir, cp, rm, readdir, readFile } from 'node:fs/promises';
 import { join, basename, relative } from 'node:path';
-import { adapterBase, generateHeadersFile } from './shared.js';
+import { adapterBase, generateHeadersFile } from './shared.ts';
 // Isomorphic, zero-import module — safe to load from an adapter, which Node's
 // native ESM loader evaluates before Vite's resolver exists. Same precedent as
 // `adapters/shared.ts` importing `../shared/base-path.js`.
@@ -21,9 +21,9 @@ import {
   HEADERS_FILE,
   USER_MERGED_PLATFORM_FILES,
   USER_PLATFORM_DIR,
-} from '../shared/static-platform-files.js';
-import { detectFsIdentity, fsKey } from './fs-identity.js';
-import type { TimberConfig } from './types';
+} from '../shared/static-platform-files.ts';
+import { detectFsIdentity, fsKey } from './fs-identity.ts';
+import type { TimberConfig } from './types.ts';
 
 /** Options for the shared build output steps. */
 export interface BuildOutputBaseOptions {

package/src/adapters/cloudflare-dev.ts

@@ -30,7 +30,7 @@
  */
 
 import type { Plugin, ViteDevServer } from 'vite';
-import { runWithBindings } from './cloudflare.js';
+import { runWithBindings } from './cloudflare.ts';
 
 /**
  * Dynamically import wrangler. Extracted as a named export so tests
@@ -140,6 +140,12 @@ export function cloudflareDevBindings(options: CloudflareDevBindingsOptions = {}
     apply: 'serve',
 
     async configureServer(server: ViteDevServer) {
+      // The analyze crawl (design/47 §6) boots a middleware-mode server
+      // only to walk import edges — it never renders a request, so the
+      // workerd boot and the wrangler remote-bindings handshake (~6.8 s
+      // measured) are pure waste there. Skip the proxy entirely.
+      if (process.env.TIMBER_ANALYZE === '1') return;
+
       // Dynamic import — wrangler is an optional peer dependency.
       // Users must install it themselves: `pnpm add -D wrangler`
       const { getPlatformProxy } = await (options._loadWrangler ?? loadWrangler)();

package/src/adapters/cloudflare-kv-cache.ts

@@ -1,6 +1,6 @@
-import type { CacheHandler } from '../cache/index';
-import { getCloudflareBindings } from './cloudflare';
-import { warnLossyJsonValue } from '../cache/json-lossy-check.js';
+import type { CacheHandler } from '../cache/index.ts';
+import { getCloudflareBindings } from './cloudflare.ts';
+import { warnLossyJsonValue } from '../cache/json-lossy-check.ts';
 
 /**
  * Cloudflare Workers KV interface — the subset of KVNamespace we depend on.
@@ -38,9 +38,9 @@ const LEGACY_GRACE_MS = 30 * 86400 * 1000;
  * new format (TagIndexEntry[]). Old-format entries get a 30-day grace period
  * so they survive until explicitly invalidated or cycled through a new set().
  */
-function parseTagIndex(raw: unknown): TagIndexEntry[] {
+function parseTagIndex(raw: unknown, now: number): TagIndexEntry[] {
   if (!Array.isArray(raw)) return [];
-  const legacyDeadline = Date.now() + LEGACY_GRACE_MS;
+  const legacyDeadline = now + LEGACY_GRACE_MS;
   return raw.map((item: unknown) => {
     if (typeof item === 'string') return { key: item, expiresAt: legacyDeadline };
     return item as TagIndexEntry;
@@ -143,7 +143,7 @@ export class CloudflareKVCacheHandler implements CacheHandler {
     const kvExpiresAt = now + kvTtl * 1000;
     await Promise.all(
       opts.tags.map(async (tag) => {
-        const existing = parseTagIndex(await kv.get(this.tagKey(tag), { type: 'json' }));
+        const existing = parseTagIndex(await kv.get(this.tagKey(tag), { type: 'json' }), now);
         const fresh = existing.filter((e) => e.expiresAt > now && e.key !== key);
         fresh.push({ key, expiresAt: kvExpiresAt });
         await kv.put(this.tagKey(tag), JSON.stringify(fresh), {
@@ -164,8 +164,8 @@ export class CloudflareKVCacheHandler implements CacheHandler {
       if (raw) {
         await Promise.all(
           raw.tags.map(async (tag) => {
-            const entries = parseTagIndex(await kv.get(this.tagKey(tag), { type: 'json' }));
             const now = Date.now();
+            const entries = parseTagIndex(await kv.get(this.tagKey(tag), { type: 'json' }), now);
             const filtered = entries.filter((e) => e.key !== opts.key);
             if (filtered.length > 0) {
               await kv.put(this.tagKey(tag), JSON.stringify(filtered), {
@@ -181,7 +181,10 @@ export class CloudflareKVCacheHandler implements CacheHandler {
     }
 
     if (opts.tag) {
-      const entries = parseTagIndex(await kv.get(this.tagKey(opts.tag), { type: 'json' }));
+      const entries = parseTagIndex(
+        await kv.get(this.tagKey(opts.tag), { type: 'json' }),
+        Date.now()
+      );
       if (entries.length > 0) {
         // Re-check each member's stored tags before deleting — the tag index
         // can contain stale references from partial writes or entries whose

package/src/adapters/cloudflare.ts

@@ -8,21 +8,21 @@ import { execFile } from 'node:child_process';
 import { join, relative } from 'node:path';
 import { parse as parseJsonc } from 'jsonc-parser';
 import { AsyncLocalStorage } from 'node:async_hooks';
-import type { TimberPlatformAdapter, TimberConfig } from './types';
+import type { TimberPlatformAdapter, TimberConfig } from './types.ts';
 import {
   runSharedBuildSteps,
   findUnhashedStaticFiles,
   buildStaticDirectoryOutput,
   writeHeadersFile,
-} from './build-output-helper.js';
-import { adapterBase, generateHeadersFile } from './shared.js';
+} from './build-output-helper.ts';
+import { adapterBase, generateHeadersFile } from './shared.ts';
 // Isomorphic, zero-import module — safe to load from an adapter, which Node's
 // native ESM loader evaluates before Vite's resolver exists. Same precedent as
 // `adapters/shared.ts` importing `../shared/base-path.js`.
-import { RSC_KEY_HEADERS } from '../shared/rsc-cache-key.js';
+import { RSC_KEY_HEADERS } from '../shared/rsc-cache-key.ts';
 // Same reasoning: the media type the origin's own RSC gate matches on, so the
 // two predicates cannot drift apart. See `shared/rsc-media-type.ts`.
-import { RSC_CONTENT_TYPE } from '../shared/rsc-media-type.js';
+import { RSC_CONTENT_TYPE } from '../shared/rsc-media-type.ts';
 
 // ─── Bindings passthrough ─────────────────────────────────────────────────
 // ALS stores the env object per-request so server components and middleware
@@ -381,7 +381,7 @@ import { AsyncLocalStorage } from 'node:async_hooks'
 // for cache.component payloads.
 import './_timber-runtime-init.js'
 import './_timber-prebuilt-source.js'
-${manifestImport}import handler, { runWithWaitUntil, runWithWorkersCachePurge } from '${rscEntryRelative}'
+${manifestImport}import handler, { runWithWaitUntil, runWithWorkersCachePurge, stripHeadBody } from '${rscEntryRelative}'
 ${handlersImport}
 
 // Bind Cloudflare env to ALS so getCloudflareBindings() works at runtime.
@@ -479,12 +479,18 @@ ${handlersSpread}  async fetch(request, env, ctx) {
     // One-time on first request; resolved-promise await thereafter.
     await initPlatformTracer()
 
-    // Edge-cache GET/HEAD responses via the Cache API. RSC navigation
-    // requests (Accept: text/x-component) are excluded. Their varying
-    // inputs are now in the URL via ?_rsc= (TIM-1268), but this cache keys
-    // on the request URL alone and cannot honour Vary, so a payload request
-    // that arrives without the param — stripped query, hand-rolled client —
-    // would share a key with the document.
+    // Edge-cache GET/HEAD responses via the Cache API (caches.default).
+    // caches.default and ctx.cache.purge() operate on the same underlying
+    // Cloudflare CDN cache — "independent" in the CF docs means independent
+    // write APIs, not independent stores (TIM-1172). Tag-based purging via
+    // revalidateTag() clears entries stored here when their Cache-Tag header
+    // matches the invalidated tag. See design/25 §TIM-1172.
+    //
+    // RSC navigation requests (Accept: text/x-component) are excluded.
+    // Their varying inputs are now in the URL via ?_rsc= (TIM-1268), but
+    // this cache keys on the request URL alone and cannot honour Vary, so a
+    // payload request that arrives without the param — stripped query,
+    // hand-rolled client — would share a key with the document.
     //
     // This exclusion is load-bearing in the other direction too: the store
     // predicate below treats "Vary: Accept" as honoured *because* of it
@@ -502,7 +508,7 @@ ${handlersSpread}  async fetch(request, env, ctx) {
       // see canHonorVary. Entries written before that predicate existed are
       // exactly the ones that would be served to the wrong client.
       if (cached) {
-        if (canHonorVary(cached.headers.get('Vary'))) return cached
+        if (canHonorVary(cached.headers.get('Vary'))) return stripHeadBody(cached, request.method)
         // Declining the hit means nobody will ever read this body. Release
         // it rather than leaving the stream dangling for the rest of the
         // request (design/02-rendering-pipeline.md §"Cancel Readers When You
@@ -527,7 +533,7 @@ ${handlersSpread}  async fetch(request, env, ctx) {
     // it has 'public' or 's-maxage' (a shared-cache TTL directive) and no
     // 'no-store' or 'private'. Cloudflare's cache.put() only accepts GET
     // requests and rejects 206, so only store GET 200s. HEAD requests
-    // benefit from cache.match() which handles HEAD→GET matching automatically.
+    // are served from cache.match() hits with the body stripped (TIM-1325).
     // See design/25-production-deployments.md §"CDN / Edge Cache".
     if (cache && request.method === 'GET' && response.status === 200) {
       const cc = response.headers.get('Cache-Control')
@@ -610,7 +616,7 @@ globalThis.__TIMBER_PREBUILT_SOURCE__ = {
 
   const entries: string[] = [];
   for (const { file, bytes } of data.payloads) {
-    const b64 = bytes.toString('base64');
+    const b64 = Buffer.from(bytes).toString('base64');
     entries.push(`  ${JSON.stringify(file)}: ${JSON.stringify(b64)}`);
   }
 

package/src/adapters/compress-module.ts

@@ -21,7 +21,7 @@ import { transformWithOxc } from 'vite';
 // in both dev (Vite resolves the TS source) and the published package
 // (the string is inlined into the compiled adapter entry).
 import compressSource from '../server/compress.ts?raw';
-import { RSC_CONTENT_TYPE } from '../shared/rsc-media-type.js';
+import { RSC_CONTENT_TYPE } from '../shared/rsc-media-type.ts';
 
 /**
  * The one import `server/compress.ts` is allowed to carry, and its inlined
@@ -36,7 +36,7 @@ import { RSC_CONTENT_TYPE } from '../shared/rsc-media-type.js';
 const INLINED_IMPORTS: ReadonlyArray<{ pattern: RegExp; replacement: string }> = [
   {
     pattern:
-      /^import\s*\{\s*RSC_CONTENT_TYPE\s*,?\s*\}\s*from\s*["'][^"']*shared\/rsc-media-type\.js["'];?[ \t]*$/m,
+      /^import\s*\{\s*RSC_CONTENT_TYPE\s*,?\s*\}\s*from\s*["'][^"']*shared\/rsc-media-type\.(?:js|ts)["'];?[ \t]*$/m,
     replacement: `const RSC_CONTENT_TYPE = ${JSON.stringify(RSC_CONTENT_TYPE)};`,
   },
 ];

package/src/adapters/nitro-presets.ts

@@ -0,0 +1,139 @@
+// Nitro preset catalog — per-platform build configuration.
+//
+// Shared by the nitro adapter (build + entry generation) and the preview
+// module. See design/25-production-deployments.md for the preset matrix.
+
+/**
+ * Supported Nitro deployment presets.
+ *
+ * Each preset maps to a Nitro deployment target. The adapter generates
+ * the appropriate configuration and entry point for the selected platform.
+ */
+export type NitroPreset =
+  | 'vercel'
+  | 'vercel-edge'
+  | 'netlify'
+  | 'netlify-edge'
+  | 'aws-lambda'
+  | 'deno-deploy'
+  | 'azure-functions'
+  | 'node-server'
+  | 'bun';
+
+/** Preset-specific Nitro configuration. */
+export interface PresetConfig {
+  /** Nitro preset name passed to the Nitro build. */
+  nitroPreset: string;
+  /** Output directory name within the build dir. */
+  outputDir: string;
+  /**
+   * Path to the server bundle directory relative to outputDir.
+   * Nitro places the bundled server entry + _chunks/ here.
+   * Most presets use `server`; Vercel uses `functions/__server.func`.
+   */
+  serverBundleDir: string;
+  /** Whether the runtime supports waitUntil. */
+  supportsWaitUntil: boolean;
+  /** Whether the runtime supports application-level 103 Early Hints. */
+  supportsEarlyHints: boolean;
+  /** Value for TIMBER_RUNTIME env var. See design/25-production-deployments.md. */
+  runtimeName: string;
+  /** Additional nitro.config fields for this preset. */
+  extraConfig?: Record<string, unknown>;
+}
+
+export const PRESET_CONFIGS: Record<NitroPreset, PresetConfig> = {
+  'vercel': {
+    nitroPreset: 'vercel',
+    outputDir: '.vercel/output',
+    serverBundleDir: 'functions/__server.func',
+    supportsWaitUntil: true,
+    supportsEarlyHints: false,
+    runtimeName: 'vercel',
+    extraConfig: { vercel: { functions: { maxDuration: 30 } } },
+  },
+  'vercel-edge': {
+    nitroPreset: 'vercel-edge',
+    outputDir: '.vercel/output',
+    serverBundleDir: 'functions/__server.func',
+    supportsWaitUntil: true,
+    supportsEarlyHints: false,
+    runtimeName: 'vercel-edge',
+  },
+  'netlify': {
+    nitroPreset: 'netlify',
+    outputDir: '.netlify/functions-internal',
+    serverBundleDir: 'server',
+    supportsWaitUntil: false,
+    supportsEarlyHints: false,
+    runtimeName: 'netlify',
+  },
+  'netlify-edge': {
+    nitroPreset: 'netlify-edge',
+    outputDir: '.netlify/edge-functions',
+    serverBundleDir: 'server',
+    supportsWaitUntil: true,
+    supportsEarlyHints: false,
+    runtimeName: 'netlify-edge',
+  },
+  'aws-lambda': {
+    nitroPreset: 'aws-lambda',
+    outputDir: '.output',
+    serverBundleDir: 'server',
+    supportsWaitUntil: false,
+    supportsEarlyHints: false,
+    runtimeName: 'aws-lambda',
+  },
+  'deno-deploy': {
+    nitroPreset: 'deno-deploy',
+    outputDir: '.output',
+    serverBundleDir: 'server',
+    supportsWaitUntil: true,
+    supportsEarlyHints: false,
+    runtimeName: 'deno-deploy',
+  },
+  'azure-functions': {
+    nitroPreset: 'azure-functions',
+    outputDir: '.output',
+    serverBundleDir: 'server',
+    supportsWaitUntil: false,
+    supportsEarlyHints: false,
+    runtimeName: 'azure-functions',
+  },
+  'node-server': {
+    nitroPreset: 'node-server',
+    outputDir: '.output',
+    serverBundleDir: 'server',
+    supportsWaitUntil: true,
+    // Disabled by default: most node-server deployments sit behind a
+    // reverse proxy (nginx, caddy, traefik) that doesn't support 103
+    // Early Hints over HTTP/1.1. Sending 103 causes nginx to intermittently
+    // treat the response as an error and retry after proxy_connect_timeout
+    // (~5s stalls on ~23% of requests). Link headers on the 200 response
+    // are the safe fallback — Cloudflare and other CDNs convert them to
+    // 103 automatically at the edge (over HTTP/2+ to the browser).
+    supportsEarlyHints: false,
+    runtimeName: 'node-server',
+  },
+  'bun': {
+    nitroPreset: 'bun',
+    outputDir: '.output',
+    serverBundleDir: 'server',
+    supportsWaitUntil: true,
+    // Disabled for same reason as node-server — reverse proxies choke on 103.
+    // Link headers on the 200 response are converted to 103 by CDNs.
+    supportsEarlyHints: false,
+    runtimeName: 'bun',
+  },
+};
+
+/** Presets that produce a locally-runnable server entry. */
+export const LOCALLY_PREVIEWABLE = new Set<NitroPreset>(['node-server', 'bun']);
+
+/**
+ * Get the preset configuration for a given preset name.
+ * @internal Exported for testing.
+ */
+export function getPresetConfig(preset: NitroPreset): PresetConfig {
+  return PRESET_CONFIGS[preset];
+}