sveltekit-adapter-middy 0.2.0 → 0.5.0

package/README.md

@@ -29,42 +29,179 @@ Creates a lambda that supports a Function URL with streaming responses.
 - Extendable with Middy middlewares:
   - `http-content-encoding`
   - `http-security-headers`
-  - `ssm`/`secrets-manger`
+  - `ssm`/`secrets-manager`
 - Removes `x-sveltekit-page` headers
 - Multiple `Set-Cookies`
-- Override `Origin` header with `ORIGIN` env
+- Trusted request origin via `HEADER_ORIGIN`, keeping SvelteKit's CSRF check intact
+- Lambda event and context available as `platform`
+- Server instrumentation (`src/instrumentation.server.js`, eg OpenTelemetry)
 
-Note: Bring your own deployment.
+Note: Bring your own deployment. The build writes one bundle per lambda to `out/<name>.mjs` (`index.mjs`, plus one per split entry), each exporting `handler`, so the Lambda handler setting is `index.handler`. The response is streamed, so create the Function URL with `InvokeMode: RESPONSE_STREAM`.
 
 ## Getting started
 
 ```bash
-npm i -D sveltekit-adapter-middy
+npm i -D sveltekit-adapter-middy @middy/core
 ```
 
+Requires SvelteKit 3, Middy 8, and Node.js 26 (to build and as the Lambda runtime). `@middy/core` is a peer dependency: the handler is bundled from your project, so it uses your copy.
+
+As of October 2026, the Lambda `nodejs26.x` runtime is in public preview, which AWS says not to use for production. Until it's generally available, you can set `esbuildOptions: { target: 'node24' }` and deploy on `nodejs24.x`.
+
 ```js
+// vite.config.js
+import { sveltekit } from '@sveltejs/kit/vite'
 import adapter from 'sveltekit-adapter-middy'
 
 export default {
-  kit: {
-    adapter: adapter({
-      // options
+  plugins: [
+    sveltekit({
+      adapter: adapter({
+        // options
+      })
     })
-  }
+  ]
 }
 ```
 
 ### Options
 
