@sproutboat/runtime 0.34.5 → 0.36.0

package/src/native-fetch-prelude.js

@@ -3092,18 +3092,59 @@ __sbStartupMark();
 // string via the same primitives as __sbEnv / __sbRandomBytes (proven working),
 // then parsed — Porffor's number boxing for a bare inline-C assignment is not
 // relied on. `__sbEntry` samples it around the handler for per-invocation CPU.
+// The number comes back as a number: no text and no parse around it.
 function __sbCpuMs() {
-  let res = "";
+  let ms = 0;
   // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
   Porffor.c`
     struct timespec __ts;
     clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &__ts);
-    double __ms = (double)__ts.tv_sec * 1000.0 + (double)__ts.tv_nsec / 1000000.0;
+    ms = (f64)((double)__ts.tv_sec * 1000.0 + (double)__ts.tv_nsec / 1000000.0);
+  `;
+  return ms;
+}
+
+// The `x-sb-cpu-ms` value for a CPU time in ms, as three decimals, floored at zero: one format call
+// in C, where it was a format, a parse and a toFixed.
+// oxlint-disable-next-line no-unused-vars -- `cpu` is read inside the RawC block below, not by JS.
+function __sbCpuStamp(cpu) {
+  let res = "0.000";
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    double __d = cpu.type == 1 ? (double)cpu.val : 0.0;
+    if (!(__d >= 0)) __d = 0;
     char __b[32];
-    int __n = snprintf(__b, sizeof(__b), "%.3f", __ms);
+    int __n = snprintf(__b, sizeof(__b), "%.3f", __d);
     if (__n > 0) res = porf_box((f64)porf_native_fetch_alloc_bytestring(__b, (size_t)__n), 195);
   `;
-  return res === "" ? 0 : parseFloat(res);
+  return res;
+}
+
+// Per-request CPU (toolchain async-context.ts): a request is a small id whose thread CPU time is
+// summed over the slices in which it ran, however requests interleave. 0 when no slot is free.
+function __sbCpuBegin() {
+  let id = 0;
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    id = (f64)porf_cpu_begin();
+  `;
+  return id;
+}
+// oxlint-disable-next-line no-unused-vars -- `cell` is read inside the RawC block below, not by JS.
+function __sbCpuTake(cell) {
+  let ms = 0;
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    ms = porf_cpu_read_ms((u32)cell.val);
+  `;
+  return ms;
+}
+// oxlint-disable-next-line no-unused-vars -- `cell` is read inside the RawC block below, not by JS.
+function __sbCpuEnd(cell) {
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    porf_cpu_end((u32)cell.val);
+  `;
 }
 
 // #28 — stamp `x-sb-cpu-ms` onto a handler Response. Porffor alpha-10's
