retake-dev 0.4.0

package/src/runtime/36-scripts.js

@@ -0,0 +1,129 @@
+// Scripts and stylesheets the app adds once its clock runs (chunk loaders:
+// Turbopack, webpack, next/script, third-party tags) load in real time. Live,
+// a lazy chunk landed at 233ms; in a rebuild (from the cache) at 83ms, so the
+// code in it ran at another moment and every Math.random() after it came out
+// different (F48). With RT.holdScripts (the front server's frames), when each
+// one finished loading is recorded ({ type: "script", url, n, ok }; n counts
+// the earlier loads of that URL on this page), and a replay holds the element
+// back (preloading it) until the recording reaches that moment, then puts it
+// in and waits for it to load (scriptBusy, see settle() in 00-core.js). One
+// the recording doesn't have goes in at once, as before.
+// Native import() can't be held (Vite's lazy routes, Astro islands).
+
+let scriptBusy = 0
+const scriptSeen = new WeakSet() // elements already counted (a preview moving one back isn't a load)
+const scriptCount = new Map() // url -> loads so far on this page
+const scriptHeld = new Map() // "url#n" -> puts the held element in
+const scriptGiven = new Set() // "url#n" the replay reached before the app added it
+
+const SCRIPT_TYPES = /^(|module|text\/javascript|application\/javascript|text\/ecmascript|application\/ecmascript)$/
+function loadUrl(node) {
+  if (!node || node.nodeType !== 1) return null
+  if (node.tagName === "SCRIPT") return node.src && SCRIPT_TYPES.test((node.type || "").trim().toLowerCase()) ? node.src : null
+  if (node.tagName === "LINK") return /(^|\s)stylesheet(\s|$)/i.test(node.rel || "") && !node.disabled ? node.href || null : null
+  return null
+}
+const loadsSomething = (n) => !!n && (n.tagName === "SCRIPT" || n.tagName === "LINK") && !!loadUrl(n)
+
+// Is that load in the recording still ahead of this replay?
+function scriptAhead(url, n) {
+  for (let i = cursor.event; i < rec.events.length; i++) {
+    const e = rec.events[i]
+    if (e.type === "script" && e.url === url && e.n === n) return true
+  }
+  return false
+}
+
+// Put it in now, and have time wait for it (3s at most: one that never loads
+// mustn't stall every frame after it).
+function insertWaited(node, insert, preload) {
+  scriptBusy++
+  let done = false
+  const end = () => {
+    if (done) return
+    done = true
+    scriptBusy--
+  }
+  node.addEventListener("load", end, { once: true })
+  node.addEventListener("error", end, { once: true })
+  real.setTimeout(end, 3000)
+  if (preload) preload.remove()
+  return insert()
+}
+
+// The app adding a script or stylesheet (`insert` does it for real).
+function trackLoad(node, insert) {
+  if (!clock.booted || previewing || scriptSeen.has(node) || !rec) return insert()
+  const url = loadUrl(node)
+  if (!url) return insert()
+  scriptSeen.add(node)
+  const n = scriptCount.get(url) || 0
+  scriptCount.set(url, n + 1)
+  const key = url + "#" + n
+  if (!hasFuture() && !clock.seeking) {
+    // Live: when it's in is recorded.
+    const done = (ok) => recordEvent(ok ? { type: "script", url, n } : { type: "script", url, n, ok: false })
+    node.addEventListener("load", () => done(true), { once: true })
+    node.addEventListener("error", () => done(false), { once: true })
+    return insert()
+  }
+  if (scriptGiven.delete(key)) return insertWaited(node, insert)
+  if (!scriptAhead(url, n)) return insert()
+  // Held until its moment; fetched meanwhile, so it's in the cache by then.
+  let preload = null
+  try {
+    preload = document.createElement("link")
+    preload.rel = "preload"
+    preload.as = node.tagName === "SCRIPT" ? "script" : "style"
+    if (node.crossOrigin != null) preload.crossOrigin = node.crossOrigin
+    preload.href = url
+    scriptOrig.appendChild.call(document.head || document.documentElement, preload)
+  } catch {}
+  scriptHeld.set(key, () => insertWaited(node, insert, preload))
+  return node
+}
+
+// The recording reached a load.
+function deliverScript(ev) {
+  const key = ev.url + "#" + ev.n
+  const go = scriptHeld.get(key)
+  if (!go) return scriptGiven.add(key)
+  scriptHeld.delete(key)
+  go()
+}
+// At the live edge nothing more is coming from the recording (it was cut, or
+// forked): whatever is still held goes in.
+function releaseHeldScripts() {
+  if (!scriptHeld.size || hasFuture()) return
+  const all = [...scriptHeld.values()]
+  scriptHeld.clear()
+  for (const go of all) go()
+}
+
+const scriptOrig = { appendChild: Node.prototype.appendChild, insertBefore: Node.prototype.insertBefore }
+if (RT.holdScripts) {
+  const NP = Node.prototype
+  NP.appendChild = function (node) {
+    if (!loadsSomething(node)) return scriptOrig.appendChild.call(this, node)
+    return trackLoad(node, () => scriptOrig.appendChild.call(this, node))
+  }
+  NP.insertBefore = function (node, ref) {
+    if (!loadsSomething(node)) return scriptOrig.insertBefore.call(this, node, ref)
+    return trackLoad(node, () => scriptOrig.insertBefore.call(this, node, ref))
+  }
+  // append/prepend/before/after take several nodes: with a script among them,
+  // each goes in on its own, in the same order.
+  const EP = Element.prototype
+  for (const m of ["append", "prepend", "before", "after"]) {
+    const orig = EP[m]
+    if (typeof orig !== "function") continue
+    const reversed = m === "prepend" || m === "after"
+    EP[m] = function (...nodes) {
+      if (!nodes.some(loadsSomething)) return orig.apply(this, nodes)
+      for (const n of reversed ? nodes.reverse() : nodes) {
+        if (loadsSomething(n)) trackLoad(n, () => orig.call(this, n))
+        else orig.call(this, n)
+      }
+    }
+  }
+}

