@sproutboat/runtime 0.35.0 → 0.37.1

package/test/concurrent-driver.ts

@@ -0,0 +1,291 @@
+import assert from "node:assert/strict";
+
+// Drives test/fixtures/concurrent-app.js with many interleaved requests and checks that every
+// reply holds only its own request's values. Used by native-concurrent-requests.ts (a standalone
+// binary) and by sproutd's smoke (a worker serving up to 8 requests at once).
+
+/** An upstream the app's fetch() calls: answers after `ms`, echoing the id it was asked for. */
+export function startUpstream() {
+  return Bun.serve({
+    port: 0,
+    hostname: "127.0.0.1",
+    async fetch(request) {
+      const url = new URL(request.url);
+      await Bun.sleep(Number(url.searchParams.get("ms") || 0));
+      return Response.json({ id: url.searchParams.get("id"), header: request.headers.get("x-rid") });
+    },
+  });
+}
+
+type Json = string | number | boolean | null | Json[] | { readonly [key: string]: Json };
+
+let seed = 12345;
+const rand = (n: number) => {
+  seed = (seed * 1103515245 + 12345) & 0x7fffffff;
+  return seed % n;
+};
+
+export interface DriverOptions {
+  readonly base: string;
+  readonly host?: string;
+  readonly upstream?: string;
+  readonly requests: number;
+  readonly rounds: number;
+  /** Whether the host carries client WebSockets (a standalone binary answers 501). */
+  readonly clientSockets: boolean;
+  readonly store: boolean;
+  /** Most requests (and sockets) in flight at once; sproutd queues 32 per app and refuses the rest. Default: all. */
+  readonly limit?: number;
+}
+
+const randomId = (round: number, i: number) => `r${round}-${i}-${rand(1e9).toString(36)}`;
+
+export async function drive(options: DriverOptions): Promise<{ requests: number; failures: string[] }> {
+  const { base, upstream, requests, rounds } = options;
+  const failures: string[] = [];
+  const fail = (msg: string) => failures.push(msg);
+  const hostHeader: Record<string, string> = options.host ? { host: options.host } : {};
+  const get = (path: string, rid: string, init: RequestInit = {}) =>
+    fetch(`${base}${path}`, {
+      ...init,
+      headers: { ...hostHeader, "x-rid": rid, cookie: `sid=${rid}` },
+    });
+  const expectOwn = (kind: string, rid: string, value: Json, expected: Json) => {
+    if (JSON.stringify(value) !== JSON.stringify(expected))
+      fail(`${kind} ${rid}: got ${JSON.stringify(value)}, wanted ${JSON.stringify(expected)}`);
+  };
+  let total = 0;
+
+  const one = async (round: number, i: number) => {
+    const rid = randomId(round, i);
+    const delays = [rand(8), rand(8), rand(8)].join(",");
+    total++;
+    switch (i % 10) {
+      case 0:
+      case 1: {
+        const alloc = i % 2 ? "&alloc=1" : "";
+        const up = upstream ? `&up=${encodeURIComponent(upstream)}` : "";
+        const r = await get(`/mix?d=${delays}${alloc}${up}`, rid);
+        const body: {
+          rid: string;
+          steps: {
+            rid: string;
+            cookie: string;
+            url: string;
+            method: string;
+            env: string;
+            ctx: boolean;
+            cf: boolean;
+            headers: boolean;
+          }[];
+          mine: { id: string; text: string; list: string };
+          extra: string;
+          xrid: string;
+          upstream?: { id: string; header: string };
+        } = await r.json();
+        expectOwn("mix.rid", rid, body.rid, rid);
+        expectOwn("mix.header", rid, r.headers.get("x-rid"), rid);
+        expectOwn("mix.echo", rid, r.headers.get("x-echo"), rid);
+        for (const s of body.steps) {
+          expectOwn("mix.step.rid", rid, s.rid, rid);
+          expectOwn("mix.step.cookie", rid, s.cookie, `sid=${rid}`);
+          expectOwn("mix.step.url", rid, new URL(s.url).searchParams.get("d"), delays);
+          expectOwn("mix.step.flags", rid, [s.method, s.env, s.ctx, s.cf, s.headers], ["GET", "hi", true, true, true]);
+        }
+        expectOwn("mix.mine", rid, [body.mine.id, body.mine.text], [rid, "t-" + rid]);
+        expectOwn("mix.list", rid, body.mine.list, Array.from({ length: 20 }, (_, k) => `${rid}:${k}`).join(","));
+        expectOwn("mix.extra", rid, [body.extra, body.xrid], [rid, rid]);
+        if (upstream) expectOwn("mix.upstream", rid, [body.upstream?.id, body.upstream?.header], [rid, rid]);
+        break;
+      }
+      case 2: {
+        const r = await get(`/promise?d=${delays}`, rid);
+        const body: {
+          rid: string;
+          all: string[];
+          raced: string;
+          settled: string[];
+          again: string;
+        } = await r.json();
+        expectOwn(
+          "promise",
+          rid,
+          [body.rid, body.all, body.raced, body.settled, body.again],
+          [rid, [rid, rid, rid], rid, ["e-" + rid, rid], rid],
+        );
+        break;
+      }
+      case 3: {
+        const r = await get(`/boom?d=${delays}`, rid);
+        if (r.status !== 500) fail(`boom ${rid}: status ${r.status}`);
+        const text = await r.text();
+        if (text.includes("boom-")) fail(`boom ${rid}: the error text reached the client: ${text}`);
+        break;
+      }
+      case 4: {
+        const r = await get(`/catch?d=${delays}`, rid);
+        const body: { rid: string; message: string; again: string } = await r.json();
+        expectOwn("catch", rid, [body.rid, body.message, body.again], [rid, "caught-" + rid, rid]);
+        break;
+      }
+      case 5: {
+        const r = await get(`/reject?d=${delays}`, rid);
+        const body: { rid: string; ok: boolean; again: string } = await r.json();
+        expectOwn("reject", rid, [r.status, body.rid, body.ok, body.again], [200, rid, true, rid]);
+        break;
+      }
+      case 6: {
+        // A request body that arrives in pieces while others are being served.
+        const pieces = 3 + rand(4);
+        const data: Uint8Array[] = [];
+        let sum = 0;
+        let bytes = 0;
+        for (let p = 0; p < pieces; p++) {
+          const chunk = new Uint8Array(1000 + rand(3000));
+          for (let k = 0; k < chunk.length; k++) chunk[k] = rand(256);
+          for (const b of chunk) sum = (sum + b) % 1000003;
+          bytes += chunk.length;
+          data.push(chunk);
+        }
+        const stream = new ReadableStream<Uint8Array>({
+          async pull(controller) {
+            const next = data.shift();
+            if (!next) return controller.close();
+            await Bun.sleep(1 + rand(5));
+            controller.enqueue(next);
+          },
+        });
+        // SAFETY: Bun accepts a streamed body with duplex: "half"; its RequestInit type does not list the field.
+        const r = await get(`/body`, rid, { method: "POST", body: stream, duplex: "half" } as RequestInit);
+        const body: { rid: string; bytes: number; sum: number; again: string } = await r.json();
+        expectOwn("body", rid, [body.rid, body.bytes, body.sum, body.again], [rid, bytes, sum, rid]);
+        break;
+      }
+      case 7: {
+        const r = await get(`/stream?d=${delays}`, rid);
+        const text = await r.text();
+        const lines = text.trim().split("\n");
+        expectOwn(
+          "stream",
+          rid,
+          lines,
+          Array.from({ length: 8 }, (_, k) => `${rid}:${k}:${rid}`),
+        );
+        break;
+      }
+      case 8: {
+        if (options.store && round % 2 === 0) {
+          const r = await get(`/store?d=${delays}`, rid);
+          const body: { rid: string; kv: string; row: string; again: string } = await r.json();
+          expectOwn("store", rid, [body.rid, body.kv, body.row, body.again], [rid, rid, "v-" + rid, rid]);
+        } else {
+          const r = await get(`/pair?d=${rand(4)}`, rid);
+          const body: { rid: string; log: string[] } = await r.json();
+          expectPair(rid, body);
+        }
+        break;
+      }
+      case 9: {
+        const text = "x".repeat(2000 + rand(5000)) + rid;
+        const r = await get(`/text?d=${delays}`, rid, { method: "POST", body: text });
+        const body: { rid: string; bytes: number; sum: number; again: string } = await r.json();
+        let sum = 0;
+        for (let k = 0; k < text.length; k++) sum = (sum + text.charCodeAt(k)) % 1000003;
+        expectOwn("text", rid, [body.rid, body.bytes, body.sum, body.again], [rid, text.length, sum, rid]);
+        break;
+      }
+    }
+    if (i % 10 === 0) {
+      // ctx.waitUntil ran with this request's values, whatever ran in between.
+      await Bun.sleep(40);
+      const w: {
+        rid: string;
+        again: string;
+        mine: string;
+        ctx: boolean;
+      } | null = await (await get(`/wu`, rid)).json();
+      expectOwn("waitUntil", rid, w, { rid, again: rid, mine: rid, ctx: true });
+    }
+  };
+
+  const expectPair = (rid: string, body: { rid: string; log: string[] }) => {
+    const want: string[] = [];
+    for (let k = 0; k < 4; k++) want.push(`s:${rid}:${k}`, `c:echo:${rid}:${k}:${rid}`);
+    const sorted = (a: string[]) => [...a].sort();
+    expectOwn("pair", rid, [body.rid, sorted(body.log)], [rid, sorted(want)]);
+  };
+
+  const socket = async (round: number, i: number) => {
+    const rid = randomId(round, i);
+    total++;
+    // SAFETY: Bun takes a headers option on the WebSocket constructor; the DOM type does not list it.
+    const ws = new WebSocket(`${base.replace("http:", "ws:")}/ws?d=${rand(6)}`, {
+      headers: { ...hostHeader, "x-rid": rid },
+    } as never);
+    const got: string[] = [];
+    await new Promise<void>((done) => {
+      const timer = setTimeout(() => {
+        fail(`ws ${rid}: timed out with ${got.join(",")}`);
+        done();
+      }, 15000);
+      ws.addEventListener("open", () => {
+        for (let k = 0; k < 4; k++) ws.send(`m${k}`);
+      });
+      ws.addEventListener("message", (e) => {
+        got.push(String(e.data));
+        if (got.length === 4) {
+          clearTimeout(timer);
+          ws.close(1000, "done");
+          done();
+        }
+      });
+      ws.addEventListener("error", () => {
+        clearTimeout(timer);
+        fail(`ws ${rid}: error`);
+        done();
+      });
+    });
+    expectOwn(
+      "ws",
+      rid,
+      got.sort(),
+      [0, 1, 2, 3].map((k) => `${rid}|m${k}|${rid}`),
+    );
+  };
+
+  for (let round = 0; round < rounds; round++) {
+    const work: (() => Promise<void>)[] = [];
+    for (let i = 0; i < requests; i++) {
+      work.push(() =>
+        one(round, i).catch((error) => {
+          fail(`request ${round}-${i} threw ${String(error)}`);
+        }),
+      );
+    }
+    if (options.clientSockets) {
+      for (let i = 0; i < 6; i++)
+        work.push(() => socket(round, i).catch((error) => fail(`socket ${round}-${i} threw ${String(error)}`)));
+    }
+    // At most `limit` at a time, started in order.
+    let next = 0;
+    const runner = async () => {
+      while (next < work.length) {
+        const job = work[next++];
+        if (job) await job();
+      }
+    };
+    await Promise.all(Array.from({ length: Math.min(options.limit ?? work.length, work.length) }, runner));
+  }
+  // Nothing shared between requests: no two saw the same cf, headers or ctx object.
+  const report: {
+    maxActive: number;
+    cfShared: boolean;
+    headersShared: boolean;
+    ctxShared: boolean;
+  } = await (await get("/report", "report")).json();
+  if (report.cfShared || report.headersShared || report.ctxShared)
+    fail(`objects shared across requests: ${JSON.stringify(report)}`);
+  if (report.maxActive < 2) fail(`requests never overlapped (max ${report.maxActive} at once)`);
+  assert(Array.isArray(failures));
+  return { requests: total, failures };
+}

