okengine 0.23.0 → 0.23.2

package/src/compiler/effects-fetch.test.ts

@@ -3,6 +3,7 @@
  */
 
 import { describe, expect, test } from "bun:test";
+import { extractFromSources } from "./extract.ts";
 import { inferEffects, type AstNode, type InferBinding } from "./effects-infer.ts";
 
 function parseDo(src: string): AstNode {
@@ -39,5 +40,81 @@ describe("inferEffects — fx.fetch → effects.fetches", () => {
     expect(inferred.effects.fetches).toEqual(["api.stripe.com"]);
     expect(inferred.effects.calls).toBeUndefined();
     expect(inferred.effects.sends).toBeUndefined();
+    expect(inferred.bareIrreversible).toEqual(["fetch"]);
+  });
+
+  test("fx.fetch inside fx.step is not a bare irreversible call", () => {
+    const stepBody = {
+      type: "ArrowFunctionExpression",
+      params: [],
+      body: {
+        type: "BlockStatement",
+        body: [
+          {
+            type: "ExpressionStatement",
+            expression: {
+              type: "CallExpression",
+              callee: {
+                type: "MemberExpression",
+                object: { type: "Identifier", name: "fx" },
+                property: { type: "Identifier", name: "fetch" },
+                computed: false,
+              },
+              arguments: [{ type: "Literal", value: "https://example.com/data" }],
+            },
+          },
+        ],
+      },
+    };
+    const inferred = inferEffects({
+      doNode: {
+        type: "ArrowFunctionExpression",
+        params: [
+          { type: "Identifier", name: "_input" },
+          { type: "Identifier", name: "fx" },
+        ],
+        body: {
+          type: "BlockStatement",
+          body: [
+            {
+              type: "ExpressionStatement",
+              expression: {
+                type: "CallExpression",
+                callee: {
+                  type: "MemberExpression",
+                  object: { type: "Identifier", name: "fx" },
+                  property: { type: "Identifier", name: "step" },
+                  computed: false,
+                },
+                arguments: [{ type: "Literal", value: "load" }, stepBody],
+              },
+            },
+          ],
+        },
+      } as AstNode,
+      bindings: new Map<string, InferBinding>(),
+      hasExplicitEffects: false,
+    });
+    expect(inferred.bareIrreversible).toEqual([]);
+    expect(inferred.steps).toEqual(["load"]);
+    expect(inferred.effects.fetches).toEqual(["example.com"]);
+  });
+});
+
+describe("extract — durable fx.fetch outside fx.step", () => {
+  test("OKE1901 when a durable flow calls fx.fetch directly", async () => {
+    await expect(
+      extractFromSources({
+        "src/flows/load.ts": `
+import { flow, on, http } from "okengine";
+export const load = on(http.get("/load"), flow("load", {
+  durable: true,
+  do: async (_input, fx) => {
+    return fx.fetch("https://example.com/data");
+  },
+}));
+`,
+      }),
+    ).rejects.toThrow(/OKE1901/);
   });
 });

package/src/compiler/effects-infer.ts

@@ -110,6 +110,11 @@ export interface InferEffectsOptions {
    * never pass `fx` into another function.
    */
   readonly resolveCallee?: (callee: AstNode, file: string) => FxCalleeResolution;
+  /**
+   * Flow name of an imported handle in `file`. Absent when inference does
+   * not follow imports (unit tests).
+   */
+  readonly resolveFlowRef?: (localName: string, file: string) => string | undefined;
 }
 
 /** Result of effect inference for one flow body. */