package/src/runtime/37-next.js

@@ -0,0 +1,150 @@
+// Next.js 16's debug channel (F49). In development, Next sends React's debug
+// data for each request over its HMR socket, keyed by the request's
+// `x-nextjs-request-id` header, and React waits for that stream (and its
+// end) before it shows a soft navigation or a server action's result. A
+// replayed request never reached the server, so nothing would come. So the
+// debug data that arrives for a recorded request is kept with it
+// (`entry.debug`), and a replay hands it, then its end, to Next's HMR client
+// the way the server sent it: the data as the answer starts, the end once the
+// answer has ended.
+//
+// The page's own debug data (for its HTML request, `self.__next_r`) is kept
+// with its segment too: a rebuild given the page as it was recorded (F56)
+// gets it the same way, since the server sent it to the original page only.
+//
+// The message (next@16.3, client/dev/hot-reloader/app/web-socket.js) is
+// binary: [0 (REACT_DEBUG_CHUNK), id length, id bytes, chunk bytes]; no chunk
+// bytes means the stream has ended. Only for the Next version the server
+// detected (RT.next); any other version gets the CLI's warning only.
+// RT.next "auto": the server knows it's Next but not which (fronting a bare
+// URL, `retake http://localhost:3000`): Next's client says, `window.next.version`,
+// set before it connects its HMR socket or sends a request.
+
+const nextOn = () => RT.next === 16 || (RT.next === "auto" && /^16\./.test(String((W.next && W.next.version) || "")))
+const nextLive = new Map() // request id -> the recorded fetch entry it's for (live requests)
+let nextOwn = false // dispatching our own message (not the server's)
+const nextQueue = [] // [id, chunk bytes | null] waiting for Next's HMR socket
+const nextId = (headers) => (nextOn() && headers && headers.get("x-nextjs-request-id")) || null
+
+// A live request Next will send debug data for: keep it with the recording.
+function nextLiveRequest(entry, headers) {
+  const id = nextId(headers)
+  if (!id) return
+  nextLive.set(id, entry)
+  if (nextLive.size > 200) nextLive.delete(nextLive.keys().next().value)
+}
+// A message on Next's HMR socket (the server's): debug data for a live request.
+function nextDevMessage(e) {
+  if (nextOwn || !nextOn() || !(e.data instanceof ArrayBuffer) || e.data.byteLength < 2) return
+  const bytes = new Uint8Array(e.data)
+  if (bytes[0] !== 0) return
+  const len = bytes[1]
+  if (bytes.length <= 2 + len) return
+  const id = new TextDecoder().decode(bytes.subarray(2, 2 + len))
+  const chunk = toB64(bytes.subarray(2 + len))
+  const entry = nextLive.get(id)
+  if (entry) (entry.debug || (entry.debug = [])).push(chunk)
+  else if (id === W.__next_r && RT.docId && !RT.docStored && rec) {
+    // This page's own: kept with the segment this page is (rec itself for the first).
+    const seg = rec.doc === RT.docId ? rec : (rec.segments || []).find((s) => s.doc === RT.docId)
+    if (seg) (seg.docDebug || (seg.docDebug = [])).push(chunk)
+  }
+}
+
+// Next's HMR socket names the page's request (`/_next/hmr?id=<__next_r>`), and
+// the server keeps one socket per id: when one closes, the id is dropped, along
+// with whichever socket last registered it. A page served as it was recorded
+// (F56) carries the recorded page's id, shared with the frame it was recorded
+// in and every other build of it, so swapping one in for another left the new
+// frame's socket without hot updates. Such a page's socket gets an id of its own
+// (its debug data comes from the recording, below, not from the server).
+//
+// The server also sends a live request's debug data to the socket registered
+// under the request's `x-nextjs-html-request-id` (= `__next_r`): with no socket
+// under that id any more, a soft navigation or server action made live from
+// such a frame waited for ever. So its live requests carry the socket's id
+// (`nextLiveInit`).
+let nextSocketId = null
+function nextSocketUrl(url) {
+  if (!RT.docStored || !W.__next_r) return url
+  try {
+    const u = new URL(String(url), location.href)
+    if (!/^\/_next\/(webpack-)?hmr\b/.test(u.pathname) || u.searchParams.get("id") !== W.__next_r) return url
+    nextSocketId = nextSocketId || `${W.__next_r}-retake-${Math.round(performance.timeOrigin + real.perfNow()).toString(36)}${real.random().toString(36).slice(2, 6)}`
+    u.searchParams.set("id", nextSocketId)
+    return u.href
+  } catch {
+    return url
+  }
+}
+// A server component edit makes Next's router refetch the page's RSC payload,
+// marked `next-hmr-refresh: 1`. It's the dev server's doing, not the app's:
+// recorded, a later edit's refetch in a frame with a future (after a rewind)
+// was answered with the payload of the edit before, and the page kept showing
+// old code (F77). It goes to the network, unrecorded, like the HMR socket.
+const nextHmrRefresh = (headers) => !!headers && headers.get("next-hmr-refresh") === "1"
+
+// A live request from such a page: [input, init] naming its socket, not the page.
+const HTML_ID = "x-nextjs-html-request-id"
+function nextLiveInit(input, init) {
+  if (!nextSocketId) return [input, init]
+  try {
+    if (init && init.headers) {
+      const h = new Headers(init.headers)
+      if (h.get(HTML_ID) !== W.__next_r) return [input, init]
+      h.set(HTML_ID, nextSocketId)
+      return [input, { ...init, headers: h }]
+    }
+    if (typeof Request !== "undefined" && input instanceof Request && input.headers.get(HTML_ID) === W.__next_r) {
+      const r = new Request(input, init)
+      r.headers.set(HTML_ID, nextSocketId)
+      return [r, undefined]
+    }
+  } catch {}
+  return [input, init]
+}
+
+// A page served as it was recorded: its debug data comes from the recording.
+let nextDocSent = false
+function nextDocReplay() {
+  if (nextDocSent || !nextOn() || !RT.docStored || !W.__next_r || !rec) return
+  nextDocSent = true
+  const seg = segmentsOf().find((s) => s.doc === RT.docId)
+  for (const b64 of (seg && seg.docDebug) || []) nextQueue.push([W.__next_r, fromB64(b64)])
+  nextQueue.push([W.__next_r, null])
+}
+
+// A replayed request's answer starts: its debug data goes to Next.
+function nextReplayStart(entry, headers) {
+  const id = nextId(headers)
+  if (!id) return
+  for (const b64 of entry.debug || []) nextQueue.push([id, fromB64(b64)])
+  flushNext()
+}
+// ...and ends: so does its debug stream.
+function nextReplayEnd(headers) {
+  const id = nextId(headers)
+  if (!id) return
+  nextQueue.push([id, null])
+  flushNext()
+}
+function flushNext() {
+  if (!nextQueue.length) return
+  let ws = null
+  for (const w of devSockets) if (/\/_next\/hmr\b/.test(w.url) && w.readyState === 1) ws = w
+  if (!ws) return // sent once the socket opens (see 35-network.js)
+  for (const [id, chunk] of nextQueue.splice(0)) {
+    const idBytes = new TextEncoder().encode(id)
+    if (idBytes.length > 255) continue
+    const data = new Uint8Array(2 + idBytes.length + (chunk ? chunk.length : 0))
+    data[1] = idBytes.length
+    data.set(idBytes, 2)
+    if (chunk) data.set(chunk, 2 + idBytes.length)
+    nextOwn = true
+    try {
+      ws.dispatchEvent(new MessageEvent("message", { data: data.buffer, origin: new URL(ws.url).origin }))
+    } catch {} finally {
+      nextOwn = false
+    }
+  }
+}