package/test/fixtures/als-app.js

@@ -0,0 +1,136 @@
+// AsyncLocalStorage as Workers has it (nodejs_compat). The same file runs on workerd for the
+// comparison, where the class comes from node:async_hooks; here the prelude's global stands in
+// until the CLI maps the import.
+const ALS = globalThis.__sbAlsForTest || globalThis.AsyncLocalStorage;
+const als = new ALS();
+const other = new ALS();
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function run(path, id, delay) {
+  if (path === "/basic") {
+    const out = [];
+    out.push(als.getStore());
+    out.push(als.run("a", () => als.getStore()));
+    out.push(als.run("a", () => als.run("b", () => als.getStore())));
+    out.push(als.run("a", () => als.run("b", () => als.exit(() => als.getStore()))));
+    out.push(als.run("a", () => other.run("x", () => [als.getStore(), other.getStore()])));
+    out.push(als.getStore());
+    try {
+      als.run("t", () => {
+        throw new Error("boom");
+      });
+    } catch (e) {
+      out.push(["threw", e.message, als.getStore()]);
+    }
+    out.push(als.run("args", (x, y) => [als.getStore(), x, y], 1, 2));
+    out.push(als.run("v", () => 7));
+    return out;
+  }
+  if (path === "/await") {
+    return als.run({ id }, async () => {
+      const seen = [als.getStore().id];
+      await sleep(delay);
+      seen.push(als.getStore().id);
+      await null;
+      seen.push(als.getStore().id);
+      await Promise.resolve().then(() => seen.push(als.getStore().id));
+      await new Promise((resolve) =>
+        setTimeout(() => {
+          seen.push(als.getStore().id);
+          resolve();
+        }, delay),
+      );
+      await Promise.all([
+        sleep(delay),
+        (async () => {
+          await sleep(1);
+          seen.push(als.getStore().id);
+        })(),
+      ]);
+      const viaThen = await new Promise((resolve) => {
+        sleep(delay).then(() => resolve(als.getStore().id));
+      });
+      seen.push(viaThen);
+      queueMicrotask(() => seen.push("q" + als.getStore().id));
+      await sleep(1);
+      let ticks = 0;
+      await new Promise((resolve) => {
+        const timer = setInterval(() => {
+          seen.push("i" + als.getStore().id);
+          if (++ticks === 2) {
+            clearInterval(timer);
+            resolve();
+          }
+        }, 1);
+      });
+      try {
+        await Promise.reject(new Error("r"));
+      } catch (e) {
+        seen.push("c" + als.getStore().id);
+      }
+      await Promise.allSettled([Promise.reject(new Error("s"))]);
+      seen.push("s" + als.getStore().id);
+      return seen;
+    });
+  }
+  if (path === "/bind") {
+    const snapped = als.run("captured", () => ALS.snapshot());
+    const bound = () => snapped(() => als.getStore());
+    const snap = als.run("snap", () => ALS.snapshot());
+    const results = [bound(), als.run("other", () => bound()), snap(() => als.getStore()), als.getStore()];
+    await sleep(1);
+    results.push(
+      await als.run("later", async () => {
+        await sleep(1);
+        return bound();
+      }),
+    );
+    return results;
+  }
+  if (path === "/nested-async") {
+    const inner = async () => {
+      await sleep(delay);
+      return als.getStore();
+    };
+    const a = als.run("outer", async () => {
+      const x = await inner();
+      const y = await als.run("inner", () => inner());
+      const z = await inner();
+      return [x, y, z, als.getStore()];
+    });
+    return await a;
+  }
+  if (path === "/leak") {
+    // A run() that finished leaves nothing behind, even while its async work is pending.
+    let pending;
+    als.run("gone", () => {
+      pending = sleep(delay);
+    });
+    const before = als.getStore();
+    await pending;
+    return [before, als.getStore()];
+  }
+  return null;
+}
+
+export default {
+  async fetch(request, env, ctx) {
+    const url = new URL(request.url);
+    const id = url.searchParams.get("id") || "";
+    const delay = Number(url.searchParams.get("d") || 1);
+    if (url.pathname === "/wu") {
+      als.run({ id }, () => {
+        ctx.waitUntil(
+          (async () => {
+            await sleep(delay);
+            globalThis.__alsWu = als.getStore().id;
+          })(),
+        );
+      });
+      return new Response("scheduled");
+    }
+    if (url.pathname === "/wu-read") return new Response(String(globalThis.__alsWu));
+    const result = await run(url.pathname, id, delay);
+    return Response.json(result);
+  },
+};

