@dotpress/testing 2.0.0-alpha.4 → 2.0.0-alpha.5

package/dist/index.js

@@ -1,3 +1,10 @@
+import {
+  closeOf,
+  createFetchTarget,
+  createMemoryLogger,
+  toRequest
+} from "./chunk-MUWNILMA.js";
+
 // src/assertions.ts
 import { expect } from "vitest";
 var ExpectationError = class extends Error {
@@ -16,17 +23,17 @@ var matches = (actual, expected) => {
   }
 };
 var show = (value) => {
-  let json2;
+  let json;
   try {
-    json2 = JSON.stringify(
+    json = JSON.stringify(
       value,
       (_key, item) => typeof item === "object" && item !== null && "asymmetricMatch" in item ? item.toAsymmetricMatcher?.() ?? String(item) : item
     );
   } catch {
-    json2 = void 0;
+    json = void 0;
   }
-  json2 ??= String(value);
-  return json2.length > 300 ? `${json2.slice(0, 297)}...` : json2;
+  json ??= String(value);
+  return json.length > 300 ? `${json.slice(0, 297)}...` : json;
 };
 var checkTimes = (label, times) => {
   if (times !== void 0 && (!Number.isInteger(times) || times < 0)) {
@@ -42,1291 +49,6 @@ ${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) => {
@@ -1336,7 +58,7 @@ var encodeBase64 = (bytes) => {
   }
   return btoa(binary);
 };
-var decodeBase64 = (text2) => Uint8Array.from(atob(text2), (char) => char.charCodeAt(0));
+var decodeBase64 = (text) => Uint8Array.from(atob(text), (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 };
@@ -1493,33 +215,47 @@ var lambdaContext = () => ({
   getRemainingTimeInMillis: () => 3e4
 });
 var createLambdaTarget = (handler, options) => {
+  const close = closeOf("createLambdaTarget()", options, [
+    "format",
+    "close",
+    "sourceIp"
+  ]);
   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 createFetchTarget(
+    async (request) => {
+      const event = await toLambdaEvent(
+        request,
+        options.format,
+        options.sourceIp
       );
-    }
-    return fromLambdaResult(result);
-  }, options.close);
+      let result;
+      try {
+        result = await invoke(event, lambdaContext());
+      } catch {
+        return Response.json(
+          { message: "Internal server error" },
+          { status: 502 }
+        );
+      }
+      return fromLambdaResult(result);
+    },
+    { close }
+  );
 };
 
 // src/memory.ts
 import {
-  DEFAULT_BODY_LIMIT as DEFAULT_BODY_LIMIT2,
-  createApp,
+  createApp
+} from "@dotpress/core";
+import {
+  DEFAULT_BODY_LIMIT,
   createRouteMatcher,
   fromWebRequest,
   readRequestBody,
   toWebResponse
-} from "@dotpress/core";
+} from "@dotpress/core/adapter";
 var memoryAdapter = (options = {}) => {
-  const bodyLimit = options.bodyLimit ?? DEFAULT_BODY_LIMIT2;
+  const bodyLimit = options.bodyLimit ?? DEFAULT_BODY_LIMIT;
   let routes = [];
   let matcher;
   let runtime;
@@ -1796,8 +532,6 @@ var expectNoMailSent = (outbox, criteria = {}) => {
 };
 export {
   ExpectationError,
-  createFetchTarget,
-  createHttpTarget,
   createLambdaTarget,
   createMemoryLogger,
   createTestApp,
@@ -1807,7 +541,6 @@ export {
   expectNoMailSent,
   fromLambdaResult,
   memoryAdapter,
-  runConformanceSuite,
   toLambdaEvent
 };
 //# sourceMappingURL=index.js.map