-- `handlerPath` (string): Relative path to handler override file. Overriding allows you to add in Content-Encoding, Security Headers, and pass in secrets more securely. Defaults to build-in minimalist handler.
+- `handlerPath` (string): Relative path to handler override file. Overriding allows you to add in Content-Encoding, Security Headers, and pass in secrets more securely. Defaults to the built-in minimalist handler. See [Handler resolution](#handler-resolution).
 - `out` (string): Relative path to build dir. Defaults to `build`
-- `esbuildOptions` (object): `esbuild` option overrides. See [code]() for defaults.
+- `esbuildOptions` (object): `esbuild` option overrides. See [`index.js`](index.js) for defaults (ESM bundle targeting `node26`).
+- `split` (object): Route splitting, `name` to route prefix. Defaults to `{}` (single lambda). `index` is reserved for the remainder lambda.
+
+### Request details
+
+- `getClientAddress()` returns `requestContext.http.sourceIp`, the TCP peer, unless `XFF_DEPTH` is set. A Function URL is public, so anyone can call it with their own `x-forwarded-for`. Set `XFF_DEPTH` to the number of trusted proxies in front of the lambda (`1` for CloudFront) to use the entry that many places from the right. A trailing entry equal to `sourceIp` is skipped, since that's the Function URL recording its own peer rather than a proxy you trust. A value below `1` is treated as unset. Only do this when those proxies are the only way in, eg the Function URL uses `AWS_IAM` auth with CloudFront origin access control.
+- `platform` is `{ event, context }`: the Function URL event and the Lambda context, including anything middleware added (eg `ssm` with `setToContext`). Read it as `event.platform` in hooks, `load` and actions, and type it by declaring `App.Platform` in `src/app.d.ts`. Outside Lambda (`vite dev`, prerendering) it is `{ event: {}, context: {} }`, so reads don't throw, but values middleware adds only exist in Lambda.
+- `HEADER_ORIGIN` should be the origin browsers use, eg `https://example.com`. Without it the url origin comes from the `host` header, which behind CloudFront is the Function URL domain, so every form post fails the CSRF check. A warning is logged at cold start when it's unset.
+- `read()` from `$app/server` is not supported. Static assets are written to `out/assets` for S3/CloudFront rather than bundled into the lambda, so there's no file for it to read. Using it fails the build rather than the request.
+- A body on a `GET` or `HEAD` is dropped; `Request` refuses to carry one.
+- Function URLs move the `cookie` header into `event.cookies`; it's joined back into `cookie` for SvelteKit.
+- `src/instrumentation.server.js` is bundled into each lambda and runs at cold start, after the private env is set and before any app code. OpenTelemetry auto-instrumentation patches modules as they load, so it can only patch what isn't bundled: Node.js built-ins, and any package you mark `esbuildOptions.external` and ship with the lambda (eg in a layer).
+- `request.signal` aborts when Middy's early timeout fires, so fetches in `load` can stop work the response will never carry.
+- AWS documents the query string characters Function URLs support as `a-z A-Z 0-9 . _ - % & = +`, which leaves out a raw `/`. `sveltekitMiddleware` encodes the `?/action` form action URLs SvelteKit renders. It rewrites every `action="?/` in the html, so text that reads that way, eg a code sample, comes out as `action="?%2F` too. That only covers html rendered on the server: a form rendered in the browser after client-side navigation still has `action="?/login"`, and `use:enhance` posts to it. Write form actions pre-encoded, eg `<form method="POST" action="?%2Flogin">`, so they work either way. Encode any `/` in your own query strings too, eg `?redirectTo=%2Fadmin`, or in `fetch('?%2Faction')` calls from client code.
+
+### Route splitting
+
+Build separate lambdas per route prefix, each with its own handler (and so its own middleware, IAM role, memory, and concurrency).
+
+```js
+adapter({
+  split: {
+    // `/admin/*` -> build/admin.mjs, using the default handler
+    admin: '/admin',
+    // `/api/*` -> build/api.mjs, using a custom handler
+    api: { prefix: '/api', handlerPath: './lambda/api.js' }
+  }
+})
+```
+
+Routes not matching any prefix go to `build/index.mjs`, as before. Static assets and prerendered pages are unaffected.
+
+Prefixes match SvelteKit **route ids**, not request paths, so param segments are written out literally:
+
+```js
+adapter({
+  split: {
+    // src/routes/[[lang]]/admin/**
+    admin: '/[[lang]]/admin',
+    // anything a prefix can't express
+    api: (route) => /(^|\/)api(\/|$)/.test(route.id)
+  }
+})
+```
+
+When prefixes overlap, the longest string prefix wins, so `/admin/reports` beats `/admin` whatever the key order. Function prefixes are tried after every string prefix, in the order given. An entry that matches no routes logs a warning; it's usually a typo, such as a trailing `/`.
+
+Routing requests to the right lambda is up to your infrastructure (eg CloudFront behaviours per path pattern). Note a localised prefix needs a pattern per shape — `/admin*` and `/*/admin*` for an optional `[[lang]]`. A split lambda only knows its own routes, so anything else sent to it renders a 404.
+
+### Handler resolution
+
+Each entry picks its handler from the first of these that exists. Specific beats global, and within each tier explicit beats implicit:
+
+1. that entry's own `handlerPath`
+2. `handler.js` beside the route it serves, eg `src/routes/admin/handler.js` for prefix `/admin`
+3. the top-level `handlerPath`
+4. `src/handler.js`
+5. the built-in minimalist handler
+
+So once a route has a `split` entry, its middleware stack needs no more config. Drop a `handler.js` next to the route (one beside a route that no `split` entry matches is not used):
+
+```js
+// src/routes/admin/handler.js — only this lambda loads these parameters
+import middy from '@middy/core'
+import { executionModeStreamifyResponse } from '@middy/core/StreamifyResponse'
+import ssm from '@middy/ssm'
+import sveltekitHandler from './sveltekitHandler.js'
+import sveltekitMiddleware from './sveltekitMiddleware.js'
+
+export const handler = middy({ executionMode: executionModeStreamifyResponse })
+  .use([
+    // `event.platform.context.dbUrl` in hooks, `load` and actions
+    ssm({ fetchData: { dbUrl: '/app/admin/db-url' }, setToContext: true }),
+    sveltekitMiddleware()
+  ])
+  .handler(sveltekitHandler)
+```
+
+Notes:
+
+- Keep `sveltekitMiddleware()` last in `.use([...])`. Middy runs `after` hooks in reverse order, so it then rewrites the html before anything else sees it. Compression from `http-content-encoding` listed after it would run first, and the rewrite would corrupt the compressed bytes.
+- `./sveltekitHandler.js` and `./sveltekitMiddleware.js` always resolve to the adapter's copies in the build directory, not to files next to your handler. Any other import, relative or bare, resolves from where your handler lives.
+- A `handlerPath` that doesn't exist throws rather than silently falling back.
+- Prefixes match route ids, so layout groups are ignored: `src/routes/(app)/admin/handler.js` serves prefix `/admin`.
+- A function prefix has no route directory, so it never picks up a route-local `handler.js`. Give it a `handlerPath`.
+- SvelteKit ignores non-`+` files in the routes directory, so a colocated `handler.js` doesn't become a route.
 
 ## Recommended Infrastructure
 
-- CloudFront: Route to static assets / pages, with fallback to server side rendering
+- CloudFront: Route to static assets / pages, with fallback to server side rendering. Not all of `/_app/*` is static: send `/_app/immutable/*` to S3, but remote function calls (`query`, `command`, `form`) go to `/_app/remote/*` and must reach the lambda (both under `paths.base`, with `_app` being `appDir`)
 - S3: store static assets and pages
-- Lambda Function URL: server side rendering
+- Lambda Function URL: server side rendering, with `InvokeMode: RESPONSE_STREAM`, and with `AWS_IAM` auth and CloudFront origin access control so CloudFront is the only way in
+
+## Upgrading to 0.5
+
+This release requires SvelteKit 3, Middy 8, and Node.js 26; use 0.4 for SvelteKit 2. `@middy/core` is now a peer dependency, so install it in your project: `npm i -D @middy/core`.
+
+Changes that need action:
+
+- **Set `XFF_DEPTH=1` behind CloudFront.** `getClientAddress()` now ignores `x-forwarded-for` unless `XFF_DEPTH` is set, because anyone calling the Function URL directly could forge it. Without it you get CloudFront's edge ip.
+
+Fixes that change behaviour:
+
+- Lambda event and context now reach SvelteKit as `platform`, so values middleware puts on the context are usable in hooks, `load` and actions.
+- esbuild warnings and errors are reported through the SvelteKit build log, once.
+- Request cookies now reach SvelteKit. They arrive in `event.cookies` and were previously dropped.
+- Streamed pages flush their shell as soon as it renders, instead of waiting for the next chunk.
+- An html response with no body (`HEAD`, `204`) no longer crashes the lambda.
+- Overlapping split prefixes resolve to the longest one rather than the first declared.
+- A `handler.js` in a root layout group (`src/routes/(app)/handler.js`) now serves prefix `/`.
+
+Server instrumentation (`src/instrumentation.server.js`) is supported; previously the build failed with `adapter_instrumentation_unsupported`.
+
+`event.platform` is `{ event: {}, context: {} }` under `vite dev` and while prerendering, rather than `undefined`.
+
+A request `Request` can't represent, eg a header value beyond Latin-1, gets a `400` rather than failing the lambda.
+
+Build logs and SvelteKit errors name the adapter `sveltekit-adapter-middy`, its package name, rather than `@middy/sveltekit`.
+
+Types now ship with the package, and the package resolves for `require()` as well as `import`.
+
+A custom handler is bundled from where it lives, so it can import your own project code by relative path.
+
+The server is now built with `builder.generateServerInstance`, so the build directory has `server.js` (exporting a ready `server`) in place of `manifest.js`. The bundled `sveltekitMiddleware.js` already uses it; a custom handler that imported `./manifest.js` or `Server` from `./index.js` should import `{ server }` from `./server.js` instead.
+
+## Upgrading to 0.4
+
+Two behaviour changes need action:
+
+**Set `HEADER_ORIGIN`.** It previously overwrote the client's `Origin` header and was used as the request url origin, which made SvelteKit's CSRF check compare a value against itself — cross-site form posts were never rejected. The url origin now comes from `HEADER_ORIGIN` (or `host`) and the client's header is left alone, so the check works. If `HEADER_ORIGIN` doesn't match the origin browsers actually use, your own form posts will start returning 403.
+
+**`read()` from `$app/server` now fails the build.** It was declared as supported but never wired up, so it failed at runtime instead. If a route uses it, either drop the call or fetch the asset from your CDN.
+
+Also: a request body arriving on a `GET`/`HEAD` is dropped rather than throwing, `content-encoding` is no longer misread as a body encoding (`gzip` threw), and `getClientAddress()` returns a single ip rather than the raw `x-forwarded-for` list.
 
 ## Roadmap
 

package/index.d.ts

@@ -0,0 +1,21 @@
+// Copyright 2026 will Farrell, and sveltekit-adapter-middy contributors.
+// SPDX-License-Identifier: MIT
+import type { Adapter, RouteDefinition } from "@sveltejs/kit";
+import type { BuildOptions } from "esbuild";
+
+type Prefix = string | ((route: RouteDefinition) => boolean);
+
+interface SplitEntry {
+	prefix: Prefix;
+	handlerPath?: string;
+}
+
+export interface Options {
+	out?: string;
+	handlerPath?: string;
+	esbuildOptions?: BuildOptions;
+	split?: Record<string, Prefix | SplitEntry>;
+}
+
+declare function sveltekitAdapterMiddy(opts?: Options): Adapter;
+export default sveltekitAdapterMiddy;

package/index.js

@@ -1,18 +1,92 @@
 // Copyright 2026 will Farrell, and sveltekit-adapter-middy contributors.
 // SPDX-License-Identifier: MIT
-import { writeFileSync } from "node:fs";
+import { existsSync, readdirSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import esbuild from "esbuild";
 
-const name = "@middy/sveltekit";
-const files = fileURLToPath(new URL("./", import.meta.url).href);
+const name = "sveltekit-adapter-middy";
+const files = fileURLToPath(new URL("./", import.meta.url));
+
+// `src/routes/admin/handler.js` -> `/admin`, matching the route id: layout
+// groups `(app)` are stripped, param segments `[[lang]]` are kept as written
+const routeHandlers = (routesDir) =>
+	new Map(
+		readdirSync(routesDir, { recursive: true })
+			.filter((file) => basename(file) === "handler.js")
+			.map((file) => [
+				`/${dirname(file)
+					.split(sep)
+					.filter((segment) => segment !== "." && !segment.startsWith("("))
+					.join("/")}`,
+				join(routesDir, file),
+			]),
+	);
+
+// Specific beats global, explicit beats implicit: the entry's own `handlerPath`,
+// then a handler beside the route, then the top-level `handlerPath`, then
+// `src/handler.js`, then the built-in. A configured path that isn't there throws
+// rather than silently deploying the wrong middleware stack.
+export const resolveHandler = (entry, { routesDir, handlerPath, builtin }) => {
+	const configured = (path) => {
+		if (!existsSync(path)) {
+			throw new Error(`${name}: handlerPath not found: ${path}`);
+		}
+		return path;
+	};
+
+	if (entry.handlerPath) return configured(entry.handlerPath);
+	// Function prefixes and `index` (no prefix) never match a route id key
+	const local = routeHandlers(routesDir).get(entry.prefix);
+	if (local) return local;
+	if (handlerPath) return configured(handlerPath);
+	const project = join(dirname(routesDir), "handler.js");
+	return existsSync(project) ? project : builtin;
+};
+
+// Routes matching an entry prefix go to that entry, everything else to `index`.
+// Prefixes match route ids, so param segments are written out: `/[[lang]]/admin`.
+// A function prefix covers anything a string can't express.
+const matches = ({ prefix }, route) =>
+	typeof prefix === "function"
+		? prefix(route)
+		: route.id === prefix || route.id.startsWith(`${prefix}/`);
+
+// Specific beats global: the longest string prefix is tried first, function
+// prefixes last in the order given
+const specificity = ({ prefix }) =>
+	typeof prefix === "string" ? prefix.length : -1;
+
+export const splitRoutes = (routes, entries) => {
+	const split = { index: [] };
+	for (const { name } of entries) split[name] = [];
+	const ordered = entries.toSorted((a, b) => specificity(b) - specificity(a));
+	for (const route of routes) {
+		const owner = ordered.find((entry) => matches(entry, route));
+		split[owner?.name ?? "index"].push(route);
+	}
+	return split;
+};
+
+// Stryker disable all: build glue (log text, esbuild options), exercised by the adapt tests
+
+// The handler is bundled where it lives, so its own relative imports resolve;
+// only the adapter's files point into the build directory
+const adapterFiles = (dir) => ({
+	name: "adapter-middy",
+	setup(build) {
+		build.onResolve(
+			{ filter: /^\.\/sveltekit(Handler|Middleware)\.js$/ },
+			({ path }) => ({ path: join(dir, path) }),
+		);
+	},
+});
 
 const sveltekitAdapterMiddy = (opts = {}) => {
-	const {
-		out = "build",
-		handlerPath = `${files}/handler.js`,
-		esbuildOptions = {},
-	} = opts;
+	const { out = "build", handlerPath, esbuildOptions = {}, split = {} } = opts;
+	if (Object.hasOwn(split, "index")) {
+		throw new Error(`${name}: split entry name "index" is reserved`);
+	}
 
 	return {
 		name,
@@ -23,65 +97,102 @@ const sveltekitAdapterMiddy = (opts = {}) => {
 			builder.rimraf(tmp);
 
 			builder.log.minor("Copying static assets");
-			const _clientFiles = await builder.writeClient(
-				`${out}/assets${builder.config.kit.paths.base}`,
-			);
+			await builder.writeClient(`${out}/assets${builder.config.paths.base}`);
 
-			builder.log.minor("Building server");
 			await builder.writeServer(tmp);
-			writeFileSync(
-				`${tmp}/manifest.js`,
-				[
-					`export const manifest = ${builder.generateManifest({
-						relativePath: "./",
-					})};`,
-					`export const prerendered = new Set(${JSON.stringify(
-						builder.prerendered.paths,
-					)});`,
-					`export const base = ${JSON.stringify(
-						builder.config.kit.paths.base,
-					)};`,
-				].join("\n\n"),
-			);
 
 			builder.copy(
-				`${files}/sveltekitMiddleware.js`,
+				`${files}sveltekitMiddleware.js`,
 				`${tmp}/sveltekitMiddleware.js`,
 			);
-			builder.copy(
-				`${files}/sveltekitHandler.js`,
-				`${tmp}/sveltekitHandler.js`,
+			builder.copy(`${files}sveltekitHandler.js`, `${tmp}/sveltekitHandler.js`);
+
+			const entries = Object.entries(split).map(([name, value]) => {
+				const config = typeof value === "object" ? value : { prefix: value };
+				return {
+					name,
+					prefix: config.prefix,
+					handlerPath: config.handlerPath,
+				};
+			});
+			// Like Kit's default, fully prerendered routes stay out of the server
+			const routes = splitRoutes(
+				builder.routes.filter((route) => route.prerender !== true),
+				entries,
 			);
-			builder.copy(handlerPath, `${tmp}/handler.js`);
+			for (const { name: entryName } of entries) {
+				if (routes[entryName].length === 0) {
+					builder.log.warn(
+						`${name}: split entry ${entryName} matches no routes`,
+					);
+				}
+			}
+			entries.push({ name: "index" });
 
-			try {
-				const result = await esbuild.build({
-					target: "node24",
-					bundle: true,
-					platform: "node",
-					format: "esm",
-					treeShaking: true,
-					...esbuildOptions,
-					entryPoints: [`${tmp}/handler.js`],
-					outfile: `${out}/index.mjs`,
-					external: ["node:*", ...(esbuildOptions?.external ?? [])],
+			// Instrumentation (eg OpenTelemetry) loads before the app, with
+			// the private env (`$app/env/private`) set. One bundle, so the app shares its env module.
+			const initializer =
+				builder.hasServerInstrumentationFile() &&
+				builder.createInstrumentationInitializer({
+					outputDirectory: tmp,
+					serverDirectory: tmp,
 				});
+			const instrumented = (entryHandler) => {
+				const entry = join(tmp, "instrumented.js");
+				writeFileSync(
+					entry,
+					[
+						`import ${JSON.stringify(initializer)};`,
+						`import ${JSON.stringify(join(tmp, "instrumentation.server.js"))};`,
+						`export const { handler } = await import(${JSON.stringify(entryHandler)});`,
+					].join("\n"),
+				);
+				return entry;
+			};
 
-				if (result.warnings.length > 0) {
-					const formatted = await esbuild.formatMessages(result.warnings, {
-						kind: "warning",
-						color: true,
+			const resolveOptions = {
+				routesDir: builder.config.files.routes,
+				handlerPath,
+				builtin: `${files}handler.js`,
+			};
+
+			try {
+				for (const entry of entries) {
+					const entryHandler = resolveHandler(entry, resolveOptions);
+					builder.log.minor(`Building server: ${entry.name} (${entryHandler})`);
+					builder.generateServerInstance(`${tmp}/server.js`, {
+						routes: routes[entry.name],
+						serverDirectory: tmp,
+					});
+					const result = await esbuild.build({
+						target: "node26",
+						bundle: true,
+						platform: "node",
+						format: "esm",
+						treeShaking: true,
+						// Reported once, through the builder log, below
+						logLevel: "silent",
+						...esbuildOptions,
+						entryPoints: [
+							initializer ? instrumented(entryHandler) : entryHandler,
+						],
+						outfile: `${out}/${entry.name}.mjs`,
+						external: ["node:*", ...(esbuildOptions?.external ?? [])],
+						plugins: [adapterFiles(tmp), ...(esbuildOptions?.plugins ?? [])],
 					});
 
-					console.error(formatted.join("\n"));
+					const warnings = await esbuild.formatMessages(result.warnings, {
+						kind: "warning",
+					});
+					for (const warning of warnings) builder.log.warn(warning);
 				}
 			} catch (err) {
-				const formatted = await esbuild.formatMessages(err.errors, {
+				// Only esbuild failures carry `errors`, anything else is rethrown as is
+				if (!Array.isArray(err?.errors)) throw err;
+				const errors = await esbuild.formatMessages(err.errors, {
 					kind: "error",
-					color: true,
 				});
-
-				console.error(formatted.join("\n"));
+				for (const error of errors) builder.log.error(error);
 
 				throw new Error(
 					`Bundling with esbuild failed with ${err.errors.length} ${
@@ -91,13 +202,17 @@ const sveltekitAdapterMiddy = (opts = {}) => {
 			}
 
 			builder.log.minor("Prerendering static pages");
-			const _prerenderedFiles = await builder.writePrerendered(
-				`${out}/prerendered${builder.config.kit.paths.base}`,
+			await builder.writePrerendered(
+				`${out}/prerendered${builder.config.paths.base}`,
 			);
 		},
 		supports: {
-			read: () => true,
+			read: () => false,
+			instrumentation: () => true,
 		},
+		// `vite dev` and prerendering run outside Lambda; middleware values on
+		// `context` only exist there
+		emulate: () => ({ platform: () => ({ event: {}, context: {} }) }),
 	};
 };
 export default sveltekitAdapterMiddy;

package/package.json

@@ -1,28 +1,27 @@
 {
 	"name": "sveltekit-adapter-middy",
-	"version": "0.2.0",
+	"version": "0.5.0",
 	"description": "SvelteKit adapter for AWS Lambda with Middy",
 	"type": "module",
+	"packageManager": "npm@12.0.1+sha512.L5T9i/YAQWQQWqTS/xZxJkei/9zcu99hCeE4qi41IyBVV7mRQad3qc2JfuOktwmH+qwGI/V2rbCL+/UYxb1+RQA==",
 	"engines": {
-		"node": ">=24"
+		"node": ">=26"
 	},
-	"engineStrict": true,
 	"workspaces": [
 		".github"
 	],
 	"publishConfig": {
 		"access": "public"
 	},
-	"module": "./index.js",
 	"exports": {
 		".": {
-			"import": {
-				"default": "./index.js"
-			}
+			"types": "./index.d.ts",
+			"default": "./index.js"
 		}
 	},
 	"files": [
 		"index.js",
+		"index.d.ts",
 		"handler.js",
 		"sveltekitMiddleware.js",
 		"sveltekitHandler.js"
@@ -31,11 +30,11 @@
 		"prepare": "husky",
 		"git:pre-commit": "npm run git:lint-staged && npm run git:test-staged",
 		"git:commit-msg": "commitlint --config commitlint.config.cjs --edit",
-		"git:lint-staged": "npm run test:lint",
-		"git:unit-staged": "node --test",
+		"git:lint-staged": "biome check --staged --no-errors-on-unmatched",
+		"git:unit-staged": "node --test ./*.test.js",
 		"git:test-staged": "npm run git:unit-staged",
 		"lint": "biome check --write --no-errors-on-unmatched",
-		"test": "npm run test:lint && npm run test:unit && npm run test:mutation && npm run test:types && npm run test:sast && npm run test:perf && npm run test:dast",
+		"test": "npm run test:lint && npm run test:unit && npm run test:e2e && npm run test:mutation && npm run test:types && npm run test:sast && npm run test:bench && npm run test:dast",
 		"test:sast": "npm run test:sast:license && npm run test:sast:lockfile && npm run test:sast:semgrep && npm run test:sast:trufflehog && npm run test:sast:gitleaks && npm run test:sast:actionlint && npm run test:sast:zizmor && npm run test:sast:trivy",
 		"test:sast:actionlint": "actionlint",
 		"test:sast:gitleaks": "npm run test:sast:gitleaks:dir && npm run test:sast:gitleaks:git",
@@ -44,22 +43,26 @@
 		"test:sast:license": "license-check-and-add check -f .license.config.json",
 		"test:sast:lockfile": "lockfile-lint --path package-lock.json --type npm --allowed-hosts npm --validate-https",
 		"test:sast:semgrep": "semgrep scan --config auto --error",
-		"test:sast:trivy": "trivy fs --scanners vuln,license --include-dev-deps --ignored-licenses 0BSD,Apache-2.0,BSD-1-Clause,BSD-2-Clause,BSD-3-Clause,CC0-1.0,CC-BY-4.0,ISC,MIT,Python-2.0,LGPL-3.0-or-later,MPL-2.0,BlueOak-1.0.0,Unlicense --exit-code 1 --skip-files '**/bun.lock' --disable-telemetry .",
+		"test:sast:trivy": "trivy fs --scanners vuln,license --include-dev-deps --ignored-licenses 0BSD,Apache-2.0,BSD-1-Clause,BSD-2-Clause,BSD-3-Clause,CC0-1.0,CC-BY-4.0,ISC,MIT,Python-2.0,LGPL-3.0-or-later,MPL-2.0,BlueOak-1.0.0,Unlicense --exit-code 1 --disable-telemetry .",
 		"test:sast:trufflehog": "trufflehog filesystem --only-verified --log-level=-1 ./",
 		"test:sast:zizmor": "zizmor .github",
-		"test:lint": "biome check --staged --no-errors-on-unmatched",
-		"test:unit": "node --test --test-force-exit --experimental-test-coverage --test-coverage-lines=80 --test-coverage-branches=70 --test-coverage-functions=80 --test-coverage-exclude=sveltekitMiddleware.js --test-coverage-exclude=handler.js --test-coverage-exclude=index.js ./*.test.js",
+		"test:lint": "biome ci --no-errors-on-unmatched",
+		"test:unit": "node --test --test-force-exit --experimental-test-coverage --test-coverage-lines=100 --test-coverage-branches=100 --test-coverage-functions=100 --test-coverage-include=index.js --test-coverage-include=sveltekitHandler.js ./*.test.js",
+		"test:e2e": "node --test ./e2e/*.test.js",
 		"test:mutation": "stryker run",
 		"test:types": "tstyche",
-		"test:perf": "node --test --test-concurrency=1 ./*.perf.js",
+		"test:bench": "node ./handler.bench.js",
 		"test:dast": "npm run test:dast:fuzz",
 		"test:dast:fuzz": "node --test ./*.fuzz.js",
 		"rm": "npm run rm:macos && npm run rm:node_modules && npm run rm:lock",
 		"rm:macos": "find . -name '.DS_Store' -type f -delete",
 		"rm:lock": "find . -name 'package-lock.json' -type f -delete",
 		"rm:node_modules": "find . -name 'node_modules' -type d -prune -exec rm -rf '{}' +",
+		"release:staged": "npm whoami >/dev/null && npm stage list $(npm pkg get name | tr -d '\"') --json | jq -r '.[] | \"\\(.packageName)@\\(.version) \\(.actor) \\(.shasum)\"'",
+		"release:approve": "npm stage list $(npm pkg get name | tr -d '\"') --json | jq -r --arg v \"$npm_package_version\" '.[] | select(.version == $v) | .id' | xargs -n1 -o npm stage approve",
 		"release:license:add": "license-check-and-add add -f .license.config.json",
-		"release:license:remove": "license-check-and-add remove -f .license.config.json"
+		"release:license:remove": "license-check-and-add remove -f .license.config.json",
+		"release:tag": "git tag -s -m $npm_package_version $npm_package_version"
 	},
 	"license": "MIT",
 	"keywords": [
@@ -70,7 +73,6 @@
 		"Serverless",
 		"AWS",
 		"AWS Lambda",
-		"Middy",
 		"HTTP",
 		"SSR"
 	],