package/test/fixtures/concurrent-app.js

@@ -0,0 +1,229 @@
+// The app under test in native-concurrent-requests.ts: every route keeps its own request's
+// values in locals, awaits on timers, fetch(), body streams, KV, D1 and WebSockets, and
+// reports what it saw before and after each await. A reply that holds another request's id
+// is a leak between interleaved requests. Written to the subset every host compiles.
+const seenCf = [];
+const seenHeaders = [];
+const seenCtx = [];
+const wakeups = {};
+let active = 0;
+let maxActive = 0;
+let dbReady = false;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function handle(request, env, ctx) {
+  {
+    const url = new URL(request.url);
+    const path = url.pathname;
+    const rid = request.headers.get("x-rid") || url.searchParams.get("id") || "";
+    const delays = (url.searchParams.get("d") || "3,3,3").split(",").map(Number);
+    const snap = () => ({
+      rid: request.headers.get("x-rid"),
+      cookie: request.headers.get("cookie"),
+      url: request.url,
+      method: request.method,
+      env: env.GREETING,
+      ctx: ctx === myCtx,
+      cf: request.cf === myCf,
+      headers: request.headers === myHeaders,
+    });
+    const myCtx = ctx;
+    const myCf = request.cf;
+    const myHeaders = request.headers;
+    seenCf.push(myCf);
+    seenHeaders.push(myHeaders);
+    seenCtx.push(ctx);
+
+    if (path === "/report") {
+      return Response.json({
+        n: seenCf.length,
+        maxActive,
+        cfShared: new Set(seenCf).size !== seenCf.length,
+        headersShared: new Set(seenHeaders).size !== seenHeaders.length,
+        ctxShared: new Set(seenCtx).size !== seenCtx.length,
+      });
+    }
+    if (path === "/wu") return Response.json(wakeups[rid] || null);
+
+    if (path === "/mix") {
+      // Locals that must survive every await and every collection in between.
+      const mine = { id: rid, list: [], text: "t-" + rid };
+      for (let i = 0; i < 20; i++) mine.list.push(rid + ":" + i);
+      const out = { rid, steps: [snap()] };
+      const extra = new Headers(request.headers);
+      extra.set("x-mine", rid);
+      ctx.waitUntil(
+        (async () => {
+          await sleep(5 + delays[0]);
+          wakeups[rid] = { rid, again: request.headers.get("x-rid"), mine: mine.id, ctx: ctx === myCtx };
+        })(),
+      );
+      for (let i = 0; i < delays.length; i++) {
+        await sleep(delays[i]);
+        if (url.searchParams.get("alloc")) {
+          // Garbage between awaits: forces collections while other requests are suspended.
+          let junk = [];
+          for (let k = 0; k < 40; k++) junk.push("j".repeat(2000 + k) + k);
+          junk = null;
+        }
+        out.steps.push(snap());
+      }
+      const upstream = url.searchParams.get("up");
+      if (upstream) {
+        const r = await fetch(upstream + "/echo?id=" + rid + "&ms=" + delays[0], { headers: { "x-rid": rid } });
+        out.upstream = await r.json();
+        out.steps.push(snap());
+      }
+      out.mine = { id: mine.id, text: mine.text, list: mine.list.join(",") };
+      out.extra = extra.get("x-mine");
+      out.xrid = extra.get("x-rid");
+      return Response.json(out, { headers: { "x-rid": rid, "x-echo": rid } });
+    }
+
+    if (path === "/promise") {
+      // A promise returned from an async function and adopted by another, with timers between.
+      const inner = async () => {
+        await sleep(delays[0]);
+        return { rid, from: "inner", seen: request.headers.get("x-rid") };
+      };
+      const outer = async () => {
+        const v = await inner();
+        await sleep(delays[1] || 1);
+        return v;
+      };
+      const all = await Promise.all([outer(), outer(), inner()]);
+      const raced = await Promise.race([sleep(50).then(() => "slow"), sleep(delays[0]).then(() => rid)]);
+      const settled = await Promise.allSettled([Promise.reject(new Error("e-" + rid)), Promise.resolve(rid)]);
+      return Response.json({
+        rid,
+        all: all.map((x) => x.seen),
+        raced,
+        settled: [settled[0].reason.message, settled[1].value],
+        again: request.headers.get("x-rid"),
+      });
+    }
+
+    if (path === "/boom") {
+      await sleep(delays[0]);
+      throw new Error("boom-" + rid);
+    }
+    if (path === "/catch") {
+      try {
+        await sleep(delays[0]);
+        throw new Error("caught-" + rid);
+      } catch (error) {
+        await sleep(delays[1] || 1);
+        return Response.json({ rid, message: error.message, again: request.headers.get("x-rid") });
+      }
+    }
+    if (path === "/reject") {
+      // Nothing waits on this rejection: the request and its neighbours go on.
+      Promise.reject(new Error("unhandled-" + rid));
+      await sleep(delays[0]);
+      return Response.json({ rid, ok: true, again: request.headers.get("x-rid") });
+    }
+
+    if (path === "/body") {
+      // The body is read in pieces with a timer between each, other requests interleaving.
+      const reader = request.body.getReader();
+      let bytes = 0;
+      let sum = 0;
+      let pieces = 0;
+      for (;;) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        pieces++;
+        bytes += value.length;
+        for (let i = 0; i < value.length; i++) sum = (sum + value[i]) % 1000003;
+        await sleep(1);
+      }
+      return Response.json({ rid, bytes, sum, pieces, again: request.headers.get("x-rid") });
+    }
+    if (path === "/text") {
+      const text = await request.text();
+      await sleep(delays[0]);
+      let sum = 0;
+      for (let i = 0; i < text.length; i++) sum = (sum + text.charCodeAt(i)) % 1000003;
+      return Response.json({ rid, bytes: text.length, sum, again: request.headers.get("x-rid") });
+    }
+
+    if (path === "/stream") {
+      let i = 0;
+      const n = 8;
+      const stream = new ReadableStream({
+        async pull(controller) {
+          await sleep(delays[0]);
+          if (i === n) {
+            controller.close();
+            return;
+          }
+          controller.enqueue(new TextEncoder().encode(rid + ":" + i + ":" + request.headers.get("x-rid") + "\n"));
+          i++;
+        },
+      });
+      return new Response(stream, { headers: { "content-type": "text/plain", "x-rid": rid } });
+    }
+
+    if (path === "/store") {
+      if (!dbReady) {
+        dbReady = true;
+        await env.DB.exec("CREATE TABLE IF NOT EXISTS t (rid TEXT, v TEXT)");
+      }
+      await env.KV.put("k-" + rid, rid);
+      await sleep(delays[0]);
+      const kv = await env.KV.get("k-" + rid);
+      await env.DB.prepare("INSERT INTO t (rid, v) VALUES (?, ?)")
+        .bind(rid, "v-" + rid)
+        .run();
+      await sleep(delays[1] || 1);
+      const row = await env.DB.prepare("SELECT v FROM t WHERE rid = ?").bind(rid).first();
+      return Response.json({ rid, kv, row: row && row.v, again: request.headers.get("x-rid") });
+    }
+
+    if (path === "/pair") {
+      // A WebSocketPair that stays in the worker: messages with timers between them.
+      const [client, server] = Object.values(new WebSocketPair());
+      server.accept();
+      client.accept();
+      const log = [];
+      server.addEventListener("message", (e) => {
+        log.push("s:" + e.data);
+        server.send("echo:" + e.data + ":" + request.headers.get("x-rid"));
+      });
+      client.addEventListener("message", (e) => log.push("c:" + e.data));
+      for (let i = 0; i < 4; i++) {
+        client.send(rid + ":" + i);
+        await sleep(delays[0]);
+      }
+      await sleep(5);
+      client.close(1000, rid);
+      return Response.json({ rid, log });
+    }
+
+    if (path === "/ws") {
+      // A client socket (hosts that carry them): each message is answered after a timer.
+      if (request.headers.get("Upgrade") !== "websocket") return new Response("expected websocket", { status: 426 });
+      const [client, server] = Object.values(new WebSocketPair());
+      server.accept();
+      server.addEventListener("message", async (e) => {
+        await sleep(delays[0]);
+        server.send(rid + "|" + e.data + "|" + request.headers.get("x-rid"));
+      });
+      return new Response(null, { status: 101, webSocket: client });
+    }
+
+    return new Response("ok " + rid);
+  }
+}
+
+export default {
+  async fetch(request, env, ctx) {
+    active++;
+    if (active > maxActive) maxActive = active;
+    try {
+      return await handle(request, env, ctx);
+    } finally {
+      active--;
+    }
+  },
+};