okengine 0.2.8 → 0.3.2

package/src/kernel/hooks.ts

@@ -150,19 +150,34 @@ export interface PipelineResult {
   readonly response: Response | undefined;
 }
 
+/** Serialize a pipeline outcome into an HTTP response (app-layer encoder). */
+export type PipelineEncoder = (result: {
+  readonly response?: Response | undefined;
+  readonly failure?: FlowFailure | undefined;
+  readonly output?: unknown;
+  readonly error?: unknown;
+}) => Response;
+
 /**
  * Run the seven-stage pipeline around `handler`.
  *
+ * When `encode` is given (HTTP triggers), the outcome is serialized into
+ * `ctx.response` **before** `onResponse`, so the last stage sees — and may
+ * replace — the final response, as {@link InvocationContext.response}
+ * documents. Without `encode` (non-HTTP triggers) behavior is unchanged.
+ *
  * @param ctx - Invocation context
  * @param fx - Fx door
  * @param hooks - Merged hooks
  * @param handler - Flow body (the `handler` stage)
+ * @param encode - HTTP response encoder (e.g. `encodeExecuteResult`)
  */
 export async function runPipeline(
   ctx: InvocationContext,
   fx: Fx,
   hooks: HookMap,
   handler: () => unknown | Promise<unknown>,
+  encode?: PipelineEncoder,
 ): Promise<PipelineResult> {
   let shortCircuit: "response" | "error" | undefined;
 
@@ -215,6 +230,13 @@ export async function runPipeline(
     await runStage("onError", hooks, ctx, fx);
   }
 
+  // Serialize before the last stage so `onResponse` sees the final response
+  // (short-circuit wins; encoder input mirrors the app layer exactly).
+  if (encode !== undefined && ctx.response === undefined) {
+    const failure = isFlowFailure(ctx.error) ? ctx.error : undefined;
+    ctx.response = encode({ failure, output: ctx.result, error: ctx.error });
+  }
+
   await runStage("onResponse", hooks, ctx, fx);
 
   const failure = isFlowFailure(ctx.error) ? ctx.error : undefined;

package/src/kernel/index.ts

@@ -103,6 +103,8 @@ export {
 export {
   createFx,
   createFxContext,
+  isJsonResult,
+  jsonResultBrand,
   resolveName,
   resolveStoreRef,
   type CreateFxOptions,
@@ -113,12 +115,14 @@ export {
   type FxCallHandler,
   type FxClock,
   type FxContext,
+  type FxJson,
   type FxLog,
   type FxOperator,
   type FxSearchOptions,
   type FxSendOptions,
   type FxStoreHandle,
   type FxTenant,
+  type JsonResult,
   type NamedRef,
 } from "./fx.ts";
 
@@ -236,6 +240,7 @@ export {
   every,
   http,
   internal,
+  isResourceMount,
   isSignalTriggerSource,
   normalizeTrigger,
   table,
@@ -246,6 +251,8 @@ export {
   type HttpMethod,
   type HttpTrigger,
   type InternalTrigger,
+  type ResourceFlowBag,
+  type ResourceMount,
   type SignalAsTrigger,
   type SignalSource,
   type TableHandle,

package/src/kernel/on.ts

@@ -8,8 +8,11 @@
 
 import { isFlow, type AnyFlowDef, type FlowDef, type FlowErrorMap } from "./flow.ts";
 import {
+  isResourceMount,
   normalizeTrigger,
   type BoundTriggerOf,
+  type ResourceFlowBag,
+  type ResourceMount,
   type SignalSource,
   type Trigger,
 } from "./triggers.ts";
@@ -39,17 +42,55 @@ export function on<
 >(
   trigger: T,
   flowDef: FlowDef<I, O, E, D, Trigger | undefined>,
-): FlowDef<I, O, E, D, BoundTriggerOf<T>> {
+): FlowDef<I, O, E, D, BoundTriggerOf<T>>;
+/**
+ * Mount a CRUD resource (`http.resource(path, ops)`): registers the five
+ * verb bindings and returns the ops bag (unit keys `list` · `create` ·
+ * `get` · `update` · `remove`) for `.adopt({ notes })`.
+ *
+ * @param mount - Branded {@link ResourceMount}
+ */
+export function on(mount: ResourceMount): ResourceFlowBag;
+export function on(
+  triggerOrMount: Trigger | SignalSource | ResourceMount,
+  flowDef?: FlowDef<any, any, any, any, Trigger | undefined>,
+): unknown {
+  if (isResourceMount(triggerOrMount)) {
+    if (flowDef !== undefined) {
+      throw new TypeError("on(http.resource(...)) takes no second argument");
+    }
+    const byIdVerb: Partial<Record<string, "get" | "update" | "remove">> = {
+      GET: "get",
+      PATCH: "update",
+      DELETE: "remove",
+    };
+    const baseVerb: Partial<Record<string, "list" | "create">> = {
+      GET: "list",
+      POST: "create",
+    };
+    const ops: Record<string, unknown> = {};
+    for (const { trigger, flow } of triggerOrMount.mounts) {
+      const key = trigger.path.endsWith("/:id")
+        ? byIdVerb[trigger.method]
+        : baseVerb[trigger.method];
+      if (key === undefined || !isFlow(flow)) {
+        throw new TypeError("on(http.resource(...)) expects the five CRUD FlowDefs");
+      }
+      on(trigger, flow as FlowDef<any, any, any, any, Trigger | undefined>);
+      ops[key] = flow;
+    }
+    return ops as unknown as ResourceFlowBag;
+  }
   if (!isFlow(flowDef)) {
     throw new TypeError("on() expected a flow() definition as the second argument");
   }
-  const normalized = normalizeTrigger(trigger);
+  const normalized = normalizeTrigger(triggerOrMount as Trigger | SignalSource);
   const list = flowDef.triggers as Trigger[];
   list.push(normalized);
   // Stamp runtime carrier for the first bound trigger (type follows BoundTriggerOf).
   (flowDef as { $trigger: Trigger }).$trigger = normalized;
   bindings.push({ trigger: normalized, flow: flowDef as AnyFlowDef });
-  return flowDef as unknown as FlowDef<I, O, E, D, BoundTriggerOf<T>>;
+  return flowDef;
 }
 
 /**

package/src/kernel/plugin.ts

@@ -6,9 +6,9 @@
  * and records exactly what was requested (capability capture). We never
  * statically analyse plugin source to guess intent.
  *
- * Contributions: flows · hooks · context decorations · elements · drivers ·
- * image recipes · DB schema · typed errors · client extensions · CLI
- * commands · Console panels.
+ * Contributions: flows · hooks · edge handlers (unmatched requests) ·
+ * context decorations · elements · drivers · image recipes · DB schema ·
+ * typed errors · client extensions · CLI commands · Console panels.
  *
  * @see docs/spec/unified-theory.md §14
  * @see docs/spec/console.md §9.15
@@ -87,6 +87,17 @@ export interface ImageRecipeContribution {
   readonly recipe: string;
 }
 
+/**
+ * Edge handler — runs for HTTP requests that match **no** flow (the prime
+ * example: a CORS preflight `OPTIONS` for a path bound to another method).
+ * Handlers run in install order; the first to return a {@link Response}
+ * answers, `undefined` passes to the next handler, then the plain 404.
+ */
+export type EdgeHandler = (
+  request: Request,
+  info: { readonly method: string; readonly path: string },
+) => undefined | Response | Promise<undefined | Response>;
+
 /** Table / DB schema contribution. */
 export interface TableContribution {
   /** Table name — conflict namespace shared across plugins. */
@@ -135,6 +146,12 @@ export interface PluginApi {
    * @param fn - Hook function
    */
   hook(stage: HookStage, fn: HookFn): PluginApi;
+  /**
+   * Register an edge handler (intercept — requests that match no flow).
+   *
+   * @param fn - Edge handler
+   */
+  edge(fn: EdgeHandler): PluginApi;
   /**
    * Decorate the invocation context (declare — once at boot).
    *
@@ -242,6 +259,7 @@ export interface PluginCapabilities {
 export interface PluginRegistration {
   readonly capabilities: PluginCapabilities;
   readonly hooks: Partial<Record<HookStage, HookFn[]>>;
+  readonly edges: readonly EdgeHandler[];
   readonly decorations: Readonly<Record<string, unknown>>;
   readonly elements: readonly PluginElement[];
   readonly tables: readonly TableContribution[];
@@ -285,6 +303,12 @@ export interface PluginDef<D extends Record<string, unknown> = {}> {
    * @param fn - Hook function
    */
   hook(stage: HookStage, fn: HookFn): PluginDef<D>;
+  /**
+   * Queue an edge handler contribution (requests that match no flow).
+   *
+   * @param fn - Edge handler
+   */
+  edge(fn: EdgeHandler): PluginDef<D>;
   /**
    * Queue a context decoration. Accumulates types for `.plug()`.
    *
@@ -398,6 +422,12 @@ export function plugin(name: string, options: PluginOptions): PluginDef {
       });
       return def;
     },
+    edge(fn) {
+      steps.push((api) => {
+        api.edge(fn);
+      });
+      return def;
+    },
     decorate(key, value) {
       steps.push((api) => {
         api.decorate(key, value);

package/src/kernel/registry-isolation.test.ts

@@ -0,0 +1,74 @@
+/**
+ * Registry isolation — two `oke()` apps in one process must not share routes.
+ *
+ * This is the multi-app / future-`mount()` guarantee: constructing one app
+ * can never pull another app's flows through the process-global `on()`
+ * registry. Before the fix, `oke()` adopted the registry snapshot and left
+ * it intact, so App B below silently served App A's `/a` route (leakage).
+ * The default `registry: "consume"` mode drains the registry at construction.
+ */
+
+import { afterEach, describe, expect, test } from "bun:test";
+import { oke } from "./app.ts";
+import { flow, resetFlowSeq } from "./flow.ts";
+import { listBindings, on, resetBindings, type Binding } from "./on.ts";
+import { http } from "./triggers.ts";
+
+afterEach(() => {
+  resetBindings();
+  resetFlowSeq();
+});
+
+describe("registry isolation", () => {
+  test("consume (default): App B does not serve App A routes", async () => {
+    on(http.get("/a"), flow({ name: "app-a.ping", do: () => "a" }));
+    const appA = oke({ name: "app-a" });
+
+    // No resetBindings() between the apps — the pre-fix leak scenario.
+    on(http.get("/b"), flow({ name: "app-b.ping", do: () => "b" }));
+    const appB = oke({ name: "app-b" });
+
+    // Pre-fix this was 200: App B adopted App A's leftover binding.
+    expect((await appB.fetch(new Request("http://localhost/a"))).status).toBe(404);
+
+    const own = await appB.fetch(new Request("http://localhost/b"));
+    expect(own.status).toBe(200);
+    expect(await own.json()).toEqual({ data: "b", error: null });
+
+    // App A still serves its own route after App B was constructed.
+    const stillA = await appA.fetch(new Request("http://localhost/a"));
+    expect(stillA.status).toBe(200);
+    expect(await stillA.json()).toEqual({ data: "a", error: null });
+
+    // Consume drained the registry — nothing left for a third app.
+    expect(listBindings()).toHaveLength(0);
+  });
+
+  test("keep: today's behavior — registry survives construction", async () => {
+    on(http.get("/a"), flow({ name: "kept.ping", do: () => "a" }));
+    oke({ name: "app-a", registry: "keep" });
+    expect(listBindings()).toHaveLength(1);
+
+    const appB = oke({ name: "app-b", registry: "keep" });
+    expect((await appB.fetch(new Request("http://localhost/a"))).status).toBe(200);
+  });
+
+  test("ignore: only options.bindings are served", async () => {
+    on(http.get("/stray"), flow({ name: "stray.ping", do: () => "stray" }));
+
+    const onlyB: Binding = {
+      trigger: http.get("/b"),
+      flow: flow({ name: "only-b.ping", do: () => "b" }),
+    };
+    const app = oke({ name: "app-b", registry: "ignore", bindings: [onlyB] });
+
+    expect((await app.fetch(new Request("http://localhost/stray"))).status).toBe(404);
+
+    const res = await app.fetch(new Request("http://localhost/b"));
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ data: "b", error: null });
+
+    // Ignore never touches the registry.
+    expect(listBindings()).toHaveLength(1);
+  });
+});

package/src/kernel/registry.ts

@@ -20,6 +20,7 @@ import type {
   ClientExtensionContribution,
   ConsolePanelContribution,
   DriverContribution,
+  EdgeHandler,
   ImageRecipeContribution,
   PluginApi,
   PluginCapabilities,
@@ -62,6 +63,7 @@ export function createRecordingApi(identity: { readonly name: string; readonly v
   snapshot(): PluginRegistration;
 } {
   const hooks: Partial<Record<HookStage, HookFn[]>> = {};
+  const edges: EdgeHandler[] = [];
   const decorations: Record<string, unknown> = {};
   const elements: PluginElement[] = [];
   const tables: TableContribution[] = [];
@@ -81,7 +83,7 @@ export function createRecordingApi(identity: { readonly name: string; readonly v
     if (!declares.includes(cap)) declares.push(cap);
   }
 
-  function pushIntercept(stage: HookStage): void {
+  function pushIntercept(stage: HookStage | "edge"): void {
     if (!intercepts.includes(stage)) intercepts.push(stage);
   }
 
@@ -93,6 +95,11 @@ export function createRecordingApi(identity: { readonly name: string; readonly v
       pushIntercept(stage);
       return api;
     },
+    edge(fn) {
+      edges.push(fn);
+      pushIntercept("edge");
+      return api;
+    },
     decorate(key, value) {
       decorations[key] = value;
       pushDeclare(`decorate:${key}`);
@@ -168,6 +175,7 @@ export function createRecordingApi(identity: { readonly name: string; readonly v
           needs: needs.slice(),
         },
         hooks: { ...hooks },
+        edges: edges.slice(),
         decorations: { ...decorations },
         elements: elements.slice(),
         tables: tables.slice(),
@@ -231,6 +239,12 @@ export interface PluginRegistry {
    * @param flowName - Flow name (for `flow` kind)
    */
   hooksAt(scopeKind: PluginScope["kind"], unit: string | undefined, flowName: string): HookMap;
+  /**
+   * Edge handlers in install order. They answer requests that match no
+   * flow, so there is no flow/unit scope to filter by — every installed
+   * handler runs.
+   */
+  edgeHandlers(): readonly EdgeHandler[];
   /**
    * Merged decorations visible to a flow at the given unit.
    *
@@ -380,6 +394,13 @@ export function createPluginRegistry(): PluginRegistry {
       }
       return out;
     },
+    edgeHandlers() {
+      const out: EdgeHandler[] = [];
+      for (const entry of installed) {
+        out.push(...entry.registration.edges);
+      }
+      return out;
+    },
     tableContributions() {
       const seenPlugins = new Set<string>();
       const out: TableContribution[] = [];

package/src/kernel/triggers.ts

@@ -100,6 +100,59 @@ function createHttpTrigger<M extends HttpMethod, P extends string>(
   return trigger;
 }
 
+/** Flow shape accepted by {@link http.resource} (duck-typed — any FlowDef). */
+export type ResourceFlow = { readonly name: string };
+
+/** The five CRUD ops {@link http.resource} mounts. */
+export interface ResourceFlowBag {
+  readonly list: unknown;
+  readonly create: unknown;
+  readonly get: unknown;
+  readonly update: unknown;
+  readonly remove: unknown;
+}
+
+/**
+ * A mounted resource — the single argument to the `on(http.resource(…))`
+ * overload. Branded so `on` can tell it apart from a plain trigger.
+ */
+export interface ResourceMount {
+  readonly [resourceMountBrand]: true;
+  readonly mounts: ReadonlyArray<{ readonly trigger: HttpTrigger; readonly flow: unknown }>;
+}
+/** Brand for {@link ResourceMount}. */
+export const resourceMountBrand: unique symbol = Symbol.for("oke.resource.mount");
+
+/**
+ * Mount a CRUD resource at `path`: `list`/`create` on the base, `get` /
+ * `update` / `remove` on `/:id`. Bind via `on(http.resource(…))`.
+ *
+ * @param path - Base path (`/notes`)
+ * @param ops - The five FlowDefs (usually `resource.all()`)
+ */
+function httpResource<P extends string>(path: P, ops: ResourceFlowBag): ResourceMount {
+  const id = `${path}/:id`;
+  return {
+    [resourceMountBrand]: true,
+    mounts: [
+      { trigger: http.get(path), flow: ops.list },
+      { trigger: http.post(path), flow: ops.create },
+      { trigger: http.get(id), flow: ops.get },
+      { trigger: http.patch(id), flow: ops.update },
+      { trigger: http.delete(id), flow: ops.remove },
+    ],
+  };
+}
+
+/** True when `value` is a {@link ResourceMount}. */
+export function isResourceMount(value: unknown): value is ResourceMount {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    (value as ResourceMount)[resourceMountBrand] === true
+  );
+}
+
 /**
  * Shape of the {@link http} trigger namespace. Each method keeps `P` as a
  * generic type parameter so callers (and the client) retain literal path
@@ -134,6 +187,11 @@ export interface HttpTriggerNamespace {
    * @param path - Route path
    */
   head<P extends string>(path: P): HttpTrigger<"HEAD", P>;
+  /**
+   * Mount a CRUD resource (list/create on `path`, get/update/remove on
+   * `path/:id`) for the `on(http.resource(…))` overload.
+   */
+  resource<P extends string>(path: P, ops: ResourceFlowBag): ResourceMount;
 }
 
 /**
@@ -182,6 +240,7 @@ export const http: HttpTriggerNamespace = {
   head<P extends string>(path: P): HttpTrigger<"HEAD", P> {
     return createHttpTrigger("HEAD", path);
   },
+  resource: httpResource,
 };
 
 /**

package/src/manifest/fixtures/skyport.excerpt.json

@@ -46,6 +46,6 @@
     }
   },
   "journeys": { "book-a-flight": { "slo": { "availability": "99.5%" }, "composes": "99.6%" } },
-  "drivers": { "prod": ["postgres", "redis", "s3", "smtp", "sops", "anthropic", "pgvector"] },
+  "drivers": { "prod": ["postgres", "redis", "s3", "smtp", "openbao", "anthropic", "pgvector"] },
   "tenancy": { "isolation": "row" }
 }

package/src/manifest/fixtures/skyport.manifest.json

@@ -137,7 +137,7 @@
     }
   },
   "drivers": {
-    "prod": ["postgres", "redis", "s3", "smtp", "sops", "anthropic", "pgvector"]
+    "prod": ["postgres", "redis", "s3", "smtp", "openbao", "anthropic", "pgvector"]
   },
   "tenancy": { "isolation": "row" },
   "i18n": {

package/src/manifest/index.ts

@@ -1,7 +1,7 @@
 /**
  * Manifest — the 100-year artifact.
  *
- * Public contract: `spec/manifest.v1.schema.json`
+ * Public contract: `manifest.v1.schema.json`
  */
 
 export type * from "./types.ts";

package/src/manifest/types.ts

@@ -1,5 +1,5 @@
 /**
- * TypeScript surface matching `spec/manifest.v1.schema.json`.
+ * TypeScript surface matching `manifest.v1.schema.json`.
  *
  * Kept hand-aligned with the schema (the public, runtime-neutral contract).
  * Within major version `1.x`, only additive schema changes are allowed.

package/src/manifest/validate.ts

@@ -1,5 +1,5 @@
 /**
- * Runtime validation of Manifest documents against `spec/manifest.v1.schema.json`.
+ * Runtime validation of Manifest documents against `manifest.v1.schema.json`.
  */
 
 import Ajv2020, { type AnySchema, type ErrorObject } from "ajv/dist/2020.js";
@@ -19,7 +19,7 @@ export type ManifestValidationResult =
   | { ok: true; manifest: Manifest }
   | { ok: false; issues: ManifestValidationIssue[] };
 
-const SCHEMA_URL = new URL("../../spec/manifest.v1.schema.json", import.meta.url);
+const SCHEMA_URL = new URL("../../manifest.v1.schema.json", import.meta.url);
 
 let validator: ReturnType<Ajv2020["compile"]> | undefined;
 let schemaDocument: unknown;

package/src/plugins/compression.test.ts

@@ -0,0 +1,127 @@
+/**
+ * `compression` plugin — gzip negotiation, thresholds, and skip rules
+ * through the real pipeline.
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+import { oke } from "../kernel/app.ts";
+import { flow, resetFlowSeq } from "../kernel/flow.ts";
+import { on, resetBindings } from "../kernel/on.ts";
+import { http } from "../kernel/triggers.ts";
+import { acceptsGzip, compression } from "./compression.ts";
+
+beforeEach(() => {
+  resetBindings();
+  resetFlowSeq();
+});
+
+/** Big JSON payload above the default 1 KiB threshold. */
+function bigPayload() {
+  return { items: Array.from({ length: 100 }, (_, i) => ({ id: i, name: `item-${i}` })) };
+}
+
+describe("acceptsGzip", () => {
+  test("parses plain, starred, and q-valued tokens", () => {
+    expect(acceptsGzip(null)).toBe(false);
+    expect(acceptsGzip("")).toBe(false);
+    expect(acceptsGzip("gzip")).toBe(true);
+    expect(acceptsGzip("br, gzip")).toBe(true);
+    expect(acceptsGzip("gzip;q=0")).toBe(false);
+    expect(acceptsGzip("gzip;q=0.0")).toBe(false);
+    expect(acceptsGzip("gzip;q=0.5")).toBe(true);
+    expect(acceptsGzip("*")).toBe(true);
+    expect(acceptsGzip("*;q=0")).toBe(false);
+    expect(acceptsGzip("br")).toBe(false);
+  });
+});
+
+describe("compression plugin", () => {
+  test("gzips a large JSON body when the client accepts gzip", async () => {
+    on(http.get("/big"), flow({ name: "big.get", do: bigPayload }));
+    const app = oke({ name: "zip" }).plug(compression());
+
+    const res = await app.fetch(
+      new Request("http://localhost/big", { headers: { "accept-encoding": "gzip" } }),
+    );
+
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-encoding")).toBe("gzip");
+    expect(res.headers.get("vary")).toContain("accept-encoding");
+    expect(res.headers.get("content-length")).toBeNull();
+
+    const roundTrip = JSON.parse(
+      new TextDecoder().decode(Bun.gunzipSync(await res.arrayBuffer())),
+    ) as {
+      data: { items: unknown[] };
+    };
+    expect(roundTrip.data.items).toHaveLength(100);
+  });
+
+  test("passes through untouched without Accept-Encoding: gzip", async () => {
+    on(http.get("/big"), flow({ name: "big.get", do: bigPayload }));
+    const app = oke({ name: "zip-plain" }).plug(compression());
+
+    const res = await app.fetch(new Request("http://localhost/big"));
+
+    expect(res.headers.get("content-encoding")).toBeNull();
+    const body = (await res.json()) as { data: { items: unknown[] } };
+    expect(body.data.items).toHaveLength(100);
+  });
+
+  test("skips bodies under minSize", async () => {
+    on(http.get("/small"), flow({ name: "small.get", do: () => ({ ok: true }) }));
+    const app = oke({ name: "zip-small" }).plug(compression());
+
+    const res = await app.fetch(
+      new Request("http://localhost/small", { headers: { "accept-encoding": "gzip" } }),
+    );
+
+    expect(res.headers.get("content-encoding")).toBeNull();
+  });
+
+  test("minSize: 0 compresses even tiny bodies", async () => {
+    on(http.get("/small"), flow({ name: "small.get", do: () => ({ ok: true }) }));
+    const app = oke({ name: "zip-zero" }).plug(compression({ minSize: 0 }));
+
+    const res = await app.fetch(
+      new Request("http://localhost/small", { headers: { "accept-encoding": "gzip" } }),
+    );
+
+    expect(res.headers.get("content-encoding")).toBe("gzip");
+  });
+
+  test("skips non-matching content types and no-transform responses", async () => {
+    on(
+      http.get("/img"),
+      flow({
+        name: "img.get",
+        do: () =>
+          new Response(new Uint8Array(4096), {
+            headers: { "content-type": "image/png" },
+          }),
+      }),
+    );
+    on(
+      http.get("/nt"),
+      flow({
+        name: "nt.get",
+        do: () =>
+          Response.json(
+            { data: bigPayload(), error: null },
+            { headers: { "cache-control": "no-transform" } },
+          ),
+      }),
+    );
+    const app = oke({ name: "zip-skip" }).plug(compression());
+
+    const img = await app.fetch(
+      new Request("http://localhost/img", { headers: { "accept-encoding": "gzip" } }),
+    );
+    expect(img.headers.get("content-encoding")).toBeNull();
+
+    const nt = await app.fetch(
+      new Request("http://localhost/nt", { headers: { "accept-encoding": "gzip" } }),
+    );
+    expect(nt.headers.get("content-encoding")).toBeNull();
+  });
+});