@sproutboat/runtime 0.44.0 → 0.46.0

package/src/native-fetch-prelude.js

@@ -3043,6 +3043,12 @@ if (globalThis.setTimeout == null) globalThis.setTimeout = setTimeout;
 if (globalThis.clearTimeout == null) globalThis.clearTimeout = clearTimeout;
 if (globalThis.setInterval == null) globalThis.setInterval = setInterval;
 if (globalThis.clearInterval == null) globalThis.clearInterval = clearInterval;
+// The runtime's timers, for the prelude's own use. Once a Durable Object is built at the eviction date, the four globals become
+// wrappers that pin the object that armed a timer (__sbDOWrapTimers); a parked timer or a poll of ours must never pin anything.
+const __sbSetTimeout = globalThis.setTimeout;
+const __sbClearTimeout = globalThis.clearTimeout;
+const __sbSetInterval = globalThis.setInterval;
+const __sbClearInterval = globalThis.clearInterval;
 
 // Prepended to every handler by tools/compile.ts, before Porffor's native-fetch
 // bundled handler. Porffor's runtime/fetch-globals.js (checked through alpha-10)
@@ -3895,7 +3901,7 @@ if (typeof globalThis.EventTarget !== "function") {
     }
     static timeout(ms) {
       const signal = new AbortSignal();
-      setTimeout(() => signal.__sbAbort(namedError("TimeoutError", "The operation timed out")), ms);
+      __sbSetTimeout(() => signal.__sbAbort(namedError("TimeoutError", "The operation timed out")), ms);
       return signal;
     }
     static any(signals) {
@@ -11024,28 +11030,63 @@ function __sbR2StrictObject(meta, bytes, range, include) {
   };
   if (bytes == null) return obj;
   let used = false;
+  // A lazy body (bytes.lazy: the object's file, read as asked) is never read whole unless text(), json(),
+  // arrayBuffer() or blob() ask for all of it; its stream reads one chunk at a time.
+  const lazy = bytes.lazy === true;
   const take = () => {
     if (used) throw new TypeError("Body has already been used. It can only be used once. Use tee() first if you need to read it twice.");
     used = true;
-    return bytes;
+    return lazy ? __sbR2ReadAll(bytes, range) : bytes;
   };
   // The stream is made when first asked for: text() and friends read the bytes directly,
   // so an object read as text never holds a second copy (sproutd #22).
   let stream = null;
   Object.defineProperty(obj, "body", {
     get: () => {
-      if (stream === null) stream = new Response(__sbBufFrom(bytes)).body;
+      if (stream === null) stream = lazy ? __sbR2LazyStream(bytes, range) : new Response(__sbBufFrom(bytes)).body;
       return stream;
     },
     enumerable: true,
   });
   Object.defineProperty(obj, "bodyUsed", { get: () => used, enumerable: true });
-  obj.text = async () => __sbFromUtf8(take());
-  obj.json = async () => JSON.parse(__sbFromUtf8(take()));
-  obj.arrayBuffer = async () => __sbBufFrom(take());
-  obj.blob = async () => new Blob([__sbBufFrom(take())], { type: obj.httpMetadata.contentType || "" });
+  // A lazy body reads into a Uint8Array (never a bytestring), so each of these takes bytes, not text.
+  obj.text = async () => (lazy ? new TextDecoder().decode(take()) : __sbFromUtf8(take()));
+  obj.json = async () => JSON.parse(lazy ? new TextDecoder().decode(take()) : __sbFromUtf8(take()));
+  obj.arrayBuffer = async () => (lazy ? take().buffer : __sbBufFrom(take()));
+  obj.blob = async () => new Blob([lazy ? take().buffer : __sbBufFrom(take())], { type: obj.httpMetadata.contentType || "" });
   return obj;
 }