@@ -3113,8 +3154,7 @@ function __sbCpuMs() {
 // with one extra header. Safe only for a string body (the norm under
 // http-sync-v0) with no Set-Cookie to comma-fold; anything else is returned
 // untouched and the edge simply omits cpuMs for that request.
-function __sbTagCpu(res, t0) {
-  const cpu = __sbCpuMs() - t0;
+function __sbTagCpu(res, cpu) {
   try {
     // A string body and no Set-Cookie, as before. The native writer reads Headers' flat `_entries`,
     // so the stamp is appended to the handler's own Response instead of building a second one (a
@@ -3122,7 +3162,7 @@ function __sbTagCpu(res, t0) {
     // the handler set itself is replaced by the measured one, as before.
     const headers = res && res.headers;
     if (headers && __sbIsStr(__sbRawBody(res)) && !headers.has("set-cookie")) {
-      const stamp = (cpu >= 0 ? cpu : 0).toFixed(3);
+      const stamp = __sbCpuStamp(cpu);
       const entries = headers._entries;
       let set = false;
       for (let i = 0; i < entries.length; i += 2) {
@@ -5295,6 +5335,11 @@ function __sbD1Param(value, strict) {
 // The broker transport leaves it unset and keeps the string hop. (No initializer: the transport is placed ahead of the prelude, and `= null` would run after its assignment.)
 // oxlint-disable-next-line no-unassigned-vars -- the embedded transport assigns it; the broker transport does not.
 var __sbCallDirect;
+// The embedded transport also answers a strict D1 query without the generic dispatch around it
+// (a request object, a walk down the op list, a result object): (db, sql, params) -> the reply
+// __sbD1Run builds. Unset elsewhere, and the query goes through __sbD1Rpc as before.
+// oxlint-disable-next-line no-unassigned-vars -- the embedded transport assigns it; the broker transport does not.
+var __sbD1QueryDirect;
 function __sbRpcDirect(op, extra) {
   if (!__sbCallDirect) return __sbRpc(op, extra);
   const req = { v: 1, id: ++__sbReqId, op };
@@ -5355,10 +5400,30 @@ function __sbD1Fail(message) {
 // transaction statements are refused, exec() runs line by line, and withSession() exists.
 var __sbD1NoTransactions =
   "D1_ERROR: To execute a transaction, please use the state.storage.transaction() or state.storage.transactionSync() APIs instead of the SQL BEGIN TRANSACTION or SAVEPOINT statements. The JavaScript API is safer because it will automatically roll back on exceptions, and because it interacts correctly with Durable Objects' automatic atomic write coalescing.";
+// A statement's first word is one of the transaction keywords: read by character code, where the
+// regular expression this replaced was compiled on every query. The word ends at the first character
+// that is not a letter, digit or underscore (the regular expression's \b after a keyword).
+function __sbD1IsTransaction(text) {
+  let end = 0;
+  while (end < text.length && end < 10) {
+    const c = text.charCodeAt(end) | 32;
+    if (c < 97 || c > 122) break;
+    end++;
+  }
+  if (end < 3 || end > 9) return false;
+  if (end < text.length) {
+    const c = text.charCodeAt(end);
+    if ((c >= 48 && c <= 57) || (c >= 65 && c <= 90) || c === 95 || (c >= 97 && c <= 122)) return false;
+  }
+  const word = text.slice(0, end).toLowerCase();
+  return (
+    word === "begin" || word === "commit" || word === "end" || word === "rollback" || word === "savepoint" || word === "release"
+  );
+}
 function __sbD1Check(sql) {
   const text = String(sql).trim();
   if (!text) throw __sbD1Fail("D1_ERROR: No SQL statements detected.");
-  if (/^(BEGIN|COMMIT|END|ROLLBACK|SAVEPOINT|RELEASE)\b/i.test(text)) throw __sbD1Fail(__sbD1NoTransactions);
+  if (__sbD1IsTransaction(text)) throw __sbD1Fail(__sbD1NoTransactions);
 }
 function __sbD1Meta(meta, started) {
   const changes = Number(meta.changes) || 0;
@@ -5394,70 +5459,91 @@ function __sbD1Promise(run) {
     return Promise.reject(err);
   }
 }
-function __sbMakeD1(dbName) {
-  // The synchronous core: the answer to one statement as columns, rows and meta.
-  function query(sql, params, strict) {
-    if (strict) __sbD1Check(sql);
-    const started = Date.now();
-    const r = __sbD1Rpc("d1.query", { db: dbName, sql, params }, strict);
-    if (!strict) return { results: r.results || [], success: true, meta: r.meta || {} };
-    const table = __sbD1Table(r);
-    return { columns: table.columns, rows: table.rows, meta: __sbD1Meta(r.meta || {}, started) };
-  }
-  function stmt(sql, params) {
-    const s = {
-      __sql: sql,
-      __params: params,
-      bind() {
-        const strict = __sbD1Strict();
-        const list = [];
-        for (let i = 0; i < arguments.length; i++) list.push(__sbD1Param(arguments[i], strict));
-        return stmt(sql, list);
-      },
-      all() {
-        if (!__sbD1Strict()) return query(sql, params, false);
-        return __sbD1Promise(() => {
-          const t = query(sql, params, true);
-          return { success: true, meta: t.meta, results: __sbD1Objects(t.columns, t.rows) };
-        });
-      },
-      run() {
-        return s.all();
-      },
-      raw(options) {
-        if (!__sbD1Strict()) {
-          const rows = query(sql, params, false).results;
-          const out = [];
-          for (let i = 0; i < rows.length; i++) {
-            const cols = [];
-            for (const k in rows[i]) cols.push(rows[i][k]);
-            out.push(cols);
-          }
-          return out;
-        }
-        return __sbD1Promise(() => {
-          const t = query(sql, params, true);
-          return options && options.columnNames ? [t.columns].concat(t.rows) : t.rows;
-        });
-      },
-      first(column) {
-        if (!__sbD1Strict()) {
-          const rows = query(sql, params, false).results;
-          if (rows.length === 0) return null;
-          return column == null ? rows[0] : rows[0][column];
-        }
-        return __sbD1Promise(() => {
-          const t = query(sql, params, true);
-          if (column == null) return t.rows.length ? __sbD1Objects(t.columns, [t.rows[0]])[0] : null;
-          const at = t.columns.indexOf(String(column));
-          if (!t.rows.length) return null;
-          if (at < 0) throw __sbD1Fail("D1_COLUMN_NOTFOUND: Column not found (" + column + ")");
-          return t.rows[0][t.columns.lastIndexOf(String(column))];
-        });
-      },
-    };
-    return s;
+// A strict query's reply from the embedded transport's direct lane, or through the generic
+// dispatch. The errors read the same either way: "D1_ERROR: ..." for SQLite's, and the
+// transport's own prefix for anything else.
+function __sbD1Direct(name, sql, params) {
+  try {
+    return __sbD1QueryDirect(name, sql, params);
+  } catch (err) {
+    const message = "sproutboat d1.query: " + (String((err && err.message) || err) || "failed");
+    const at = message.indexOf("D1_");
+    throw new Error(at > 0 ? message.slice(at) : message);
+  }
+}
+// The synchronous core: the answer to one statement as columns, rows and meta. meta is only built
+// when the caller will hand it out (all() and run()): raw() and first() drop it, and building it
+// reads the clock twice.
+function __sbD1Query(dbName, sql, params, strict, wantMeta) {
+  if (strict) __sbD1Check(sql);
+  const started = !strict || wantMeta ? Date.now() : 0;
+  const r = strict && __sbD1QueryDirect ? __sbD1Direct(dbName, sql, params) : __sbD1Rpc("d1.query", { db: dbName, sql, params }, strict);
+  if (!strict) return { results: r.results || [], success: true, meta: r.meta || {} };
+  const table = __sbD1Table(r);
+  return { columns: table.columns, rows: table.rows, meta: wantMeta ? __sbD1Meta(r.meta || {}, started) : null };
+}
+// A prepared statement. A class, so a prepare() or bind() does not allocate five closures.
+class __SbD1Statement {
+  constructor(dbName, sql, params) {
+    this.__name = dbName;
+    this.__sql = sql;
+    this.__params = params;
+  }
+  bind() {
+    const strict = __sbD1Strict();
+    const list = [];
+    for (let i = 0; i < arguments.length; i++) list.push(__sbD1Param(arguments[i], strict));
+    return new __SbD1Statement(this.__name, this.__sql, list);
+  }
+  all() {
+    if (!__sbD1Strict()) return __sbD1Query(this.__name, this.__sql, this.__params, false, true);
+    try {
+      const t = __sbD1Query(this.__name, this.__sql, this.__params, true, true);
+      return Promise.resolve({ success: true, meta: t.meta, results: __sbD1Objects(t.columns, t.rows) });
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  run() {
+    return this.all();
+  }
+  raw(options) {
+    if (!__sbD1Strict()) {
+      const rows = __sbD1Query(this.__name, this.__sql, this.__params, false, true).results;
+      const out = [];
+      for (let i = 0; i < rows.length; i++) {
+        const cols = [];
+        for (const k in rows[i]) cols.push(rows[i][k]);
+        out.push(cols);
+      }
+      return out;
+    }
+    try {
+      const t = __sbD1Query(this.__name, this.__sql, this.__params, true, false);
+      return Promise.resolve(options && options.columnNames ? [t.columns].concat(t.rows) : t.rows);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  first(column) {
+    if (!__sbD1Strict()) {
+      const rows = __sbD1Query(this.__name, this.__sql, this.__params, false, true).results;
+      if (rows.length === 0) return null;
+      return column == null ? rows[0] : rows[0][column];
+    }
+    try {
+      const t = __sbD1Query(this.__name, this.__sql, this.__params, true, false);
+      if (column == null) return Promise.resolve(t.rows.length ? __sbD1Objects(t.columns, [t.rows[0]])[0] : null);
+      const at = t.columns.indexOf(String(column));
+      if (!t.rows.length) return Promise.resolve(null);
+      if (at < 0) throw __sbD1Fail("D1_COLUMN_NOTFOUND: Column not found (" + column + ")");
+      return Promise.resolve(t.rows[0][t.columns.lastIndexOf(String(column))]);
+    } catch (err) {
+      return Promise.reject(err);
+    }
   }
+}
+function __sbMakeD1(dbName) {
   function batch(statements) {
     const strict = __sbD1Strict();
     const list = [];
@@ -5495,7 +5581,7 @@ function __sbMakeD1(dbName) {
   }
   const db = {
     prepare(sql) {
-      return stmt(String(sql), []);
+      return new __SbD1Statement(dbName, String(sql), []);
     },
     batch(statements) {
       if (!__sbD1Strict()) return batch(statements);
@@ -9099,7 +9185,7 @@ function __sbInstallWebSockets() {
   globalThis.WebSocketRequestResponsePair = __SbWebSocketRequestResponsePair;
 }
 
-async function __sbFetchWithDrain(res, tasks, bindingCall, rethrow, top) {
+async function __sbFetchWithDrain(res, tasks, bindingCall, rethrow, top, cpuCell) {
   let r;
   try {
     r = res && __sbIsFn(res.then) ? await res : res;
@@ -9111,16 +9197,22 @@ async function __sbFetchWithDrain(res, tasks, bindingCall, rethrow, top) {
   } catch (error) {
     // A Durable Object's stub.fetch() from 2026-10-29: the caller gets the exception.
     if (rethrow) {
-      __sbDrainWaitUntil(tasks);
+      if (tasks.length) __sbDrainWaitUntil(tasks);
       throw error;
     }
     // #179 — a rejected handler promise must not take the process down with it.
     r = __sbErrorResponse(error, bindingCall);
   }
+  // From 2026-11-02 an async handler reports its CPU too: the thread time of the slices in which this
+  // request ran, not its neighbours' (before it, only a handler that answered synchronously did).
+  if (cpuCell) {
+    if (__sbCompatDate() >= "2026-11-02") __sbTagCpu(r, __sbCpuTake(cpuCell));
+    __sbCpuEnd(cpuCell);
+  }
   // The response goes out now and ctx.waitUntil work keeps running after it, as in
   // workerd; it was awaited first, so a 1.5 s background task delayed the response by
-  // 1.5 s. The 25 s cap still bounds it.
-  __sbDrainWaitUntil(tasks);
+  // 1.5 s. The 25 s cap still bounds it. Not called for no tasks: an async call is a coroutine and a promise.
+  if (tasks.length) __sbDrainWaitUntil(tasks);
   return r;
 }
 
@@ -9151,7 +9243,7 @@ function __sbErrorResponse(error, bindingCall) {
 // sees it. Returns whether the edge vouched for this one.
 function __sbBindingCallIngress(request) {
   const headers = request.headers;
-  const want = __sbEnv("SB_EDGE_TOKEN");
+  const want = __sbEdgeToken();
   const vouched = !!want && headers.get("x-sb-binding-call") === "1" && __sbEqCt(headers.get("x-sb-edge-token") || "", want);
   if (vouched) {
     const url = headers.get("x-sb-url");
@@ -9159,12 +9251,46 @@ function __sbBindingCallIngress(request) {
     if (url && URL.canParse(url) && __sbCompatDate() >= "2026-10-22") request.url = url;
     headers.delete("x-sb-remote-addr");
   }
-  for (const name of ["x-sb-binding-call", "x-sb-url", "x-sb-edge-token"]) {
-    if (headers.get(name) != null) headers.delete(name);
+  // Nearly every request carries none of the three: one look at the stored names tells, where
+  // three lookups (each validating and lowercasing its name) and an array of them did.
+  const stored = headers._entries;
+  let present = stored === undefined;
+  for (let i = 0; !present && i < stored.length; i += 2) {
+    const key = stored[i];
+    if (key === "x-sb-binding-call" || key === "x-sb-url" || key === "x-sb-edge-token") present = true;
+  }
+  if (present) {
+    for (const name of ["x-sb-binding-call", "x-sb-url", "x-sb-edge-token"]) {
+      if (headers.get(name) != null) headers.delete(name);
+    }
   }
   return vouched;
 }
 
+// SB_EDGE_TOKEN is fixed for the life of a process, like SB_TRUSTED_PROXIES above: read once.
+let __sbEdgeTokenCache;
+function __sbEdgeToken() {
+  if (__sbEdgeTokenCache === undefined) __sbEdgeTokenCache = __sbEnv("SB_EDGE_TOKEN");
+  return __sbEdgeTokenCache;
+}
+
+// One header of a request the native server built, by a name that is already lowercase and valid:
+// its stored names are scanned directly, where get() validates and lowercases the name first. A
+// name stored twice, or a headers object that is not the runtime's, goes through get().
+function __sbHeader(headers, name) {
+  const stored = headers._entries;
+  if (stored === undefined) return headers.get(name);
+  let found = null;
+  let count = 0;
+  for (let i = 0; i < stored.length; i += 2) {
+    if (stored[i] === name) {
+      found = stored[i + 1];
+      count++;
+    }
+  }
+  return count > 1 ? headers.get(name) : found;
+}
+
 function __sbLogUncaught(where, error) {
   try {
     let text = "";
@@ -9192,6 +9318,87 @@ globalThis.__sbOnUnhandledRejection = function (reason, promise) {
   }
 };
 
+// AsyncLocalStorage (node:async_hooks, as Workers has it: run, getStore, exit and the static snapshot
+// (no bind, enterWith or disable). The patched Porffor (toolchain async-context.ts) keeps one
+// "current context" value that every promise reaction, await and timer records when it is created and
+// sets when it runs. Here that value is a frame: the stores of the AsyncLocalStorage instances
+// entered so far, in two parallel arrays (a frame is never changed, run() makes a new one).
+function __sbCtxGet() {
+  let frame;
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    frame = porf_unpack(porf_async_ctx_bits);
+  `;
+  return frame;
+}
+// oxlint-disable-next-line no-unused-vars -- `frame` is read inside the RawC block below, not by JS.
+function __sbCtxSet(frame) {
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    porf_async_ctx_bits = porf_pack(frame);
+  `;
+}
+function __sbFrameIndex(frame, als) {
+  if (!frame) return -1;
+  const keys = frame.keys;
+  for (let i = 0; i < keys.length; i++) if (keys[i] === als) return i;
+  return -1;
+}
+function __sbFrameWith(frame, als, store) {
+  const keys = [];
+  const vals = [];
+  if (frame) {
+    for (let i = 0; i < frame.keys.length; i++) {
+      if (frame.keys[i] === als) continue;
+      keys.push(frame.keys[i]);
+      vals.push(frame.vals[i]);
+    }
+  }
+  keys.push(als);
+  vals.push(store);
+  return { keys, vals };
+}
+function __sbRunInFrame(frame, fn, args) {
+  const previous = __sbCtxGet();
+  __sbCtxSet(frame);
+  try {
+    return fn.apply(undefined, args);
+  } finally {
+    __sbCtxSet(previous);
+  }
+}
+// A function constructor, not a class: Porffor refuses `new` on a class reached through an alias
+// (const { AsyncLocalStorage } = globalThis), which is how a bundled import arrives.
+function __SbAsyncLocalStorage() {}
+__SbAsyncLocalStorage.prototype.run = function (store, fn, ...args) {
+  if (!__sbIsFn(fn)) throw new TypeError("The \"callback\" argument must be of type function.");
+  return __sbRunInFrame(__sbFrameWith(__sbCtxGet(), this, store), fn, args);
+};
+__SbAsyncLocalStorage.prototype.exit = function (fn, ...args) {
+  if (!__sbIsFn(fn)) throw new TypeError("The \"callback\" argument must be of type function.");
+  return __sbRunInFrame(__sbFrameWith(__sbCtxGet(), this, undefined), fn, args);
+};
+__SbAsyncLocalStorage.prototype.getStore = function () {
+  const frame = __sbCtxGet();
+  const at = __sbFrameIndex(frame, this);
+  return at === -1 ? undefined : frame.vals[at];
+};
+__SbAsyncLocalStorage.prototype.enterWith = function () {
+  throw new Error("AsyncLocalStorage.enterWith() is not supported");
+};
+__SbAsyncLocalStorage.prototype.disable = function () {
+  throw new Error("AsyncLocalStorage.disable() is not supported");
+};
+// AsyncLocalStorage.bind(fn) is not provided: Porffor compiles a call of .bind on a function value to
+// Function.prototype.bind whatever properties the function has. snapshot() does the same job.
+__SbAsyncLocalStorage.snapshot = function () {
+  const frame = __sbCtxGet();
+  return function (fn, ...args) {
+    return __sbRunInFrame(frame, fn, args);
+  };
+};
+globalThis.AsyncLocalStorage = __SbAsyncLocalStorage;
+
 // Shared by alarm and scheduled: both reply with an empty 204 once their
 // handler (and anything it queued via `waitUntil`) has settled.
 async function __sb204WithDrain(res, tasks) {
@@ -9328,12 +9535,24 @@ function __sbIngressStream(request, id) {
   request.bytes = async () => await all();
 }
 
+// The id of the current request's streamed body, 0 when it has none (op "t" of __sbReqBodyOp),
+// as a number: every request asks, and the text round trip was a format and a parse.
+function __sbReqBodyTake() {
+  let id = 0;
+  // oxlint-disable-next-line no-unused-expressions -- Porffor.c`...` is inline C the compiler consumes, not a JS expression.
+  Porffor.c`
+    extern unsigned int sb_reqbody_take_current(void);
+    id = (f64)sb_reqbody_take_current();
+  `;
+  return id;
+}
+
 // Native HTTP ingress stores the body as one character per raw byte. Keep
 // that representation for binary consumers, but decode text lazily before
 // handing the request to user code. Request.text() in Porffor otherwise treats
 // the raw bytes as already-decoded characters and corrupts Unicode/HMAC input.
 function __sbDecodeIngress(request) {
-  const streamed = __sbCompatDate() >= "2026-10-27" ? Number(__sbReqBodyOp("t", 0, "")) : 0;
+  const streamed = __sbCompatDate() >= "2026-10-27" ? __sbReqBodyTake() : 0;
   if (streamed > 0) {
     __sbIngressStream(request, streamed);
     return;
@@ -9369,7 +9588,7 @@ function __sbTrustedProxiesOnce() {
 
 globalThis.__sbEntry = function (handlers, request) {
   __sbDecodeIngress(request);
-  const trigger = request.headers.get("x-sb-trigger");
+  const trigger = __sbHeader(request.headers, "x-sb-trigger");
   if (!trigger) {
     const bindingCall = __sbBindingCallIngress(request);
     // #163/#128 — expose the request metadata the edge already has, the
@@ -9379,7 +9598,7 @@ globalThis.__sbEntry = function (handlers, request) {
     const __cf = request.cf || {};
     if (__sbTrustedProxiesOnce().length === 0) {
       // No trusted proxy (the usual case): the peer is the client and no forwarded header counts.
-      __cf.clientIp = __sbNormalizeIp(request.headers.get("x-sb-remote-addr") || "");
+      __cf.clientIp = __sbNormalizeIp(__sbHeader(request.headers, "x-sb-remote-addr") || "");
     } else {
       __cf.clientIp = __sbClientIp(request);
       const __httpProtocol = __sbTrustedProxyHeader(request, "x-sb-http-protocol");
@@ -9402,7 +9621,8 @@ globalThis.__sbEntry = function (handlers, request) {
     // itself returned, but never one derived from `.then()`, so chaining the
     // tag on hangs the request forever. cpuMs is documented as absent for
     // async handlers (see LogEvent in services/edge) — that is this.
-    const __t0 = __sbCpuMs();
+    const __cpuCell = __sbCpuBegin();
+    const __t0 = __cpuCell ? 0 : __sbCpuMs();
     const __sbTasks = [];
     const ctx = {
       waitUntil(p) {
@@ -9424,14 +9644,21 @@ globalThis.__sbEntry = function (handlers, request) {
     } catch (error) {
       // #179 — a synchronous throw anywhere in the handler must not take the
       // whole process (and every other in-flight request) down with it.
+      __sbCpuEnd(__cpuCell);
       return __sbErrorResponse(error, bindingCall);
     }
     // Same promise-identity rule as above applies to `__sbFetchWithDrain`'s
     // own return, which is why it's tail-called rather than chained on here.
-    if (__sbTasks.length || (__res && __sbIsFn(__res.then)) || __sbHasStreamBody(__res)) return __sbFetchWithDrain(__res, __sbTasks, bindingCall, false, true);
+    if (__sbTasks.length || (__res && __sbIsFn(__res.then)) || __sbHasStreamBody(__res)) return __sbFetchWithDrain(__res, __sbTasks, bindingCall, false, true, __cpuCell);
     // A WebSocket handshake answer (from 2026-10-30): its client end becomes the host socket.
-    if (__sbHasWebSocket(__res)) return __sbWsHostResponse(__res);
-    return __sbTagCpu(__res, __t0);
+    if (__sbHasWebSocket(__res)) {
+      __sbCpuEnd(__cpuCell);
+      return __sbWsHostResponse(__res);
+    }
+    // The request ran alone from start to here: its own slices, or the process delta where no slot was free.
+    const __cpu = __cpuCell ? __sbCpuTake(__cpuCell) : __sbCpuMs() - __t0;
+    __sbCpuEnd(__cpuCell);
+    return __sbTagCpu(__res, __cpu);
   }
   if (!__sbTriggerAuthed(request)) return new Response("forbidden", { status: 403 });