@dotpress/testing 0.0.0-stage → 2.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1813 @@
+// src/assertions.ts
+import { expect } from "vitest";
+var ExpectationError = class extends Error {
+  name = "AssertionError";
+};
+var matches = (actual, expected) => {
+  try {
+    if (typeof expected === "object" && expected !== null && typeof actual === "object" && actual !== null) {
+      expect(actual).toMatchObject(expected);
+    } else {
+      expect(actual).toEqual(expected);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+};
+var show = (value) => {
+  let json2;
+  try {
+    json2 = JSON.stringify(
+      value,
+      (_key, item) => typeof item === "object" && item !== null && "asymmetricMatch" in item ? item.toAsymmetricMatcher?.() ?? String(item) : item
+    );
+  } catch {
+    json2 = void 0;
+  }
+  json2 ??= String(value);
+  return json2.length > 300 ? `${json2.slice(0, 297)}...` : json2;
+};
+var checkTimes = (label, times) => {
+  if (times !== void 0 && (!Number.isInteger(times) || times < 0)) {
+    throw new TypeError(`${label}: times must be a non-negative integer.`);
+  }
+};
+var assertCount = (description, found, times, recorded) => {
+  if (times === void 0 ? found > 0 : found === times) return;
+  const expected = times === void 0 ? description.some : times === 0 ? description.none : `${description.some} ${times === 1 ? "once" : `${times} times`}`;
+  throw new ExpectationError(
+    `Expected ${expected}, found ${found}.
+${recorded}`
+  );
+};
+
+// src/conformance.ts
+import {
+  DEFAULT_BODY_LIMIT,
+  createRouter,
+  file,
+  json,
+  notFoundError,
+  redirect,
+  sse,
+  stream,
+  text,
+  unauthorizedError
+} from "@dotpress/core";
+import { describe, expect as expect2, it, vi } from "vitest";
+
+// src/logger.ts
+var createMemoryLogger = () => {
+  const entries = [];
+  const create = () => ({
+    debug: (...args) => void entries.push({ level: "debug", args }),
+    info: (...args) => void entries.push({ level: "info", args }),
+    warn: (...args) => void entries.push({ level: "warn", args }),
+    error: (...args) => void entries.push({ level: "error", args }),
+    child: () => create()
+  });
+  return Object.assign(create(), { entries });
+};
+
+// src/request.ts
+var toRequest = async (path, init) => {
+  const request = new Request(new URL(path, "http://localhost"), init);
+  if (!(init?.body instanceof FormData)) return request;
+  return new Request(request, { body: await request.arrayBuffer() });
+};
+
+// src/conformance.ts
+var createHttpTarget = (baseUrl, close) => ({
+  fetch: (path, init) => fetch(new URL(path, baseUrl), init),
+  close
+});
+var createFetchTarget = (handle, close) => ({
+  fetch: async (path, init) => handle(await toRequest(path, init)),
+  close
+});
+var TIMEOUT = 2e3;
+var within = (promise, label) => Promise.race([
+  promise,
+  new Promise(
+    (_, reject) => setTimeout(
+      () => reject(new Error(`Timed out waiting for: ${label}`)),
+      TIMEOUT
+    )
+  )
+]);
+var deferred = () => {
+  let resolve;
+  const promise = new Promise((done) => {
+    resolve = done;
+  });
+  return { promise, resolve };
+};
+var waitForAbort = (signal) => new Promise((resolve) => {
+  if (signal.aborted) resolve();
+  signal.addEventListener("abort", () => resolve(), { once: true });
+});
+var readChunk = async (reader) => {
+  const { done, value } = await reader.read();
+  return done ? void 0 : new TextDecoder().decode(value);
+};
+var runConformanceSuite = (options) => {
+  const serve = async (define, appOptions = {}) => {
+    const router = createRouter();
+    define(router);
+    return options.setup({
+      logger: createMemoryLogger(),
+      ...appOptions,
+      routers: [router]
+    });
+  };
+  const withApp = async (define, run, appOptions) => {
+    const target = await serve(define, appOptions);
+    try {
+      await run(target);
+    } finally {
+      await target.close();
+    }
+  };
+  const postJson = (body) => ({
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  describe(`${options.name} adapter conformance`, () => {
+    describe("routing", () => {
+      it("serves JSON results", () => withApp(
+        (router) => {
+          router.defineRoute({ path: "/hello", handler: () => ({ hi: 1 }) });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/hello");
+          expect2(res.status).toBe(200);
+          expect2(res.headers.get("content-type")).toBe(
+            "application/json; charset=utf-8"
+          );
+          expect2(await res.json()).toEqual({ hi: 1 });
+        }
+      ));
+      it("routes every HTTP method", () => withApp(
+        (router) => {
+          for (const method of [
+            "get",
+            "post",
+            "put",
+            "patch",
+            "delete",
+            "options"
+          ]) {
+            router.defineRoute({
+              method,
+              path: "/resource",
+              handler: ({ req }) => ({ method: req.method })
+            });
+          }
+          router.defineRoute({
+            method: "head",
+            path: "/resource",
+            handler: ({ res }) => {
+              res.setHeader("x-head", "yes");
+            }
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          for (const method of [
+            "GET",
+            "POST",
+            "PUT",
+            "PATCH",
+            "DELETE",
+            "OPTIONS"
+          ]) {
+            const res = await fetch2("/resource", { method });
+            expect2(await res.json()).toEqual({ method });
+          }
+          const head = await fetch2("/resource", { method: "HEAD" });
+          expect2(head.headers.get("x-head")).toBe("yes");
+        }
+      ));
+      it("extracts decoded path parameters", () => withApp(
+        (router) => {
+          router.defineRoute({
+            path: "/orgs/:orgId/files/:name",
+            handler: ({ req }) => req.params
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/orgs/acme/files/a%20b%2Fc%C3%A9");
+          expect2(await res.json()).toEqual({ orgId: "acme", name: "a b/c\xE9" });
+        }
+      ));
+      it("gives static segments priority over parameters", () => withApp(
+        (router) => {
+          router.defineRoute({
+            path: "/users/:id",
+            handler: ({ req }) => ({ id: req.params.id })
+          });
+          router.defineRoute({ path: "/users/me", handler: () => "me" });
+        },
+        async ({ fetch: fetch2 }) => {
+          expect2(await (await fetch2("/users/me")).json()).toBe("me");
+          expect2(await (await fetch2("/users/42")).json()).toEqual({
+            id: "42"
+          });
+        }
+      ));
+      it("ignores trailing slashes and matches case-sensitively", () => withApp(
+        (router) => {
+          router.defineRoute({ path: "/users", handler: () => "users" });
+        },
+        async ({ fetch: fetch2 }) => {
+          expect2((await fetch2("/users/")).status).toBe(200);
+          expect2((await fetch2("/Users")).status).toBe(404);
+        }
+      ));
+      it("returns the standard 404 error for unknown paths", () => withApp(
+        (router) => {
+          router.defineRoute({ path: "/items", handler: () => [] });
+        },
+        async ({ fetch: fetch2 }) => {
+          for (const method of ["GET", "POST"]) {
+            const res = await fetch2("/missing", { method });
+            expect2(res.status).toBe(404);
+            expect2(res.headers.get("x-request-id")).toBeTruthy();
+            expect2(await res.json()).toEqual({
+              status: 404,
+              error: "NOT_FOUND",
+              message: "Route not found"
+            });
+          }
+        }
+      ));
+      it("returns 405 with an Allow header for unsupported methods", () => withApp(
+        (router) => {
+          router.defineRoute({ path: "/items/:id", handler: () => ({}) });
+          router.defineRoute({
+            method: "delete",
+            path: "/items/:id",
+            handler: () => {
+            }
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          for (const method of ["POST", "OPTIONS"]) {
+            const res = await fetch2("/items/1", { method });
+            expect2(res.status).toBe(405);
+            expect2(res.headers.get("allow")).toBe("GET, HEAD, DELETE");
+            expect2(res.headers.get("x-request-id")).toBeTruthy();
+            expect2(await res.json()).toEqual({
+              status: 405,
+              error: "METHOD_NOT_ALLOWED",
+              message: "Method not allowed"
+            });
+          }
+        }
+      ));
+      it("answers HEAD requests with the GET route, without body", () => withApp(
+        (router) => {
+          router.defineRoute({ path: "/data", handler: () => ({ a: 1 }) });
+          router.defineRoute({
+            path: "/stream",
+            handler: () => stream(["never sent"])
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/data", { method: "HEAD" });
+          expect2(res.status).toBe(200);
+          expect2(res.headers.get("content-type")).toBe(
+            "application/json; charset=utf-8"
+          );
+          expect2(await res.text()).toBe("");
+          const streamed = await fetch2("/stream", { method: "HEAD" });
+          expect2(streamed.status).toBe(200);
+          expect2(await streamed.text()).toBe("");
+        }
+      ));
+      it("mounts groups with their prefix and middlewares", () => {
+        const calls = [];
+        const track = (name) => () => {
+          calls.push(name);
+        };
+        return withApp(
+          (router) => {
+            const api = router.createGroup("/api", [track("api")]);
+            api.createGroup("/admin", [track("admin")]).defineRoute({
+              path: "/stats",
+              middlewares: [track("route")],
+              handler: () => ({ ok: true })
+            });
+          },
+          async ({ fetch: fetch2 }) => {
+            expect2(await (await fetch2("/api/admin/stats")).json()).toEqual({
+              ok: true
+            });
+            expect2(calls).toEqual(["global", "api", "admin", "route"]);
+          },
+          { middlewares: [track("global")] }
+        );
+      });
+      it("serves the routes under the base path only", () => withApp(
+        (router) => {
+          router.defineRoute({
+            path: "/users/:id",
+            handler: ({ req }) => ({ id: req.params.id, path: req.path })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/my-app/api/users/42");
+          expect2(res.status).toBe(200);
+          expect2(await res.json()).toEqual({
+            id: "42",
+            path: "/my-app/api/users/42"
+          });
+          for (const path of ["/users/42", "/my-app/users/42"]) {
+            const outside = await fetch2(path);
+            expect2(outside.status, path).toBe(404);
+            expect2(await outside.json()).toMatchObject({
+              error: "NOT_FOUND"
+            });
+          }
+        },
+        { basePath: "/my-app/api" }
+      ));
+    });
+    describe("request", () => {
+      it("parses the query string", () => withApp(
+        (router) => {
+          router.defineRoute({
+            path: "/search",
+            handler: ({ req }) => req.query
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2(
+            "/search?q=hello+world&tag=a&tag=b&name=%C3%A9&empty="
+          );
+          expect2(await res.json()).toEqual({
+            q: "hello world",
+            tag: ["a", "b"],
+            name: "\xE9",
+            empty: ""
+          });
+        }
+      ));
+      it("exposes the method, path, URL, headers and cookies", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/inspect",
+            handler: ({ req }) => ({
+              method: req.method,
+              path: req.path,
+              url: req.url && new URL(req.url).pathname + new URL(req.url).search,
+              custom: req.header("X-Custom"),
+              lowercase: req.headers["x-custom"],
+              cookies: req.cookies
+            })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/inspect?a=1", {
+            method: "POST",
+            headers: {
+              "X-Custom": "value",
+              cookie: "session=abc; theme=dark%20blue"
+            }
+          });
+          expect2(await res.json()).toEqual({
+            method: "POST",
+            path: "/inspect",
+            url: "/inspect?a=1",
+            custom: "value",
+            lowercase: "value",
+            cookies: { session: "abc", theme: "dark blue" }
+          });
+        }
+      ));
+      it("exposes the client IP address", () => withApp(
+        (router) => {
+          router.defineRoute({
+            path: "/ip",
+            handler: ({ req }) => ({ ip: req.ip })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const { ip } = await (await fetch2("/ip")).json();
+          expect2(ip).toMatch(/^((::ffff:)?127\.0\.0\.1|::1)$/);
+        }
+      ));
+      it("parses JSON bodies", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/echo",
+            handler: ({ req }) => ({ body: req.body })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/echo", postJson({ a: [1, "\xE9"], b: null }));
+          expect2(await res.json()).toEqual({ body: { a: [1, "\xE9"], b: null } });
+        }
+      ));
+      it("rejects malformed JSON bodies", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/echo",
+            handler: () => ({ unreachable: true })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/echo", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: '{"broken":'
+          });
+          expect2(res.status).toBe(400);
+          expect2(res.headers.get("x-request-id")).toBeTruthy();
+          expect2(await res.json()).toEqual({
+            status: 400,
+            error: "MALFORMED_BODY",
+            message: "Malformed request body"
+          });
+        }
+      ));
+      it("parses URL-encoded, text and binary bodies", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/echo",
+            handler: ({ req }) => req.body instanceof Uint8Array ? { bytes: [...req.body] } : { body: req.body }
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const form = await fetch2("/echo", {
+            method: "POST",
+            headers: { "content-type": "application/x-www-form-urlencoded" },
+            body: "name=Ada+Lovelace&tag=a&tag=b"
+          });
+          expect2(await form.json()).toEqual({
+            body: { name: "Ada Lovelace", tag: ["a", "b"] }
+          });
+          const plain = await fetch2("/echo", {
+            method: "POST",
+            headers: { "content-type": "text/plain; charset=utf-8" },
+            body: "h\xE9llo"
+          });
+          expect2(await plain.json()).toEqual({ body: "h\xE9llo" });
+          const binary = await fetch2("/echo", {
+            method: "POST",
+            headers: { "content-type": "application/octet-stream" },
+            body: new Uint8Array([0, 1, 254, 255])
+          });
+          expect2(await binary.json()).toEqual({ bytes: [0, 1, 254, 255] });
+        }
+      ));
+      it("exposes the raw body on rawBody routes", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/webhooks",
+            rawBody: true,
+            schema: (z) => ({ body: z.object({ type: z.string() }) }),
+            handler: ({ req }) => ({
+              raw: new TextDecoder().decode(req.rawBody),
+              type: req.body.type
+            })
+          });
+          router.defineRoute({
+            method: "post",
+            path: "/ping",
+            rawBody: true,
+            handler: ({ req }) => ({ length: req.rawBody.byteLength })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const payload = '{ "type" :  "invoice.paid", "id": "\xE9" }';
+          const res = await fetch2("/webhooks", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: payload
+          });
+          expect2(await res.json()).toEqual({
+            raw: payload,
+            type: "invoice.paid"
+          });
+          const empty = await fetch2("/ping", { method: "POST" });
+          expect2(await empty.json()).toEqual({ length: 0 });
+        }
+      ));
+      it("gives an undefined body when there is none", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/empty",
+            handler: ({ req }) => ({ hasBody: req.body !== void 0 })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/empty", { method: "POST" });
+          expect2(await res.json()).toEqual({ hasBody: false });
+        }
+      ));
+      it("rejects bodies larger than the default limit", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/upload",
+            handler: () => ({ unreachable: true })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const payload = new Uint8Array(DEFAULT_BODY_LIMIT + 1);
+          const declared = await fetch2("/upload", {
+            method: "POST",
+            headers: { "content-type": "application/octet-stream" },
+            body: payload
+          });
+          expect2(declared.status).toBe(413);
+          expect2(await declared.json()).toEqual({
+            status: 413,
+            error: "PAYLOAD_TOO_LARGE",
+            message: "Request body too large"
+          });
+          const chunked = await fetch2("/upload", {
+            method: "POST",
+            headers: { "content-type": "application/octet-stream" },
+            body: new ReadableStream({
+              start(controller) {
+                controller.enqueue(payload.subarray(0, DEFAULT_BODY_LIMIT));
+                controller.enqueue(new Uint8Array(1));
+                controller.close();
+              }
+            }),
+            duplex: "half"
+          });
+          expect2(chunked.status).toBe(413);
+        }
+      ));
+      it("accepts bodies up to the default limit", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/upload",
+            handler: ({ req }) => ({
+              size: req.body.byteLength
+            })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/upload", {
+            method: "POST",
+            headers: { "content-type": "application/octet-stream" },
+            body: new Uint8Array(DEFAULT_BODY_LIMIT)
+          });
+          expect2(await res.json()).toEqual({ size: DEFAULT_BODY_LIMIT });
+        }
+      ));
+      it("rejects compressed request bodies", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/echo",
+            handler: () => ({ unreachable: true })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/echo", {
+            method: "POST",
+            headers: {
+              "content-type": "application/json",
+              "content-encoding": "gzip"
+            },
+            body: new Uint8Array([31, 139, 8, 0])
+          });
+          expect2(res.status).toBe(415);
+          expect2(await res.json()).toMatchObject({
+            error: "UNSUPPORTED_MEDIA_TYPE"
+          });
+        }
+      ));
+    });
+    describe("uploads", () => {
+      const formWith = (entries) => {
+        const form = new FormData();
+        for (const [name, value] of entries) form.append(name, value);
+        return form;
+      };
+      it("parses multipart bodies into fields and files", () => {
+        const bytes = Uint8Array.from({ length: 256 }, (_, index) => index);
+        return withApp(
+          (router) => {
+            router.defineRoute({
+              method: "post",
+              path: "/documents",
+              schema: (z) => ({
+                body: z.object({ title: z.string() }),
+                files: z.object({
+                  document: z.file().mime(["application/pdf"])
+                })
+              }),
+              handler: async ({ req }) => ({
+                title: req.body.title,
+                name: req.files.document.name,
+                type: req.files.document.type,
+                bytes: [
+                  ...new Uint8Array(await req.files.document.arrayBuffer())
+                ]
+              })
+            });
+            router.defineRoute({
+              method: "post",
+              path: "/gallery",
+              handler: ({ req }) => ({
+                fields: req.body,
+                files: Object.fromEntries(
+                  Object.entries(req.files).map(([name, value]) => [
+                    name,
+                    [value].flat().map((file2) => file2.name)
+                  ])
+                )
+              })
+            });
+          },
+          async ({ fetch: fetch2 }) => {
+            const res = await fetch2("/documents", {
+              method: "POST",
+              body: formWith([
+                ["title", "Contrat sign\xE9"],
+                [
+                  "document",
+                  new File([bytes], "contrat \xE9t\xE9.pdf", {
+                    type: "application/pdf"
+                  })
+                ]
+              ])
+            });
+            expect2(await res.json()).toEqual({
+              title: "Contrat sign\xE9",
+              name: "contrat \xE9t\xE9.pdf",
+              type: "application/pdf",
+              bytes: [...bytes]
+            });
+            const gallery = await fetch2("/gallery", {
+              method: "POST",
+              body: formWith([
+                ["tag", "sea"],
+                ["tag", "sun"],
+                ["photos", new File(["a"], "a.jpg")],
+                ["photos", new File(["b"], "b.jpg")],
+                ["cover", new File(["c"], "c.jpg")]
+              ])
+            });
+            expect2(await gallery.json()).toEqual({
+              fields: { tag: ["sea", "sun"] },
+              files: { photos: ["a.jpg", "b.jpg"], cover: ["c.jpg"] }
+            });
+          }
+        );
+      });
+      it("validates files", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/avatar",
+            schema: (z) => ({
+              files: z.object({
+                avatar: z.file().max(10).mime(["image/png"])
+              })
+            }),
+            handler: () => ({ ok: true })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/avatar", {
+            method: "POST",
+            body: formWith([
+              [
+                "avatar",
+                new File([new Uint8Array(11)], "a.gif", {
+                  type: "image/gif"
+                })
+              ]
+            ])
+          });
+          expect2(res.status).toBe(400);
+          expect2(await res.json()).toMatchObject({
+            error: "VALIDATION_FAILED",
+            data: {
+              issues: [
+                { source: "files", path: ["avatar"], code: "too_big" },
+                { source: "files", path: ["avatar"], code: "invalid_value" }
+              ]
+            }
+          });
+        }
+      ));
+      it("applies the route body limit", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/large",
+            bodyLimit: 3 * DEFAULT_BODY_LIMIT,
+            handler: ({ req }) => ({
+              size: req.files.file.size
+            })
+          });
+          router.defineRoute({
+            method: "post",
+            path: "/small",
+            bodyLimit: 100,
+            handler: () => ({ unreachable: true })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const size = 2 * DEFAULT_BODY_LIMIT;
+          const large = await fetch2("/large", {
+            method: "POST",
+            body: formWith([
+              ["file", new File([new Uint8Array(size)], "big.bin")]
+            ])
+          });
+          expect2(await large.json()).toEqual({ size });
+          const small = await fetch2("/small", {
+            method: "POST",
+            body: formWith([
+              ["file", new File([new Uint8Array(200)], "a.bin")]
+            ])
+          });
+          expect2(small.status).toBe(413);
+        }
+      ));
+      it("rejects malformed multipart bodies", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/upload",
+            handler: () => ({ unreachable: true })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/upload", {
+            method: "POST",
+            headers: { "content-type": "multipart/form-data; boundary=xyz" },
+            body: "not a multipart body"
+          });
+          expect2(res.status).toBe(400);
+          expect2(await res.json()).toMatchObject({ error: "MALFORMED_BODY" });
+        }
+      ));
+    });
+    describe("validation", () => {
+      it("returns VALIDATION_FAILED errors and parsed values", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/users/:id",
+            schema: (z) => ({
+              params: z.object({ id: z.coerce.number().int() }),
+              query: z.object({ notify: z.enum(["yes", "no"]) }),
+              body: z.object({ name: z.string().trim() })
+            }),
+            handler: ({ req }) => ({
+              id: req.params.id,
+              notify: req.query.notify,
+              name: req.body.name
+            })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const invalid = await fetch2("/users/abc?notify=maybe", postJson({}));
+          expect2(invalid.status).toBe(400);
+          expect2(await invalid.json()).toMatchObject({
+            status: 400,
+            error: "VALIDATION_FAILED",
+            data: {
+              issues: [
+                { source: "params", path: ["id"] },
+                { source: "query", path: ["notify"] },
+                { source: "body", path: ["name"] }
+              ]
+            }
+          });
+          const valid = await fetch2(
+            "/users/42?notify=yes",
+            postJson({ name: "  Ada " })
+          );
+          expect2(await valid.json()).toEqual({
+            id: 42,
+            notify: "yes",
+            name: "Ada"
+          });
+        }
+      ));
+    });
+    describe("errors", () => {
+      it("serializes returned and thrown HTTP errors", () => withApp(
+        (router) => {
+          router.defineRoute({
+            path: "/returned",
+            handler: () => notFoundError("User not found", { id: "1" })
+          });
+          router.defineRoute({
+            path: "/thrown",
+            handler: ({ res }) => {
+              res.setHeader("www-authenticate", "Bearer");
+              throw unauthorizedError();
+            }
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const returned = await fetch2("/returned");
+          expect2(returned.status).toBe(404);
+          expect2(await returned.json()).toEqual({
+            status: 404,
+            error: "NOT_FOUND",
+            message: "User not found",
+            data: { id: "1" }
+          });
+          const thrown = await fetch2("/thrown");
+          expect2(thrown.status).toBe(401);
+          expect2(thrown.headers.get("www-authenticate")).toBe("Bearer");
+          expect2(await thrown.json()).toEqual({
+            status: 401,
+            error: "UNAUTHORIZED",
+            message: "Unauthorized"
+          });
+        }
+      ));
+      it("hides unexpected errors behind a 500 error and reports them", async () => {
+        const onError = vi.fn();
+        await withApp(
+          (router) => {
+            router.defineRoute({
+              path: "/crash",
+              handler: () => {
+                throw new Error("Database password is hunter2");
+              }
+            });
+          },
+          async ({ fetch: fetch2 }) => {
+            const res = await fetch2("/crash");
+            expect2(res.status).toBe(500);
+            expect2(res.headers.get("x-request-id")).toBeTruthy();
+            expect2(await res.json()).toEqual({
+              status: 500,
+              error: "INTERNAL_ERROR",
+              message: "Internal Server Error"
+            });
+            expect2(onError).toHaveBeenCalledOnce();
+          },
+          { onError }
+        );
+      });
+      it("exposes error details when exposeErrors is enabled", () => withApp(
+        (router) => {
+          router.defineRoute({
+            path: "/crash",
+            handler: () => {
+              throw new Error("Boom");
+            }
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          expect2(await (await fetch2("/crash")).json()).toMatchObject({
+            status: 500,
+            data: { name: "Error", message: "Boom" }
+          });
+        },
+        { exposeErrors: true }
+      ));
+      it("returns a 500 error when the response does not match its schema", () => withApp(
+        (router) => {
+          router.defineRoute({
+            path: "/invalid",
+            schema: (z) => ({ response: z.object({ id: z.string() }) }),
+            // @ts-expect-error the result does not match the schema
+            handler: () => ({ id: 1 })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          expect2((await fetch2("/invalid")).status).toBe(500);
+        }
+      ));
+    });
+    describe("middlewares and filters", () => {
+      it("stops the pipeline when a middleware returns a response", () => withApp(
+        (router) => {
+          router.defineRoute({
+            path: "/private",
+            middlewares: [
+              ({ req }) => req.header("authorization") ? void 0 : unauthorizedError()
+            ],
+            handler: () => ({ secret: true })
+          });
+          router.defineRoute({
+            path: "/legacy",
+            middlewares: [() => redirect("/modern", 301)],
+            handler: () => ({ unreachable: true })
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          expect2((await fetch2("/private")).status).toBe(401);
+          expect2(
+            await (await fetch2("/private", { headers: { authorization: "x" } })).json()
+          ).toEqual({ secret: true });
+          const legacy = await fetch2("/legacy", { redirect: "manual" });
+          expect2(legacy.status).toBe(301);
+          expect2(legacy.headers.get("location")).toBe("/modern");
+        }
+      ));
+      it("applies app and router response filters", () => withApp(
+        (router) => {
+          router.addResponseFilter((_ctx, result) => ({
+            ...result,
+            router: true
+          }));
+          router.defineRoute({ path: "/data", handler: () => ({ a: 1 }) });
+        },
+        async ({ fetch: fetch2 }) => {
+          expect2(await (await fetch2("/data")).json()).toEqual({
+            a: 1,
+            app: true,
+            router: true
+          });
+        },
+        {
+          responseFilters: [
+            (_ctx, result) => ({ ...result, app: true })
+          ]
+        }
+      ));
+    });
+    describe("responses", () => {
+      it("applies statuses, headers and cookies", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "post",
+            path: "/created",
+            status: 201,
+            handler: ({ res }) => {
+              res.setHeader("location", "/items/1");
+              res.setCookie("session", "abc", { httpOnly: true });
+              res.setCookie("theme", "dark");
+              return { id: 1 };
+            }
+          });
+          router.defineRoute({
+            path: "/accepted",
+            handler: ({ res }) => {
+              res.setStatus(202);
+              return json({ queued: true }, { headers: { "x-queue": "a" } });
+            }
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const created = await fetch2("/created", { method: "POST" });
+          expect2(created.status).toBe(201);
+          expect2(created.headers.get("location")).toBe("/items/1");
+          expect2(created.headers.getSetCookie()).toEqual([
+            "session=abc; Path=/; HttpOnly",
+            "theme=dark; Path=/"
+          ]);
+          const accepted = await fetch2("/accepted");
+          expect2(accepted.status).toBe(202);
+          expect2(accepted.headers.get("x-queue")).toBe("a");
+          expect2(await accepted.json()).toEqual({ queued: true });
+        }
+      ));
+      it("answers 204 without body when the handler returns nothing", () => withApp(
+        (router) => {
+          router.defineRoute({
+            method: "delete",
+            path: "/items/:id",
+            handler: () => {
+            }
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/items/1", { method: "DELETE" });
+          expect2(res.status).toBe(204);
+          expect2(res.headers.get("content-type")).toBeNull();
+          expect2(await res.text()).toBe("");
+        }
+      ));
+      it("does not add framework headers", () => withApp(
+        (router) => {
+          router.defineRoute({ path: "/plain", handler: () => "ok" });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/plain");
+          expect2(res.headers.get("x-powered-by")).toBeNull();
+          expect2(res.headers.get("etag")).toBeNull();
+        }
+      ));
+      it("sends redirects", () => withApp(
+        (router) => {
+          router.defineRoute({
+            path: "/old",
+            handler: () => redirect("/new")
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/old", { redirect: "manual" });
+          expect2(res.status).toBe(302);
+          expect2(res.headers.get("location")).toBe("/new");
+        }
+      ));
+      it("sends text responses", () => withApp(
+        (router) => {
+          router.defineRoute({
+            path: "/page",
+            handler: () => text("<h1>H\xE9llo</h1>", {
+              headers: { "content-type": "text/html; charset=utf-8" }
+            })
+          });
+          router.defineRoute({ path: "/health", handler: () => text("OK") });
+        },
+        async ({ fetch: fetch2 }) => {
+          const page = await fetch2("/page");
+          expect2(page.headers.get("content-type")).toBe(
+            "text/html; charset=utf-8"
+          );
+          expect2(await page.text()).toBe("<h1>H\xE9llo</h1>");
+          const health = await fetch2("/health");
+          expect2(health.headers.get("content-type")).toBe(
+            "text/plain; charset=utf-8"
+          );
+          expect2(await health.text()).toBe("OK");
+        }
+      ));
+      it("sends files without altering their bytes", () => {
+        const bytes = Uint8Array.from({ length: 256 }, (_, index) => index);
+        return withApp(
+          (router) => {
+            router.defineRoute({
+              path: "/download",
+              handler: () => file(bytes, {
+                filename: "rapport \xE9t\xE9.bin",
+                contentType: "application/octet-stream"
+              })
+            });
+            router.defineRoute({
+              path: "/blob",
+              handler: () => file(new Blob([bytes], { type: "image/png" }), {
+                disposition: "inline"
+              })
+            });
+          },
+          async ({ fetch: fetch2 }) => {
+            const res = await fetch2("/download");
+            expect2(res.headers.get("content-length")).toBe("256");
+            expect2(res.headers.get("content-disposition")).toBe(
+              `attachment; filename="rapport _t_.bin"; filename*=UTF-8''rapport%20%C3%A9t%C3%A9.bin`
+            );
+            expect2(new Uint8Array(await res.arrayBuffer())).toEqual(bytes);
+            const blob = await fetch2("/blob");
+            expect2(blob.headers.get("content-type")).toBe("image/png");
+            expect2(new Uint8Array(await blob.arrayBuffer())).toEqual(bytes);
+          }
+        );
+      });
+    });
+    describe("cors", () => {
+      const APP = "https://app.example.com";
+      const EVIL = "https://evil.example.org";
+      const corsRoutes = (router) => {
+        router.defineRoute({ path: "/users", handler: () => [] });
+        router.defineRoute({
+          method: "post",
+          path: "/users",
+          handler: () => ({ created: true })
+        });
+        router.defineRoute({
+          path: "/private",
+          middlewares: [() => unauthorizedError()],
+          handler: () => ({ secret: true })
+        });
+        router.defineRoute({
+          method: "options",
+          path: "/custom",
+          handler: () => ({ custom: true })
+        });
+        router.defineRoute({
+          path: "/export.csv",
+          handler: () => stream(["a,b\n"], { contentType: "text/csv" })
+        });
+      };
+      const preflight = (origin = APP) => ({
+        method: "OPTIONS",
+        headers: {
+          origin,
+          "access-control-request-method": "POST",
+          "access-control-request-headers": "content-type, authorization"
+        }
+      });
+      it("answers preflight requests before the middlewares", () => withApp(
+        corsRoutes,
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/users", preflight());
+          expect2(res.status).toBe(204);
+          expect2(res.headers.get("access-control-allow-origin")).toBe(APP);
+          expect2(res.headers.get("access-control-allow-methods")).toBe(
+            "GET, HEAD, POST"
+          );
+          expect2(res.headers.get("access-control-allow-headers")).toBe(
+            "content-type, authorization"
+          );
+          expect2(res.headers.get("access-control-max-age")).toBe("600");
+          expect2(res.headers.get("vary")).toContain("Origin");
+          expect2(await res.text()).toBe("");
+          const private_ = await fetch2("/private", preflight());
+          expect2(private_.status).toBe(204);
+          const custom = await fetch2("/custom", preflight());
+          expect2(custom.status).toBe(204);
+          expect2(custom.headers.get("access-control-allow-methods")).toBe(
+            "OPTIONS"
+          );
+          const refused = await fetch2("/users", preflight(EVIL));
+          expect2(refused.status).toBe(405);
+          expect2(
+            refused.headers.get("access-control-allow-origin")
+          ).toBeNull();
+          expect2((await fetch2("/missing", preflight())).status).toBe(404);
+        },
+        { cors: { origin: [APP], maxAge: 600 } }
+      ));
+      it("adds the CORS headers to every response, errors included", () => withApp(
+        corsRoutes,
+        async ({ fetch: fetch2 }) => {
+          const requests = [
+            ["/users", {}, 200],
+            ["/private", {}, 401],
+            ["/missing", {}, 404],
+            ["/users", { method: "DELETE" }, 405],
+            [
+              "/users",
+              {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: "{oops"
+              },
+              400
+            ],
+            ["/export.csv", {}, 200]
+          ];
+          for (const [path, init, status] of requests) {
+            const res = await fetch2(path, {
+              ...init,
+              headers: { ...init.headers, origin: APP }
+            });
+            expect2(res.status).toBe(status);
+            expect2(res.headers.get("access-control-allow-origin")).toBe(APP);
+            expect2(res.headers.get("access-control-allow-credentials")).toBe(
+              "true"
+            );
+            expect2(res.headers.get("access-control-expose-headers")).toBe(
+              "x-request-id"
+            );
+            expect2(res.headers.get("vary")).toContain("Origin");
+            await res.arrayBuffer();
+          }
+          const refused = await fetch2("/users", { headers: { origin: EVIL } });
+          expect2(refused.status).toBe(200);
+          expect2(
+            refused.headers.get("access-control-allow-origin")
+          ).toBeNull();
+          expect2(refused.headers.get("vary")).toContain("Origin");
+        },
+        {
+          cors: {
+            origin: APP,
+            credentials: true,
+            exposedHeaders: ["x-request-id"]
+          }
+        }
+      ));
+    });
+    describe("streaming", () => {
+      const incremental = options.bufferedResponses ? it.skip : it;
+      it("streams chunks", () => withApp(
+        (router) => {
+          router.defineRoute({
+            path: "/export.csv",
+            handler: () => stream(
+              async function* () {
+                yield "id,name\n";
+                yield new TextEncoder().encode("1,Ada\n");
+              },
+              { contentType: "text/csv" }
+            )
+          });
+        },
+        async ({ fetch: fetch2 }) => {
+          const res = await fetch2("/export.csv");
+          expect2(res.status).toBe(200);
+          expect2(res.headers.get("content-type")).toBe("text/csv");
+          expect2(await res.text()).toBe("id,name\n1,Ada\n");
+        }
+      ));
+      incremental("flushes Server-Sent Events as they are produced", () => {
+        const released = deferred();
+        return withApp(
+          (router) => {
+            router.defineRoute({
+              path: "/events",
+              handler: () => sse(
+                async function* ({ signal }) {
+                  try {
+                    yield { event: "ready", data: { ok: true } };
+                    await waitForAbort(signal);
+                  } finally {
+                    released.resolve();
+                  }
+                },
+                { heartbeat: false }
+              )
+            });
+          },
+          async ({ fetch: fetch2 }) => {
+            const res = await fetch2("/events");
+            expect2(res.headers.get("content-type")).toBe(
+              "text/event-stream; charset=utf-8"
+            );
+            expect2(res.headers.get("cache-control")).toBe("no-cache");
+            const reader = res.body.getReader();
+            expect2(await within(readChunk(reader), "first event")).toBe(
+              'event: ready\ndata: {"ok":true}\n\n'
+            );
+            await reader.cancel();
+            await within(released.promise, "source release on disconnect");
+          }
+        );
+      });
+      incremental(
+        "cancels the response stream when the client disconnects",
+        () => {
+          const cancelled = deferred();
+          return withApp(
+            (router) => {
+              router.defineRoute({
+                path: "/download",
+                handler: () => file(
+                  new ReadableStream({
+                    pull: (controller) => controller.enqueue(new Uint8Array(64 * 1024)),
+                    cancel: () => cancelled.resolve()
+                  })
+                )
+              });
+            },
+            async ({ fetch: fetch2 }) => {
+              const res = await fetch2("/download");
+              const reader = res.body.getReader();
+              await reader.read();
+              await reader.cancel();
+              await within(cancelled.promise, "response stream cancel");
+            }
+          );
+        }
+      );
+      incremental("aborts req.signal when the client disconnects", () => {
+        const started = deferred();
+        const aborted = deferred();
+        return withApp(
+          (router) => {
+            router.defineRoute({
+              path: "/slow",
+              handler: async ({ req }) => {
+                started.resolve();
+                await waitForAbort(req.signal);
+                aborted.resolve();
+                return { late: true };
+              }
+            });
+          },
+          async ({ fetch: fetch2 }) => {
+            const controller = new AbortController();
+            const pending = fetch2("/slow", { signal: controller.signal }).catch(
+              () => void 0
+            );
+            await within(started.promise, "handler start");
+            controller.abort();
+            await within(aborted.promise, "req.signal abort");
+            await pending;
+          }
+        );
+      });
+      incremental(
+        "aborts the connection when a stream fails",
+        () => withApp(
+          (router) => {
+            router.defineRoute({
+              path: "/broken",
+              handler: () => stream(async function* () {
+                yield "partial";
+                throw new Error("Source failed");
+              })
+            });
+          },
+          async ({ fetch: fetch2 }) => {
+            const res = await fetch2("/broken");
+            expect2(res.status).toBe(200);
+            const outcome = await within(
+              res.text().then(
+                () => "completed",
+                () => "aborted"
+              ),
+              "body read"
+            );
+            expect2(outcome).toBe("aborted");
+          }
+        )
+      );
+    });
+  });
+};
+
+// src/lambda.ts
+var CHUNK = 32768;
+var encodeBase64 = (bytes) => {
+  let binary = "";
+  for (let index = 0; index < bytes.length; index += CHUNK) {
+    binary += String.fromCharCode(...bytes.subarray(index, index + CHUNK));
+  }
+  return btoa(binary);
+};
+var decodeBase64 = (text2) => Uint8Array.from(atob(text2), (char) => char.charCodeAt(0));
+var TEXT_TYPES = /^\s*(text\/|application\/(json|x-www-form-urlencoded)\b|[^;]*\+json\b)/i;
+var eventBody = (bytes, contentType) => {
+  if (bytes.byteLength === 0) return { body: null, isBase64Encoded: false };
+  if (contentType && TEXT_TYPES.test(contentType)) {
+    try {
+      const body = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+      return { body, isBase64Encoded: false };
+    } catch {
+    }
+  }
+  return { body: encodeBase64(bytes), isBase64Encoded: true };
+};
+var rawQuery = (search) => {
+  const result = {};
+  for (const pair of search.slice(1).split("&")) {
+    if (!pair) continue;
+    const index = pair.indexOf("=");
+    const key = index === -1 ? pair : pair.slice(0, index);
+    const value = index === -1 ? "" : pair.slice(index + 1);
+    (result[key] ??= []).push(value);
+  }
+  return result;
+};
+var lastValues = (values) => Object.fromEntries(
+  Object.entries(values).map(([key, list]) => [key, list.at(-1)])
+);
+var ACCOUNT = "123456789012";
+var toLambdaEvent = async (request, format, sourceIp = "127.0.0.1") => {
+  const url = new URL(request.url);
+  const headers = { host: url.host };
+  for (const [name, value] of request.headers) headers[name] = value;
+  const { body, isBase64Encoded } = eventBody(
+    new Uint8Array(await request.arrayBuffer()),
+    request.headers.get("content-type")
+  );
+  const requestId = crypto.randomUUID();
+  const userAgent = headers["user-agent"] ?? "";
+  if (format === "v2") {
+    const { cookie, ...rest } = headers;
+    return {
+      version: "2.0",
+      routeKey: "$default",
+      rawPath: url.pathname,
+      rawQueryString: url.search.slice(1),
+      ...cookie ? { cookies: cookie.split(/;\s*/) } : {},
+      headers: rest,
+      requestContext: {
+        accountId: ACCOUNT,
+        apiId: "api",
+        domainName: url.host,
+        domainPrefix: url.hostname.split(".")[0],
+        http: {
+          method: request.method,
+          path: url.pathname,
+          protocol: "HTTP/1.1",
+          sourceIp,
+          userAgent
+        },
+        requestId,
+        routeKey: "$default",
+        stage: "$default",
+        time: (/* @__PURE__ */ new Date()).toISOString(),
+        timeEpoch: Date.now()
+      },
+      ...body === null ? {} : { body },
+      isBase64Encoded
+    };
+  }
+  const query = {};
+  for (const [key, value] of url.searchParams) (query[key] ??= []).push(value);
+  const multiValueHeaders = Object.fromEntries(
+    Object.entries(headers).map(([name, value]) => [name, [value]])
+  );
+  if (format === "alb") {
+    return {
+      requestContext: {
+        elb: {
+          targetGroupArn: `arn:aws:elasticloadbalancing:us-east-1:${ACCOUNT}:targetgroup/dotpress/0123456789abcdef`
+        }
+      },
+      httpMethod: request.method,
+      path: url.pathname,
+      multiValueQueryStringParameters: rawQuery(url.search),
+      // The load balancer appends the client address.
+      multiValueHeaders: {
+        ...multiValueHeaders,
+        "x-forwarded-for": [
+          headers["x-forwarded-for"] ? `${headers["x-forwarded-for"]}, ${sourceIp}` : sourceIp
+        ],
+        "x-forwarded-proto": [url.protocol.slice(0, -1)]
+      },
+      body: body ?? "",
+      isBase64Encoded
+    };
+  }
+  const hasQuery = Object.keys(query).length > 0;
+  return {
+    resource: "/{proxy+}",
+    path: url.pathname,
+    httpMethod: request.method,
+    headers,
+    multiValueHeaders,
+    queryStringParameters: hasQuery ? lastValues(query) : null,
+    multiValueQueryStringParameters: hasQuery ? query : null,
+    pathParameters: { proxy: url.pathname.slice(1) },
+    stageVariables: null,
+    requestContext: {
+      accountId: ACCOUNT,
+      apiId: "api",
+      domainName: url.host,
+      httpMethod: request.method,
+      identity: { sourceIp, userAgent },
+      path: url.pathname,
+      protocol: "HTTP/1.1",
+      requestId,
+      requestTimeEpoch: Date.now(),
+      resourcePath: "/{proxy+}",
+      stage: "$default"
+    },
+    body,
+    isBase64Encoded
+  };
+};
+var NULL_BODY_STATUSES = /* @__PURE__ */ new Set([101, 204, 205, 304]);
+var fromLambdaResult = (result) => {
+  const { statusCode, headers, multiValueHeaders, cookies, body, ...rest } = result;
+  const responseHeaders = new Headers();
+  for (const [name, value] of Object.entries(headers ?? {})) {
+    for (const item of Array.isArray(value) ? value : [value]) {
+      responseHeaders.append(name, item);
+    }
+  }
+  for (const [name, values] of Object.entries(multiValueHeaders ?? {})) {
+    for (const value of values) responseHeaders.append(name, value);
+  }
+  for (const cookie of cookies ?? []) {
+    responseHeaders.append("set-cookie", cookie);
+  }
+  const content = !body || NULL_BODY_STATUSES.has(statusCode) ? null : rest.isBase64Encoded ? decodeBase64(body) : body;
+  return new Response(content, {
+    status: statusCode,
+    headers: responseHeaders
+  });
+};
+var lambdaContext = () => ({
+  awsRequestId: crypto.randomUUID(),
+  functionName: "dotpress-test",
+  functionVersion: "$LATEST",
+  invokedFunctionArn: `arn:aws:lambda:us-east-1:${ACCOUNT}:function:dotpress-test`,
+  memoryLimitInMB: "128",
+  logGroupName: "/aws/lambda/dotpress-test",
+  logStreamName: "test",
+  callbackWaitsForEmptyEventLoop: true,
+  getRemainingTimeInMillis: () => 3e4
+});
+var createLambdaTarget = (handler, options) => {
+  const invoke = handler;
+  return createFetchTarget(async (request) => {
+    const event = await toLambdaEvent(request, options.format, options.sourceIp);
+    let result;
+    try {
+      result = await invoke(event, lambdaContext());
+    } catch {
+      return Response.json(
+        { message: "Internal server error" },
+        { status: 502 }
+      );
+    }
+    return fromLambdaResult(result);
+  }, options.close);
+};
+
+// src/memory.ts
+import {
+  DEFAULT_BODY_LIMIT as DEFAULT_BODY_LIMIT2,
+  createApp,
+  createRouteMatcher,
+  fromWebRequest,
+  readRequestBody,
+  toWebResponse
+} from "@dotpress/core";
+var memoryAdapter = (options = {}) => {
+  const bodyLimit = options.bodyLimit ?? DEFAULT_BODY_LIMIT2;
+  let routes = [];
+  let matcher;
+  let runtime;
+  const handle = async (request) => {
+    if (!matcher || !runtime) {
+      throw new Error("The memory adapter is not mounted: call createApp().");
+    }
+    const normalized = fromWebRequest(request, {
+      ip: options.ip ?? "127.0.0.1"
+    });
+    const match = matcher.match(request.method, normalized.path);
+    if (!match) {
+      await request.body?.cancel();
+      return runtime.handleNotFound(normalized);
+    }
+    try {
+      const { body, files, rawBody } = await readRequestBody(
+        request,
+        match.route.definition.bodyLimit ?? bodyLimit
+      );
+      normalized.body = body;
+      normalized.files = files;
+      normalized.rawBody = rawBody;
+    } catch (error) {
+      return runtime.handleError(error, normalized);
+    }
+    normalized.params = match.params;
+    return match.route.execute(normalized);
+  };
+  return {
+    name: "memory",
+    mount(compiledRoutes, dotpressRuntime) {
+      if (runtime) throw new Error("The memory adapter is already mounted.");
+      routes = compiledRoutes;
+      matcher = createRouteMatcher(compiledRoutes);
+      runtime = dotpressRuntime;
+    },
+    native: () => ({ routes }),
+    async fetch(request) {
+      return toWebResponse(await handle(request), request.method);
+    }
+  };
+};
+var createTestApp = async (options = {}) => {
+  const { adapter: adapterOptions, ...appOptions } = options;
+  const logger = appOptions.logger ?? createMemoryLogger();
+  const adapter = memoryAdapter(adapterOptions);
+  const app = await createApp({ ...appOptions, logger, adapter });
+  return {
+    app,
+    adapter,
+    logger,
+    fetch: async (path, init) => adapter.fetch(await toRequest(path, init)),
+    close: () => app.close()
+  };
+};
+
+// src/events.ts
+var OPTIONS = ["times", "metadata", "delay"];
+var emissionsOf = (label, source) => {
+  if (typeof source === "object" && source !== null) {
+    if ("emitted" in source && Array.isArray(source.emitted)) {
+      return source.emitted;
+    }
+    if ("sent" in source && Array.isArray(source.sent)) {
+      const emissions = /* @__PURE__ */ new Map();
+      for (const envelope of source.sent) {
+        emissions.set(envelope.emissionId, {
+          emissionId: envelope.emissionId,
+          event: envelope.event,
+          payload: envelope.payload,
+          delay: void 0,
+          metadata: envelope.metadata,
+          emittedAt: new Date(envelope.emittedAt)
+        });
+      }
+      return [...emissions.values()];
+    }
+  }
+  throw new TypeError(
+    `${label}: expected a fake event bus (createFakeEventBus()) or a memory transport (createMemoryTransport()).`
+  );
+};
+var nameOf = (label, event) => {
+  const name = typeof event === "string" ? event : event?.name;
+  if (typeof name !== "string" || name === "") {
+    throw new TypeError(
+      `${label}: expected an event created by defineEvent(), or its name.`
+    );
+  }
+  return name;
+};
+var find = (label, source, event, payload, options) => {
+  const name = nameOf(label, event);
+  if (options !== void 0 && (typeof options !== "object" || options === null)) {
+    throw new TypeError(`${label}: expected an object of options.`);
+  }
+  const values = options ?? {};
+  for (const key of Object.keys(values)) {
+    if (!OPTIONS.includes(key)) {
+      throw new TypeError(`${label}: unknown option "${key}".`);
+    }
+  }
+  checkTimes(label, values.times);
+  const emissions = emissionsOf(label, source);
+  if ("delay" in values && !("emitted" in source)) {
+    throw new TypeError(
+      `${label}: delay is only recorded by a fake event bus (createFakeEventBus()).`
+    );
+  }
+  const found = emissions.filter(
+    (emission) => emission.event === name && (payload === void 0 || matches(emission.payload, payload)) && (values.metadata === void 0 || matches(emission.metadata, values.metadata)) && (!("delay" in values) || emission.delay === values.delay)
+  );
+  const details = [
+    payload === void 0 ? "" : ` with payload ${show(payload)}`,
+    values.metadata === void 0 ? "" : ` and metadata ${show(values.metadata)}`,
+    "delay" in values ? ` and delay ${String(values.delay)}` : ""
+  ].join("");
+  const recorded = emissions.length === 0 ? "No event was emitted." : `Emitted events:
+${emissions.map(
+    (emission) => `  - ${emission.event} ${show(emission.payload)}${emission.delay === void 0 ? "" : ` (delay ${emission.delay})`}`
+  ).join("\n")}`;
+  return {
+    found,
+    description: {
+      some: `event "${name}" emitted${details}`,
+      none: `no event "${name}" emitted${details}`
+    },
+    recorded,
+    times: values.times
+  };
+};
+function expectEventEmitted(source, event, ...rest) {
+  const label = "expectEventEmitted()";
+  const [payload, options] = rest;
+  const { found, description, recorded, times } = find(
+    label,
+    source,
+    event,
+    payload,
+    options
+  );
+  if (times === 0) {
+    throw new TypeError(
+      `${label}: times must be at least 1 (use expectEventNotEmitted()).`
+    );
+  }
+  assertCount(description, found.length, times, recorded);
+  return found.at(-1);
+}
+function expectEventNotEmitted(source, event, ...rest) {
+  const label = "expectEventNotEmitted()";
+  const { found, description, recorded } = find(
+    label,
+    source,
+    event,
+    rest[0],
+    void 0
+  );
+  assertCount(description, found.length, 0, recorded);
+}
+
+// src/mail.ts
+var ADDRESS_KEYS = ["to", "cc", "bcc", "replyTo"];
+var KEYS = /* @__PURE__ */ new Set([
+  ...ADDRESS_KEYS,
+  "from",
+  "template",
+  "locale",
+  "subject",
+  "html",
+  "text",
+  "tags",
+  "metadata",
+  "headers",
+  "attachments"
+]);
+var lower = (address) => address.trim().toLowerCase();
+var checkAddresses = (label, key, value) => {
+  const list = typeof value === "string" ? [value] : value;
+  if (!Array.isArray(list) || list.length === 0 || !list.every((item) => typeof item === "string" && item.trim() !== "")) {
+    throw new TypeError(
+      `${label}: ${key} must be an email address, or a non-empty array of them.`
+    );
+  }
+  return list.map(lower);
+};
+var predicateOf = (label, criteria) => {
+  if (typeof criteria !== "object" || criteria === null) {
+    throw new TypeError(`${label}: expected an object of criteria.`);
+  }
+  const values = criteria;
+  for (const key of Object.keys(values)) {
+    if (!KEYS.has(key)) {
+      throw new TypeError(`${label}: unknown criterion "${key}".`);
+    }
+  }
+  const addresses = ADDRESS_KEYS.flatMap(
+    (key) => values[key] === void 0 ? [] : [{ key, expected: checkAddresses(label, key, values[key]) }]
+  );
+  const { from, template } = values;
+  if (from !== void 0 && (typeof from !== "string" || from.trim() === "")) {
+    throw new TypeError(`${label}: from must be an email address.`);
+  }
+  const templateName = template === void 0 ? void 0 : typeof template === "string" ? template : template?.name;
+  if (template !== void 0 && typeof templateName !== "string") {
+    throw new TypeError(`${label}: template must be a template, or its name.`);
+  }
+  const others = Object.entries(values).filter(
+    ([key, value]) => value !== void 0 && !ADDRESS_KEYS.includes(key) && key !== "from" && key !== "template"
+  );
+  return (message) => addresses.every(({ key, expected }) => {
+    const actual = message[key].map(
+      ({ address }) => lower(address)
+    );
+    return expected.every((address) => actual.includes(address));
+  }) && (from === void 0 || lower(message.from.address) === lower(from)) && (templateName === void 0 || message.template === templateName) && others.every(
+    ([key, value]) => matches(message[key], value)
+  );
+};
+var outboxOf = (label, outbox) => {
+  const sent = outbox?.sent;
+  if (!Array.isArray(sent)) {
+    throw new TypeError(
+      `${label}: expected the memory provider of the mailer (createMemoryProvider()).`
+    );
+  }
+  return sent;
+};
+var recipients = (addresses) => addresses.map(({ address }) => address).join(", ");
+var recordedOf = (messages) => messages.length === 0 ? "No message was sent." : `Sent messages:
+${messages.map(
+  (message) => `  - to ${recipients(message.to)}: ${show(message.subject)}${message.template === void 0 ? "" : ` (template ${message.template})`}`
+).join("\n")}`;
+var describeCriteria = (criteria) => {
+  const shown = Object.keys(criteria).length === 0 ? "" : ` ${show(criteria)}`;
+  return {
+    some: `a message${shown} sent`,
+    none: `no message${shown} sent`
+  };
+};
+var expectMailSent = (outbox, criteria = {}, options = {}) => {
+  const label = "expectMailSent()";
+  const messages = outboxOf(label, outbox);
+  const matching = predicateOf(label, criteria);
+  if (typeof options !== "object" || options === null) {
+    throw new TypeError(`${label}: expected an object of options.`);
+  }
+  for (const key of Object.keys(options)) {
+    if (key !== "times") {
+      throw new TypeError(`${label}: unknown option "${key}".`);
+    }
+  }
+  checkTimes(label, options.times);
+  if (options.times === 0) {
+    throw new TypeError(
+      `${label}: times must be at least 1 (use expectNoMailSent()).`
+    );
+  }
+  const found = messages.filter(matching);
+  assertCount(
+    describeCriteria(criteria),
+    found.length,
+    options.times,
+    recordedOf(messages)
+  );
+  return found.at(-1);
+};
+var expectNoMailSent = (outbox, criteria = {}) => {
+  const label = "expectNoMailSent()";
+  const messages = outboxOf(label, outbox);
+  const found = messages.filter(predicateOf(label, criteria));
+  assertCount(describeCriteria(criteria), found.length, 0, recordedOf(messages));
+};
+export {
+  ExpectationError,
+  createFetchTarget,
+  createHttpTarget,
+  createLambdaTarget,
+  createMemoryLogger,
+  createTestApp,
+  expectEventEmitted,
+  expectEventNotEmitted,
+  expectMailSent,
+  expectNoMailSent,
+  fromLambdaResult,
+  memoryAdapter,
+  runConformanceSuite,
+  toLambdaEvent
+};
+//# sourceMappingURL=index.js.map