@@ -129,6 +134,11 @@ export interface InferredEffects {
   readonly nondeterministic: boolean;
   /** True when the body references `fx.auth.userId`. */
   readonly readsUserId: boolean;
+  /**
+   * `fx.fetch` / `fx.send` calls that are not inside an `fx.step` callback.
+   * A `durable: true` flow must not call these directly.
+   */
+  readonly bareIrreversible: readonly ("fetch" | "send")[];
 }
 
 const READ_METHODS = new Set([
@@ -145,6 +155,10 @@ const READ_METHODS = new Set([
   "page",
   "search",
   "raw",
+  "innerJoin",
+  "leftJoin",
+  "rightJoin",
+  "fullJoin",
 ]);
 
 const WRITE_METHODS = new Set([
@@ -175,6 +189,10 @@ const TABLE_ARG_METHODS = new Set([
   "count",
   "page",
   "search",
+  "innerJoin",
+  "leftJoin",
+  "rightJoin",
+  "fullJoin",
 ]);
 
 /**
@@ -204,7 +222,8 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
     name: "liveQuery" | "applySearchEmbedCdc";
     call: CallExpression;
   }> = [];
-  const chains = collectFxChains(options, opaque, userIdRoots, intrinsics);
+  const bareIrreversible = new Set<"fetch" | "send">();
+  const chains = collectFxChains(options, opaque, userIdRoots, intrinsics, bareIrreversible);
 
   for (const { call, chain } of chains) {
     if (chain.rootMethod === "raw") {
@@ -313,7 +332,13 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
     }
 
     if (chain.rootMethod === "call" && call === chain.rootCall) {
-      const ref = resolveCallTarget(call.arguments[0], options.bindings);
+      const arg = unwrapValueNode(call.arguments[0]);
+      const local = identifierName(arg);
+      const imported =
+        local && options.file && options.resolveFlowRef
+          ? options.resolveFlowRef(local, options.file)
+          : undefined;
+      const ref = imported ?? resolveCallTarget(call.arguments[0], options.bindings);
       if (ref) calls.add(ref);
       continue;
     }
@@ -359,18 +384,28 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
       // Skip incomplete chains (`select` before `.from`, `insert` before table) —
       // the sibling call that carries the table arg records the real resource.
       const leaf = resolved.methods[resolved.methods.length - 1]!;
-      const hasTable = tableFromStoreChain(call, options.bindings, chain) !== undefined;
+      const tables = tablesFromStoreChain(call, options.bindings, chain);
+      const hasTable = tables.length > 0;
       if (!hasTable && (leaf === "select" || leaf === "insert" || leaf === "update")) {
         continue;
       }
       // Intermediate chain links that only forward (where/values/returning)
       // still carry read/write from earlier methods — record once we have a table
       // or a terminal key-based op.
-      if (!hasTable && (leaf === "where" || leaf === "values" || leaf === "returning")) {
+      if (
+        !hasTable &&
+        (leaf === "where" || leaf === "values" || leaf === "returning" || leaf === "groupBy")
+      ) {
         continue;
       }
-      if (op === "read" || op === "both") reads.add(resolved.resource);
-      if (op === "write" || op === "both") writes.add(resolved.resource);
+      const resources =
+        tables.length > 0
+          ? tables.map((table) => sqlTableRef(table) as ResourceRef)
+          : [resolved.resource];
+      for (const resource of resources) {
+        if (op === "read" || op === "both") reads.add(resource);
+        if (op === "write" || op === "both") writes.add(resource);
+      }
     }
   }
 
@@ -407,6 +442,7 @@ export function inferEffects(options: InferEffectsOptions): InferredEffects {
     cacheIneligible: usesRaw && !options.hasExplicitEffects,
     nondeterministic: asks.size > 0 || embeds.size > 0 || decides.size > 0,
     readsUserId: userIdRoots.some((node) => containsAuthUserId(node)),
+    bareIrreversible: [...bareIrreversible],
   };
 }
 
@@ -610,21 +646,37 @@ function tableFromStoreChain(
   bindings: ReadonlyMap<string, InferBinding>,
   chain?: FxChain,
 ): string | undefined {
+  return tablesFromStoreChain(call, bindings, chain)[0];
+}
+
+/**
+ * Every table argument on a store chain, including joins.
+ *
+ * @param call - Any call in the chain
+ * @param bindings - Scope bindings
+ * @param chain - Precomputed chain when already known
+ */
+function tablesFromStoreChain(
+  call: CallExpression,
+  bindings: ReadonlyMap<string, InferBinding>,
+  chain?: FxChain,
+): string[] {
   const found = tableFromStoreWalk(call, bindings, chain);
-  if (found) return found;
+  if (found.length > 0) return found;
   if (chain?.aliasLeaf && chain.aliasLeaf !== call) {
     return tableFromStoreWalk(chain.aliasLeaf, bindings);
   }
-  return undefined;
+  return [];
 }
 
 function tableFromStoreWalk(
   call: CallExpression,
   bindings: ReadonlyMap<string, InferBinding>,
   chain?: FxChain,
-): string | undefined {
+): string[] {
   let current: AstNode | undefined = call;
   const seen = new Set<AstNode>();
+  const names: string[] = [];
   while (current && current.type === "CallExpression" && !seen.has(current)) {
     seen.add(current);
     const c = current as CallExpression;
@@ -644,7 +696,8 @@ function tableFromStoreWalk(
         const id = identifierName(c.arguments[0]);
         if (id) {
           const binding = bindings.get(id);
-          return binding?.kind === "table" ? binding.ref : id;
+          const tableName = binding?.kind === "table" ? binding.ref : id;
+          if (!names.includes(tableName)) names.push(tableName);
         }
       }
     }
@@ -658,7 +711,7 @@ function tableFromStoreWalk(
     }
     break;
   }
-  return undefined;
+  return names;
 }
 
 function methodNameOfCall(call: CallExpression): string | undefined {
@@ -908,7 +961,9 @@ function collectFxChains(
   opaque: string[],
   userIdRoots: AstNode[],
   intrinsics: Array<{ name: "liveQuery" | "applySearchEmbedCdc"; call: CallExpression }>,
+  bareIrreversible: Set<"fetch" | "send">,
 ): ChainHit[] {
+  const stepBodies = new Set<AstNode>();
   const hits: ChainHit[] = [];
   const seen = new Set<AstNode>();
 
@@ -918,7 +973,7 @@ function collectFxChains(
     aliases: ReadonlyMap<string, ChainAlias>,
     locals: ReadonlyMap<string, AstNode>,
   ): void => {
-    analyzeFunction(fn, "fx", aliases, locals, file);
+    analyzeFunction(fn, "fx", aliases, locals, file, stepBodies.has(fn));
   };
 
   const analyzeFunction = (
@@ -927,13 +982,14 @@ function collectFxChains(
     outerAliases: ReadonlyMap<string, ChainAlias>,
     outerLocals: ReadonlyMap<string, AstNode>,
     file: string,
+    insideStep: boolean,
   ): void => {
     if (seen.has(fn)) return;
     seen.add(fn);
     userIdRoots.push(fn);
     const body = (fn as AstNode & { body?: AstNode }).body;
     if (!body) return;
-    analyzeBody(body, door, outerAliases, outerLocals, file);
+    analyzeBody(body, door, outerAliases, outerLocals, file, insideStep);
   };
 
   const analyzeBody = (
@@ -942,6 +998,7 @@ function collectFxChains(
     outerAliases: ReadonlyMap<string, ChainAlias>,
     outerLocals: ReadonlyMap<string, AstNode>,
     file: string,
+    insideStep: boolean,
   ): void => {
     const aliases = new Map(outerAliases);
     const locals = new Map(outerLocals);
@@ -951,6 +1008,20 @@ function collectFxChains(
     });
     for (const call of callsSkippingNested(body)) {
       const chain = chainFromCall(call, aliases);
+      if (chain?.rootMethod === "step") {
+        for (const arg of call.arguments) {
+          const fn = unwrapValue(arg);
+          if (fn && isFunctionNode(fn)) stepBodies.add(fn);
+        }
+      }
+      if (
+        !insideStep &&
+        chain &&
+        call === chain.rootCall &&
+        (chain.rootMethod === "fetch" || chain.rootMethod === "send")
+      ) {
+        bareIrreversible.add(chain.rootMethod);
+      }
       if (chain) {
         hits.push({ call, chain });
         continue;
@@ -961,7 +1032,7 @@ function collectFxChains(
       if (seen.has(nested)) continue;
       const shadows = functionParams(nested).some((param) => paramIdentifierName(param) === door);
       if (shadows) continue;
-      analyzeFunction(nested, door, aliases, locals, file);
+      analyzeFunction(nested, door, aliases, locals, file, insideStep || stepBodies.has(nested));
     }
   };
 
@@ -972,9 +1043,9 @@ function collectFxChains(
     if (second && paramIdentifierName(second) !== "fx") {
       opaque.push("the do callback's second parameter is not named fx");
     }
-    analyzeFunction(options.doNode, "fx", new Map(), new Map(), startFile);
+    analyzeFunction(options.doNode, "fx", new Map(), new Map(), startFile, false);
   } else {
-    analyzeBody(options.doNode, "fx", new Map(), new Map(), startFile);
+    analyzeBody(options.doNode, "fx", new Map(), new Map(), startFile, false);
   }
 
   return hits;

package/src/compiler/effects-join.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Joins and groupBy list every source table under the flow's reads.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { extractFromSources } from "./extract.ts";
+
+describe("extractManifest — joins", () => {
+  test("innerJoin and groupBy record every table", async () => {
+    const manifest = await extractFromSources({
+      "src/app.ts": `
+        import { oke } from "okengine";
+        export const app = oke({ name: "joins" });
+      `,
+      "src/flows/orders.ts": `
+        import { on, flow, http, store, field } from "okengine";
+        import { eq, count } from "drizzle-orm";
+
+        export const db = store.sql("db");
+        export const orders = store.schema.table("orders", {
+          id: field.text().primaryKey(),
+          customerId: field.text(),
+        });
+        export const customers = store.schema.table("customers", {
+          id: field.text().primaryKey(),
+        });
+
+        export const totals = on(
+          http.get("/totals"),
+          flow("orders.totals", {
+            do: async (_input, fx) => {
+              return fx
+                .store(db)
+                .select({ n: count() })
+                .from(orders)
+                .innerJoin(customers, eq(orders.customerId, customers.id))
+                .groupBy(customers.id);
+            },
+          }),
+        );
+      `,
+    });
+    expect(manifest.flows?.["orders.totals"]?.effects?.reads?.slice().sort()).toEqual([
+      "sql:customers",
+      "sql:orders",
+    ]);
+  });
+});

package/src/compiler/extract.test.ts

@@ -1577,6 +1577,34 @@ export const ping = flow({ do: () => ({ ok: true }) });
     expect(manifest.flows?.["notes.ping"]).toBeDefined();
   });
 
+  test("fx.call of an imported flow handle records that flow's name", async () => {
+    const tasks = `
+import { on, flow, http } from "okengine";
+export const create = on(
+  http.post("/tasks"),
+  flow("tasks.create", { do: async () => ({ id: "1" }) }),
+);
+`;
+    const forms = `
+import { on, flow, http } from "okengine";
+import { create as createTask } from "../tasks/index.ts";
+export const submit = on(
+  http.post("/forms/:id/submit"),
+  flow("forms.submit", {
+    do: async (_input, fx) => {
+      await fx.call(createTask, { title: "SSO" });
+      return { ok: true };
+    },
+  }),
+);
+`;
+    const manifest = await extractFromSources({
+      "src/flows/tasks/index.ts": tasks,
+      "src/flows/forms/index.ts": forms,
+    });
+    expect(manifest.flows?.["forms.submit"]?.effects?.calls).toEqual(["tasks.create"]);
+  });
+
   test("effects are identical for the same do body in a tree file vs a barrel", async () => {
     const doBody = `
       const rows = await fx.store(db).select().from(notes);

package/src/compiler/extract.ts

@@ -2194,6 +2194,7 @@ function registerFlow(args: {
         flowName: name,
         file: args.file.path,
         resolveCallee: (callee, file) => args.scope.fxIndex.resolve(file, callee),
+        resolveFlowRef: (localName, file) => args.scope.fxIndex.flowRef(file, localName),
       })
     : {
         effects: {} as Effects,
@@ -2202,6 +2203,7 @@ function registerFlow(args: {
         cacheIneligible: false,
         nondeterministic: false,
         readsUserId: false,
+        bareIrreversible: [] as ("fetch" | "send")[],
       };
 
   let effects: Effects | undefined;
@@ -2262,7 +2264,15 @@ function registerFlow(args: {
   const line = lineAt(args.file.source, args.flowCall.start ?? 0);
   flow.source = `${args.file.path}:${line}`;
 
-  if (boolProp(opts, "durable")) flow.durable = true;
+  if (boolProp(opts, "durable")) {
+    flow.durable = true;
+    const bare = inferred.bareIrreversible[0];
+    if (bare !== undefined) {
+      throw new Error(
+        `OKE1901: durable flow "${name}" calls fx.${bare} outside fx.step. Wrap fx.fetch and fx.send in fx.step.`,
+      );
+    }
+  }
   assertDecisionPlacement(name, flow, args.scope);
   if (typeof liveFromTrigger === "string") {
     flow.live = liveFromTrigger;

package/src/compiler/fx-index.ts

@@ -26,6 +26,14 @@ export interface FxIndex {
    * @param callee - Call callee node
    */
   resolve(file: string, callee: AstNode): FxCalleeResolution;
+  /**
+   * Flow name behind an imported handle (`import { create as createTask }`).
+   * Absent when `localName` is not a named import of a `flow()` / `on()` export.
+   *
+   * @param file - File that contains the `fx.call`
+   * @param localName - Local binding (`createTask`)
+   */
+  flowRef(file: string, localName: string): string | undefined;
 }
 
 interface NamedImport {
@@ -61,6 +69,8 @@ interface FileFx {
   readonly functions: Map<string, AstNode>;
   readonly imports: Map<string, ImportBinding>;
   readonly exports: Map<string, LocalExport | Reexport>;
+  /** Local binding → `flow("name")` / `on(…, flow("name"))` literal. */
+  readonly flowNames: Map<string, string>;
 }
 
 const INTRINSIC_SOURCES: Readonly<
@@ -176,7 +186,29 @@ export function buildFxIndex(
     return resolveExport(target, imported.imported, seen);
   }
 
+  function flowExportName(file: string, exportName: string, seen: Set<string>): string | undefined {
+    const key = `${file}#flow:${exportName}`;
+    if (seen.has(key)) return undefined;
+    seen.add(key);
+    const indexed = byFile.get(file);
+    if (!indexed) return undefined;
+    const exported = indexed.exports.get(exportName);
+    if (!exported) return indexed.flowNames.get(exportName);
+    if (exported.kind === "local") return indexed.flowNames.get(exported.binding);
+    const target = resolveModule(file, exported.from);
+    if (!target) return undefined;
+    return flowExportName(target, exported.imported, seen);
+  }
+
   return {
+    flowRef(file, localName) {
+      const from = normalizePosix(file);
+      const imported = byFile.get(from)?.imports.get(localName);
+      if (!imported || imported.kind !== "named") return undefined;
+      const target = resolveModule(from, imported.from);
+      if (!target) return undefined;
+      return flowExportName(target, imported.imported, new Set());
+    },
     resolve(file, callee) {
       const from = normalizePosix(file);
       const seen = new Set<string>();
@@ -212,9 +244,10 @@ function indexFile(program: AstNode): FileFx {
   const functions = new Map<string, AstNode>();
   const imports = new Map<string, ImportBinding>();
   const exports = new Map<string, LocalExport | Reexport>();
+  const flowNames = new Map<string, string>();
   const body = (program as AstNode & { body?: AstNode[] }).body ?? [];
-  for (const stmt of body) indexStmt(stmt, functions, imports, exports);
-  return { functions, imports, exports };
+  for (const stmt of body) indexStmt(stmt, functions, imports, exports, flowNames);
+  return { functions, imports, exports, flowNames };
 }
 
 function indexStmt(
@@ -222,6 +255,7 @@ function indexStmt(
   functions: Map<string, AstNode>,
   imports: Map<string, ImportBinding>,
   exports: Map<string, LocalExport | Reexport>,
+  flowNames: Map<string, string>,
 ): void {
   if (stmt.type === "ImportDeclaration") {
     indexImport(stmt, imports);
@@ -232,7 +266,7 @@ function indexStmt(
     return;
   }
   if (stmt.type === "VariableDeclaration") {
-    rememberVars(stmt, functions, exports, false);
+    rememberVars(stmt, functions, exports, flowNames, false);
     return;
   }
   if (stmt.type === "ExportDefaultDeclaration") {
@@ -247,7 +281,7 @@ function indexStmt(
   const decl = (stmt as AstNode & { declaration?: AstNode | null }).declaration;
   const source = stringArg((stmt as AstNode & { source?: AstNode }).source);
   if (decl?.type === "FunctionDeclaration") rememberFunction(decl, functions, exports, true);
-  if (decl?.type === "VariableDeclaration") rememberVars(decl, functions, exports, true);
+  if (decl?.type === "VariableDeclaration") rememberVars(decl, functions, exports, flowNames, true);
   const specifiers = (stmt as AstNode & { specifiers?: AstNode[] }).specifiers ?? [];
   for (const spec of specifiers) {
     const local = exportedLocalName(spec);
@@ -309,6 +343,7 @@ function rememberVars(
   decl: AstNode,
   functions: Map<string, AstNode>,
   exports: Map<string, LocalExport | Reexport>,
+  flowNames: Map<string, string>,
   exportIt: boolean,
 ): void {
   const declarations = (decl as AstNode & { declarations?: AstNode[] }).declarations ?? [];
@@ -317,10 +352,29 @@ function rememberVars(
     if (!name) continue;
     const init = (item as AstNode & { init?: AstNode | null }).init;
     if (init && isFunctionNode(unwrapValue(init))) functions.set(name, unwrapValue(init));
+    const flowName = init ? flowLiteralName(unwrapValue(init)) : undefined;
+    if (flowName) flowNames.set(name, flowName);
     if (exportIt) exports.set(name, { kind: "local", binding: name });
   }
 }
 
+/**
+ * `flow("name")` / `call("name")` / `on(trigger, flow("name"))` literal.
+ *
+ * @param node - Initializer
+ */
+function flowLiteralName(node: AstNode): string | undefined {
+  if (node.type !== "CallExpression") return undefined;
+  const call = node as AstNode & { callee: AstNode; arguments?: AstNode[] };
+  const callee = identifierName(call.callee);
+  if (callee === "flow" || callee === "call") return stringArg(call.arguments?.[0]);
+  if (callee === "on") {
+    const body = call.arguments?.[1];
+    return body ? flowLiteralName(unwrapValue(body)) : undefined;
+  }
+  return undefined;
+}
+
 function exportedLocalName(spec: AstNode): string | undefined {
   return (
     identifierName((spec as AstNode & { local?: AstNode }).local) ??

package/src/compiler/http-parse.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, test } from "bun:test";
+
+import { assembleInput, HttpBodyRejected, parseBody } from "./http-parse.ts";
+
+function request(body: string, contentType?: string, length?: string): Request {
+  const headers = new Headers();
+  if (contentType) headers.set("content-type", contentType);
+  if (length) headers.set("content-length", length);
+  return new Request("http://localhost/hooks", { method: "POST", body, headers });
+}
+
+describe("request bodies", () => {
+  test("rejects an overstated and an honest body over the cap", async () => {
+    await expect(
+      parseBody(request("{}", "application/json", "99"), { maxBytes: 4 }),
+    ).rejects.toBeInstanceOf(HttpBodyRejected);
+    await expect(
+      parseBody(request("{}", "application/json"), { maxBytes: 1 }),
+    ).rejects.toMatchObject({
+      code: "PayloadTooLarge",
+    });
+  });
+
+  test("sendBeacon text/plain JSON is 415 unless the route opts out", async () => {
+    const beacon = request('{"n":1}', "text/plain;charset=UTF-8");
+    await expect(parseBody(beacon)).rejects.toMatchObject({ code: "UnsupportedMediaType" });
+    await expect(
+      parseBody(request('{"n":1}', "text/plain"), { jsonContentType: "any" }),
+    ).resolves.toEqual({
+      n: 1,
+    });
+  });
+
+  test("a form body that parses as JSON is 415, and a normal form body stays a string", async () => {
+    await expect(
+      parseBody(request("{not json", "application/x-www-form-urlencoded")),
+    ).resolves.toBe("{not json");
+    await expect(
+      parseBody(request('{"a":1}', "application/x-www-form-urlencoded")),
+    ).rejects.toMatchObject({ code: "UnsupportedMediaType" });
+    await expect(parseBody(request("a=1&b=2", "application/x-www-form-urlencoded"))).resolves.toBe(
+      "a=1&b=2",
+    );
+  });
+
+  test("application/json must parse, and +json is accepted", async () => {
+    await expect(parseBody(request("{", "application/json"))).rejects.toMatchObject({
+      code: "InvalidQuery",
+      reason: "malformed_body",
+    });
+    await expect(
+      parseBody(request('{"n":1}', "application/vnd.x+json; charset=utf-8")),
+    ).resolves.toEqual({ n: 1 });
+  });
+
+  test("drops __proto__ and keeps a constructor field", async () => {
+    const parsed = await parseBody(
+      request('{"__proto__":{"isAdmin":true},"constructor":"ok"}', "application/json"),
+    );
+    expect((parsed as { isAdmin?: boolean; constructor?: string }).isAdmin).toBeUndefined();
+    expect((parsed as { constructor?: string }).constructor).toBe("ok");
+    expect(Object.prototype).not.toHaveProperty("isAdmin");
+    const input = assembleInput({ body: parsed });
+    expect((input as { isAdmin?: boolean }).isAdmin).toBeUndefined();
+
+    const escaped = await parseBody(
+      request('{"\\u005f\\u005fproto\\u005f\\u005f":{"isAdmin":true},"a":1}', "application/json"),
+    );
+    expect((escaped as { a?: number; isAdmin?: boolean }).a).toBe(1);
+    expect((escaped as { isAdmin?: boolean }).isAdmin).toBeUndefined();
+  });
+
+  test("a tighter cap cancels a chunked body instead of buffering it", async () => {
+    let pulled = 0;
+    const stream = new ReadableStream<Uint8Array>({
+      pull(controller) {
+        pulled += 1;
+        if (pulled > 4) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(new Uint8Array(8));
+      },
+    });
+    const req = new Request("http://localhost/hooks", {
+      method: "POST",
+      body: stream,
+      headers: { "content-type": "application/octet-stream" },
+    });
+    await expect(parseBody(req, { maxBytes: 8 })).rejects.toMatchObject({
+      code: "PayloadTooLarge",
+    });
+    expect(pulled).toBeLessThan(4);
+  });
+
+  test("an empty body is undefined", async () => {
+    await expect(
+      parseBody(new Request("http://localhost/", { method: "DELETE" })),
+    ).resolves.toBeUndefined();
+  });
+});