@daloyjs/core 0.35.0 → 0.35.1

package/README.md

@@ -27,12 +27,16 @@ DaloyJS exists to be the framework you'd build if you took the best ideas from e
 
 | You want                                                | Today's best-of                                       | What DaloyJS gives you                                                                                                                               |
 | ------------------------------------------------------- | ----------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Best **OpenAPI ergonomics**                             | [FastAPI](https://fastapi.tiangolo.com)               | First-class OpenAPI 3.1 generation from a single route definition; one-line `docs: true` auto-mounts `/docs` and `/openapi.json`.                                                           |
-| Best **Vercel / serverless / edge fit**                 | [Hono](https://hono.dev/docs/)                        | Web-standard `Request → Response` core, multi-runtime adapters.                                                                                      |
-| Mature **Swagger / docs / ops** in Node                 | [Fastify](https://fastify.dev/docs/latest/Reference/) | Encapsulated plugins, structured logger, graceful shutdown, request ids, hooks.                                                                       |
-| Modern **TS-first DX**, Bun acceptable                  | [Elysia](https://elysiajs.com/at-glance.html)         | End-to-end typed handlers, typed context, typed client.                                                                                              |
-| Best-in-class **typed client codegen** for any consumer | [Hey API](https://heyapi.dev/openapi-ts/get-started)  | One command (`pnpm gen`) emits a fully-typed fetch SDK from your spec.                                                                                 |
-| **Portable supply-chain hardening for the apps you build** | [pnpm](https://pnpm.io/motivation) defaults + a zero-runtime-dep core | pnpm scaffolds keep the hardened `.npmrc` (`ignore-scripts`, 24h release-age cooldown, explicit build allowlist), source-verified lockfiles, zero runtime deps, CycloneDX + SPDX SBOM, and an opt-in hardened GitHub Actions bundle for teams that ship on GitHub. npm/yarn/bun scaffolds still get the runtime guardrails and generated CI/Docker install commands that disable lifecycle scripts, but pnpm's release-age and workspace checks are pnpm features. |
+| Best **OpenAPI ergonomics**                                | [FastAPI](https://fastapi.tiangolo.com)                               | OpenAPI 3.1 from a single route definition; `docs: true` mounts `/docs` and `/openapi.json`.                          |
+| Best **Vercel / serverless / edge fit**                    | [Hono](https://hono.dev/docs/)                                        | Web-standard `Request → Response` core with adapters for Node, Bun, Deno, Cloudflare, Vercel, Fastly, and Lambda.     |
+| Mature **Swagger / docs / ops** in Node                    | [Fastify](https://fastify.dev/docs/latest/Reference/)                 | Encapsulated plugins, structured logger, graceful shutdown, request ids, and lifecycle hooks — all first-party.       |
+| Modern **TS-first DX**, Bun acceptable                     | [Elysia](https://elysiajs.com/at-glance.html)                         | End-to-end typed handlers, typed context, and a typed in-process client — no codegen step required.                   |
+| Best-in-class **typed client codegen** for any consumer    | [Hey API](https://heyapi.dev/openapi-ts/get-started)                  | One `pnpm gen` command emits a fully-typed fetch SDK from your live OpenAPI spec.                                     |
+| Opinionated **DI / module architecture** for large teams   | [NestJS](https://docs.nestjs.com/)                                    | Plugin encapsulation, `register()` prefixes, and `defineDependency()` typed-DI with per-request dedup — no decorators. |
+| Minimalist **async middleware cascade**                    | [Koa](https://koajs.com/)                                             | Koa-style `Context` on a web-standard core, with validation, OpenAPI, errors, and security headers in-box.            |
+| **Services + real-time** API framework                     | [FeathersJS](https://feathersjs.com/)                                 | First-party `app.ws()` with CSWSH refuse-to-boot guards, plus SSE / NDJSON streaming over explicit OpenAPI routes.    |
+| Battle-tested **Node middleware compatibility**            | [Express v5](https://expressjs.com/en/blog/2024-10-15-v5-release)     | Regex-free trie router, schema-validated routes, RFC 9457 problem+json, and refuse-to-boot guards on every runtime.   |
+| **Portable supply-chain hardening** for the apps you build | [pnpm](https://pnpm.io/motivation) defaults + a zero-runtime-dep core | Hardened `.npmrc`, source-verified lockfiles, zero runtime deps, CycloneDX + SPDX SBOM, and npm provenance attestations. |
 
 ```
 framework test suite passing · ≥90% line + function coverage / ≥90% branch coverage · typechecks on TypeScript 6 with `strict: true`
@@ -338,6 +342,19 @@ miss                        4,763,878 ops/sec
 - Body parsing is lazy and only runs when a route declares a body schema.
 - No regex on the hot path.
 
+### Cold-start tip (serverless / edge)
+
+For deployments where every millisecond of startup matters (Lambda, Vercel Edge, Cloudflare Workers, Fastly Compute), import `App` from the deep entry point instead of the barrel:
+
+```ts
+import { App } from "@daloyjs/core/app";   // ~13 ms faster cold start than "@daloyjs/core"
+import { serve } from "@daloyjs/core/node";
+```
+
+`@daloyjs/core/app` resolves to the **same `App` class with the same secure-by-default constructor** — `secureHeaders`, `requestId`, body limits, request timeouts, `fetchGuard`, prototype-pollution guards, problem+json redaction, and every other guardrail are still wired automatically. The deep import only skips loading unrelated peripheral modules (`jwk`, `jwt`, `multipart`, `websocket`, `streaming`, `compression`, `subdomains`, etc.) that the barrel re-exports for convenience. If you use any of those, import them directly from their own subpaths (`@daloyjs/core/jwk`, `@daloyjs/core/multipart`, …) so each one is paid for only when used.
+
+Long-lived Node servers will not notice the difference. This is purely a cold-start optimization for serverless.
+
 ---
 
 ## Test client + contract tests
@@ -409,32 +426,131 @@ The core only ever sees `Request → Response`. Adapters live at the edge.
 
 ## Status
 
-DaloyJS is in **public preview** (`0.x`). The public API may still change between minor versions; deprecations will get at least one minor cycle once `1.0.0` ships. The framework is already in use for production trials — every release ships with **≥90% line + function coverage and ≥90% branch coverage**, strict TypeScript, OpenSSF Scorecard, CodeQL + Opengrep dual SAST, zizmor workflow linting, and npm provenance. Coverage was relaxed from a former 100% gate so that complex security work isn't blocked chasing throwaway tests for unreachable defensive branches or tsx source-map phantoms; see [AGENTS.md](AGENTS.md) for the policy.
+DaloyJS is in **public preview** (`0.x`). The public API may still change between minor versions; deprecations will get at least one minor cycle once `1.0.0` ships. The framework is already in use for production trials.
 
-What works today, at a glance:
+**Release quality bar.** Every release ships with **≥90% line + function coverage and ≥90% branch coverage**, strict TypeScript, OpenSSF Scorecard, CodeQL + Opengrep dual SAST, zizmor workflow linting, and npm provenance. Coverage was relaxed from a former 100% gate so complex security work isn't blocked chasing throwaway tests for unreachable defensive branches or tsx source-map phantoms; see [AGENTS.md](AGENTS.md) for the policy.
 
-- Contract-first routing, Standard Schema validation (Zod 4 / Valibot / ArkType / TypeBox), and OpenAPI 3.1 from a single source of truth.
-- Adapters for Node (Heroku/Railway/Render/Fly.io), Bun, Deno, Cloudflare Workers, Vercel Node / Edge / Next.js / Netlify Edge, Fastly Compute, and AWS Lambda / Netlify Functions / Lambda Function URLs.
-- Built-in security primitives (body limits, prototype-pollution-safe JSON, path-traversal guard, request timeouts, header injection guards, **duplicate `Host` / `Content-Length` rejection**, **stripped `Server` / `X-Powered-By` headers by default**, **structured-log redaction defaults** for authorization / cookie / password / token / JWT-shaped values, **`secureHeaders()` auto-applied since `0.16.0`** with user-installed overrides automatically replacing the auto instance, **cross-origin state-changing requests rejected with `403` since `0.16.0`** unless a route's `cors()` policy allows the request origin, **refuse-to-boot on weak session secrets, `cors({ origin: "*" })`, `session()` + state-changing route without `csrf()`, and unconfigured `X-Forwarded-*` in production since `0.17.0`**, **connection-draining shutdown with `Connection: close` on `503` and in-flight responses, `crashOnUnhandledRejection` default-on in production, and `app.healthcheck()` / `app.readinesscheck()` primitives with bearer-token auth + per-IP rate limit since `0.18.0`**, **`rateLimit({ groupId })` shared buckets, `combine` primitives `every` / `some` / `except`, `ipRestriction()` with CIDR-aware IPv4/IPv6 allow/deny lists, and `internal: true` route flag + `app.inject()` since `0.19.0`**, **`loadShedding()` event-loop-pressure middleware (auto-`503` + `Retry-After`), `app.cspReportRoute()` rate-limited CSP violation receiver + `secureHeaders({ reportingEndpoints, reportTo })` wiring, `disconnectStatusCode: 499` default for client-aborted requests, and `defineConfig({ schema, source })` boot-time typed configuration validation since `0.20.0`**, **`createJwtSigner()` / `createJwtVerifier()` with `alg`-discipline (no `alg: "none"`, explicit allowlist, HS+JWK refused at construction) + `exp`-required sign refusal, `requireScopes()` with RFC-6750 `WWW-Authenticate: Bearer` challenge + per-request scope aggregation, and `etag()` helper with `Set-Cookie` / `Cache-Control: private | no-store | no-cache` auto-skip (cross-tenant fingerprinting defense) since `0.21.0`**, **`jwk()` asymmetric-only JWKS middleware (refuses `HS*` at construction, `kid` + JWT-vs-JWK `alg` cross-check, `https://` JWKS URL with TTL caching + in-flight-promise dedup, normalizes `scope` / `scp` / `scopes` claims), per-scheme `verify(credentials, ctx)` revalidation hook on `bearerAuth()` / `jwk()`, `basicAuth({ onAuthSuccess })` typed-context callback, and `Cache-Control: no-store` on every first-party auth helper 401 challenge since `0.22.0`**, **`wsRateLimit()` for WebSocket upgrades, `loginThrottle()` credential-entry preset, `rotateSession()` privilege-change session rotation, `fileField({ magicBytes })` upload signature checks, `requirePayloadAuth` security-scheme guard, and WebSocket safe defaults since `0.23.0`**, **`app({ behindProxy })` declarative model (replaces `trustProxy`), adapter-independent `ConnInfo` abstraction (`getConnInfo()` / lazy `ctx.remoteAddress` / `ctx.remotePort`), `daloy doctor` production-posture validator (with `--audit-secrets` + `--no-audit-defaults`), container-first `create-daloy` templates (`HEALTHCHECK` to `/readyz`, `STOPSIGNAL SIGTERM`, non-root user, `tini` PID 1), PSL-aware `subdomains()` helper with `≤ 90 days` snapshot guard, plugin `dependencies: string[]` refuse-to-boot, namespace-protected `decorate({ override })`, plugin extension ordering with `before` / `after` + cycle detection, `behindProxy.hops` collapses to the `(N+1)`-from-rightmost slot, `defineDependency()` typed-DI helper with per-request deduplication, scheme-aware `ctx.state.auth` typed contract, plugin lifecycle encapsulation default of `local`, and required `name` + optional `seed` for stateful plugins since `0.24.0`**, **`compression()` middleware (built on the web-standard `CompressionStream`, prefers `br` > `gzip` > `deflate` and probes runtime support once) with BREACH-aware always-on guards (skip `Set-Cookie` / `Authorization` / session-or-CSRF cookie / already-compressed content types), `minimumSize: 1024` + negative-compression-ratio post-check, no configurable `compressLevel` knob (CPU-DoS defense — `level: 9` is refused at construction), always-on `Vary: Accept-Encoding`, and strong → weak ETag downgrade per RFC 9110 §8.8.3 since `0.25.0`**, **`secureDefaults: false` refuse-to-construct in production (unless `acknowledgeInsecureDefaults: true`) + once-per-process `error` log naming every disabled default, `createJwtSigner()` / `createJwtVerifier()` refuse HS-shaped secrets `< 32` bytes (RFC 7518 §3.2), `secureHeaders()` refuses to construct with both `frameOptions: false` AND no CSP `frame-ancestors` directive (no clickjacking defense), and mandatory hardware-backed 2FA for every contributor with publish access (documented in `SECURITY.md`) since `0.26.0`**, and **single-source-of-truth cookie and temporal-claim helpers (`@daloyjs/core/cookie`, `@daloyjs/core/time-claims`), `session()` / `csrf()` `__Secure-` cookie refuse-to-boot, zero-runtime-dependency CI governance, and secret-comparison CI grep gate since `0.27.0`**, and **pattern-agnostic-framework parity audit suite since `0.28.0`** (`scripts/verify-parity-audits.ts` static gates wired into CI as `pnpm verify:parity-audits` — refuses public setters on `request.url` / `request.path` / `request.method`, refuses `ctx.respond = false`-style response-bypass switches, refuses `Referer`-based redirect targets, refuses `AES-CBC` / `SHA-1` / third-party crypto reach inside the cookie helper module, refuses adapter dispatch via `allowInternal: true` / `app.inject()`, and reaffirms the zero-runtime-dependency posture — plus `daloy doctor --audit-defaults` live-config checks that flag wildcard-credentials CORS, > 24 h CORS `maxAge`, > 25 MiB blanket body limits, zero `idleTimeoutMs` in production, `allowUnsafeValidationDetails` / `exposeFrameworkIdentity` / `enableServerTimingInProduction` opt-ins that the public type does not expose), and **zero-runtime-dependency batteries-included parity & governance audit suite since `0.29.0`** (`SECURITY-CONTACTS.md` rotation file with machine-readable ACTIVE block + `<!-- last-exercise: -->` marker, `scripts/verify-governance-audits.ts` static gates wired into CI as `pnpm verify:governance-audits` — refuses a missing/stale rotation file, refuses runtime deps on `@daloyjs/core/package.json`, refuses removal of the plugin-prerequisite refuse-to-boot path or the `topoSortExtensions` cycle-detection throw from `src/app.ts`, and reaffirms the governance floor: top-level `permissions:` on every workflow, `persist-credentials: false` on every `actions/checkout`, 40-hex SHA pinning on every third-party `uses:`, `step-security/harden-runner` on every workflow that uses third-party actions, and `.github/CODEOWNERS` on privileged files — plus a release-workflow contributor-rotation refusal step that exits non-zero when `github.actor` is not on the `SECURITY-CONTACTS` ACTIVE rotation), and **multi-runtime web-standard ergonomic-framework parity bake-ins since `0.30.0`** (`Cache-Control: no-store` baked into `UnauthorizedError` / `ForbiddenError` / `TooManyRequestsError` so every first-party auth helper 401 / 403 / 429 response is uncacheable, `cspReportRoute()` refuses `application/json` with `415` and refuses `maxBodyBytes > 64 KiB` at construction with the default production logger sink omitting the parsed report body unless `logCspReportBodies: true` is set explicitly (PII defense — CSP reports include the violated source URL), `cors()` `allowMethods` default narrowed to `[GET, HEAD, POST]` with `methods: ['*']` refused at construction (`PUT` / `PATCH` / `DELETE` are now explicit opt-ins), and `scripts/verify-runtime-parity-audits.ts` wired into CI as `pnpm verify:runtime-parity-audits` covering all of the above plus the reverse-proxy-helper absence audit and the compression skip-already-encoded reaffirm), and **mature-Node ergonomic-framework second-pass bake-ins since `0.31.0`** (`useSemicolonDelimiter: false` router-level audit so `/users/42;admin=true` cannot smuggle attacker-controlled query data past auth / CSRF / rate-limit middleware via a reverse-proxy / origin disagreement on RFC 3986 path-segment delimiters, `allowErrorHandlerOverride: false` audit so the framework never ships a standalone `setErrorHandler()` / `onError()` class method that could silently overwrite previously-registered error handlers, `requestId()` `trustIncoming: false` default audit so client-supplied `X-Request-ID` headers cannot poison framework logs by default, RFC 7231 + RFC 5789 HTTP-method allowlist now runtime-enforced inside `app.route()` (WebDAV / `TRACE` / `CONNECT` rejected at the framework boundary), `Connection: close` on every response produced during graceful shutdown reaffirmed by audit, and `scripts/verify-routing-hardening-audits.ts` wired into CI as `pnpm verify:routing-hardening-audits` covering all of the above), and **leftover focused slice since `0.32.0`** (`app.ws()` now scans the effective hook stack for header-mutating middleware — `secureHeaders()` / `cors()` / `csrf()` / `compression()` — and refuses-at-registration with a structured error naming both the WebSocket route AND every conflicting middleware unless the handler opts in via `acknowledgeHeaderMutatingMiddleware: true`, new `httpError({ status, problem, headers?, res? })` factory in `@daloyjs/core` extracts headers from a custom `Response` and refuses-at-construction with `MessageLeakError` when the response would leak request-scoped state — `Set-Cookie`, `Server-Timing`, `X-*-Token`, or `Cache-Control` other than `no-store` / `no-cache` all trip the gate, leaving only the `WWW-Authenticate` / `Proxy-Authenticate` / `Retry-After` / `Content-Type` / `Content-Language` allowlist (with `Content-Length` accepted for safety validation but not forwarded), plus a new `ProblemRenderOptions.contextHeaders` extension so direct callers of `HttpError.toResponse()` get the same Context-merge as the framework boundary, and the `PluginExtension` contract now accepts `responseHeaders?: readonly string[]` — `topoSortExtensions()` refuses-at-call when two extensions declare overlapping `responseHeaders` without declaring a `before` / `after` relationship between them so plugin-registration order can no longer non-deterministically pick a winner on a shared response header) — WebSocket public-route exposure can be acknowledged explicitly, while middleware/header-order checks remain registration invariants) plus first-party middleware (`secureHeaders` with CSP nonce + Trusted Types, `cors`, `rateLimit`, `requestId`, `bearerAuth`, `basicAuth`, `csrf` with **double-submit cookie** + **Fetch-Metadata** strategies, `session`, `timing` / `timingSafeEqual`) and **zero-knob crypto helpers** (`passwordHash` / `passwordVerify` at `@daloyjs/core/hashing`, `verifyWebhookSignature` / `signWebhookPayload`).
-- Streaming helpers (SSE + NDJSON), multipart ergonomics, OpenTelemetry-compatible tracing, signed-cookie sessions with pluggable stores, and a Redis-backed rate-limit store at `@daloyjs/core/rate-limit-redis`.
-- Request-smuggling singleton-header rejection now covers duplicate `Transfer-Encoding` in addition to duplicate `Host` and `Content-Length`.
-- WebSocket primitives with the same Bun-style handler shape (`open`/`message`/`close`/`drain`/`error`) running on both Node and Bun adapters, plus typed `app.ws(path, handler)` registration and route-table awareness so the upgrade listener is only installed when WS routes exist.
-- Production WebSocket routes under `secureDefaults` require a pre-upgrade `beforeUpgrade` decision hook or an explicit `acknowledgeUnauthenticated: true` marker, **AND** an Origin policy (`allowedOrigins: "same-origin"` / `string[]` / predicate) or `acknowledgeCrossOriginUpgrade: true` since `0.33.0` to close the Cross-Site WebSocket Hijacking (CSWSH) class of bug — Storybook's [CVE-2026-27148](https://www.aikido.dev/blog/storybooks-websockets-attack) is the representative case: cookie auth alone does not stop a malicious site from opening an authenticated WS handshake from a victim's browser, because browsers always attach cookies on the upgrade. The Origin check runs **before** `beforeUpgrade` in both Node and Bun adapters; `httpError({ res })` also uses case-insensitive header merging and never forwards a custom response's `Content-Length` onto the rendered `problem+json` body.
-- Registration-conflict guards are deliberate startup invariants: use `acknowledgeHeaderMutatingMiddleware` for reviewed WebSocket/middleware scopes and explicit plugin `before` / `after` ordering for shared `responseHeaders`, rather than expecting `secureDefaults: false` to suppress those checks.
-- Pretty `printStartupBanner()` / `formatStartupBanner()` startup helpers at `@daloyjs/core/banner`, used by every starter template so `pnpm dev` greets you with a colorized boxed panel (TTY + `NO_COLOR` / `FORCE_COLOR` aware, with an ASCII fallback for dumb terminals).
+### Routing, validation, and docs
+
+- Contract-first routing with Standard Schema validation (Zod 4, Valibot, ArkType, TypeBox) and OpenAPI 3.1 generated from a single source of truth.
+- Live OpenAPI 3.1 spec served as both JSON (`GET /openapi.json`) and YAML (`GET /openapi.yaml`) when `docs: true`, with Scalar UI theming and custom CSS via `docs.scalar`.
+- Zero-config OpenAPI `info` autofill from `package.json` (Node / Bun) or `deno.json` / `deno.jsonc` (Deno); explicit `openapi.info` values always win.
+- RFC 7231 + RFC 5789 HTTP-method allowlist enforced inside `app.route()` (WebDAV, `TRACE`, `CONNECT` rejected at the framework boundary).
+- AI-friendly route metadata via optional `meta: { examples, extensions, summary, description, tags }`; examples are validated against your schemas at build time, surfaced as OpenAPI `examples` + `x-daloy-*` extensions, and dumped as `routes.json` / `routes.yaml` via `daloy inspect --ai`.
 - In-process test client (`app.request()`), contract-test runner, in-process typed client, and Hey API codegen via `pnpm gen`.
-- One-command watch loop: `daloy dev` delegates to the host runtime's native watcher (`node --import tsx --watch`, `bun --hot`, or `deno run --watch`) with a `--runtime` override for cross-runtime `package.json` scripts.
-- AI-friendly route metadata via an optional `meta: { examples, extensions, summary, description, tags }` field on `route()`; examples are validated against your Standard Schemas at build time, surfaced into OpenAPI as `examples` + `x-daloy-*` extensions, and dumped as a sibling `routes.json` (or `routes.yaml` via `--yaml` / `--format yaml`, ~30% fewer LLM tokens) through `daloy inspect --ai` for LLM / Hey API / codegen consumption.
-- Zero-config OpenAPI `info` autofill from `package.json` (Node / Bun) or `deno.json` / `deno.jsonc` (Deno) — explicit `openapi.info` values always win.
-- Live OpenAPI 3.1 spec served as both JSON (`GET /openapi.json`) and YAML (`GET /openapi.yaml`) when `docs: true`, with Scalar UI theming/custom CSS via `docs.scalar` — covers Swagger UI's `swagger.yaml` convention out of the box.
-- `pnpm create daloy` scaffolder with Node, Bun, Deno, Cloudflare Worker, and Vercel Edge templates, plus optional `--with-ci` GitHub Actions / Dependabot / CODEOWNERS / SECURITY.md hardening. The generated `deploy.yml` for container templates signs every pushed GHCR image with **Sigstore Cosign** (keyless OIDC) and attaches an **SPDX SBOM attestation** so consumers can `cosign verify` + `cosign verify-attestation --type spdxjson` instead of trusting the registry alone (Aikido [container-security checklist](https://www.aikido.dev/blog/container-security-best-practices) — "Use Signed Images" + "Generate an SBOM").
-- Plugin encapsulation, decorators, structured logging, request-id propagation, lifecycle events (`onPluginInstalled`, `onShutdown`, `onClose`), and graceful shutdown.
-- Integration guides for transactional email providers — AWS SES, SendGrid, Resend, Postmark, Mailgun, and Mailtrap — with a common `EmailSender` plugin pattern and runtime-compatibility matrix.
-- Authentication & authorization guides for AWS Cognito, Microsoft Entra ID (MSAL), Auth0, Okta, and Clerk — with a common bearer-auth plugin, scope/role enforcement, and runtime-compatibility matrix.
-- Since `0.34.0` the supply-chain verification suite that runs in CI was expanded beyond the parity / governance / runtime-parity / routing-hardening gates with a series of focused static checks — `pnpm verify:no-shrinkwrap`, `verify:no-bin-shadowing`, `verify:no-native-addons`, `verify:no-polyfill-cdns` (hijacked-CDN IOCs and typosquats), `verify:no-redos-patterns`, `verify:no-leaky-agent-skills`, `verify:no-toxic-agent-skills`, `verify:no-toxic-skills`, `verify:runtime-eol` (refuses to release on a Node line past its EOL date), plus IOC additions to `verify:no-registry-exfiltration` / `verify:no-lockfile-sources` covering the Beamglea phishing-CDN campaign, the `naya-flore` / `nvlore-hsc` WhatsApp remote-kill-switch campaign, the Toptal GitHub-org hijack, the `xuxingfeng` and `xlsx-to-json-lh` destructive-payload campaigns, `react-login-page` keylogger, `@crypto-exploit` wallet drainers, the Vietnam-Telegram-ban Fastlane typosquats, surveillance-malware packages, the Discord-webhook reconnaissance campaign, and npm-package-aliasing dependency-confusion patterns. The release workflow itself moved to `npm stage publish ... --provenance` so the protected `npm-publish` GitHub Environment approval is now followed by an out-of-band `npm stage approve` step with maintainer MFA before any version becomes installable.
-- A self-paced [workshop](./workshop/README.md) (4-hour and 8-hour tracks) for senior TypeScript/Node developers: contract-first routes, validation, errors, middleware composition, JWT/JWK, sessions, WebSocket upgrades, CSRF/CORS, `fetchGuard()` SSRF defaults, OpenAPI tuning, and contract testing — every exercise is a single self-contained `tsx --watch` file with ordered coding-steps and reference solutions.
-
-Roadmap, version-by-version plan, and shipped/in-progress checklists live in [ROADMAP.md](./ROADMAP.md).
+
+### Runtimes and deployment
+
+- Adapters for Node (Heroku, Railway, Render, Fly.io), Bun, Deno, Cloudflare Workers, Vercel Node / Edge / Next.js / Netlify Edge, Fastly Compute, and AWS Lambda / Netlify Functions / Lambda Function URLs.
+- `daloy dev` watch loop delegates to the host runtime's native watcher (`node --import tsx --watch`, `bun --hot`, or `deno run --watch`) with a `--runtime` override for cross-runtime `package.json` scripts.
+- `pnpm create daloy` scaffolder with Node, Bun, Deno, Cloudflare Worker, and Vercel Edge templates, plus optional `--with-ci` GitHub Actions / Dependabot / CODEOWNERS / SECURITY.md hardening.
+- Container-first templates: `HEALTHCHECK` to `/readyz`, `STOPSIGNAL SIGTERM`, non-root user, `tini` as PID 1.
+- Generated `deploy.yml` for container templates signs every pushed GHCR image with **Sigstore Cosign** (keyless OIDC) and attaches an **SPDX SBOM attestation** so consumers can `cosign verify` and `cosign verify-attestation --type spdxjson` instead of trusting the registry alone.
+- Pretty `printStartupBanner()` / `formatStartupBanner()` helpers at `@daloyjs/core/banner`, used by every starter template (TTY + `NO_COLOR` / `FORCE_COLOR` aware, ASCII fallback for dumb terminals).
+
+### Core security primitives
+
+- Body limits, prototype-pollution-safe JSON, path-traversal guard, request timeouts, header injection guards.
+- Request-smuggling defense: duplicate `Host`, `Content-Length`, and `Transfer-Encoding` headers are rejected.
+- `Server` and `X-Powered-By` headers stripped by default.
+- Structured-log redaction defaults for authorization, cookie, password, token, and JWT-shaped values.
+- `secureHeaders()` auto-applied; user-installed instances automatically replace the auto one.
+- Cross-origin state-changing requests rejected with `403` unless a route's `cors()` policy allows the origin.
+- Production mode strips `detail` from 5xx problem+json automatically.
+- Real **405** with `Allow` header instead of a misleading 404.
+- `Cache-Control: no-store` baked into `UnauthorizedError` / `ForbiddenError` / `TooManyRequestsError` so every first-party auth 401 / 403 / 429 response is uncacheable.
+
+### Refuse-to-boot guardrails
+
+The framework refuses to start (or to construct) when configuration is unsafe:
+
+- Weak session secrets, `cors({ origin: "*" })` with credentials, `session()` + state-changing route without `csrf()`, and unconfigured `X-Forwarded-*` in production.
+- `secureDefaults: false` in production unless `acknowledgeInsecureDefaults: true` is set, plus a once-per-process `error` log naming every disabled default.
+- `createJwtSigner()` / `createJwtVerifier()` refuse `alg: "none"`, accept only an explicit allowlist, refuse HS + JWK combinations, refuse to sign without `exp`, and refuse HS-shaped secrets under 32 bytes (RFC 7518 §3.2).
+- `secureHeaders()` refuses to construct with `frameOptions: false` AND no CSP `frame-ancestors` directive (no clickjacking defense).
+- `cors()` refuses `methods: ['*']` at construction; default `allowMethods` narrowed to `[GET, HEAD, POST]` so `PUT` / `PATCH` / `DELETE` become explicit opt-ins.
+- `cspReportRoute()` refuses non-`application/json` (415) and refuses `maxBodyBytes > 64 KiB` at construction. The default production logger sink omits the parsed report body unless `logCspReportBodies: true` is set explicitly.
+- `session()` and `csrf()` refuse cookies that violate the `__Secure-` prefix policy.
+- Plugin `dependencies: string[]` refuse-to-boot when a prerequisite is missing; `topoSortExtensions()` refuses cycles, and refuses two extensions declaring overlapping `responseHeaders` without a `before` / `after` relationship.
+- `app.ws()` scans the effective hook stack and refuses-at-registration when header-mutating middleware (`secureHeaders()`, `cors()`, `csrf()`, `compression()`) is present, unless the handler opts in via `acknowledgeHeaderMutatingMiddleware: true`.
+
+### First-party middleware
+
+- `secureHeaders` with strict CSP baseline, per-request **nonces**, **Trusted Types** (`require-trusted-types-for 'script'`), `frame-ancestors`, `cross-origin-opener-policy` / `cross-origin-resource-policy`, and reporting endpoints.
+- `cors` with explicit-allowlist enforcement.
+- `csrf` with **double-submit cookie** (default) and **Fetch-Metadata** (`Sec-Fetch-Site`-based, tokenless) strategies; timing-safe verification.
+- `rateLimit` with token-bucket + `Retry-After`, shared `groupId` buckets, and a Redis-backed store at `@daloyjs/core/rate-limit-redis`.
+- `loadShedding()` event-loop-pressure middleware (auto-`503` + `Retry-After`).
+- `loginThrottle()` credential-entry preset and `rotateSession()` privilege-change session rotation.
+- `ipRestriction()` with CIDR-aware IPv4 / IPv6 allow / deny lists.
+- `combine` primitives: `every`, `some`, `except`.
+- `requestId()` with cryptographic ids; `trustIncoming: false` by default so client-supplied `X-Request-ID` headers cannot poison logs.
+- `bearerAuth()` and `basicAuth()` with per-scheme `verify(credentials, ctx)` revalidation hooks, typed-context `onAuthSuccess` callback, and `Cache-Control: no-store` on every 401 challenge.
+- `jwk()` asymmetric-only JWKS middleware: refuses `HS*` at construction, cross-checks `kid` and JWT-vs-JWK `alg`, requires `https://` JWKS URLs with TTL caching + in-flight-promise dedup, normalizes `scope` / `scp` / `scopes` claims.
+- `requireScopes()` with RFC-6750 `WWW-Authenticate: Bearer` challenge and per-request scope aggregation.
+- `session()` with signed cookies and pluggable stores.
+- `compression()` built on web-standard `CompressionStream` (prefers `br` > `gzip` > `deflate`), with BREACH-aware always-on guards (skips `Set-Cookie`, `Authorization`, session / CSRF cookies, already-compressed content types), `minimumSize: 1024`, negative-compression-ratio post-check, no configurable `compressLevel` knob (CPU-DoS defense — `level: 9` is refused at construction), always-on `Vary: Accept-Encoding`, and strong → weak ETag downgrade per RFC 9110 §8.8.3.
+- `etag()` helper auto-skips on `Set-Cookie` and private / no-store / no-cache `Cache-Control` (cross-tenant fingerprinting defense).
+- `timing` / `timingSafeEqual` helpers.
+- `fileField({ magicBytes })` upload signature checks.
+- `ipRestriction()`, `wsRateLimit()`, `requirePayloadAuth` security-scheme guard.
+- Zero-knob crypto helpers: `passwordHash` / `passwordVerify` at `@daloyjs/core/hashing`, `verifyWebhookSignature` / `signWebhookPayload`.
+- `fetchGuard()` SSRF defaults.
+
+### WebSockets
+
+- WebSocket primitives with the Bun-style handler shape (`open` / `message` / `close` / `drain` / `error`) running on both Node and Bun adapters.
+- Typed `app.ws(path, handler)` registration; the upgrade listener is only installed when WS routes exist.
+- Production WebSocket routes under `secureDefaults` require:
+  - a pre-upgrade `beforeUpgrade` decision hook or an explicit `acknowledgeUnauthenticated: true`, **AND**
+  - an Origin policy (`allowedOrigins: "same-origin"` / `string[]` / predicate) or `acknowledgeCrossOriginUpgrade: true`.
+
+  This closes the Cross-Site WebSocket Hijacking (CSWSH) class of bug — Storybook's [CVE-2026-27148](https://www.aikido.dev/blog/storybooks-websockets-attack) is the representative case: cookie auth alone does not stop a malicious site from opening an authenticated WS handshake from a victim's browser. The Origin check runs **before** `beforeUpgrade` in both adapters.
+
+### Lifecycle and ops
+
+- Plugin encapsulation (Fastify-style), decorators, structured logging, request-id propagation.
+- Lifecycle events: `onPluginInstalled`, `onShutdown`, `onClose`.
+- Connection-draining graceful shutdown with `Connection: close` on `503` and in-flight responses.
+- `crashOnUnhandledRejection` default-on in production.
+- `app.healthcheck()` / `app.readinesscheck()` primitives with bearer-token auth and per-IP rate limit.
+- `disconnectStatusCode: 499` default for client-aborted requests.
+- `defineConfig({ schema, source })` boot-time typed configuration validation.
+- `app({ behindProxy })` declarative model (replaces `trustProxy`); `behindProxy.hops` collapses to the `(N+1)`-from-rightmost slot.
+- Adapter-independent `ConnInfo` abstraction: `getConnInfo()`, lazy `ctx.remoteAddress`, `ctx.remotePort`.
+- `daloy doctor` production-posture validator with `--audit-secrets` and `--audit-defaults` (flags wildcard-credentials CORS, > 24h CORS `maxAge`, > 25 MiB blanket body limits, zero `idleTimeoutMs` in production, and unsafe opt-ins).
+- PSL-aware `subdomains()` helper with a `≤ 90 days` snapshot guard.
+- `defineDependency()` typed-DI helper with per-request deduplication.
+- Scheme-aware `ctx.state.auth` typed contract; named, optionally seeded stateful plugins.
+
+### Streaming and integrations
+
+- Streaming helpers (SSE + NDJSON), multipart ergonomics, OpenTelemetry-compatible tracing.
+- Integration guides for transactional email — AWS SES, SendGrid, Resend, Postmark, Mailgun, Mailtrap — with a common `EmailSender` plugin pattern and runtime-compatibility matrix.
+- Authentication & authorization guides for AWS Cognito, Microsoft Entra ID (MSAL), Auth0, Okta, and Clerk — with a common bearer-auth plugin, scope / role enforcement, and runtime-compatibility matrix.
+
+### Supply-chain hardening (CI)
+
+A growing suite of static gates runs on every push and PR:
+
+- Parity / governance / runtime-parity / routing-hardening audits: `verify:parity-audits`, `verify:governance-audits`, `verify:runtime-parity-audits`, `verify:routing-hardening-audits`.
+- Source-tree gates: `verify:no-shrinkwrap`, `verify:no-bin-shadowing`, `verify:no-native-addons`, `verify:no-polyfill-cdns` (hijacked-CDN IOCs and typosquats), `verify:no-redos-patterns`, `verify:no-encoded-payloads`, `verify:no-invisible-unicode`, `verify:no-weak-random`, `verify:no-unsafe-buffer`, `verify:no-leaked-credentials`, `verify:no-vulnerable-sandboxes`.
+- Agent-skill gates: `verify:no-leaky-agent-skills`, `verify:no-toxic-agent-skills`, `verify:no-toxic-skills`.
+- Dependency gates: `verify:no-runtime-deps`, `verify:dep-licenses`, `verify:known-dep-names`, `verify:lockfile-sources`, `verify:no-registry-exfiltration`, `verify:no-remote-exec`, `verify:no-lifecycle-scripts`, `verify:runtime-eol` (refuses to release on a Node line past its EOL date).
+- IOC coverage in `verify:no-registry-exfiltration` and `verify:lockfile-sources` for active campaigns including Beamglea phishing-CDN, `naya-flore` / `nvlore-hsc` WhatsApp remote-kill-switch, the Toptal GitHub-org hijack, `xuxingfeng` and `xlsx-to-json-lh` destructive payloads, `react-login-page` keylogger, `@crypto-exploit` wallet drainers, Vietnam-Telegram-ban Fastlane typosquats, surveillance-malware packages, the Discord-webhook reconnaissance campaign, and npm-package-aliasing dependency-confusion patterns.
+- `SECURITY-CONTACTS.md` rotation file with a machine-readable ACTIVE block and `<!-- last-exercise: -->` marker; the release workflow refuses to publish when `github.actor` is not on the ACTIVE rotation.
+- Governance floor reaffirmed by audit: top-level `permissions:` on every workflow, `persist-credentials: false` on every `actions/checkout`, 40-hex SHA pinning on every third-party `uses:`, `step-security/harden-runner` on every workflow using third-party actions, and `.github/CODEOWNERS` on privileged files.
+- Mandatory hardware-backed 2FA for every contributor with publish access (documented in `SECURITY.md`).
+- `@daloyjs/core` is published with CycloneDX 1.5 + SPDX 2.3 SBOMs and npm `--provenance`; the release workflow uses `npm stage publish` so the protected `npm-publish` GitHub Environment approval is followed by an out-of-band `npm stage approve` step with maintainer MFA before any version is installable.
+
+### Other helpers
+
+- Single-source-of-truth cookie and temporal-claim helpers at `@daloyjs/core/cookie` and `@daloyjs/core/time-claims`.
+- `httpError({ status, problem, headers?, res? })` factory extracts headers from a custom `Response` and refuses-at-construction with `MessageLeakError` if the response would leak request-scoped state (`Set-Cookie`, `Server-Timing`, `X-*-Token`, or any `Cache-Control` other than `no-store` / `no-cache`). The allowlist is `WWW-Authenticate` / `Proxy-Authenticate` / `Retry-After` / `Content-Type` / `Content-Language` (with `Content-Length` accepted for safety validation but not forwarded).
+- `ProblemRenderOptions.contextHeaders` lets direct callers of `HttpError.toResponse()` get the same Context-merge as the framework boundary.
+- A self-paced [workshop](./workshop/README.md) (4-hour and 8-hour tracks) for senior TypeScript / Node developers: contract-first routes, validation, errors, middleware composition, JWT / JWK, sessions, WebSocket upgrades, CSRF / CORS, `fetchGuard()` SSRF defaults, OpenAPI tuning, and contract testing. Every exercise is a single self-contained `tsx --watch` file with ordered coding steps and reference solutions.
+
+Roadmap and shipped / in-progress checklists live in [ROADMAP.md](./ROADMAP.md).
 
 ## Contributing
 

package/dist/adapters/bun.d.ts

@@ -39,4 +39,3 @@ export interface BunServerHandle {
 }
 /** Start `Bun.serve` bound to the given {@link App}, wiring HTTP and WebSocket routes. */
 export declare function serve(app: App, opts?: BunServeOptions): BunServerHandle;
-//# sourceMappingURL=bun.d.ts.map

package/dist/adapters/bun.js

@@ -246,4 +246,3 @@ function toBunBinary(data) {
         return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
     return new Uint8Array(data);
 }
-//# sourceMappingURL=bun.js.map

package/dist/adapters/cloudflare.d.ts

@@ -27,4 +27,3 @@ interface ExecutionContextLike {
 /** Wrap an {@link App} in the `{ fetch }` object expected by Cloudflare Workers and other web-standard hosts. */
 export declare function toFetchHandler<Env = unknown>(app: App): ExportedFetchHandler<Env>;
 export {};
-//# sourceMappingURL=cloudflare.d.ts.map

package/dist/adapters/cloudflare.js

@@ -4,4 +4,3 @@ export function toFetchHandler(app) {
         fetch: (req) => app.fetch(req),
     };
 }
-//# sourceMappingURL=cloudflare.js.map

package/dist/adapters/deno.d.ts

@@ -35,4 +35,3 @@ export interface DenoServerHandle {
 }
 /** Start `Deno.serve` bound to the given {@link App} with graceful-shutdown wiring. */
 export declare function serve(app: App, opts?: DenoServeOptions): DenoServerHandle;
-//# sourceMappingURL=deno.d.ts.map

package/dist/adapters/deno.js

@@ -43,4 +43,3 @@ export function serve(app, opts = {}) {
     };
     return { shutdown };
 }
-//# sourceMappingURL=deno.js.map

package/dist/adapters/fastly.d.ts

@@ -22,4 +22,3 @@ import type { App } from "../app.js";
 export declare function toFastlyHandler(app: App): (req: Request) => Promise<Response>;
 /** Register a Fastly Compute `fetch` event listener that delegates to the given {@link App}. */
 export declare function installFastlyListener(app: App): void;
-//# sourceMappingURL=fastly.d.ts.map

package/dist/adapters/fastly.js

@@ -10,4 +10,3 @@ export function installFastlyListener(app) {
     }
     g.addEventListener("fetch", (event) => event.respondWith(app.fetch(event.request)));
 }
-//# sourceMappingURL=fastly.js.map

package/dist/adapters/lambda.d.ts

@@ -71,4 +71,3 @@ export type LambdaResponse = LambdaResponseV1 | LambdaResponseV2;
 export type LambdaHandler = (event: LambdaEvent) => Promise<LambdaResponse>;
 /** Wrap an {@link App} as a Lambda/Netlify handler accepting either v1.0 or v2.0 event payloads. */
 export declare function toLambdaHandler(app: App): LambdaHandler;
-//# sourceMappingURL=lambda.d.ts.map

package/dist/adapters/lambda.js

@@ -115,4 +115,3 @@ function bytesToBase64(bytes) {
         binary += String.fromCharCode(bytes[i]);
     return btoa(binary);
 }
-//# sourceMappingURL=lambda.js.map

package/dist/adapters/node.d.ts

@@ -32,4 +32,3 @@ export interface NodeServerHandle {
 }
 /** Start a Node.js HTTP (and optional WebSocket) server bound to the given {@link App}. */
 export declare function serve(app: App, opts?: NodeServerOptions): NodeServerHandle;
-//# sourceMappingURL=node.d.ts.map

package/dist/adapters/node.js

@@ -4,30 +4,30 @@
  */
 import { createServer, } from "node:http";
 import { Readable } from "node:stream";
+import { DALOY_RAW_BODY } from "../app.js";
 import { FrameSink, encodeFrame, encodeClosePayload, encodeSendPayload, validateUpgrade, validateSelectedSubprotocol, checkWebSocketOrigin, WS_OPCODE, WS_CLOSE_CODE, WS_READY_STATE, WS_MAX_CONTROL_PAYLOAD, WebSocketProtocolError, WebSocketPayloadTooLargeError, } from "../websocket.js";
 /** Start a Node.js HTTP (and optional WebSocket) server bound to the given {@link App}. */
 export function serve(app, opts = {}) {
     const trustProxy = opts.trustProxy === true;
-    const server = createServer({ maxHeaderSize: opts.maxHeaderBytes ?? 16 * 1024 }, async (req, res) => {
-        try {
-            const request = await toWebRequest(req, trustProxy);
-            const response = await app.fetch(request);
-            await sendWebResponse(response, res);
+    const server = createServer({ maxHeaderSize: opts.maxHeaderBytes ?? 16 * 1024 }, (req, res) => {
+        // GET/HEAD: no body work, dispatch directly. Keep this first so the GET
+        // hot path doesn't pay for any of the buffering bookkeeping below.
+        const method = req.method;
+        if (method === "GET" || method === "HEAD" || method === undefined) {
+            dispatchToApp(app, req, res, trustProxy, undefined);
+            return;
         }
-        catch (e) {
-            if (!res.headersSent) {
-                res.statusCode = 500;
-                res.setHeader("content-type", "application/problem+json");
-                res.end(JSON.stringify({
-                    type: "https://daloyjs.dev/errors/internal",
-                    title: "Internal Server Error",
-                    status: 500,
-                }));
-            }
-            else {
-                res.destroy(e);
-            }
+        // POST/PUT/PATCH/DELETE with a small known content-length: pre-buffer
+        // bytes from the Node socket directly so the Request constructor gets a
+        // Uint8Array body instead of `Readable.toWeb(req)`. This skips the
+        // WHATWG-stream adapter that dominates POST throughput on Node.
+        const cl = req.headers["content-length"];
+        const n = cl ? Number(cl) : NaN;
+        if (Number.isFinite(n) && n >= 0 && n <= BUFFERED_BODY_MAX_BYTES) {
+            bufferRequestBody(req, n).then((bytes) => dispatchToApp(app, req, res, trustProxy, bytes), (e) => writeAdapterError(res, e));
+            return;
         }
+        dispatchToApp(app, req, res, trustProxy, undefined);
     });
     server.requestTimeout = opts.connectionTimeoutMs ?? 30_000;
     server.headersTimeout = opts.connectionTimeoutMs ?? 30_000;
@@ -69,33 +69,145 @@ export function serve(app, opts = {}) {
     }
     return { server, port, close };
 }
-async function toWebRequest(req, trustProxy) {
+/**
+ * Maximum content-length (in bytes) that the Node adapter will pre-buffer
+ * before constructing the `Request`. Bodies above this fall back to the
+ * streaming `Readable.toWeb` path so unbounded uploads can't exhaust
+ * adapter memory. 1 MiB matches the default `App.bodyLimitBytes`.
+ */
+const BUFFERED_BODY_MAX_BYTES = 1024 * 1024;
+function dispatchToApp(app, req, res, trustProxy, bufferedBody) {
+    let request;
+    try {
+        request = toWebRequest(req, trustProxy, bufferedBody);
+    }
+    catch (e) {
+        writeAdapterError(res, e);
+        return;
+    }
+    const responseOrPromise = app.fetch(request);
+    if (responseOrPromise instanceof Promise) {
+        responseOrPromise.then((response) => {
+            try {
+                const sent = sendWebResponse(response, res);
+                if (sent instanceof Promise)
+                    sent.catch((e) => writeAdapterError(res, e));
+            }
+            catch (e) {
+                writeAdapterError(res, e);
+            }
+        }, (e) => writeAdapterError(res, e));
+    }
+    else {
+        try {
+            const sent = sendWebResponse(responseOrPromise, res);
+            if (sent instanceof Promise)
+                sent.catch((e) => writeAdapterError(res, e));
+        }
+        catch (e) {
+            writeAdapterError(res, e);
+        }
+    }
+}
+function bufferRequestBody(req, expected) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let received = 0;
+        let settled = false;
+        const onData = (chunk) => {
+            if (settled)
+                return;
+            received += chunk.length;
+            if (received > expected) {
+                settled = true;
+                cleanup();
+                req.destroy();
+                reject(new Error("Request body exceeded declared Content-Length"));
+                return;
+            }
+            chunks.push(chunk);
+        };
+        const onEnd = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (received === 0) {
+                resolve(new Uint8Array(0));
+                return;
+            }
+            const buf = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, received);
+            resolve(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
+        };
+        const onErr = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(err);
+        };
+        const cleanup = () => {
+            req.off("data", onData);
+            req.off("end", onEnd);
+            req.off("error", onErr);
+            req.off("aborted", onErr);
+        };
+        req.on("data", onData);
+        req.on("end", onEnd);
+        req.on("error", onErr);
+        req.on("aborted", onErr);
+    });
+}
+function writeAdapterError(res, e) {
+    if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader("content-type", "application/problem+json");
+        res.end(JSON.stringify({
+            type: "https://daloyjs.dev/errors/internal",
+            title: "Internal Server Error",
+            status: 500,
+        }));
+    }
+    else {
+        res.destroy(e);
+    }
+}
+function toWebRequest(req, trustProxy, bufferedBody) {
+    const reqHeaders = req.headers;
     const forwardedHost = trustProxy
-        ? firstHeader(req.headers["x-forwarded-host"])
+        ? firstHeader(reqHeaders["x-forwarded-host"])
         : undefined;
-    const host = forwardedHost ?? req.headers.host ?? "localhost";
+    const host = forwardedHost ?? reqHeaders.host ?? "localhost";
     const forwardedProto = trustProxy
-        ? firstHeader(req.headers["x-forwarded-proto"])
+        ? firstHeader(reqHeaders["x-forwarded-proto"])
         : undefined;
     const proto = forwardedProto ??
         (req.socket.encrypted ? "https" : "http");
     const url = `${proto}://${host}${req.url ?? "/"}`;
     const headers = new Headers();
-    for (const [k, v] of Object.entries(req.headers)) {
+    for (const k in reqHeaders) {
+        const v = reqHeaders[k];
         if (v === undefined)
             continue;
-        if (Array.isArray(v))
-            headers.set(k, v.join(", "));
-        else
-            headers.set(k, String(v));
+        headers.set(k, Array.isArray(v) ? v.join(", ") : v);
     }
     const method = req.method ?? "GET";
-    const init = { method, headers };
-    if (method !== "GET" && method !== "HEAD") {
-        init.body = Readable.toWeb(req);
-        init.duplex = "half";
+    if (method === "GET" || method === "HEAD") {
+        return new Request(url, { method, headers });
     }
-    return new Request(url, init);
+    if (bufferedBody !== undefined) {
+        return new Request(url, {
+            method,
+            headers,
+            body: bufferedBody,
+        });
+    }
+    return new Request(url, {
+        method,
+        headers,
+        body: Readable.toWeb(req),
+        duplex: "half",
+    });
 }
 function firstHeader(v) {
     if (v === undefined)
@@ -106,14 +218,43 @@ function firstHeader(v) {
     const comma = raw.indexOf(",");
     return (comma === -1 ? raw : raw.slice(0, comma)).trim() || undefined;
 }
-async function sendWebResponse(res, out) {
+function sendWebResponse(res, out) {
     out.statusCode = res.status;
     res.headers.forEach((v, k) => out.setHeader(k, v));
+    // Fast-path: response was produced by serializeResult and carries the raw
+    // body bytes via the DALOY_RAW_BODY Symbol. Skip arrayBuffer() and the
+    // reader-loop microtask churn entirely for buffer-backed responses.
+    const raw = res[DALOY_RAW_BODY];
+    if (raw !== undefined) {
+        if (raw === null) {
+            out.end();
+        }
+        else {
+            out.end(raw);
+        }
+        return;
+    }
     if (!res.body) {
         out.end();
         return;
     }
-    const reader = res.body.getReader();
+    const ct = out.getHeader("content-type");
+    const isStream = ct && typeof ct === "string" && ct.startsWith("text/event-stream");
+    const rawLength = out.getHeader("content-length");
+    const contentLength = typeof rawLength === "number"
+        ? rawLength
+        : typeof rawLength === "string"
+            ? Number(rawLength)
+            : Number.NaN;
+    if (!isStream && Number.isFinite(contentLength) && contentLength <= 64 * 1024) {
+        return res.arrayBuffer().then((ab) => {
+            out.end(Buffer.from(ab));
+        });
+    }
+    return pumpBody(res.body, out);
+}
+async function pumpBody(body, out) {
+    const reader = body.getReader();
     while (true) {
         const { done, value } = await reader.read();
         if (done)
@@ -390,4 +531,3 @@ class NodeWebSocketConnection {
         }
     }
 }
-//# sourceMappingURL=node.js.map

package/dist/adapters/vercel.d.ts

@@ -43,4 +43,3 @@ export declare const toEdgeHandler: typeof toWebHandler;
  */
 export declare function toRouteHandlers(app: App): RouteHandlers;
 export {};
-//# sourceMappingURL=vercel.d.ts.map

package/dist/adapters/vercel.js

@@ -23,4 +23,3 @@ export function toRouteHandlers(app) {
         out[method] = handler;
     return out;
 }
-//# sourceMappingURL=vercel.js.map