@@ -80,8 +82,7 @@
 	},
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/willfarrell/sveltekit-adapter-middy.git",
-		"directory": ""
+		"url": "git+https://github.com/willfarrell/sveltekit-adapter-middy.git"
 	},
 	"bugs": {
 		"url": "https://github.com/willfarrell/sveltekit-adapter-middy/issues"
@@ -92,23 +93,27 @@
 		"url": "https://github.com/sponsors/willfarrell"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.5.3",
-		"@commitlint/cli": "^21.2.1",
-		"@commitlint/config-conventional": "^21.2.0",
-		"@stryker-mutator/core": "^9.0.0",
-		"fast-check": "^4.9.0",
-		"husky": "^9.1.7",
+		"@biomejs/biome": "^2.0.0",
+		"@commitlint/cli": "^21.0.0",
+		"@commitlint/config-conventional": "^21.0.0",
+		"@stryker-mutator/core": "^10.0.0",
+		"fast-check": "^4.0.0",
+		"husky": "^9.0.0",
 		"license-check-and-add": "4.0.5",
-		"tinybench": "^6.0.2",
-		"tstyche": "^7.2.1",
-		"typescript": "^6.0.3"
+		"tstyche": "^7.0.0",
+		"typescript": "^6.0.0"
 	},
 	"overrides": {
-		"qs": "^6.15.2"
+		"qs": "^6.15.2",
+		"brace-expansion": "^5.0.12",
+		"fast-uri": "^3.1.7"
+	},
+	"peerDependencies": {
+		"@middy/core": "^8.0.0-alpha.1",
+		"@sveltejs/kit": "^3.0.0"
 	},
 	"dependencies": {
-		"@datastream/string": "0.5.0",
-		"@middy/core": "^7.7.0",
-		"esbuild": "^0.28.1"
-	}
+		"esbuild": "^0.28.0"
+	},
+	"types": "./index.d.ts"
 }