package/src/runtime/38-observers.js

@@ -0,0 +1,252 @@
+// Things the browser tells the app on its own schedule: IntersectionObserver
+// and ResizeObserver callbacks (on real rendering steps) and Worker messages
+// (from another thread). Each delivery is recorded with its entries and
+// moment and replayed from the recording, so they land at the same virtual
+// time and with the same values.
+
+// ---- IntersectionObserver / ResizeObserver --------------------------------------
+
+let obsSeq = 0
+const observers = new Map() // creation order -> wrapper
+
+const rectOf = (r) => (r ? [r.x, r.y, r.width, r.height] : null)
+const toRect = (a) => (a ? DOMRectReadOnly.fromRect({ x: a[0], y: a[1], width: a[2], height: a[3] }) : null)
+const sizeOf = (list) => [...(list || [])].map((s) => [s.inlineSize, s.blockSize])
+const toSizes = (a) => (a || []).map(([inlineSize, blockSize]) => ({ inlineSize, blockSize }))
+
+function wrapObserver(Real, pack, unpack) {
+  const Wrapped = function (callback, options) {
+    if (!new.target) throw new TypeError("Failed to construct: Please use the 'new' operator")
+    const self = this
+    this._id = ++obsSeq
+    this._cb = callback
+    this._targets = []
+    this._off = false
+    observers.set(this._id, this)
+    this._real = new Real((entries) => self._got(entries), options)
+  }
+  Wrapped.prototype.observe = function (target, opts) {
+    if (!this._targets.includes(target)) this._targets.push(target)
+    this._off = false
+    return this._real.observe(target, opts)
+  }
+  Wrapped.prototype.unobserve = function (target) {
+    return this._real.unobserve(target)
+  }
+  Wrapped.prototype.disconnect = function () {
+    this._off = true
+    return this._real.disconnect()
+  }
+  Wrapped.prototype.takeRecords = function () {
+    return this._real.takeRecords ? this._real.takeRecords() : []
+  }
+  for (const k of ["root", "rootMargin", "thresholds", "scrollMargin", "delay", "trackVisibility"]) {
+    Object.defineProperty(Wrapped.prototype, k, {
+      get() {
+        return this._real[k]
+      },
+    })
+  }
+  Wrapped.prototype._got = function (entries) {
+    // In the past, the recording delivers them; while rebuilding, too.
+    if (hasFuture() || clock.seeking) return
+    const data = []
+    for (const e of entries) {
+      let k = this._targets.indexOf(e.target)
+      if (k < 0) {
+        this._targets.push(e.target)
+        k = this._targets.length - 1
+      }
+      data.push(pack(e, k))
+    }
+    recordEvent({ type: "obs", o: this._id, entries: data })
+    this._deliver(data)
+  }
+  Wrapped.prototype._deliver = function (data) {
+    if (this._off) return
+    const list = data.map((d) => unpack(d, this._targets[d.k])).filter((e) => e.target)
+    if (list.length) safeCall(this._cb, [list, this])
+  }
+  return Wrapped
+}
+
+function deliverObserved(ev) {
+  const o = observers.get(ev.o)
+  if (o) o._deliver(ev.entries)
+}
+
+if (W.IntersectionObserver) {
+  W.IntersectionObserver = wrapObserver(
+    W.IntersectionObserver,
+    (e, k) => ({ k, i: e.isIntersecting ? 1 : 0, r: e.intersectionRatio, b: rectOf(e.boundingClientRect), n: rectOf(e.intersectionRect), rb: rectOf(e.rootBounds), v: e.isVisible ? 1 : 0 }),
+    (d, target) => ({
+      target,
+      time: performance.now(),
+      isIntersecting: !!d.i,
+      intersectionRatio: d.r,
+      boundingClientRect: toRect(d.b),
+      intersectionRect: toRect(d.n),
+      rootBounds: toRect(d.rb),
+      isVisible: !!d.v,
+    }),
+  )
+}
+if (W.ResizeObserver) {
+  W.ResizeObserver = wrapObserver(
+    W.ResizeObserver,
+    (e, k) => ({ k, cr: rectOf(e.contentRect), bb: sizeOf(e.borderBoxSize), cb: sizeOf(e.contentBoxSize), dp: sizeOf(e.devicePixelContentBoxSize) }),
+    (d, target) => ({
+      target,
+      contentRect: toRect(d.cr),
+      borderBoxSize: toSizes(d.bb),
+      contentBoxSize: toSizes(d.cb),
+      devicePixelContentBoxSize: toSizes(d.dp),
+    }),
+  )
+}
+
+// ---- Workers ------------------------------------------------------------------------
+// A worker's messages are recorded (when they're plain data) and replayed
+// without starting the worker. A worker that sends anything else (transferables,
+// class instances) runs for real on replay too, and isn't deterministic.
+
+let workerSeq = 0
+const workers = new Map()
+const clockedWorkers = new Set()
+function tickWorkers(t) {
+  for (const w of clockedWorkers) {
+    if (w._clocked && w._real && !w._dead) {
+      try {
+        w._real.postMessage({ __retakeTick: t })
+      } catch {}
+    }
+  }
+}
+const RealWorker = W.Worker
+
+function plainData(v, depth = 0) {
+  if (depth > 50) return false
+  if (v === null || ["string", "number", "boolean", "undefined"].includes(typeof v)) return true
+  if (Array.isArray(v)) return v.every((x) => plainData(x, depth + 1))
+  if (typeof v === "object" && Object.getPrototypeOf(v) === Object.prototype) return Object.values(v).every((x) => plainData(x, depth + 1))
+  return false
+}
+
+// Workers run on the page's virtual clock too: each one starts with a prelude
+// that replaces its timers, rAF, performance.now, Date and Math.random with
+// versions driven by the page (a tick per frame) and seeded per worker, then
+// loads the real worker script. So a worker drawing confetti on an
+// OffscreenCanvas draws the same thing at the same moment on every replay.
+function workerPrelude(url, type, seedFor, epochAt) {
+  const load = type === "module" ? `await import(${JSON.stringify(url)})` : `importScripts(${JSON.stringify(url)})`
+  return `(() => {
+  const BASE = ${JSON.stringify(url)}, PERF = 1000, EPOCH = ${epochAt}
+  let now = 0, state = ${seedFor} >>> 0, seq = 1
+  const timers = new Map(), rafs = new Map()
+  Math.random = () => { state = (state + 0x6d2b79f5) >>> 0; let x = state; x = Math.imul(x ^ (x >>> 15), x | 1); x ^= x + Math.imul(x ^ (x >>> 7), x | 61); return ((x ^ (x >>> 14)) >>> 0) / 4294967296 }
+  performance.now = () => now + PERF
+  const RD = Date
+  function VDate(...a) { if (!new.target) return new RD(EPOCH + now).toString(); return a.length ? new RD(...a) : new RD(EPOCH + now) }
+  VDate.prototype = RD.prototype; VDate.now = () => EPOCH + now; VDate.parse = RD.parse; VDate.UTC = RD.UTC
+  self.Date = VDate
+  const add = (fn, d, a, rep) => { const id = seq++; const delay = Math.max(rep ? 4 : 0, Number(d) || 0); timers.set(id, { fn, a, due: now + delay, delay, rep }); return id }
+  self.setTimeout = (fn, d, ...a) => (typeof fn === "function" ? add(fn, d, a, false) : 0)
+  self.setInterval = (fn, d, ...a) => (typeof fn === "function" ? add(fn, d, a, true) : 0)
+  self.clearTimeout = self.clearInterval = (id) => timers.delete(id)
+  self.requestAnimationFrame = (cb) => { const id = seq++; rafs.set(id, cb); return id }
+  self.cancelAnimationFrame = (id) => rafs.delete(id)
+  if (self.importScripts) { const ri = self.importScripts.bind(self); self.importScripts = (...u) => ri(...u.map((x) => new URL(x, BASE).href)) }
+  function advance(t) {
+    for (let n = 0; n < 5000; n++) {
+      let best = null
+      for (const x of timers.values()) if (x.due <= t && (!best || x.due < best.due)) best = x
+      if (!best) break
+      now = Math.max(now, best.due)
+      if (best.rep) best.due += best.delay; else for (const [k, v] of timers) if (v === best) timers.delete(k)
+      try { best.fn(...best.a) } catch (e) { setTimeout(() => { throw e }) }
+    }
+    now = t
+    const q = [...rafs.values()]; rafs.clear()
+    for (const cb of q) try { cb(now + PERF) } catch (e) {}
+  }
+  self.addEventListener("message", (e) => { if (e.data && e.data.__retakeTick != null) { e.stopImmediatePropagation(); advance(e.data.__retakeTick) } })
+})();
+${load}
+`
+}
+
+if (RealWorker) {
+  class RetakeWorker extends EventTarget {
+    constructor(url, opts) {
+      if (isExempt()) return new RealWorker(url, opts)
+      super()
+      this.onmessage = this.onerror = this.onmessageerror = null
+      this._id = ++workerSeq
+      workers.set(this._id, this)
+      const list = rec.workers || (rec.workers = {})
+      const known = list[this._id]
+      if (hasFuture() && known && known.ok) {
+        this._replay = true // messages come from the recording
+        return
+      }
+      if (!known) list[this._id] = { url: String(url), ok: true }
+      let real = null
+      try {
+        const abs = new URL(String(url), location.href).href
+        const type = opts && opts.type === "module" ? "module" : "classic"
+        const code = workerPrelude(abs, type, (seed ^ Math.imul(this._id, 0x9e3779b1)) >>> 0, rec.epoch)
+        const blob = URL.createObjectURL(new Blob([code], { type: "text/javascript" }))
+        real = new RealWorker(blob, { ...opts, type: type === "module" ? "module" : "classic" })
+        this._clocked = true
+      } catch {
+        real = new RealWorker(url, opts) // e.g. a CSP that forbids blob: workers
+      }
+      this._real = real
+      clockedWorkers.add(this)
+      this._real.onmessage = (e) => this._got(e.data)
+      this._real.onmessageerror = (e) => this._emit("messageerror", e)
+      this._real.onerror = (e) => {
+        const ev = new ErrorEvent("error", { message: e.message, filename: e.filename, lineno: e.lineno, colno: e.colno, error: e.error })
+        this._emit("error", ev)
+        if (ev.defaultPrevented) e.preventDefault()
+      }
+    }
+    _emit(type, ev) {
+      const prop = this["on" + type]
+      if (typeof prop === "function") safeCall(prop.bind(this), [ev])
+      this.dispatchEvent(ev)
+    }
+    _got(data) {
+      arrive(() => {
+        if (!hasFuture() && !clock.seeking) {
+          const entry = rec.workers[this._id]
+          if (entry && entry.ok && plainData(data)) recordEvent({ type: "worker", w: this._id, d: data === undefined ? { $u: 1 } : { v: data } })
+          else if (entry) entry.ok = false
+        }
+        this._emit("message", new MessageEvent("message", { data }))
+      })
+    }
+    postMessage(msg, transfer) {
+      // A worker handed a canvas draws on the page: it has to run for real on
+      // replays (on the virtual clock), not be stood in for by its messages.
+      const list = [].concat((transfer && transfer.transfer) || transfer || [])
+      if (typeof OffscreenCanvas !== "undefined" && list.some((x) => x instanceof OffscreenCanvas)) {
+        const entry = rec.workers && rec.workers[this._id]
+        if (entry) entry.ok = false
+      }
+      if (this._real) this._real.postMessage(msg, transfer)
+    }
+    terminate() {
+      this._dead = true
+      clockedWorkers.delete(this)
+      if (this._real) this._real.terminate()
+    }
+  }
+  W.Worker = RetakeWorker
+}
+
+function deliverWorker(ev) {
+  const w = workers.get(ev.w)
+  if (!w || !w._replay || w._dead) return
+  w._emit("message", new MessageEvent("message", { data: ev.d && "v" in ev.d ? ev.d.v : undefined }))
+}