buninu-browser 0.5.1 → 0.6.0

package/lib/renderer/video-presentation.js

@@ -1,4 +1,5 @@
 import { seekVideoKeyframe } from "../media/video-keyframe.js";
+import { captureViewport } from "../paint/frame.js";
 
 // Runs in the compositor Worker, never in the page's JavaScript turn. Both
 // queue duration and decoded pixel memory are bounded. No audio extrapolation.
@@ -15,15 +16,27 @@ export class VideoPresentation {
     this.stop();
     const epoch = this.epoch;
     this.config = config;
+    this.revision = 0;
+    this.exhaustedReported = false;
+    this.extension = null;
+    this.continuationFloor = null;
     config.started = performance.now();
     try {
       const decoder = await this.engine.decode(config.bytes, config.options);
+      // WASM opens synchronously: audio timing messages may still be queued
+      // behind it. Yield a task before choosing the resumed frame position.
+      await new Promise(resolve => setTimeout(resolve, 0));
       if (epoch !== this.epoch) { decoder.close(); return; }
       this.decoder = decoder;
       const startTime = config.startTime ?? 0;
       const endTime = config.endTime ?? Infinity;
-      this.nextTime = config.time >= endTime ? endTime
-        : config.time > startTime ? seekVideoKeyframe(decoder, config.time, startTime) : startTime;
+      // Opening a growing snapshot can take time while audio keeps playing.
+      // Seek against its latest measured clock, not the stale open request.
+      // Keep the original clock anchor: changing config.time would count the
+      // opening delay twice for a video whose clock advances without audio.
+      this.resumeTime = Math.min(endTime, Math.max(config.time, this.time()));
+      this.nextTime = this.resumeTime >= endTime ? endTime
+        : this.resumeTime > startTime ? seekVideoKeyframe(decoder, this.resumeTime, startTime, config.bytes) : startTime;
       this.width = Math.max(1, Math.min(480, decoder.width));
       this.height = Math.max(1, Math.round(this.width * decoder.height / Math.max(1, decoder.width)));
       if (this.height > 480) {
@@ -39,6 +52,7 @@ export class VideoPresentation {
   stop(id) {
     if (id !== undefined && this.config?.id !== id) return;
     this.epoch++;
+    this.extension = null;
     clearTimeout(this.timer);
     this.decoder?.close();
     this.decoder = null;
@@ -53,6 +67,8 @@ export class VideoPresentation {
     this.clocks.set(id, seconds);
     // Audio stream identifiers increase monotonically within this renderer.
     if (this.clocks.size > 32) this.clocks.delete(this.clocks.keys().next().value);
+    if (this.config?.audioId != null && (this.decoder || this.extension || this.eof) && this.config.audioId === id)
+      this.present(this.time());
   }
   bind(id, audioId, audioStart, time, endTime) {
     if (this.config?.id !== id) return;
@@ -66,6 +82,69 @@ export class VideoPresentation {
       this.queue = this.queue.filter(frame => frame.time + 1e-6 < endTime);
     }
   }
+  // Only an exhausted snapshot of this same source/configuration can grow.
+  // Preserve its queued frames and measured clock while replacing the decoder;
+  // stop/open still owns seeks, pauses, navigation and configuration changes.
+  async extend(request) {
+    const current = this.config;
+    if (!current || request.id !== current.id || request.revision !== this.revision || this.extension) return false;
+    const reject = error => {
+      this.report({ id: current.id, revision: this.revision, continuationError: String(error) });
+      return false;
+    };
+    if (!this.eof || !Number.isSafeInteger(current.generation) || request.snapshotId !== current.snapshotId
+      || !Number.isSafeInteger(request.generation) || request.generation <= current.generation
+      || !(request.bytes instanceof Uint8Array) || request.bytes.length <= current.bytes.length
+      || !Number.isFinite(request.boundary) || Math.abs(request.boundary - this.nextTime) > 1e-6)
+      return reject("stale video snapshot continuation");
+    const epoch = this.epoch, boundary = this.nextTime;
+    const expected = { width: this.decoder?.width, height: this.decoder?.height, fps: this.decoder?.fps };
+    const extension = this.extension = request;
+    this.decoder?.close();
+    this.decoder = null;
+    let decoder;
+    try {
+      decoder = await this.engine.decode(request.bytes, current.options);
+      await new Promise(resolve => setTimeout(resolve, 0));
+      if (epoch !== this.epoch || this.config !== current || this.extension !== extension) {
+        decoder.close();
+        return false;
+      }
+      if (decoder.width !== expected.width || decoder.height !== expected.height || decoder.fps !== expected.fps)
+        throw new Error("video snapshot configuration changed");
+      if (boundary + 1e-6 >= (current.endTime ?? Infinity))
+        throw new Error("video continuation crossed its configuration boundary");
+      const start = current.startTime ?? 0;
+      this.nextTime = boundary > start ? seekVideoKeyframe(decoder, boundary, start, request.bytes) : start;
+      this.decoder = decoder;
+      decoder = null;
+      this.resumeTime = boundary;
+      // Old queued frames own every timestamp before the decoded boundary.
+      // A containing GOP frame must not be queued twice after seeking back.
+      this.continuationFloor = boundary;
+      current.bytes = request.bytes;
+      current.generation = request.generation;
+      this.revision++;
+      this.eof = false;
+      this.reportedEnd = false;
+      this.exhaustedReported = false;
+      this.extension = null;
+    } catch (error) {
+      decoder?.close();
+      if (epoch === this.epoch && this.config === current && this.extension === extension) {
+        this.extension = null;
+        this.nextTime = Math.min(boundary, current.endTime ?? Infinity);
+        reject(error);
+        this.present(this.time());
+      }
+      return false;
+    }
+    // Commit the new revision before any of its time/EOF reports arrive.
+    this.report({ id: current.id, revision: this.revision, continued: request.generation });
+    clearTimeout(this.timer);
+    this.step();
+    return true;
+  }
   time() {
     const c = this.config;
     if (c.audioId != null) return c.audioStart + (this.clocks.get(c.audioId) ?? 0);
@@ -73,21 +152,55 @@ export class VideoPresentation {
     if (c.hasAudio) return c.time;
     return c.time + (performance.now() - c.started) / 1000;
   }
+  // An already decoded frame can become due between decode turns. Publish it
+  // when measured audio advances, without another decode or an estimated clock.
+  // The queue is consumed synchronously by both callers, so a frame is sent once.
+  present(time) {
+    let latest = null;
+    while (this.queue.length && this.queue[0].time <= time + 1e-6) latest = this.queue.shift();
+    if (latest) {
+      this.frame = latest;
+      if (this.config.shared) {
+        const meta = new Int32Array(this.config.shared, 0, 4);
+        Atomics.add(meta, 0, 1);
+        new Uint8Array(this.config.shared, 16, latest.pixels.length).set(latest.pixels);
+        Atomics.store(meta, 1, latest.width);
+        Atomics.store(meta, 2, latest.height);
+        Atomics.add(meta, 0, 1);
+      }
+      this.changed();
+      this.report({ id: this.config.id, time: latest.time,
+        ...(Number.isSafeInteger(this.config.generation) ? { revision: this.revision } : {}) });
+    }
+    if (this.eof && !this.extension && !this.queue.length && time >= this.nextTime && !this.reportedEnd) {
+      this.reportedEnd = true;
+      this.report({ id: this.config.id, end: this.nextTime,
+        ...(Number.isSafeInteger(this.config.generation) ? { revision: this.revision } : {}) });
+    }
+  }
   step() {
-    if (!this.decoder || !this.config) return;
+    if (!this.config) return;
+    if (!this.decoder) {
+      this.present(this.time());
+      if (this.extension || (this.eof && !this.reportedEnd)) this.timer = setTimeout(() => this.step(), 10);
+      else this.timer = null;
+      return;
+    }
     const time = this.time();
     const endTime = this.config.endTime ?? Infinity;
     const deadline = performance.now() + 8;
     try {
       while (!this.eof && this.queue.length < this.limit && this.nextTime <= time + 0.75
         && this.nextTime + 1e-6 < endTime) {
-        const pixels = this.decoder.nextFrame(this.width, this.height);
+        const duration = 1 / (this.decoder.fps || 30);
+        const keep = this.nextTime + duration > Math.max(this.config.time, this.resumeTime)
+          && (this.continuationFloor == null || this.nextTime + 1e-6 >= this.continuationFloor);
+        // Preserve codec dependencies while discarding a reopened GOP's prefix.
+        // Only frames that can enter the queue need full-size RGBA conversion.
+        const pixels = this.decoder.nextFrame(keep ? this.width : 1, keep ? this.height : 1);
         if (!pixels) { this.eof = true; break; }
-        const frame = { pixels, time: this.nextTime, width: this.width, height: this.height };
-        this.nextTime += 1 / (this.decoder.fps || 30);
-        // A reopened decoder starts at an earlier keyframe. Decode through
-        // that prefix without flashing it over the last displayed picture.
-        if (frame.time + 1 / (this.decoder.fps || 30) > this.config.time) this.queue.push(frame);
+        if (keep) this.queue.push({ pixels, time: this.nextTime, width: this.width, height: this.height });
+        this.nextTime += duration;
         if (performance.now() >= deadline) break;
       }
     } catch {
@@ -101,45 +214,197 @@ export class VideoPresentation {
       this.eof = true;
       this.nextTime = endTime;
     }
-    let latest = null;
-    while (this.queue.length && this.queue[0].time <= time + 1e-6) latest = this.queue.shift();
-    if (latest) {
-      this.frame = latest;
-      if (this.config.shared) {
-        const meta = new Int32Array(this.config.shared, 0, 4);
-        Atomics.add(meta, 0, 1);
-        new Uint8Array(this.config.shared, 16, latest.pixels.length).set(latest.pixels);
-        Atomics.store(meta, 1, latest.width);
-        Atomics.store(meta, 2, latest.height);
-        Atomics.add(meta, 0, 1);
-      }
-      this.changed();
-      this.report({ id: this.config.id, time: latest.time });
+    if (this.eof && !this.exhaustedReported && Number.isSafeInteger(this.config.generation)) {
+      this.exhaustedReported = true;
+      this.report({ id: this.config.id, revision: this.revision, exhaustedAt: this.nextTime });
     }
-    if (this.eof && !this.queue.length && time >= this.nextTime && !this.reportedEnd) {
-      this.reportedEnd = true;
-      this.report({ id: this.config.id, end: this.nextTime });
-    }
-    this.timer = setTimeout(() => this.step(), 10);
+    this.present(time);
+    if (this.eof && this.reportedEnd && !this.extension) { this.timer = null; return; }
+    // Yield to pending captures/audio messages, but do not add another 10ms
+    // per decoded frame while playback is behind the measured audio clock.
+    const catchingUp = !this.eof && this.queue.length < this.limit && this.nextTime <= this.time();
+    this.timer = setTimeout(() => this.step(), catchingUp ? 0 : 10);
   }
 }
 
 // Black/white raster passes capture the video's contribution after clipping,
 // opacity, subtitles and controls. This preserves foreground pixels instead of
 // pasting a rectangular video over the page's UI.
-export function compositeVideo(tile, frame) {
+// Layers are immutable raster results. Keep sampling geometry and mask runs
+// only as long as their layer lives; a decoded frame never enters this cache.
+const videoPlans = new WeakMap();
+const bgraBases = new WeakMap();
+function videoPlan(tile, frame, region = null) {
   const layer = tile.videoLayer;
-  if (!layer || !frame) return tile;
-  const pixels = new Uint8Array(layer.base);
   const { x, y, width, height } = layer.rect;
-  for (let py = Math.max(0, Math.floor(y)); py < Math.min(tile.pixelHeight, Math.ceil(y + height)); py++) {
-    const sy = Math.max(0, Math.min(frame.height - 1, Math.floor((py - y) / height * frame.height)));
-    for (let px = Math.max(0, Math.floor(x)); px < Math.min(tile.pixelWidth, Math.ceil(x + width)); px++) {
-      const sx = Math.max(0, Math.min(frame.width - 1, Math.floor((px - x) / width * frame.width)));
-      const dst = (py * tile.pixelWidth + px) * 4, src = (sy * frame.width + sx) * 4;
-      for (let c = 0; c < 3; c++) pixels[dst + c] = Math.min(255,
-        layer.base[dst + c] + Math.round(frame.pixels[src + c] * layer.mask[dst + c] / 255));
+  const crop = region ?? { x: 0, y: 0, width: tile.pixelWidth, height: tile.pixelHeight };
+  const key = [tile.pixelWidth, tile.pixelHeight, frame.width, frame.height, x, y, width, height,
+    crop.x, crop.y, crop.width, crop.height].join(",");
+  const previous = videoPlans.get(layer);
+  if (previous?.key === key) return previous;
+  const left = Math.max(0, Math.floor(x), crop.x), right = Math.min(tile.pixelWidth, Math.ceil(x + width), crop.x + crop.width);
+  const top = Math.max(0, Math.floor(y), crop.y), bottom = Math.min(tile.pixelHeight, Math.ceil(y + height), crop.y + crop.height);
+  const xs = new Int32Array(Math.max(0, right - left));
+  for (let px = left; px < right; px++)
+    xs[px - left] = Math.max(0, Math.min(frame.width - 1, Math.floor((px - x) / width * frame.width)));
+  const rows = [];
+  for (let py = top; py < bottom; py++) {
+    const source = Math.max(0, Math.min(frame.height - 1, Math.floor((py - y) / height * frame.height))) * frame.width;
+    const maskTarget = py * tile.pixelWidth + left;
+    const target = (py - crop.y) * crop.width + left - crop.x;
+    const runs = [];
+    let kind = -1, begin = 0;
+    for (let i = 0; i < xs.length; i++) {
+      const d = (maskTarget + i) * 4, m = layer.mask, b = layer.base;
+      const next = !(m[d] || m[d + 1] || m[d + 2]) ? 0
+        : m[d] === 255 && m[d + 1] === 255 && m[d + 2] === 255
+          && !(b[d] || b[d + 1] || b[d + 2]) ? (b[d + 3] === 255 ? 3 : 1) : 2;
+      if (next !== kind) {
+        if (kind > 0) runs.push(begin, i, kind);
+        begin = i; kind = next;
+      }
+    }
+    if (kind > 0) runs.push(begin, xs.length, kind);
+    rows.push({ source, target, maskTarget, runs });
+  }
+  const repeatedRows = rows.some((row, i) => i > 0 && row.source === rows[i - 1].source);
+  const plan = { key, xs, rows, repeatedRows };
+  videoPlans.set(layer, plan);
+  return plan;
+}
+
+function videoBase(layer, bgra) {
+  let base = layer.base;
+  if (bgra) {
+    base = bgraBases.get(layer);
+    if (!base) {
+      base = new Uint8Array(layer.base);
+      const words = new Uint32Array(base.buffer);
+      for (let i = 0; i < words.length; i++) {
+        const p = words[i];
+        words[i] = (p & 0xff00ff00) | ((p & 0xff) << 16) | ((p >>> 16) & 0xff);
+      }
+      bgraBases.set(layer, base);
     }
   }
-  return { ...tile, pixels };
+  return base;
+}
+
+function videoBackground(tile, bgra) {
+  return bgra && tile.background
+    ? [tile.background[2], tile.background[1], tile.background[0], tile.background[3]] : tile.background;
+}
+
+// Only fully opaque video runs replace all four bytes. Copy their complement
+// from the immutable base; translucent overlays and preserved alpha still need
+// the original pixels. Keep these source views on the existing geometry plan,
+// so a new crop/format replaces the cache instead of retaining old captures.
+function copyStaticVideoBase(base, plan) {
+  let copies = plan.baseCopies;
+  if (!copies || copies.buffer !== base.buffer || copies.offset !== base.byteOffset || copies.length !== base.length) {
+    const spans = [];
+    let copied = 0;
+    for (const { target, runs } of plan.rows) for (let r = 0; r < runs.length; r += 3) {
+      if (runs[r + 2] !== 3) continue;
+      const from = (target + runs[r]) * 4, to = (target + runs[r + 1]) * 4;
+      if (from > copied) spans.push([copied, base.subarray(copied, from)]);
+      copied = to;
+    }
+    if (copied < base.length) spans.push([copied, base.subarray(copied)]);
+    copies = plan.baseCopies = { buffer: base.buffer, offset: base.byteOffset, length: base.length, spans };
+  }
+  const pixels = Bun.allocUnsafe(base.length);
+  // Captures are transferred/detached after delivery. Never borrow a pool or
+  // expose a nonzero offset to the packed-pixel compositor.
+  if (!(pixels.buffer instanceof ArrayBuffer) || pixels.byteOffset !== 0 || pixels.buffer.byteLength !== base.length)
+    return new Uint8Array(base);
+  for (const [offset, span] of copies.spans) pixels.set(span, offset);
+  return pixels;
+}
+
+function compositeVideoPixels(tile, frame, pixels, format, region = null) {
+  const layer = tile.videoLayer;
+  const bgra = format === "bgra";
+  const { xs, rows, repeatedRows } = videoPlan(tile, frame, region);
+  const targetWords = new Uint32Array(pixels.buffer, 0, Math.floor(pixels.byteLength / 4));
+  const sourceWords = frame.pixels.byteOffset % 4 === 0
+    ? new Uint32Array(frame.pixels.buffer, frame.pixels.byteOffset, Math.floor(frame.pixels.byteLength / 4)) : null;
+  // Upscaling often repeats one decoded row several times. Expand it once,
+  // then copy opaque spans; keep only one scratch row for this capture.
+  let expanded = null, expandedSource = -1;
+  // Decode output and raster tiles are RGBA. Preserve the raster's alpha:
+  // the black/white mask already accounts for video opacity and overlays.
+  for (const { source, target, maskTarget, runs } of rows) {
+    for (let r = 0; r < runs.length; r += 3) {
+      const end = runs[r + 1];
+      const kind = runs[r + 2];
+      if (kind === 3 && sourceWords && repeatedRows) {
+        if (expandedSource !== source) {
+          expanded ??= new Uint32Array(xs.length);
+          for (let i = 0; i < xs.length; i++) {
+            const p = sourceWords[source + xs[i]];
+            expanded[i] = 0xff000000 | (bgra
+              ? (p & 0x0000ff00) | ((p & 0xff) << 16) | ((p >>> 16) & 0xff)
+              : p & 0x00ffffff);
+          }
+          expandedSource = source;
+        }
+        targetWords.set(runs[r] === 0 && end === xs.length
+          ? expanded : expanded.subarray(runs[r], end), target + runs[r]);
+      } else if ((kind === 1 || kind === 3) && sourceWords) {
+        for (let i = runs[r]; i < end; i++) {
+          const dst = target + i;
+          const p = sourceWords[source + xs[i]];
+          targetWords[dst] = (kind === 3 ? 0xff000000 : targetWords[dst] & 0xff000000) | (bgra
+            ? (p & 0x0000ff00) | ((p & 0xff) << 16) | ((p >>> 16) & 0xff)
+            : p & 0x00ffffff);
+        }
+      } else if (kind === 1 || kind === 3) {
+        for (let i = runs[r]; i < end; i++) {
+          const dst = (target + i) * 4, src = (source + xs[i]) * 4;
+          pixels[dst] = frame.pixels[src + (bgra ? 2 : 0)];
+          pixels[dst + 1] = frame.pixels[src + 1];
+          pixels[dst + 2] = frame.pixels[src + (bgra ? 0 : 2)];
+          if (kind === 3) pixels[dst + 3] = 255;
+        }
+      } else {
+        for (let i = runs[r]; i < end; i++) {
+          const dst = (target + i) * 4, src = (source + xs[i]) * 4, mask = (maskTarget + i) * 4;
+          for (let c = 0; c < 3; c++) pixels[dst + (bgra ? 2 - c : c)] = Math.min(255,
+            layer.base[mask + c] + Math.round(frame.pixels[src + c] * layer.mask[mask + c] / 255));
+        }
+      }
+    }
+  }
+}
+
+export function compositeVideo(tile, frame, format = "rgba") {
+  if (!tile.videoLayer || !frame) return tile;
+  const pixels = new Uint8Array(videoBase(tile.videoLayer, format === "bgra"));
+  compositeVideoPixels(tile, frame, pixels, format);
+  return { ...tile, pixels, pixelFormat: format, background: videoBackground(tile, format === "bgra") };
+}
+
+/**
+ * Cut the static base before composing video, avoiding offscreen prepaint
+ * pixels on each raw capture. Scaled clips keep the full-composite fallback.
+ * Pixel sampling stays in the original tile's coordinates: translating a
+ * fractional video rect before nearest-neighbour sampling changes its phase.
+ * The result exclusively owns its pixels; neither the tile nor its mask/base
+ * can be modified or detached when the caller consumes the capture.
+ */
+export function captureVideoViewport(tile, frame, x, y, width, height, clip, format = "rgba") {
+  if (!tile.videoLayer || !frame || (clip && clip.scale !== 1)) return null;
+  const base = videoBase(tile.videoLayer, format === "bgra");
+  const captured = captureViewport({ ...tile, pixels: base, background: videoBackground(tile, format === "bgra") },
+    x, y, width, height, clip);
+  const region = {
+    x: Math.round(((clip?.x ?? x) - tile.x) * tile.scale),
+    y: Math.round(((clip?.y ?? y) - tile.y) * tile.scale),
+    width: captured.width, height: captured.height,
+  };
+  const pixels = captured.pixels.buffer === base.buffer
+    ? copyStaticVideoBase(captured.pixels, videoPlan(tile, frame, region)) : captured.pixels;
+  compositeVideoPixels(tile, frame, pixels, format, region);
+  return { ...captured, pixels, pixelFormat: format };
 }

package/lib/renderer/video-worker.js

@@ -0,0 +1,46 @@
+// Decoding must not block screenshot composition (or vice versa). Initialise
+// WASM before the compositor announces readiness and seccomp is installed.
+import wasmpeg from '../../vendor/wasmpeg/src/js/index.js';
+import { VideoPresentation } from './video-presentation.js';
+
+// The decoder can keep advancing while the compositor is busy. Bound pixels
+// waiting across the Worker boundary to one transmitted and one latest frame.
+// Keep an outstanding delivery across stop/open: its ACK must be received
+// before another generation can send, and cannot acknowledge a newer frame.
+let inFlight = null, pending = null, nextDelivery = 0;
+function sendLatest() {
+  if (inFlight || !pending) return;
+  const {id, frame} = pending;
+  pending = null;
+  if (video.config?.id !== id) return;
+  const delivery = ++nextDelivery;
+  inFlight = {id, delivery};
+  try { postMessage({ type: 'frame', id, delivery, frame }, [frame.pixels.buffer]); }
+  catch (error) { inFlight = null; throw error; }
+}
+
+const video = new VideoPresentation(wasmpeg, () => {
+  pending = {id:video.config.id, frame:video.frame};
+  sendLatest();
+}, report => postMessage({ type: 'report', report }));
+
+self.onmessage = ({data}) => {
+  switch (data.type) {
+    case 'open': pending = null; void video.open(data.config); break;
+    case 'extend': void video.extend(data); break;
+    case 'stop':
+      if (data.id === undefined || video.config?.id === data.id) pending = null;
+      video.stop(data.id);
+      break;
+    case 'frame-ack':
+      if (inFlight?.id === data.id && inFlight.delivery === data.delivery) {
+        inFlight = null;
+        sendLatest();
+      }
+      break;
+    case 'bind': video.bind(data.id, data.audioId, data.audioStart, data.time, data.endTime); break;
+    case 'timing': video.timing(data.id, data.seconds); break;
+  }
+};
+await wasmpeg.load();
+postMessage({ type: 'ready' });

package/lib/renderer/workers.js

@@ -15,6 +15,7 @@ import {
   referenceHelper,
 } from "./script-rewrite.js";
 import { createPorts } from "./messaging.js";
+import { createTimers } from "./timers.js";
 
 /** Constructor reads, then the classic-script rewrite, sharing one parse when the first changes nothing. */
 function rewriteWorkerScript(source) {
@@ -44,7 +45,6 @@ function literalImports(source, base) {
   return urls;
 }
 const hostSetTimeout = globalThis.setTimeout;
-const hostClearTimeout = globalThis.clearTimeout;
 
 /**
  * @param {{
@@ -107,7 +107,6 @@ export function createWorkers({
     const worker = Object.create(Worker.prototype);
     const outside = eventTarget(() => worker);
     const inside = eventTarget(() => scope);
-    const timers = new Map();
     let nextTimer = 1;
     let terminated = false;
     let started = false;
@@ -119,8 +118,7 @@ export function createWorkers({
       terminate() {
         terminated = true;
         workerPorts.dispose();
-        for (const handle of timers.values()) hostClearTimeout(handle);
-        timers.clear();
+        timers.dispose();
         pending.length = 0;
         live.delete(state);
       },
@@ -140,21 +138,13 @@ export function createWorkers({
     const workerCall = (fn, thisArg, args) => {
       if (typeof fn === "function") Reflect.apply(fn, thisArg, args);
     };
+    const timers = createTimers({ invoke: callback => workerTask(callback), nextId: () => nextTimer++ });
     const schedule = (handler, delay, args, repeat) => {
-      const id = nextTimer++;
-      const fire = () => {
-        if (!timers.has(id)) return;
-        if (repeat) timers.set(id, hostSetTimeout(fire, Math.max(4, Number(delay) || 0)));
-        else timers.delete(id);
-        workerTask(() => typeof handler === "function" ? Reflect.apply(handler, scope, args) : evaluate(String(handler)));
-      };
-      timers.set(id, hostSetTimeout(fire, Math.max(0, Number(delay) || 0)));
-      return id;
-    };
-    const cancel = (id) => {
-      hostClearTimeout(timers.get(Number(id)));
-      timers.delete(Number(id));
+      const code = typeof handler === "function" ? null : String(handler);
+      return timers.schedule(() => typeof handler === "function"
+        ? Reflect.apply(handler, scope, args) : evaluate(code), delay, repeat);
     };
+    const cancel = id => timers.cancel(id);
     const messageFor = (target, data, ports = []) => Object.freeze({
       type: "message", data, origin: "", lastEventId: "", source: null, ports: Object.freeze([...ports]),
       target, currentTarget: target, bubbles: false, cancelable: false, defaultPrevented: false,