+// The chunk a streamed R2 body reads at a time (a Uint8Array of this size, then collected): a chunk is
+// what the worker's heap holds per read, and what the response's flow control hands to the host.
+const __SB_R2_CHUNK = 256 * 1024;
+// The bytes of a lazy body's window, all of them: text(), json(), arrayBuffer() and blob() need the whole
+// object in memory whatever they are called on.
+function __sbR2ReadAll(src, range) {
+  const out = new Uint8Array(range.length);
+  if (range.length > 0 && __sbR2ReadRange(src.bucket, src.key, src.blobId, range.offset, out) !== range.length)
+    throw new Error("sproutboat r2.get: the object could not be read");
+  return out;
+}
+// A lazy body's window as a ReadableStream of __SB_R2_CHUNK-byte reads.
+function __sbR2LazyStream(src, range) {
+  let at = 0;
+  return new ReadableStream({
+    pull(controller) {
+      if (at >= range.length) {
+        controller.close();
+        return;
+      }
+      const n = Math.min(__SB_R2_CHUNK, range.length - at);
+      const chunk = new Uint8Array(n);
+      if (__sbR2ReadRange(src.bucket, src.key, src.blobId, range.offset + at, chunk) !== n) {
+        controller.error(new Error("sproutboat r2.get: the object could not be read"));
+        return;
+      }
+      at += n;
+      controller.enqueue(chunk);
+    },
+  });
+}
 // A hex string's bytes, one char per byte.
 function __sbR2Bytes(hex) {
   let out = "";
@@ -11092,7 +11133,19 @@ function __sbMakeR2(name) {
     get(key, options) {
       return attempt(() => {
         const o = options || {};
-        const r = __sbR2Get(name, __sbR2Key(key, "get"));
+        const objectKey = __sbR2Key(key, "get");
+        // Where the transport can read an object's file as asked (embedded: sproutd and standalone), get() takes its
+        // metadata and no bytes: a range reads only its own window, a body streams. The broker answers null here
+        // and returns the object whole, as before.
+        const opened = __sbR2Open(name, objectKey);
+        if (opened !== null) {
+          if (!opened.found) return null;
+          const meta = opened.object;
+          if (!__sbR2OnlyIf(o.onlyIf, meta.md5 || meta.etag, meta.uploaded)) return __sbR2StrictObject(meta, null, { offset: 0, length: meta.size });
+          const window = o.range == null ? { offset: 0, length: meta.size } : __sbR2Range(o.range, meta.size);
+          return __sbR2StrictObject(meta, { lazy: true, bucket: name, key: objectKey, blobId: opened.blobId }, window);
+        }
+        const r = __sbR2Get(name, objectKey);
         if (!r.found) return null;
         const meta = r.object;
         if (!__sbR2OnlyIf(o.onlyIf, meta.md5 || meta.etag, meta.uploaded)) return __sbR2StrictObject(meta, null, { offset: 0, length: meta.size });
@@ -11202,27 +11255,104 @@ function __sbMakeR2(name) {
   };
 }
 
-// Asset rules use the same parsed manifest in both transports. Matching mirrors
-// @sproutboat/assets; parity tests cover the portable native implementation.
-function __sbAssetRedirect(rule, path) {
-  const star = rule.from.indexOf("*");
-  if (star !== -1) {
-    const prefix = rule.from.slice(0, star);
-    if (!path.startsWith(prefix)) return null;
-    return rule.to.split(":splat").join(path.slice(prefix.length));
+// Asset rules use the same parsed manifest in both transports. Redirect matching mirrors
+// @sproutboat/assets (Cloudflare's `_redirects` rules: the whole path must match, so a trailing
+// slash is significant; `:name` is one or more characters up to the next "/"; one `*` is
+// `:splat`; a static rule beats a dynamic one); parity tests cover the portable implementation.
+function __sbRuleAlpha(code) {
+  return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
+}
+function __sbRuleWord(code) {
+  return __sbRuleAlpha(code) || (code >= 48 && code <= 57) || code === 95;
+}
+function __sbRuleIsStatic(from) {
+  for (let i = 0; i < from.length; i++) {
+    const code = from.charCodeAt(i);
+    if (code === 42) return false;
+    if (code === 58 && i + 1 < from.length && __sbRuleAlpha(from.charCodeAt(i + 1))) return false;
   }
-  const from = rule.from.split("/").filter(Boolean);
-  const parts = path.split("/").filter(Boolean);
-  if (from.length !== parts.length) return null;
-  const params = {};
+  return true;
+}
+// Tokens are [kind, text-or-name] pairs: 0 literal text, 1 :name, 2 splat. Null: the rule can never match.
+function __sbRuleTokens(from) {
+  const tokens = [];
+  const names = [];
+  let text = "";
   for (let i = 0; i < from.length; i++) {
-    if (from[i].startsWith(":")) params[from[i].slice(1)] = parts[i];
-    else if (from[i] !== parts[i]) return null;
+    const code = from.charCodeAt(i);
+    if (code === 42) {
+      if (text !== "") tokens.push([0, text]);
+      text = "";
+      if (names.indexOf("splat") !== -1) return null;
+      names.push("splat");
+      tokens.push([2, "splat"]);
+    } else if (code === 58 && i + 1 < from.length && __sbRuleAlpha(from.charCodeAt(i + 1))) {
+      let end = i + 2;
+      while (end < from.length && __sbRuleWord(from.charCodeAt(end))) end++;
+      const name = from.slice(i + 1, end);
+      if (names.indexOf(name) !== -1) return null;
+      names.push(name);
+      if (text !== "") tokens.push([0, text]);
+      text = "";
+      tokens.push([1, name]);
+      i = end - 1;
+    } else {
+      text += from.charAt(i);
+    }
   }
+  if (text !== "") tokens.push([0, text]);
+  return tokens;
+}
+function __sbRuleMatch(tokens, t, path, p, names, values) {
+  if (t === tokens.length) return p === path.length;
+  const kind = tokens[t][0];
+  const word = tokens[t][1];
+  if (kind === 0) {
+    if (path.slice(p, p + word.length) !== word) return false;
+    return __sbRuleMatch(tokens, t + 1, path, p + word.length, names, values);
+  }
+  let limit = path.length;
+  if (kind === 1) {
+    for (let i = p; i < path.length; i++) {
+      if (path.charCodeAt(i) === 47) {
+        limit = i;
+        break;
+      }
+    }
+  }
+  const least = kind === 1 ? p + 1 : p;
+  for (let q = limit; q >= least; q--) {
+    names.push(word);
+    values.push(path.slice(p, q));
+    if (__sbRuleMatch(tokens, t + 1, path, q, names, values)) return true;
+    names.pop();
+    values.pop();
+  }
+  return false;
+}
+function __sbAssetRedirect(rule, path) {
+  if (__sbRuleIsStatic(rule.from)) return rule.from === path ? rule.to : null;
+  const tokens = __sbRuleTokens(rule.from);
+  if (tokens === null) return null;
+  const names = [];
+  const values = [];
+  if (!__sbRuleMatch(tokens, 0, path, 0, names, values)) return null;
   let to = rule.to;
-  for (const name in params) to = to.split(":" + name).join(params[name]);
+  for (let i = 0; i < names.length; i++) to = to.split(":" + names[i]).join(values[i]);
   return to;
 }
+// The first static rule that matches, else the first dynamic one: { status, location } or null.
+function __sbFindAssetRedirect(rules, path) {
+  for (let i = 0; i < rules.length; i++) {
+    if (__sbRuleIsStatic(rules[i].from) && rules[i].from === path) return { status: rules[i].status, location: rules[i].to };
+  }
+  for (let i = 0; i < rules.length; i++) {
+    if (__sbRuleIsStatic(rules[i].from)) continue;
+    const location = __sbAssetRedirect(rules[i], path);
+    if (location !== null) return { status: rules[i].status, location };
+  }
+  return null;
+}
 
 function __sbAssetHeaderMatches(pattern, path) {
   const from = pattern.split("/").filter(Boolean);
@@ -11237,11 +11367,8 @@ function __sbAssetHeaderMatches(pattern, path) {
 function __sbAssetResponse(path, r) {
   if (r.location != null) return new Response(null, { status: r.status, headers: { location: r.location } });
   const rules = r.rules || {};
-  const redirects = rules.redirects || [];
-  for (let i = 0; i < redirects.length; i++) {
-    const to = __sbAssetRedirect(redirects[i], path);
-    if (to !== null) return new Response(null, { status: redirects[i].status, headers: { location: to } });
-  }
+  const redirect = __sbFindAssetRedirect(rules.redirects || [], path);
+  if (redirect !== null) return new Response(null, { status: redirect.status, headers: { location: redirect.location } });
   const headers = new Headers();
   if (r.type) headers.set("content-type", r.type);
   if (r.found) headers.set("etag", '"' + r.hash + '"');
@@ -12155,7 +12282,7 @@ async function __sbPumpRequestBody(id, source, ended) {
       if (bytes.length === 0) continue;
       let backlog = Number(globalThis.__sbAsyncBody(id, "c", __sbToBytes(bytes)));
       while (backlog > 4 * 1024 * 1024 && !ended()) {
-        await new Promise((resolve) => setTimeout(resolve, 2));
+        await new Promise((resolve) => __sbSetTimeout(resolve, 2));
         backlog = Number(globalThis.__sbAsyncBody(id, "q", ""));
       }
     }
@@ -12175,10 +12302,10 @@ function __sbUpstreamStreamed(op, msg, label, signal) {
     let done = false;
     const finish = () => {
       done = true;
-      clearInterval(id);
+      __sbClearInterval(id);
       if (onAbort) signal.removeEventListener("abort", onAbort);
     };
-    const id = setInterval(() => {
+    const id = __sbSetInterval(() => {
       if (done) return;
       const raw = __sbHttpAsyncResult(id);
       if (controller === null) {
@@ -12314,7 +12441,7 @@ function __sbUpstream(op, msg, label, signal, always) {
     const settled = () => {
       if (onAbort) signal.removeEventListener("abort", onAbort);
     };
-    const id = setTimeout(() => {
+    const id = __sbSetTimeout(() => {
       settled();
       try {
         resolve(__sbUpstreamResponse(__sbFetchReply(__sbHttpAsyncResult(id))));
@@ -12325,7 +12452,7 @@ function __sbUpstream(op, msg, label, signal, always) {
     if (signal) {
       onAbort = () => {
         settled();
-        clearTimeout(id);
+        __sbClearTimeout(id);
         __sbCancelAsync(id);
         reject(signal.reason);
       };
@@ -12336,7 +12463,7 @@ function __sbUpstream(op, msg, label, signal, always) {
       globalThis.__sbFetchUpstream(op, msg);
     } catch (e) {
       settled();
-      clearTimeout(id);
+      __sbClearTimeout(id);
       reject(e);
     }
   });
@@ -12349,7 +12476,7 @@ function __sbUpstream(op, msg, label, signal, always) {
 globalThis.__sbInstallFetch = function () {
   __sbIngressStreamingSetup();
   __sbInstallWebSockets();
-  globalThis.fetch = function (input, init) {
+  const plainFetch = function (input, init) {
     let parts;
     try {
       parts = __sbFetchParts(input, init);
@@ -12371,6 +12498,29 @@ globalThis.__sbInstallFetch = function () {
     if (stream instanceof ReadableStream) return __sbCollectBody(stream).then((bytes) => send(__sbRequestBody(bytes)));
     return send(__sbPartsBody(parts));
   };
+  // Inside a Durable Object's event an unawaited fetch keeps its object in memory until it settles.
+  globalThis.fetch = function (input, init) {
+    const rec = __sbDOL !== null ? __sbDOFrameRec() : undefined;
+    if (rec === undefined || rec.dead) return plainFetch(input, init);
+    __sbDOPin(rec);
+    let p;
+    try {
+      p = plainFetch(input, init);
+    } catch (error) {
+      __sbDOUnpin(rec);
+      throw error;
+    }
+    return p.then(
+      (r) => {
+        __sbDOUnpin(rec);
+        return r;
+      },
+      (error) => {
+        __sbDOUnpin(rec);
+        throw error;
+      },
+    );
+  };
 };
 
 // ---------------------------------------------------------------------------
@@ -12618,6 +12768,7 @@ function __sbDOCallback(fn, args) {
 
 // One RPC call: method `method` with `args`, or the getter `method` when args is null.
 function __sbDOInvoke(cls, id, method, args) {
+  if (__sbDOEvictOn()) return __sbDOInvokeLive(cls, id, method, args);
   let copied = null;
   let inst;
   try {
@@ -12644,7 +12795,38 @@ function __sbDOInvoke(cls, id, method, args) {
   );
 }
 
+// RPC into an object that may be evicted (compatibility date 2026-11-21): the event enters through __sbDORun.
+function __sbDOInvokeLive(cls, id, method, args) {
+  let copied = null;
+  try {
+    if (args !== null) copied = __sbDOCopy(args);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  return __sbDORun(
+    cls,
+    id.toString(),
+    id,
+    (inst) => {
+      const d = __sbDOFind(__sbDOClasses[cls], method);
+      if (args === null) return d.get.call(inst);
+      if (!d || !__sbIsFn(d.value)) throw new TypeError('The RPC receiver does not implement the method "' + method + '".');
+      return d.value.apply(inst, copied);
+    },
+    false,
+  ).then(__sbDOCopy);
+}
+
 function __sbDOFetchV2(className, id, input, init) {
+  if (__sbDOEvictOn()) {
+    let request;
+    try {
+      request = new Request(input, init);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    return __sbDORun(className, id.toString(), id, (inst) => __sbDOFetchEvent(inst, request), false);
+  }
   let req;
   let inst;
   try {
@@ -12769,6 +12951,691 @@ function __sbGetDOInstance(cls, idText, idObj) {
   return inst;
 }
 
+// ---------------------------------------------------------------------------
+// Durable Object lifecycle (design 07 stage 1c, plan 018), from compatibility date 2026-11-21: an idle object
+// leaves memory and is constructed again by its next event, so one app can hold one object per customer.
+//
+// A record per object in a worker (not the bare instance): { cls, id, key, inst, state, gate, holder, tasks, busy,
+// pins, last, dead, prev, next, ... }. `busy` counts the events that entered through __sbDORun and have not
+// finished, their waitUntil drain included; `pins` counts things that outlive an event and cannot be rebuilt (a pending
+// timer, an unawaited fetch, a streamed response); open plain sockets are checked when idleness is. The records are one
+// least-recently-idle list (`head` the stalest). An object is evicted only when __sbDOIsIdle says so, in one synchronous
+// turn (__sbDOEvict): nothing in it awaits. Before the date nothing here runs and every object stays resident.
+//
+// Settings (environment; sproutd sets them from `limits ID do-idle-ms|objects|do-wait-ms`):
+//   SB_DO_IDLE_MS  how long an object sits idle before it leaves, 100 to 600000 (default 10000; 0 turns idle eviction off)
+//   SB_DO_MAX      most objects in memory in this worker (default 16 per MiB of SB_MEMORY_LIMIT, 64 to 4096; 4096 with no limit)
+//   SB_DO_WAIT_MS  how long an object's first event waits for a slot at the cap before it fails alone (default 5000)
+//   SB_DO_QUEUE_MAX  most events queued behind one object's input gate (default 1024)
+const __SB_DO_EVICT_DATE = "2026-11-21";
+const __sbDOCtxKey = {};
+let __sbDOL = null;
+
+function __sbDOEvictOn() {
+  return __sbCompatDate() >= __SB_DO_EVICT_DATE && __sbDOGated() && __sbDOv3();
+}
+
+function __sbDOEnvNum(name, fallback, min, max) {
+  const text = __sbEnv(name);
+  if (text === "") return fallback;
+  const n = Number(text);
+  return n >= min && n <= max ? Math.trunc(n) : fallback;
+}
+
+function __sbDOLife() {
+  if (__sbDOL !== null) return __sbDOL;
+  let idle = __sbDOEnvNum("SB_DO_IDLE_MS", 10000, 100, 600000);
+  if (__sbEnv("SB_DO_IDLE_MS") === "0") idle = 0;
+  const limit = Number(__sbEnv("SB_MEMORY_LIMIT"));
+  const byLimit = limit > 0 ? Math.max(64, Math.min(4096, Math.floor(limit / 1048576) * 16)) : 4096;
+  __sbDOL = {
+    idle,
+    cap: __sbDOEnvNum("SB_DO_MAX", byLimit, 1, 100000),
+    waitMs: __sbDOEnvNum("SB_DO_WAIT_MS", 5000, 10, 600000),
+    queueMax: __sbDOEnvNum("SB_DO_QUEUE_MAX", 1024, 1, 1000000),
+    recs: {},
+    head: null,
+    tail: null,
+    count: 0,
+    waiters: [],
+    sweepArmed: false,
+    hostU: -1,
+    restoreParked: false,
+    restoreTries: {},
+    noteAt: 0,
+    noteText: "",
+    pinned: 0,
+    evictedIdle: 0,
+    evictedCap: 0,
+    evictedAbort: 0,
+    waits: 0,
+    waitMsMax: 0,
+    overloaded: 0,
+    zombie: 0,
+    wakeUsLast: 0,
+    wakeUsMax: 0,
+  };
+  __sbDOWrapTimers();
+  return __sbDOL;
+}
+
+function __sbDOEvictedError() {
+  return new Error("This Durable Object instance was evicted from memory.");
+}
+
+function __sbDOOverloaded(why) {
+  const error = new Error("Durable Object is overloaded: " + why);
+  error.overloaded = true;
+  return error;
+}
+
+// The record of the object whose event is running now (the frame the event entered carries it), or undefined.
+function __sbDOFrameRec() {
+  const frame = __sbCtxGet();
+  if (!frame) return undefined;
+  const at = __sbFrameIndex(frame, __sbDOCtxKey);
+  return at === -1 ? undefined : frame.vals[at];
+}
+
+// ---- the list: head is the stalest record, tail the freshest ----
+function __sbDOLink(L, rec) {
+  rec.prev = L.tail;
+  rec.next = null;
+  if (L.tail !== null) L.tail.next = rec;
+  else L.head = rec;
+  L.tail = rec;
+  L.count++;
+}
+function __sbDOUnlink(L, rec) {
+  if (rec.prev !== null) rec.prev.next = rec.next;
+  else L.head = rec.next;
+  if (rec.next !== null) rec.next.prev = rec.prev;
+  else L.tail = rec.prev;
+  rec.prev = null;
+  rec.next = null;
+  L.count--;
+}
+// Becomes idle now: the freshest record.
+function __sbDOFresh(L, rec, now) {
+  rec.last = now === undefined ? Date.now() : now;
+  if (L.tail === rec) return;
+  __sbDOUnlink(L, rec);
+  __sbDOLink(L, rec);
+}
+
+// ---- idleness ----
+function __sbDOSocketsFree(L, rec) {
+  const plain = rec.plain;
+  if (plain.length > 0) {
+    for (let i = plain.length - 1; i >= 0; i--) if (plain[i]._state === __SB_WS_CLOSED) plain.splice(i, 1);
+    if (plain.length > 0) return false;
+  }
+  const tcp = rec.tcp;
+  if (tcp.length > 0) {
+    for (let i = tcp.length - 1; i >= 0; i--) if (tcp[i].id === 0) tcp.splice(i, 1);
+    if (tcp.length > 0) return false;
+  }
+  const sockets = rec.holder.sockets;
+  for (let i = 0; i < sockets.length; i++) {
+    const server = sockets[i];
+    if (server._state === __SB_WS_CLOSED) continue;
+    const client = server._peer;
+    // A pair whose two ends are both in the worker, or no host that takes a socket back: nothing outside holds it.
+    if (client === null || client._host === 0) return false;
+    if (L.hostU < 0) L.hostU = __sbWsOp("U", 0, "", 0) === "1" ? 1 : 0;
+    if (L.hostU !== 1) return false;
+    // An event that left the bridge and exists only in this worker (the bridge keeps the rest of the queue).
+    if (client._inbox.length > 0 || server._inbox.length > 0 || client._flushing || server._flushing) return false;
+  }
+  return true;
+}
+function __sbDOIsIdle(L, rec) {
+  const gate = rec.gate;
+  return (
+    rec.busy === 0 &&
+    rec.pins === 0 &&
+    gate.locks === 0 &&
+    gate.waiting.length === 0 &&
+    !gate.txnBusy &&
+    gate.txnQueue.length === 0 &&
+    __sbDOSocketsFree(L, rec)
+  );
+}
+
+function __sbDOPin(rec) {
+  rec.pins++;
+  if (rec.pins === 1) {
+    rec.pinSince = Date.now();
+    __sbDOL.pinned++;
+  }
+}
+function __sbDOUnpin(rec) {
+  if (rec.pins === 0) return;
+  rec.pins--;
+  if (rec.pins !== 0) return;
+  const L = __sbDOL;
+  if (rec.dead) return;
+  L.pinned--;
+  rec.pinLogged = false;
+  if (rec.busy === 0) {
+    __sbDOFresh(L, rec);
+    __sbDOServe(L);
+    __sbDOArmSweep(L);
+  }
+}
+
+// ---- eviction: one synchronous turn, nothing awaits ----
+// The reason says why: "idle", "cap" (a slot was needed), "abort" (state.abort()), "bcw" (blockConcurrencyWhile failed).
+// `force` skips the idleness check and closes the object's sockets (abort and reset); otherwise sockets go back to the host.
+function __sbDOEvict(rec, reason, force) {
+  if (rec.dead) return false;
+  const L = __sbDOL;
+  if (!force && !__sbDOIsIdle(L, rec)) return false;
+  if (rec.registered) {
+    delete L.recs[rec.key];
+    __sbDOUnlink(L, rec);
+    rec.registered = false;
+    if (rec.pins > 0) L.pinned--;
+  }
+  // Revoke: every state method of this instance now throws the evicted error, so a leftover closure cannot write as a second instance.
+  rec.dead = true;
+  __sbDOReleaseSockets(L, rec, force);
+  if (rec.usedSql) {
+    try {
+      __sbRpc("do.sql.close", { cls: rec.cls, file: rec.sqlFile });
+    } catch (error) {
+      __sbLogUncaught("do.sql.close", error);
+    }
+  }
+  const holder = rec.holder;
+  if (holder !== null) {
+    holder.inst = null;
+    holder.rec = null;
+    holder.sockets = [];
+  }
+  rec.inst = null;
+  rec.state = null;
+  rec.plain = [];
+  rec.tcp = [];
+  if (reason === "idle") L.evictedIdle++;
+  else if (reason === "cap") L.evictedCap++;
+  else L.evictedAbort++;
+  return true;
+}
+
+// The object's hibernatable sockets go back to the host (op g: unclaimed, their queued events kept), or are closed for a reset.
+function __sbDOReleaseSockets(L, rec, force) {
+  const holder = rec.holder;
+  if (holder === null) return;
+  const sockets = holder.sockets;
+  for (let i = 0; i < sockets.length; i++) {
+    const server = sockets[i];
+    const client = server._peer;
+    if (client !== null && client._pumpTimer !== undefined) {
+      __sbClearTimeout(client._pumpTimer);
+      client._pumpTimer = undefined;
+    }
+    if (server._state === __SB_WS_CLOSED) continue;
+    if (force) {
+      try {
+        server.close(1011, "Durable Object reset");
+      } catch {
+        /* already closing */
+      }
+      continue;
+    }
+    if (client !== null && client._host > 0) {
+      const hostId = client._host;
+      client._host = 0;
+      server._state = __SB_WS_CLOSED;
+      if (!L.restoreParked) {
+        L.restoreParked = true;
+        __sbWsRestorePark();
+      }
+      __sbWsOp("g", hostId, "", 0);
+    }
+  }
+}
+
+// state.abort() and a failed blockConcurrencyWhile(): the object is forgotten (storage kept) and this instance is revoked.
+function __sbDOReset(rec, reason, error) {
+  if (rec.dead) return;
+  const L = __sbDOL;
+  rec.deadError = error === undefined ? null : error;
+  __sbDOEvict(rec, reason, true);
+  // Events waiting at its gate now fail (each finds the record dead).
+  rec.gate.locks = 0;
+  __sbDOPump(rec.gate);
+  __sbDOServe(L);
+}
+
+function __sbDOStalest(L) {
+  for (let rec = L.head; rec !== null; rec = rec.next) if (__sbDOIsIdle(L, rec)) return rec;
+  return null;
+}
+
+// The sweep: idle objects older than the timeout leave, from the stale end of the list. Bounded twice: `limit` records are looked at and at
+// most `most` leave, because an eviction closes a SQLite handle (a checkpoint and its fsyncs, about a millisecond) and the whole sweep is one
+// synchronous turn: 500 objects going at once would stop every request for half a second or more (measured: p99 1.9 s in an alarm storm).
+// What is left goes on the next tick; the cap evicts one object at a time when a slot is needed in the meantime.
+function __sbDOSweep(L, limit, most) {
+  if (L.idle === 0) return;
+  const now = Date.now();
+  let seen = 0;
+  let left = most;
+  for (let rec = L.head; rec !== null && seen < limit && left > 0; ) {
+    const next = rec.next;
+    seen++;
+    if (rec.busy === 0) {
+      if (now - rec.last < L.idle) break;
+      if (rec.pins > 0) {
+        if (!rec.pinLogged && now - rec.pinSince > 60000) {
+          rec.pinLogged = true;
+          console.error("Durable Object " + rec.cls + " has been held in memory for over 60 s by a timer, a connection or a streamed response; it cannot be evicted while that lives");
+        }
+      } else if (__sbDOEvict(rec, "idle", false)) left--;
+    }
+    rec = next;
+  }
+}
+
+// The sweep timer is parked at the host (op D): the host fires it when its deadline passes, and it is not background work, so
+// an app whose objects are all evicted is still reaped on time. A host without the op (an older sproutd) gets no timer: objects
+// then leave when the next event arrives. A standalone binary has no reaper, so a plain timer does it.
+function __sbDOArmSweep(L) {
+  if (L.sweepArmed || L.idle === 0 || L.count === 0) return;
+  let delay = L.idle;
+  if (L.head !== null) delay = Math.max(50, Math.min(L.idle, L.head.last + L.idle - Date.now()));
+  const timer = __sbSetTimeout(__sbDOSweepFire, 2147483647);
+  const parked = __sbWsOp("D", Math.trunc(delay), "", timer) === "0";
+  if (parked) {
+    L.sweepArmed = true;
+    return;
+  }
+  __sbClearTimeout(timer);
+  if (!__sbHosted()) {
+    L.sweepArmed = true;
+    __sbSetTimeout(__sbDOSweepFire, delay);
+  }
+}
+function __sbDOSweepFire() {
+  const L = __sbDOL;
+  if (L === null) return;
+  L.sweepArmed = false;
+  const before = L.evictedIdle;
+  __sbDOSweep(L, 100000, 24);
+  // Objects left: SQLite hands the pages of the databases still open back too (the quiet collection follows this timer).
+  if (L.evictedIdle !== before) {
+    try {
+      __sbRpc("do.release", {});
+    } catch (error) {
+      __sbLogUncaught("do.release", error);
+    }
+  }
+  __sbDOServe(L);
+  __sbDOArmSweep(L);
+  __sbDONote(L, true);
+}
+
+// ---- acquire: the record of an object, constructing it when it has none ----
+function __sbDOResolveId(cls, idText, idObj) {
+  const stateId = idObj || (idText.indexOf("name:") === 0 ? __sbDONamedId(cls, idText.slice(5)) : __sbDOMakeId(idText, undefined));
+  return stateId;
+}
+
+// Returns the record, or a promise of one when the cap is full and nothing is idle.
+function __sbDOAcquire(cls, idText, idObj) {
+  const L = __sbDOLife();
+  // The common case: the caller's id text is the object's canonical id, so the record is one lookup away.
+  const quick = L.recs[cls + " " + idText];
+  if (quick !== undefined) return quick;
+  if (!__sbDOClasses[cls]) throw new Error("no such Durable Object class: " + cls);
+  const stateId = __sbDOResolveId(cls, idText, idObj);
+  const id = stateId.toString();
+  const key = cls + " " + id;
+  const rec = L.recs[key];
+  if (rec !== undefined) return rec;
+  __sbDOSweep(L, 8, 4);
+  if (L.count >= L.cap) {
+    const victim = __sbDOStalest(L);
+    if (victim === null) return __sbDOWait(L, cls, id, stateId, key);
+    __sbDOEvict(victim, "cap", false);
+  }
+  return __sbDOBuild(L, cls, id, stateId, key);
+}
+
+function __sbDOWait(L, cls, id, stateId, key) {
+  L.waits++;
+  return new Promise((resolve, reject) => {
+    const w = { cls, id, stateId, key, resolve, reject, timer: 0, done: false, t0: Date.now() };
+    w.timer = __sbSetTimeout(() => {
+      if (w.done) return;
+      w.done = true;
+      const at = L.waiters.indexOf(w);
+      if (at >= 0) L.waiters.splice(at, 1);
+      L.overloaded++;
+      reject(__sbDOOverloaded("too many objects are awake in this app"));
+    }, L.waitMs);
+    L.waiters.push(w);
+  });
+}
+
+// A slot or an idle object freed: serve the waiting first events in order.
+function __sbDOServe(L) {
+  while (L.waiters.length > 0) {
+    const w = L.waiters[0];
+    let rec = L.recs[w.key];
+    if (rec === undefined) {
+      if (L.count >= L.cap) {
+        const victim = __sbDOStalest(L);
+        if (victim === null) return;
+        __sbDOEvict(victim, "cap", false);
+      }
+    }
+    L.waiters.shift();
+    w.done = true;
+    __sbClearTimeout(w.timer);
+    const waited = Date.now() - w.t0;
+    if (waited > L.waitMsMax) L.waitMsMax = waited;
+    try {
+      if (rec === undefined) rec = __sbDOBuild(L, w.cls, w.id, w.stateId, w.key);
+      w.resolve(rec);
+    } catch (error) {
+      w.reject(error);
+    }
+  }
+}
+
+// A clock finer than Date.now() for the wake counter (microseconds); the performance object is built on its first read.
+function __sbDONow() {
+  const p = globalThis.performance;
+  return p && __sbIsFn(p.now) ? p.now() : Date.now();
+}
+
+function __sbDOBuild(L, cls, id, stateId, key) {
+  const Ctor = __sbDOClasses[cls];
+  const t0 = __sbDONow();
+  if (stateId.name !== undefined) __sbDOAdopt(cls, "name:" + stateId.name, id);
+  const tasks = [];
+  const gate = __sbDOMakeGate();
+  const rec = {
+    cls,
+    id,
+    key,
+    inst: null,
+    state: null,
+    gate,
+    holder: null,
+    tasks,
+    busy: 0,
+    pins: 0,
+    pinSince: 0,
+    pinLogged: false,
+    last: Date.now(),
+    usedSql: false,
+    sqlFile: "",
+    dead: false,
+    registered: false,
+    prev: null,
+    next: null,
+    frame: null,
+    plain: [],
+    tcp: [],
+    deadError: null,
+  };
+  rec.frame = __sbFrameWith(undefined, __sbDOCtxKey, rec);
+  const state = {
+    id: stateId,
+    storage: __sbDOAsyncStorage(cls, id, gate, rec),
+    blockConcurrencyWhile(fn) {
+      if (!__sbIsFn(fn))
+        throw new TypeError("Failed to execute 'blockConcurrencyWhile' on 'DurableObjectState': parameter 1 is not of type 'function'.");
+      if (rec.dead) throw __sbDOEvictedError();
+      // No event enters until fn settles; a throw or 30 s without settling resets the object, as in workerd.
+      gate.locks++;
+      let settled = false;
+      const done = () => {
+        settled = true;
+        __sbClearTimeout(timer);
+        if (!rec.dead) {
+          gate.locks--;
+          __sbDOPump(gate);
+        }
+      };
+      const timer = __sbSetTimeout(() => {
+        if (settled) return;
+        settled = true;
+        console.error("blockConcurrencyWhile() did not settle in 30 seconds: the Durable Object " + cls + " was reset");
+        __sbDOReset(rec, "bcw", new Error("Durable Object reset because blockConcurrencyWhile() did not settle in 30 seconds."));
+      }, 30000);
+      let r;
+      try {
+        r = fn();
+      } catch (error) {
+        done();
+        __sbDOReset(rec, "bcw", new Error("Durable Object reset because blockConcurrencyWhile() threw: " + String((error && error.message) || error)));
+        return Promise.reject(error);
+      }
+      return Promise.resolve(r).then(
+        (v) => {
+          done();
+          return v;
+        },
+        (error) => {
+          done();
+          __sbDOReset(rec, "bcw", new Error("Durable Object reset because blockConcurrencyWhile() failed: " + String((error && error.message) || error)));
+          throw error;
+        },
+      );
+    },
+    waitUntil(p) {
+      if (rec.dead) throw __sbDOEvictedError();
+      if (p && __sbIsFn(p.then)) tasks.push(p);
+    },
+  };
+  state.props = {};
+  state.abort = (reason) => {
+    __sbDOReset(rec, "abort");
+    throw new Error(reason == null ? "Durable Object was aborted." : String(reason));
+  };
+  const holder = { inst: null, rec, auto: null, cls, id, restored: [], sockets: [] };
+  rec.holder = holder;
+  rec.state = state;
+  if (__sbWsEnabled()) __sbDOWebSocketState(state, holder);
+  let inst;
+  try {
+    inst = new Ctor(state, __sbEnvValue());
+  } catch (error) {
+    rec.dead = true;
+    throw error;
+  }
+  // blockConcurrencyWhile() reset the object while its constructor was still running (a synchronous throw).
+  if (rec.dead) throw new Error("The Durable Object " + cls + " was reset while it was starting.");
+  holder.inst = inst;
+  inst.__sbTasks = tasks;
+  inst.__sbGate = gate;
+  rec.inst = inst;
+  inst.__sbRec = rec;
+  L.recs[key] = rec;
+  rec.registered = true;
+  __sbDOLink(L, rec);
+  const wake = Math.round((__sbDONow() - t0) * 1000);
+  L.wakeUsLast = wake;
+  if (wake > L.wakeUsMax) L.wakeUsMax = wake;
+  // Sockets restored from hibernation start delivering now that the object exists.
+  const restored = holder.restored;
+  holder.restored = [];
+  for (let i = 0; i < restored.length; i++) __sbWsPump(restored[i]);
+  __sbDOArmSweep(L);
+  return rec;
+}
+
+// ---- run an event: the one entry for RPC, stub.fetch, alarms and socket events ----
+// `run(inst)` is the event; it enters the object's gate and runs in a frame that names the object. The returned promise settles with
+// the event's value. The object counts as busy until the event and the drain of its waitUntil tasks have settled (`wait`: the
+// returned promise waits for that drain too).
+function __sbDORun(cls, idText, idObj, run, wait) {
+  let acquired;
+  try {
+    acquired = __sbDOAcquire(cls, idText, idObj);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  if (__sbIsFn(acquired.then)) return acquired.then((rec) => __sbDOStart(rec, run, wait));
+  return __sbDOStart(acquired, run, wait);
+}
+
+function __sbDOStart(rec, run, wait) {
+  const L = __sbDOL;
+  if (rec.dead) return Promise.reject(rec.deadError !== null ? rec.deadError : __sbDOEvictedError());
+  const gate = rec.gate;
+  if (gate.waiting.length >= L.queueMax) {
+    L.overloaded++;
+    return Promise.reject(__sbDOOverloaded("too many events are queued for this object"));
+  }
+  rec.busy++;
+  // The input gate, as __sbDOEnter has it: an open gate runs the event now, a shut one queues it behind the others.
+  if (gate.locks === 0 && gate.waiting.length === 0) return __sbDOEvent(L, rec, run, wait);
+  return new Promise((resolve) => {
+    gate.waiting.push(() => {
+      resolve(__sbDOEvent(L, rec, run, wait));
+    });
+  });
+}
+
+// One event, in the object's frame; busy until it and the drain of its waitUntil tasks have settled. One coroutine and nothing else
+// per event: this path is paid by every call into every object.
+async function __sbDOEvent(L, rec, run, wait) {
+  try {
+    if (rec.dead) throw rec.deadError !== null ? rec.deadError : __sbDOEvictedError();
+    return await __sbRunInFrame(rec.frame, run, [rec.inst]);
+  } finally {
+    const drained = __sbDOSettle(L, rec, wait);
+    if (drained !== undefined) await drained;
+  }
+}
+
+// The event is over: drain its waitUntil tasks (it stays busy until they settle), then it may become idle.
+function __sbDOSettle(L, rec, wait) {
+  if (rec.tasks.length > 0) {
+    const finish = () => __sbDOIdle(L, rec);
+    const drained = __sbDrainWaitUntil(rec.tasks);
+    drained.then(finish, finish);
+    return wait ? drained.then(undefined, () => {}) : undefined;
+  }
+  __sbDOIdle(L, rec);
+  return undefined;
+}
+function __sbDOIdle(L, rec) {
+  rec.busy--;
+  if (rec.busy !== 0 || rec.dead) return;
+  const now = Date.now();
+  if (rec.pins === 0) __sbDOFresh(L, rec, now);
+  if (L.waiters.length > 0) __sbDOServe(L);
+  if (!L.sweepArmed) __sbDOArmSweep(L);
+  if (now - L.noteAt >= 1000) __sbDONote(L, true);
+}
+
+// ---- pins: a timer, an unawaited fetch and a streamed response keep their object in memory ----
+// The timer globals become wrappers once the first object is built. The prelude's own timers use __sbSetTimeout and the rest,
+// which are the runtime's, so a parked timer of ours never pins anything.
+function __sbDOWrapTimers() {
+  const armed = new Map();
+  const arm = (original, repeat) =>
+    function (callback, delay, ...args) {
+      const rec = __sbDOFrameRec();
+      if (rec === undefined || rec.dead || !__sbIsFn(callback)) return original(callback, delay, ...args);
+      const slot = { id: 0, rec };
+      __sbDOPin(rec);
+      const fired = repeat
+        ? callback
+        : function (...fireArgs) {
+            armed.delete(slot.id);
+            __sbDOUnpin(slot.rec);
+            return callback.apply(undefined, fireArgs);
+          };
+      slot.id = Number(original(fired, delay, ...args));
+      armed.set(slot.id, slot);
+      return slot.id;
+    };
+  const clear = (original) =>
+    function (id) {
+      const key = Number(id);
+      const slot = armed.get(key);
+      if (slot !== undefined) {
+        armed.delete(key);
+        __sbDOUnpin(slot.rec);
+      }
+      return original(id);
+    };
+  globalThis.setTimeout = arm(__sbSetTimeout, false);
+  globalThis.setInterval = arm(__sbSetInterval, true);
+  globalThis.clearTimeout = clear(__sbClearTimeout);
+  globalThis.clearInterval = clear(__sbClearInterval);
+}
+
+// ---- counters: cheap, one host note a second at most, only when changed ----
+function __sbDOStats(L) {
+  let sqlOpen = 0;
+  try {
+    sqlOpen = Number(__sbRpc("do.stats", {}).stats.doOpen) || 0;
+  } catch {
+    sqlOpen = 0;
+  }
+  return (
+    "objects_awake=" + L.count +
+    " objects_pinned=" + L.pinned +
+    " do_sql_open=" + sqlOpen +
+    " evicted_idle=" + L.evictedIdle +
+    " evicted_cap=" + L.evictedCap +
+    " evicted_abort=" + L.evictedAbort +
+    " waits=" + L.waits +
+    " wait_ms_max=" + L.waitMsMax +
+    " overloaded=" + L.overloaded +
+    " zombie_calls=" + L.zombie +
+    " wake_us=" + L.wakeUsLast + "," + L.wakeUsMax
+  );
+}
+function __sbDONote(L, force) {
+  const now = Date.now();
+  if (!force && now - L.noteAt < 1000) return;
+  L.noteAt = now;
+  const text = __sbDOStats(L);
+  if (text === L.noteText) return;
+  L.noteText = text;
+  if (__sbHosted()) __sbHostNote("do " + text);
+  if (__sbEnv("SB_DO_STATS") === "1") console.error("do " + text);
+}
+
+// A revoked state method: the evicted (or reset) object's instance cannot touch storage any more.
+function __sbDOZombie(rec) {
+  __sbDOL.zombie++;
+  return rec.deadError !== null ? rec.deadError : __sbDOEvictedError();
+}
+function __sbDOFetchEvent(inst, req) {
+  return __sbFetchWithDrain(inst.fetch(req), [], false, true);
+}
+function __sbWsRestorePark() {
+  const timer = __sbSetTimeout(__sbWsRestoreLoop, 2147483647);
+  __sbWsOp("R", 0, "", timer);
+}
+function __sbWsRestoreFailed(id, error) {
+  __sbLogUncaught("websocket", error);
+  if (!(error && error.overloaded === true)) return;
+  const L = __sbDOL;
+  const tries = (L.restoreTries[id] || 0) + 1;
+  L.restoreTries[id] = tries;
+  if (tries >= 3) {
+    delete L.restoreTries[id];
+    // Three waits for a slot and none came: try again later, said to the client.
+    __sbWsOp("c", id, "", 1013);
+    __sbWsOp("r", id, "", 0);
+    return;
+  }
+  // Back to the host's restore list with its queued events: the next slot serves it.
+  __sbWsOp("g", id, "", 0);
+}
+
 function __sbDOStorage(cls, id) {
   return {
     get(key) {
@@ -12866,7 +13733,7 @@ function __sbDOPump(gate) {
 // Shut the gate until the next timer turn (see above).
 function __sbDOHold(gate) {
   gate.locks++;
-  setTimeout(function () {
+  __sbSetTimeout(function () {
     gate.locks--;
     __sbDOPump(gate);
   }, 0);
@@ -12902,6 +13769,12 @@ function __sbDOEnter(gate, run) {
 // (kept on the instance, as __sbAlarmAt and __sbAlarmFails)
 function __sbDOAlarmCall(inst, cls, id, at, attempts) {
   if (__sbCompatDate() < "2026-11-04") return inst.alarm();
+  // From the eviction date the count is the delivery row's (or the host's), never the instance's: the instance can be gone
+  // between two runs of the same alarm.
+  if (__sbDOEvictOn()) {
+    const retries = attempts != null && Number(attempts) > 0 ? Number(attempts) : 0;
+    return __sbDOAlarmRun(inst, { retryCount: retries, isRetry: retries > 0 });
+  }
   const when = Number(at) || 0;
   if (inst.__sbAlarmAt !== when) {
     inst.__sbAlarmAt = when;
@@ -13212,7 +14085,8 @@ function __sbDOStrictStorage(cls, id) {
     setAlarm(when) {
       const at = when instanceof Date ? when.getTime() : when;
       if (__sbDOv3()) {
-        const inst = __sbDOInstances[cls + " " + id];
+        const live = __sbDOL !== null ? __sbDOL.recs[cls + " " + id] : undefined;
+        const inst = live !== undefined ? live.inst : __sbDOInstances[cls + " " + id];
         if (inst && !__sbIsFn(inst.alarm))
           throw new TypeError("Your Durable Object class must have an alarm() handler in order to call setAlarm()");
         if (when instanceof Date || Object(when) instanceof Number) {
@@ -13254,9 +14128,11 @@ function __sbDOStrictStorage(cls, id) {
 }
 
 // The 2026-10-28 storage: every method returns a Promise; reads shut the input gate.
-function __sbDOAsyncStorage(cls, id, gate) {
+function __sbDOAsyncStorage(cls, id, gate, rec) {
   const s = __sbDOStrictStorage(cls, id);
+  // rec is the record of an object that may be evicted (2026-11-21): once it is dead every storage call fails with the evicted error.
   const settle = (f) => {
+    if (rec !== undefined && rec.dead) return Promise.reject(__sbDOZombie(rec));
     try {
       return Promise.resolve(f());
     } catch (error) {
@@ -13264,9 +14140,13 @@ function __sbDOAsyncStorage(cls, id, gate) {
     }
   };
   const read = (f) => {
+    if (rec !== undefined && rec.dead) return Promise.reject(__sbDOZombie(rec));
     __sbDOHold(gate);
     return settle(f);
   };
+  const alive = () => {
+    if (rec !== undefined && rec.dead) throw __sbDOZombie(rec);
+  };
   const storage = {
     get: (key) => read(() => s.get(key)),
     list: (options) => read(() => s.list(options)),
@@ -13277,10 +14157,13 @@ function __sbDOAsyncStorage(cls, id, gate) {
     setAlarm: (when) => settle(() => s.setAlarm(when)),
     deleteAlarm: () => settle(() => s.deleteAlarm()),
     sync: () => Promise.resolve(),
-    transaction: (fn) => __sbDOTransaction(cls, id, s, gate, fn),
+    transaction: (fn) => {
+      if (rec !== undefined && rec.dead) return Promise.reject(__sbDOZombie(rec));
+      return __sbDOTransaction(cls, id, s, gate, fn);
+    },
   };
   if (__sbDOv2()) {
-    const sql = __sbDOSql(cls, id);
+    const sql = __sbDOSql(cls, id, rec);
     storage.sql = sql;
     storage.transactionSync = (fn) => sql.__sbTransaction(fn);
     if (__sbDOv3()) {
@@ -13292,12 +14175,22 @@ function __sbDOAsyncStorage(cls, id, gate) {
         });
       // The synchronous key-value API, over the same keys as get() and put().
       storage.kv = {
-        get: (key) => s.get(key),
+        get: (key) => {
+          alive();
+          return s.get(key);
+        },
         put: (key, value) => {
+          alive();
           s.put(key, value);
         },
-        delete: (key) => s.delete(key),
-        list: (options) => s.list(options).entries(),
+        delete: (key) => {
+          alive();
+          return s.delete(key);
+        },
+        list: (options) => {
+          alive();
+          return s.list(options).entries();
+        },
       };
       // Point-in-time recovery needs the storage engine's log, which this one does not keep.
       const pitr = () => Promise.reject(new Error("Point-in-time recovery is not supported by this Durable Object storage."));
@@ -13472,9 +14365,14 @@ function __sbDOSqlPolicy(text) {
   }
 }
 
-function __sbDOSql(cls, id) {
+function __sbDOSql(cls, id, rec) {
   const file = __sbDOIsHex64(id) ? id.toLowerCase() : __sbDOSha("sbdo-file:" + id);
+  if (rec !== undefined) rec.sqlFile = file;
   const run = (sql, params) => {
+    if (rec !== undefined) {
+      if (rec.dead) throw __sbDOZombie(rec);
+      rec.usedSql = true;
+    }
     try {
       return __sbRpc("do.sql", { cls, file, sql, params });
     } catch (err) {
@@ -14027,10 +14925,10 @@ async function __sbDrainWaitUntil(tasks, logRec) {
   // busy for the full 25 s (sproutd will not reap a worker with timers left, B22).
   let timer;
   const cap = new Promise((resolve) => {
-    timer = setTimeout(resolve, __SB_WAITUNTIL_TIMEOUT_MS);
+    timer = __sbSetTimeout(resolve, __SB_WAITUNTIL_TIMEOUT_MS);
   });
   await Promise.race([__sbDrainAll(pending, logRec), cap]);
-  clearTimeout(timer);
+  __sbClearTimeout(timer);
 }
 
 async function __sbDrainAll(pending, logRec) {
@@ -14090,7 +14988,8 @@ function __sbHasStreamBody(res) {
 // x-sb-stream header, the native writer sends the status and headers and holds the
 // connection open, and each chunk is written as it arrives. Hosts that do not stream
 // (sproutd's workers, for now) link the weak fallbacks, report unsupported and keep buffering.
-// op: "s" supported, "o" open, "w" write data, "e" end. Returns a short string.
+// op: "s" supported, "o" open, "w" write data (a bytestring), "W" write the Uint8Array in data, "p" the bytes written
+// the client's connection has not taken yet, "k" park the timer in data until that falls, "e" end. Returns a short string.
 // oxlint-disable-next-line no-unused-vars -- read inside the RawC block, not by JS.
 function __sbStreamOp(op, id, data) {
   let out = "";
@@ -14100,6 +14999,11 @@ function __sbStreamOp(op, id, data) {
     extern unsigned int sb_stream_open(void);
     extern int sb_stream_write(unsigned int, const char*, size_t);
     extern void sb_stream_end(unsigned int);
+    // Flow control (sproutd): the bytes written and not yet taken by the client's connection, and a timer the
+    // host fires when that falls. A host without them (a standalone executable, whose server buffers by itself)
+    // reports none, so a stream is never held back there.
+    extern size_t sb_stream_pending(unsigned int) __attribute__((weak));
+    extern void sb_stream_wait(unsigned int, unsigned int) __attribute__((weak));
     const char* __o; size_t __ol; char* __oo = 0;
     porf_native_fetch_read_value(op, &__o, &__ol, &__oo);
     char __op = __ol ? __o[0] : 0;
@@ -14119,7 +15023,17 @@ function __sbStreamOp(op, id, data) {
         int __w = -1;
         if (porf_native_fetch_read_raw_bytes(data, &__d, &__dl) == 0) __w = sb_stream_write(__id, __d, __dl);
         snprintf(__r, sizeof(__r), "%d", __w);
-      } else if (__op == 'e') { sb_stream_end(__id); snprintf(__r, sizeof(__r), "0"); }
+      } else if (__op == 'W' && data.type == 81) {
+        // A Uint8Array written as it is, with no bytestring copy of it.
+        const u32 __ta = (u32)data.val;
+        const int32_t __len = *(int32_t*)(MEM + __ta);
+        const u32 __at = *(u32*)(MEM + __ta + 4) + 4;
+        int __w = -1;
+        if (__len >= 0) __w = sb_stream_write(__id, (const char*)(MEM + __at), (size_t)__len);
+        snprintf(__r, sizeof(__r), "%d", __w);
+      } else if (__op == 'p') snprintf(__r, sizeof(__r), "%zu", sb_stream_pending ? sb_stream_pending(__id) : (size_t)0);
+      else if (__op == 'k') { if (sb_stream_wait && data.type == 1 && data.val > 0) sb_stream_wait(__id, (unsigned int)data.val); }
+      else if (__op == 'e') { sb_stream_end(__id); snprintf(__r, sizeof(__r), "0"); }
     }
     out = porf_box((f64)porf_native_fetch_alloc_bytestring(__r, strlen(__r)), 195);
   `;
@@ -14130,6 +15044,16 @@ function __sbStreamingSupported() {
   if (__sbStreaming < 0) __sbStreaming = __sbStreamOp("s", "0", "") === "1" ? 1 : 0;
   return __sbStreaming === 1;
 }
+// What the client's connection may hold of a stream before the pump waits for it (the host credits bytes as
+// they leave): a client slower than the app is waited for, not buffered for or cut off.
+const __SB_STREAM_WINDOW = 1024 * 1024;
+// Resolves when the host says the stream's unsent bytes fell (or the client went away).
+function __sbStreamDrained(id) {
+  return new Promise((resolve) => {
+    const timer = __sbSetTimeout(resolve, 2147483647);
+    __sbStreamOp("k", id, timer);
+  });
+}
 function __sbStreamResponse(response) {
   const stream = __sbRawBody(response);
   const id = __sbStreamOp("o", "0", "");
@@ -14137,6 +15061,14 @@ function __sbStreamResponse(response) {
   response.headers._immutable = false;
   response.headers.set("x-sb-stream", id);
   response.body = "";
+  // A streamed response of a Durable Object keeps its object busy until the stream ends (this runs in the object's frame).
+  if (__sbDOL !== null) {
+    const owner = __sbDOFrameRec();
+    if (owner !== undefined && !owner.dead) {
+      __sbDOPin(owner);
+      response._sbDOPin = owner;
+    }
+  }
   (async () => {
     const reader = stream.getReader();
     try {
@@ -14148,10 +15080,22 @@ function __sbStreamResponse(response) {
         else if (value instanceof ArrayBuffer) bytes = new Uint8Array(value);
         else if (ArrayBuffer.isView(value)) bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
         else throw new TypeError("This ReadableStream did not return bytes.");
-        if (bytes.length > 0 && __sbStreamOp("w", id, __sbToBytes(bytes)) !== "0") {
-          // The client went away: stop the source.
-          reader.cancel();
-          break;
+        if (bytes.length > 0) {
+          // A whole Uint8Array goes to the host without a copy; a view of part of a buffer is copied.
+          const wrote =
+            bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+              ? __sbStreamOp("W", id, bytes)
+              : __sbStreamOp("w", id, __sbToBytes(bytes));
+          if (wrote !== "0") {
+            // The client went away: stop the source.
+            reader.cancel();
+            break;
+          }
+          // Flow control: while the connection holds more than the window, read no more of the source.
+          while (Number(__sbStreamOp("p", id, "")) > __SB_STREAM_WINDOW) {
+            await __sbStreamDrained(id);
+            // Woken by the client going away: the next write says so (-1).
+          }
         }
       }
     } catch (error) {
@@ -14159,6 +15103,7 @@ function __sbStreamResponse(response) {
       __sbLogUncaught("fetch", error);
     }
     __sbStreamOp("e", id, "");
+    if (response._sbDOPin !== undefined) __sbDOUnpin(response._sbDOPin);
   })();
   return response;
 }
@@ -14301,6 +15246,10 @@ class __SbWebSocket {
     if (this._hib !== null) throw new TypeError("Can't accept() a WebSocket that was accepted with acceptWebSocket().");
     if (this._accepted) return;
     this._accepted = true;
+    if (__sbDOL !== null) {
+      const rec = __sbDOFrameRec();
+      if (rec !== undefined && !rec.dead) rec.plain.push(this);
+    }
     __sbWsSchedule(this);
   }
   send(message) {
@@ -14472,6 +15421,16 @@ function __sbWsDispatch(ws, event) {
 
 // A hibernatable socket's event runs the object's handler through its input gate.
 function __sbWsHibernated(ws, name, args) {
+  const rec = ws._hib.holder.rec;
+  if (rec !== undefined && rec !== null) {
+    if (rec.dead || rec.inst === null || !__sbIsFn(rec.inst[name])) return;
+    __sbDOStart(
+      rec,
+      (inst) => (name === "webSocketClose" ? inst.webSocketClose(args[0], args[1], args[2], args[3]) : inst.webSocketMessage(args[0], args[1])),
+      false,
+    ).then(undefined, (error) => __sbLogUncaught("websocket", error));
+    return;
+  }
   const inst = ws._hib.holder.inst;
   if (inst == null || !__sbIsFn(inst[name])) return;
   const run = () => {
@@ -14492,12 +15451,14 @@ function __sbWsHibernated(ws, name, args) {
 // state from 2026-10-30. `holder.inst` is the object once it exists.
 function __sbDOWebSocketState(state, holder) {
   const sockets = [];
+  holder.sockets = sockets;
   const live = () => {
     for (let i = sockets.length - 1; i >= 0; i--) if (sockets[i]._state === __SB_WS_CLOSED) sockets.splice(i, 1);
     return sockets;
   };
   __sbWsHibRestore(holder, sockets);
   state.acceptWebSocket = function (ws, tags) {
+    if (holder.rec !== undefined && holder.rec !== null && holder.rec.dead) throw __sbDOZombie(holder.rec);
     if (!(ws instanceof __SbWebSocket)) throw new TypeError("acceptWebSocket needs a WebSocket");
     if (ws._accepted || ws._hib !== null || ws._host !== 0) throw new TypeError("This WebSocket was already accepted.");
     const list = [];
@@ -14572,7 +15533,8 @@ function __sbWsPump(ws) {
   for (;;) {
     const head = __sbWsOp("p", id, "", 0);
     if (head === "") {
-      const timer = setTimeout(() => __sbWsPump(ws), 2147483647);
+      const timer = __sbSetTimeout(() => __sbWsPump(ws), 2147483647);
+      ws._pumpTimer = timer;
       // From 2026-11-01 a parked socket is not background work (z): its app may be reaped.
       __sbWsOp(__sbWsHibOn() ? "z" : "w", id, "", timer);
       return;
@@ -14661,9 +15623,9 @@ function __sbTcpPump(st) {
     if (head === "") {
       if (st.id === 0) return;
       if (__sbWsCanWake()) {
-        st.timer = setTimeout(() => __sbTcpPump(st), 2147483647);
+        st.timer = __sbSetTimeout(() => __sbTcpPump(st), 2147483647);
         __sbWsOp("w", st.id, "", st.timer);
-      } else st.timer = setTimeout(() => __sbTcpPump(st), 10);
+      } else st.timer = __sbSetTimeout(() => __sbTcpPump(st), 10);
       return;
     }
     const parts = head.split(" ");
@@ -14728,7 +15690,7 @@ function __sbTcpRelease(st) {
   const id = st.id;
   if (id === 0) return;
   st.id = 0;
-  if (st.timer !== undefined) clearTimeout(st.timer);
+  if (st.timer !== undefined) __sbClearTimeout(st.timer);
   __sbWsOp("r", id, "", 0);
   __sbTcpOpen--;
 }
@@ -14876,7 +15838,7 @@ function __sbTcpFacade(st, mode, upgrade) {
       // the old socket ends once the upgrade is under way (workerd resolves its `closed`)
       const oldResolve = st.closedResolve;
       const next = __sbTcpFacade(st, "on", upgrade);
-      setTimeout(() => oldResolve(undefined), 0);
+      __sbSetTimeout(() => oldResolve(undefined), 0);
       return next;
     },
   };
@@ -14908,7 +15870,7 @@ function __sbConnect(address, options) {
   if (target.port === 25) {
     st.failed = new Error("proxy request failed, cannot connect to the specified address");
     st.eof = true;
-    setTimeout(() => __sbTcpSettle(st), 0);
+    __sbSetTimeout(() => __sbTcpSettle(st), 0);
     return socket;
   }
   const spec = target.host + "\n" + target.port + "\n" + (mode === "on" ? "1" : mode === "starttls" ? "2" : "0") + "\n" + target.host;
@@ -14916,11 +15878,15 @@ function __sbConnect(address, options) {
   if (!(id > 0)) {
     st.failed = new Error(__sbTcpOpen >= 16 ? "Too many open connections" : "TCP sockets are not available on this host");
     st.eof = true;
-    setTimeout(() => __sbTcpSettle(st), 0);
+    __sbSetTimeout(() => __sbTcpSettle(st), 0);
     return socket;
   }
   st.id = id;
   __sbTcpOpen++;
+  if (__sbDOL !== null) {
+    const rec = __sbDOFrameRec();
+    if (rec !== undefined && !rec.dead) rec.tcp.push(st);
+  }
   __sbTcpPump(st);
   return socket;
 }
@@ -14997,10 +15963,14 @@ function __sbWsConnectOutbound(ws, input, protocols) {
   ws._accepted = true;
   ws._state = 0;
   ws.url = target.url;
+  if (__sbDOL !== null) {
+    const rec = __sbDOFrameRec();
+    if (rec !== undefined && !rec.dead) rec.plain.push(ws);
+  }
   const id = __sbWsOpen(target, list, null);
   if (!(id > 0)) {
     ws._state = __SB_WS_CLOSED;
-    setTimeout(() => {
+    __sbSetTimeout(() => {
       __sbWsFire(ws, { type: "error", target: ws });
       __sbWsFire(ws, { type: "close", code: 1006, reason: "", wasClean: false, target: ws });
     }, 0);
@@ -15019,9 +15989,9 @@ function __sbWsPumpOut(ws) {
     const head = __sbWsOp("p", id, "", 0);
     if (head === "") {
       if (__sbWsCanWake()) {
-        const timer = setTimeout(() => __sbWsPumpOut(ws), 2147483647);
+        const timer = __sbSetTimeout(() => __sbWsPumpOut(ws), 2147483647);
         __sbWsOp("w", id, "", timer);
-      } else setTimeout(() => __sbWsPumpOut(ws), 15);
+      } else __sbSetTimeout(() => __sbWsPumpOut(ws), 15);
       return;
     }
     const parts = head.split(" ");
@@ -15127,7 +16097,7 @@ function __sbWsOutClose(ws, code, text) {
     const pending = ws._pending;
     ws._pending = null;
     if (pending) pending.reject(new TypeError("WebSocket connection was closed before it opened"));
-    else setTimeout(() => {
+    else __sbSetTimeout(() => {
       __sbWsFire(ws, { type: "error", target: ws });
       __sbWsFire(ws, { type: "close", code: 1006, reason: "", wasClean: false, target: ws });
     }, 0);
@@ -15136,7 +16106,7 @@ function __sbWsOutClose(ws, code, text) {
   ws._state = __SB_WS_CLOSING;
   __sbWsOp("c", id, text, code === undefined ? 1000 : code);
   // A peer that never answers the close is dropped after a while.
-  setTimeout(() => {
+  __sbSetTimeout(() => {
     if (ws._host !== id) return;
     ws._host = 0;
     __sbWsOp("r", id, "", 0);
@@ -15329,8 +16299,7 @@ function __sbWsRestoreLoop() {
       __sbLogUncaught("websocket", error);
     }
   }
-  const timer = setTimeout(__sbWsRestoreLoop, 2147483647);
-  __sbWsOp("R", 0, "", timer);
+  __sbWsRestorePark();
 }
 function __sbWsRestoreSocket(id) {
   const r = __sbRpc("do.storage.get", { cls: "__sbws", id: "index", key: "s" + id });
@@ -15349,6 +16318,10 @@ function __sbWsRestoreSocket(id) {
     return;
   }
   // Constructing the object restores its sockets (__sbWsHibRestore) and starts their pumps.
+  if (__sbDOEvictOn()) {
+    __sbDORun(target[0], target[1], undefined, () => undefined, false).then(undefined, (error) => __sbWsRestoreFailed(id, error));
+    return;
+  }
   __sbGetDOInstance(target[0], target[1]);
 }
 
@@ -15784,7 +16757,7 @@ function __sbIngressStream(request, id) {
     const state = Number(__sbReqBodyOp("p", id, ""));
     if (state === 0) {
       // Nothing yet: the server fires this timer when bytes, the end or an error arrive.
-      const timer = setTimeout(() => step(controller, resolve), 2147483647);
+      const timer = __sbSetTimeout(() => step(controller, resolve), 2147483647);
       __sbReqBodyOp("w", id, timer);
       return;
     }
@@ -15891,7 +16864,164 @@ function __sbTrustedProxiesOnce() {
   return __sbTrustedCache;
 }
 
+// R2 transfer tickets (createUploadUrl, createDownloadUrl): /__sb/r2/transfer/BUCKET/TOKEN, scoped to one object and
+// good once. A standalone executable's native server answers them before JavaScript runs (patchR2Transfer, #195);
+// on a host that forwards every path to the worker (sproutd) the worker answers them here with the same statuses
+// and headers, before the app's fetch() sees the request. The body goes straight between the connection and the
+// object's file, one step at a time (__sbR2XferOp): at most a window of it is ever in the worker.
+const __SB_R2_TRANSFER = "/__sb/r2/transfer/";
+// Set by the embedded transport (it has the ticket contexts and their steps); the broker's own listener owns the path.
+// oxlint-disable-next-line no-unassigned-vars -- set by the embedded transport, above
+var __sbR2TransferOn; // no initializer: the embedded transport (above) sets it, and an initializer here would run after it
+// [bucket, token] when the request is for a ticket (the same shape the native server accepts), else null.
+function __sbR2TransferTarget(request) {
+  const method = request.method;
+  if (method !== "GET" && method !== "PUT" && method !== "HEAD" && method !== "POST" && method !== "DELETE") return null;
+  const url = request.url;
+  const at = url.indexOf(__SB_R2_TRANSFER);
+  if (at < 0) return null;
+  const hostEnd = url.indexOf("/", url.indexOf("//") + 2);
+  if (at !== hostEnd) return null;
+  let rest = url.slice(at + __SB_R2_TRANSFER.length);
+  const cut = rest.search(/[?#]/);
+  if (cut >= 0) rest = rest.slice(0, cut);
+  const slash = rest.indexOf("/");
+  if (slash <= 0 || slash > 255 || rest.indexOf("/", slash + 1) >= 0) return null;
+  const bucket = rest.slice(0, slash);
+  const token = rest.slice(slash + 1);
+  if (token.length !== 24 || !/^[0-9a-f]+$/.test(token) || !/^[A-Za-z0-9_]+$/.test(bucket)) return null;
+  return [bucket, token];
+}
+function __sbR2TransferError(status, text) {
+  return new Response(text, { status, headers: { "content-type": "text/plain" } });
+}
+// A transfer status as a response (the native server's table: anything else is a 500).
+function __sbR2TransferFailed(status, text) {
+  const known = status === 404 || status === 410 || status === 413 || status === 422 || status === 503 || status === 507;
+  return __sbR2TransferError(known ? status : 500, text);
+}
+// Resolves when the streamed request body `body` has more (or ended or failed): the host fires the parked timer.
+function __sbR2BodyWait(body) {
+  return new Promise((resolve) => {
+    const timer = __sbSetTimeout(resolve, 2147483647);
+    __sbReqBodyOp("w", body, timer);
+  });
+}
+async function __sbR2TransferUpload(request, bucket, token, body) {
+  let declared = 0;
+  const length = request.headers.get("content-length");
+  if (length !== null && length !== "") {
+    if (!/^[0-9]+$/.test(length) || length.length > 15) return __sbR2TransferError(400, "invalid content-length");
+    declared = Number(length);
+  }
+  const opened = __sbR2XferOp("u", bucket, token, declared).split(" ");
+  if (opened[0] !== "0") return __sbR2TransferFailed(Number(opened[0]), "R2 transfer unavailable");
+  const handle = opened[1];
+  let status = 0;
+  if (body === 0) {
+    // The host delivered the body whole (or there is none): one write.
+    const raw = __sbRawBody(request);
+    if (raw != null && raw !== "") status = Number(__sbR2XferOp("b", handle, raw, 0));
+  } else {
+    for (;;) {
+      const step = __sbR2XferOp("s", handle, "", body).split(" ");
+      const kind = step[0];
+      if (kind === "d") continue;
+      if (kind === "w") {
+        await __sbR2BodyWait(body);
+        continue;
+      }
+      if (kind === "e") break;
+      // 'f': the client went away; 's': a status refused the bytes (the ticket is released with it).
+      status = kind === "s" ? Number(step[1]) : 500;
+      if (kind === "f") __sbR2XferOp("x", "0", "", Number(handle));
+      __sbReqBodyOp("c", body, "");
+      return kind === "f" ? __sbR2TransferError(500, "R2 transfer failed") : __sbR2TransferFailed(status, "R2 transfer failed");
+    }
+    __sbReqBodyOp("c", body, "");
+  }
+  if (status !== 0) return __sbR2TransferFailed(status, "R2 transfer failed");
+  const finished = Number(__sbR2XferOp("f", handle, "", 0));
+  if (finished === 201) return new Response(null, { status: 201 });
+  return __sbR2TransferFailed(finished, "R2 transfer failed");
+}
+function __sbR2TransferDownload(request, bucket, token) {
+  const opened = __sbR2XferOp("d", bucket, token, 0).split(" ");
+  if (opened[0] !== "0") return __sbR2TransferFailed(Number(opened[0]), "R2 transfer unavailable");
+  const handle = Number(opened[1]);
+  const size = Number(opened[2]);
+  const etag = opened[3];
+  const close = () => __sbR2XferOp("c", "0", "", handle);
+  const match = request.headers.get("if-none-match");
+  if (match === "*" || match === etag || match === '"' + etag + '"') {
+    close();
+    return new Response(null, { status: 304, headers: { etag } });
+  }
+  let first = 0;
+  let last = size ? size - 1 : 0;
+  let partial = false;
+  const range = request.headers.get("range");
+  if (range) {
+    const refuse = (why) => {
+      close();
+      return __sbR2TransferError(416, why);
+    };
+    if (range.slice(0, 6) !== "bytes=") return refuse("invalid range");
+    const spec = range.slice(6);
+    const dash = spec.indexOf("-");
+    if (dash <= 0) return refuse("invalid range");
+    const from = spec.slice(0, dash);
+    const to = spec.slice(dash + 1);
+    if (!/^[0-9]+$/.test(from) || (to !== "" && !/^[0-9]+$/.test(to))) return refuse("invalid range");
+    first = Number(from);
+    if (to !== "") last = Number(to);
+    if (first >= size || last < first) return refuse("range outside object");
+    if (last >= size) last = size - 1;
+    partial = true;
+  }
+  const total = size === 0 ? 0 : last - first + 1;
+  const headers = { "content-type": "application/octet-stream", etag, "accept-ranges": "bytes", "content-length": String(total) };
+  if (partial) headers["content-range"] = "bytes " + first + "-" + last + "/" + size;
+  let sent = 0;
+  const stream = new ReadableStream({
+    pull(controller) {
+      if (sent >= total) {
+        close();
+        controller.close();
+        return;
+      }
+      const chunk = new Uint8Array(Math.min(__SB_R2_CHUNK, total - sent));
+      const got = Number(__sbR2XferOp("r", String(handle), "", first + sent, chunk));
+      if (got !== chunk.length) {
+        close();
+        controller.error(new Error("R2 transfer failed"));
+        return;
+      }
+      sent += got;
+      controller.enqueue(chunk);
+    },
+    cancel() {
+      close();
+    },
+  });
+  return new Response(stream, { status: partial ? 206 : 200, headers });
+}
+// The response for a ticket request, or a Promise of it.
+function __sbR2Transfer(request, target) {
+  // The streamed body's id, taken now: a ticket request never reaches __sbDecodeIngress.
+  const body = __sbReqBodyTake();
+  const method = request.method;
+  if (method === "GET") return __sbR2TransferDownload(request, target[0], target[1]);
+  if (method !== "PUT") return __sbR2TransferError(405, "R2 transfer requires GET or PUT");
+  return __sbR2TransferUpload(request, target[0], target[1], body);
+}
+
 globalThis.__sbEntry = function (handlers, request) {
+  if (__sbR2TransferOn) {
+    const ticket = __sbR2TransferTarget(request);
+    // Through the same finish as the app's answer (promise, then a stream body is sent as it is read).
+    if (ticket !== null) return __sbFetchWithDrain(__sbR2Transfer(request, ticket), [], false, false, true, null, null);
+  }
   __sbDecodeIngress(request);
   const trigger = __sbHeader(request.headers, "x-sb-trigger");
   if (!trigger) {
@@ -16025,6 +17155,22 @@ globalThis.__sbEntry = function (handlers, request) {
     const body = __sbReadJson(request);
     const __acls = String(body.cls || "");
     const __aid = String(body.id || "");
+    if (__sbDOEvictOn()) {
+      const none = {};
+      return __sbDORun(
+        __acls,
+        __aid,
+        undefined,
+        (instance) => (__sbIsFn(instance.alarm) ? __sbDOAlarmCall(instance, __acls, __aid, body.scheduledTime, body.attempts) : none),
+        true,
+      ).then(
+        (value) => (value === none ? new Response("no alarm handler", { status: 404 }) : new Response(null, { status: 204 })),
+        (error) => {
+          __sbLogUncaught("alarm", error);
+          return error && error.overloaded === true ? new Response("alarm deferred: too many objects are awake", { status: 503 }) : new Response("alarm failed", { status: 500 });
+        },
+      );
+    }
     const inst = __sbGetDOInstance(__acls, __aid);
     if (!__sbIsFn(inst.alarm)) return new Response("no alarm handler", { status: 404 });
     const __retries = __sbCompatDate() >= "2026-11-04";