package/sveltekitHandler.js

@@ -2,64 +2,87 @@
 // SPDX-License-Identifier: MIT
 import { Readable } from "node:stream";
 
-const lambdaHandler = async (event, context, { signal: _signal }) => {
-	const { server, env: _env } = context;
-	const { headers, rawQueryString, body: rawBody, isBase64Encoded } = event;
-	const { method, path } = event.requestContext.http;
+const lambdaHandler = async (event, context, { signal }) => {
+	const { server } = context;
+	const {
+		headers,
+		cookies,
+		rawQueryString,
+		body: rawBody,
+		isBase64Encoded,
+	} = event;
+	const { method, path, sourceIp } = event.requestContext.http;
 
-	// Override origin
-	headers.origin =
-		process.env.HEADER_ORIGIN ?? headers.origin ?? "https://example.com";
+	// The url origin must come from a trusted source. SvelteKit's CSRF check
+	// rejects form posts where the `origin` header doesn't match `url.origin`,
+	// so deriving one from the other would make the check unfailable. Set
+	// `HEADER_ORIGIN` in production; `host` is only as trustworthy as what fronts it.
+	const origin =
+		process.env.HEADER_ORIGIN ?? `https://${headers.host ?? "example.com"}`;
 
 	const queryString = rawQueryString ? `?${rawQueryString}` : "";
-	const url = `${headers.origin}${path}${queryString}`;
+	const url = `${origin}${path}${queryString}`;
 
-	// Buffer.from defaults a missing encoding to utf-8
-	const encoding = isBase64Encoded ? "base64" : headers["content-encoding"];
+	// `content-encoding` is a compression scheme, not a Buffer encoding
 	const body =
-		typeof rawBody === "string" ? Buffer.from(rawBody, encoding) : rawBody;
+		isBase64Encoded && rawBody ? Buffer.from(rawBody, "base64") : rawBody;
 
-	const rendered = await server.respond(
-		new Request(url, {
+	// Anyone can call a public Function URL with their own `x-forwarded-for`, so
+	// only the `XFF_DEPTH` entries appended by trusted proxies (eg CloudFront: 1)
+	// count. Unset, the TCP peer is the client.
+	const xffDepth = Math.max(0, Number(process.env.XFF_DEPTH) || 0);
+
+	// The header object goes straight in: building a `Headers` first means
+	// Request copies every header twice
+	let request;
+	try {
+		request = new Request(url, {
 			method,
-			headers: new Headers(headers),
-			body,
-		}),
-		{
-			getClientAddress() {
-				return headers["x-forwarded-for"];
-			},
-		},
-	);
+			signal,
+			headers,
+			// Request throws if a GET/HEAD carries one, however it arrived
+			body: method === "GET" || method === "HEAD" ? null : body,
+		});
+		// Function URLs move the `cookie` header into `event.cookies`
+		if (cookies?.length) request.headers.set("cookie", cookies.join("; "));
+	} catch {
+		// Only the client's input can fail here, eg a header beyond Latin-1
+		return { statusCode: 400, body: "" };
+	}
 
-	if (rendered) {
-		const response = {
-			statusCode: rendered.status,
-			headers: {
-				"cache-control": "no-cache",
-			},
-			body: "",
-		};
+	const rendered = await server.respond(request, {
+		platform: { event, context },
+		getClientAddress() {
+			const forwarded =
+				headers["x-forwarded-for"]?.split(",").map((ip) => ip.trim()) ?? [];
+			// The Function URL may append its own peer, which no trusted proxy wrote
+			if (forwarded.at(-1) === sourceIp) forwarded.pop();
+			return (xffDepth && forwarded.at(-xffDepth)) || sourceIp;
+		},
+	});
 
-		for (const [key, value] of rendered.headers.entries()) {
-			if (key === "set-cookie") {
-				response.cookies ??= [];
-				response.cookies.push(value);
-			} else if (key !== "x-sveltekit-page") {
-				// `x-sveltekit-page` excluded, security
-				response.headers[key] = value;
-			}
-		}
+	const response = {
+		statusCode: rendered.status,
+		headers: {
+			"cache-control": "no-cache",
+		},
+		body: "",
+	};
 
-		if (rendered.body) {
-			response.body = Readable.fromWeb(rendered.body);
+	for (const [key, value] of rendered.headers.entries()) {
+		if (key === "set-cookie") {
+			response.cookies ??= [];
+			response.cookies.push(value);
+		} else if (key !== "x-sveltekit-page") {
+			// `x-sveltekit-page` excluded, security
+			response.headers[key] = value;
 		}
+	}
 
-		return response;
+	if (rendered.body) {
+		response.body = Readable.fromWeb(rendered.body);
 	}
 
-	return {
-		statusCode: 404,
-	};
+	return response;
 };
 export default lambdaHandler;

package/sveltekitMiddleware.js

@@ -1,28 +1,82 @@
 // Copyright 2026 will Farrell, and sveltekit-adapter-middy contributors.
 // SPDX-License-Identifier: MIT
-import { stringReplaceStream } from "@datastream/string";
-import { Server } from "./index.js"; // From build directory
-import { manifest } from "./manifest.js"; // From build directory
+import { pipeline, Transform } from "node:stream";
+import { StringDecoder } from "node:string_decoder";
+import { server } from "./server.js"; // From build directory
 
-const server = new Server(manifest);
-const init = server.init({ env: process.env });
+// Started at cold start; a failure is dropped so the next request retries
+const start = () =>
+	server.init({ env: process.env }).catch((err) => {
+		init = undefined;
+		throw err;
+	});
+let init = start();
+// Handled here, as no request awaits it yet; the failure is dropped, so the
+// first request starts init again
+init.catch(() => {});
 
-const formActionPattern = /action="\?\//g;
+if (!process.env.HEADER_ORIGIN) {
+	console.warn(
+		"sveltekit-adapter-middy: HEADER_ORIGIN is not set, the url origin falls back to the `host` header. Behind CloudFront that is the Function URL domain, and form posts will fail the CSRF check.",
+	);
+}
+
+const formAction = 'action="?/';
 const formActionReplacement = 'action="?%2F';
+
+// Length of the suffix of `text` that could be the start of a `formAction`
+// completed by the next chunk. `formAction` holds a single `a`, so only the
+// suffix from the last `a` can be one.
+const partialMatchLength = (text) => {
+	const suffix = text.slice(text.lastIndexOf("a"));
+	return formAction.startsWith(suffix) ? suffix.length : 0;
+};
+
+// Emits each chunk as it arrives, holding back only a possible partial match,
+// so streamed pages still flush their shell before awaited data resolves.
+// Decoding here rather than with `setEncoding` saves a utf8 round trip per
+// chunk, since a Transform turns written strings back into Buffers.
+const formActionStream = () => {
+	let tail = "";
+	const decoder = new StringDecoder(); // utf8
+	return new Transform({
+		transform(chunk, _encoding, callback) {
+			const text = (tail + decoder.write(chunk)).replaceAll(
+				formAction,
+				formActionReplacement,
+			);
+			const split = text.length - partialMatchLength(text);
+			tail = text.slice(split);
+			callback(null, text.slice(0, split));
+		},
+		flush(callback) {
+			callback(null, tail + decoder.end());
+		},
+	});
+};
+
 const sveltekitMiddleware = () => {
 	const sveltekitMiddlewareBefore = async (request) => {
 		request.context.server = server;
+		init ??= start();
 		await init;
 	};
 
 	const sveltekitMiddlewareAfter = async (request) => {
 		// Workaround: AWS Function URLs doesn't support querystring keys that contain `/`
-		if (request.response.headers?.["content-type"]?.includes("text/html")) {
-			const stream = stringReplaceStream({
-				pattern: formActionPattern,
-				replacement: formActionReplacement,
-			});
-			request.response.body = request.response.body.pipe(stream);
+		// A string body is the empty one `sveltekitHandler` sets, nothing to rewrite
+		if (
+			typeof request.response.body !== "string" &&
+			request.response.headers?.["content-type"]?.includes("text/html")
+		) {
+			// `pipeline` passes a render error on, so the response ends rather than hangs
+			request.response.body = pipeline(
+				request.response.body,
+				formActionStream(),
+				() => {},
+			);
+			// The rewrite lengthens the body; streamed, it needs no length
+			delete request.response.headers["content-length"];
 		}
 	};
 	return {