pa_encoder 0.1.0 → 0.2.0

package/dist/index.js

@@ -206,63 +206,168 @@ async function startLiveCapture({
 function installVirtualTime({
   fps = 60,
   hookDateNow = true,
-  hookPerformanceNow = true
+  hookPerformanceNow = true,
+  hookTimers = true,
+  maxTimerCallbacksPerStep = 1e4
 } = {}) {
-  if (!Number.isFinite(fps) || fps <= 0)
-    throw new TypeError("fps must be positive");
+  var _a, _b, _c, _d, _e, _f;
+  if (!Number.isFinite(fps) || fps <= 0) {
+    throw new TypeError("installVirtualTime: fps must be a positive number");
+  }
   const dtMs = 1e3 / fps;
-  const _requestAnimationFrame = window.requestAnimationFrame.bind(window);
-  const _cancelAnimationFrame = window.cancelAnimationFrame.bind(window);
-  const _dateNow = Date.now.bind(Date);
-  const _perfNow = performance.now.bind(performance);
-  let vNowMs = 0;
+  const orig = {
+    requestAnimationFrame: (_a = window.requestAnimationFrame) == null ? void 0 : _a.bind(window),
+    cancelAnimationFrame: (_b = window.cancelAnimationFrame) == null ? void 0 : _b.bind(window),
+    setTimeout: (_c = window.setTimeout) == null ? void 0 : _c.bind(window),
+    clearTimeout: (_d = window.clearTimeout) == null ? void 0 : _d.bind(window),
+    setInterval: (_e = window.setInterval) == null ? void 0 : _e.bind(window),
+    clearInterval: (_f = window.clearInterval) == null ? void 0 : _f.bind(window),
+    dateNow: Date.now.bind(Date),
+    perfNow: performance.now.bind(performance)
+  };
+  if (typeof orig.requestAnimationFrame !== "function") {
+    throw new Error("installVirtualTime: requestAnimationFrame not available");
+  }
+  if (typeof orig.cancelAnimationFrame !== "function") {
+    throw new Error("installVirtualTime: cancelAnimationFrame not available");
+  }
   let running = true;
-  let nextId = 1;
-  const pending = /* @__PURE__ */ new Map();
-  const scheduled = [];
+  let vNowMs = 0;
+  let nextRafId = 1;
+  const rafCallbacks = /* @__PURE__ */ new Map();
+  const rafQueue = [];
   function hookedRAF(cb) {
-    if (!running) return _requestAnimationFrame(cb);
-    const id = nextId++;
-    pending.set(id, cb);
-    scheduled.push(id);
+    if (!running) return orig.requestAnimationFrame(cb);
+    if (typeof cb !== "function") return orig.requestAnimationFrame(cb);
+    const id = nextRafId++;
+    rafCallbacks.set(id, cb);
+    rafQueue.push(id);
     return id;
   }
   function hookedCancelRAF(id) {
-    if (!running) return _cancelAnimationFrame(id);
-    pending.delete(id);
+    if (!running) return orig.cancelAnimationFrame(id);
+    rafCallbacks.delete(id);
+  }
+  let nextTimerId = 1;
+  const timers = /* @__PURE__ */ new Map();
+  function normalizeDelay(ms) {
+    const n = Number(ms);
+    if (!Number.isFinite(n) || n < 0) return 0;
+    return n;
+  }
+  function hookedSetTimeout(fn, delay, ...args) {
+    if (!running) return orig.setTimeout(fn, delay, ...args);
+    if (typeof fn !== "function") return orig.setTimeout(fn, delay, ...args);
+    const id = nextTimerId++;
+    const d = normalizeDelay(delay);
+    timers.set(id, {
+      type: "timeout",
+      dueMs: vNowMs + d,
+      intervalMs: 0,
+      fn: () => fn(...args)
+    });
+    return id;
+  }
+  function hookedClearTimeout(id) {
+    if (!running) return orig.clearTimeout(id);
+    timers.delete(id);
+  }
+  function hookedSetInterval(fn, delay, ...args) {
+    if (!running) return orig.setInterval(fn, delay, ...args);
+    if (typeof fn !== "function") return orig.setInterval(fn, delay, ...args);
+    const id = nextTimerId++;
+    const d = normalizeDelay(delay);
+    timers.set(id, {
+      type: "interval",
+      dueMs: vNowMs + d,
+      intervalMs: d,
+      fn: () => fn(...args)
+    });
+    return id;
+  }
+  function hookedClearInterval(id) {
+    if (!running) return orig.clearInterval(id);
+    timers.delete(id);
   }
   window.requestAnimationFrame = hookedRAF;
   window.cancelAnimationFrame = hookedCancelRAF;
+  if (hookTimers) {
+    if (typeof orig.setTimeout !== "function" || typeof orig.clearTimeout !== "function") {
+      throw new Error(
+        "installVirtualTime: setTimeout/clearTimeout not available"
+      );
+    }
+    if (typeof orig.setInterval !== "function" || typeof orig.clearInterval !== "function") {
+      throw new Error(
+        "installVirtualTime: setInterval/clearInterval not available"
+      );
+    }
+    window.setTimeout = hookedSetTimeout;
+    window.clearTimeout = hookedClearTimeout;
+    window.setInterval = hookedSetInterval;
+    window.clearInterval = hookedClearInterval;
+  }
   if (hookDateNow) {
     Date.now = function() {
-      return running ? vNowMs : _dateNow();
+      return running ? vNowMs : orig.dateNow();
     };
   }
   if (hookPerformanceNow) {
     performance.now = function() {
-      return running ? vNowMs : _perfNow();
+      return running ? vNowMs : orig.perfNow();
     };
   }
+  function flushDueTimers() {
+    let executed = 0;
+    while (true) {
+      if (executed > maxTimerCallbacksPerStep) {
+        throw new Error(
+          `VirtualTime: too many timer callbacks in a single step (>${maxTimerCallbacksPerStep}).`
+        );
+      }
+      let nextDue = Infinity;
+      for (const t of timers.values()) {
+        if (t.dueMs < nextDue) nextDue = t.dueMs;
+      }
+      if (!(nextDue <= vNowMs)) break;
+      const due = [];
+      for (const [id, t] of timers.entries()) {
+        if (t.dueMs <= vNowMs) due.push([id, t]);
+      }
+      due.sort((a, b) => a[1].dueMs - b[1].dueMs || a[0] - b[0]);
+      for (const [id, t] of due) {
+        if (!timers.has(id)) continue;
+        executed++;
+        t.fn();
+        if (t.type === "timeout") {
+          timers.delete(id);
+        } else {
+          const interval = t.intervalMs;
+          let next = t.dueMs + interval;
+          if (next <= vNowMs) next = vNowMs;
+          t.dueMs = next;
+          timers.set(id, t);
+        }
+      }
+    }
+  }
   function flushRAFFrame() {
-    const ids = scheduled.splice(0, scheduled.length);
+    const ids = rafQueue.splice(0, rafQueue.length);
     for (const id of ids) {
-      const cb = pending.get(id);
+      const cb = rafCallbacks.get(id);
       if (!cb) continue;
-      pending.delete(id);
-      try {
-        cb(vNowMs);
-      } catch (e) {
-        console.error("Error in rAF callback:", e);
-        throw e;
-      }
+      rafCallbacks.delete(id);
+      cb(vNowMs);
     }
   }
   function step(frames = 1) {
-    if (!running) throw new Error("Virtual time is not running");
-    if (!Number.isInteger(frames) || frames < 1)
-      throw new TypeError("frames must be >= 1");
+    if (!running) throw new Error("VirtualTime: not running");
+    if (!Number.isInteger(frames) || frames < 1) {
+      throw new TypeError("VirtualTime.step: frames must be an integer >= 1");
+    }
     for (let i = 0; i < frames; i++) {
       vNowMs += dtMs;
+      if (hookTimers) flushDueTimers();
       flushRAFFrame();
     }
   }
@@ -270,161 +375,297 @@ function installVirtualTime({
     running = false;
   }
   function restore() {
-    window.requestAnimationFrame = _requestAnimationFrame;
-    window.cancelAnimationFrame = _cancelAnimationFrame;
-    if (hookDateNow) Date.now = _dateNow;
-    if (hookPerformanceNow) performance.now = _perfNow;
+    window.requestAnimationFrame = orig.requestAnimationFrame;
+    window.cancelAnimationFrame = orig.cancelAnimationFrame;
+    if (hookTimers) {
+      window.setTimeout = orig.setTimeout;
+      window.clearTimeout = orig.clearTimeout;
+      window.setInterval = orig.setInterval;
+      window.clearInterval = orig.clearInterval;
+    }
+    if (hookDateNow) Date.now = orig.dateNow;
+    if (hookPerformanceNow) performance.now = orig.perfNow;
     running = false;
-    pending.clear();
-    scheduled.length = 0;
+    rafCallbacks.clear();
+    rafQueue.length = 0;
+    timers.clear();
   }
   return {
+    step,
+    restore,
+    stopVirtualTime,
     get nowMs() {
       return vNowMs;
     },
-    dtMs,
-    step,
-    stopVirtualTime,
-    restore
+    get dtMs() {
+      return dtMs;
+    }
   };
 }
 
 // src/virtual_capture.js
-function resolveCanvas(canvasOrSelector) {
-  if (canvasOrSelector instanceof HTMLCanvasElement) return canvasOrSelector;
-  if (typeof canvasOrSelector === "string") {
-    const el = document.querySelector(canvasOrSelector);
-    if (el instanceof HTMLCanvasElement) return el;
-    throw new Error(`No canvas found for selector: ${canvasOrSelector}`);
-  }
-  const first = document.querySelector("canvas");
-  if (first instanceof HTMLCanvasElement) return first;
-  throw new Error("No canvas found on the page");
-}
-async function virtualTimeCapture({
-  // IMPORTANT: loadSketch must be called AFTER hooks are installed
-  loadSketch,
-  // () => import("...")  (or any function that executes the sketch module)
-  canvas: canvasOrSelector,
-  // canvas element OR selector OR omit to use first canvas
-  fps = 60,
-  frames = 300,
-  warmupFrames = 0,
-  exporter,
-  concurrency = 2,
-  onProgress,
-  hookDateNow = true,
-  hookPerformanceNow = true,
-  signal
+function findElementDeep({
+  doc,
+  selector,
+  includeShadow = true,
+  maxIframeDepth = 8,
+  _depth = 0
 } = {}) {
-  if (typeof loadSketch !== "function") {
-    throw new TypeError(
-      "loadSketch must be a function returning a Promise (dynamic import)"
-    );
-  }
-  if (!exporter || typeof exporter.write !== "function" || typeof exporter.finalize !== "function") {
-    throw new TypeError("exporter must have write() and finalize()");
+  if (!doc || _depth > maxIframeDepth) return null;
+  try {
+    const el = doc.querySelector(selector);
+    if (el) return { el, doc };
+  } catch {
   }
-  if (!Number.isFinite(fps) || fps <= 0)
-    throw new TypeError("fps must be positive");
-  if (!Number.isInteger(frames) || frames < 1)
-    throw new TypeError("frames must be >= 1");
-  if (!Number.isInteger(warmupFrames) || warmupFrames < 0)
-    throw new TypeError("warmupFrames must be >= 0");
-  if (!Number.isInteger(concurrency) || concurrency < 1)
-    throw new TypeError("concurrency must be >= 1");
-  const vt = installVirtualTime({ fps, hookDateNow, hookPerformanceNow });
-  const worker = new Worker(new URL("./worker.js", import.meta.url), {
-    type: "module"
-  });
-  const ready = new Promise((resolve, reject) => {
-    const onMsg = (ev) => {
-      var _a, _b;
-      if (((_a = ev.data) == null ? void 0 : _a.type) === "ready") {
-        worker.removeEventListener("message", onMsg);
-        resolve();
-      } else if (((_b = ev.data) == null ? void 0 : _b.type) === "error") {
-        worker.removeEventListener("message", onMsg);
-        reject(new Error(ev.data.message || "Worker error"));
+  if (includeShadow) {
+    let all = [];
+    try {
+      all = doc.querySelectorAll("*");
+    } catch {
+      all = [];
+    }
+    for (const host of all) {
+      const sr = host.shadowRoot;
+      if (!sr) continue;
+      try {
+        const el = sr.querySelector(selector);
+        if (el) return { el, doc };
+      } catch {
       }
-    };
-    worker.addEventListener("message", onMsg);
-    worker.addEventListener("error", reject);
-  });
-  function throwIfAborted() {
-    if (signal == null ? void 0 : signal.aborted) {
-      throw signal.reason ?? new DOMException("Aborted", "AbortError");
     }
   }
-  await ready;
-  await loadSketch();
-  const canvas = resolveCanvas(canvasOrSelector);
-  for (let i = 0; i < warmupFrames; i++) {
-    throwIfAborted();
-    vt.step(1);
-  }
-  let inFlight = 0;
-  const waiters = [];
-  const ack = /* @__PURE__ */ new Map();
-  function acquireSlot() {
-    if (inFlight < concurrency) return Promise.resolve();
-    return new Promise((r) => waiters.push(r));
+  let iframes = [];
+  try {
+    iframes = doc.querySelectorAll("iframe");
+  } catch {
+    iframes = [];
   }
-  function releaseSlot() {
-    inFlight--;
-    const w = waiters.shift();
-    if (w) w();
+  for (const f of iframes) {
+    let childDoc = null;
+    try {
+      childDoc = f.contentDocument;
+    } catch {
+      childDoc = null;
+    }
+    if (!childDoc) continue;
+    const found = findElementDeep({
+      doc: childDoc,
+      selector,
+      includeShadow,
+      maxIframeDepth,
+      _depth: _depth + 1
+    });
+    if (found) return found;
   }
-  worker.addEventListener("message", async (ev) => {
-    const msg = ev.data;
-    if (!msg || typeof msg !== "object") return;
-    if (msg.type === "frame") {
-      const { frameIndex, blob } = msg;
+  return null;
+}
+function debugSnapshot(tag = "snapshot") {
+  const info = {
+    tag,
+    href: (() => {
       try {
-        await exporter.write(frameIndex, blob);
-        const entry = ack.get(frameIndex);
-        if (entry) entry.resolve();
-      } catch (e) {
-        const entry = ack.get(frameIndex);
-        if (entry) entry.reject(e);
-      } finally {
-        ack.delete(frameIndex);
-        releaseSlot();
+        return location.href;
+      } catch {
+        return "(no location)";
       }
-    } else if (msg.type === "error") {
-      console.error("Worker error:", msg.message);
+    })(),
+    readyState: (() => {
+      try {
+        return document.readyState;
+      } catch {
+        return "(no document)";
+      }
+    })(),
+    canvasCount: (() => {
+      try {
+        return document.querySelectorAll("canvas").length;
+      } catch {
+        return -1;
+      }
+    })(),
+    iframeCount: (() => {
+      try {
+        return document.querySelectorAll("iframe").length;
+      } catch {
+        return -1;
+      }
+    })()
+  };
+  console.warn("[pa_encoder]", info);
+}
+function waitForCanvasLiveDeep({
+  selector = "canvas",
+  timeoutMs = 15e3,
+  pollMs = 50,
+  includeShadow = true
+} = {}) {
+  const immediate = findElementDeep({ doc: document, selector, includeShadow });
+  if (immediate == null ? void 0 : immediate.el) return Promise.resolve(immediate);
+  return new Promise((resolve, reject) => {
+    const t0 = performance.now();
+    let done = false;
+    let intervalId = null;
+    const cleanup = (observer2) => {
+      if (done) return;
+      done = true;
+      try {
+        observer2 == null ? void 0 : observer2.disconnect();
+      } catch {
+      }
+      if (intervalId) clearInterval(intervalId);
+    };
+    const check = (observer2) => {
+      const found = findElementDeep({ doc: document, selector, includeShadow });
+      if (found == null ? void 0 : found.el) {
+        cleanup(observer2);
+        resolve(found);
+        return;
+      }
+      if (performance.now() - t0 > timeoutMs) {
+        cleanup(observer2);
+        debugSnapshot("waitForCanvasLiveDeep timeout");
+        reject(new Error(`Timed out waiting for canvas selector: ${selector}`));
+      }
+    };
+    const observer = new MutationObserver(() => check(observer));
+    observer.observe(document.documentElement, {
+      childList: true,
+      subtree: true
+    });
+    intervalId = setInterval(() => check(observer), pollMs);
+  });
+}
+function resolveCanvasFromFound(found) {
+  const el = found == null ? void 0 : found.el;
+  if (el instanceof HTMLCanvasElement) return el;
+  throw new Error("Found element is not a canvas");
+}
+async function resolveCanvasWithWaitDeep({
+  vt,
+  selector = "canvas",
+  canvasWaitFrames = 240,
+  includeShadow = true
+} = {}) {
+  const tryResolve = () => {
+    const found = findElementDeep({ doc: document, selector, includeShadow });
+    if (!(found == null ? void 0 : found.el)) throw new Error("No canvas found on the page");
+    return resolveCanvasFromFound(found);
+  };
+  try {
+    return tryResolve();
+  } catch (e) {
+    console.warn("[pa_encoder] resolveCanvas failed:", (e == null ? void 0 : e.message) ?? e);
+  }
+  for (let i = 0; i < canvasWaitFrames; i++) {
+    vt.step(1);
+    try {
+      return tryResolve();
+    } catch (e) {
+      console.warn("[pa_encoder] resolveCanvas failed:", (e == null ? void 0 : e.message) ?? e);
     }
+  }
+  throw new Error("No canvas found on the page");
+}
+async function virtualTimeCapture({
+  fps = 60,
+  canvasSelector = "canvas",
+  preWaitTimeoutMs = 15e3,
+  includeShadow = true,
+  canvasWaitFrames = 240,
+  hookDateNow = true,
+  hookPerformanceNow = true,
+  hookTimers = true,
+  frameCount = 60,
+  onFrame = null
+} = {}) {
+  debugSnapshot("virtualTimeCapture start");
+  const foundLive = await waitForCanvasLiveDeep({
+    selector: canvasSelector || "canvas",
+    timeoutMs: preWaitTimeoutMs,
+    includeShadow
+  });
+  resolveCanvasFromFound(foundLive);
+  const vt = installVirtualTime({
+    fps,
+    hookDateNow,
+    hookPerformanceNow,
+    hookTimers
   });
   try {
-    for (let i = 0; i < frames; i++) {
-      throwIfAborted();
+    let canvas = await resolveCanvasWithWaitDeep({
+      vt,
+      selector: canvasSelector || "canvas",
+      canvasWaitFrames,
+      includeShadow
+    });
+    for (let i = 0; i < frameCount; i++) {
       vt.step(1);
-      const bitmap = await createImageBitmap(canvas);
-      await acquireSlot();
-      inFlight++;
-      const done = new Promise(
-        (resolve, reject) => ack.set(i, { resolve, reject })
-      );
-      worker.postMessage(
-        {
-          type: "encode",
-          frameIndex: i,
-          bitmap,
-          width: canvas.width,
-          height: canvas.height
-        },
-        [bitmap]
-      );
-      await done;
-      onProgress == null ? void 0 : onProgress(i + 1, frames, { nowMs: vt.nowMs });
+      if (!(canvas instanceof HTMLCanvasElement) || !canvas.isConnected) {
+        canvas = await resolveCanvasWithWaitDeep({
+          vt,
+          selector: canvasSelector || "canvas",
+          canvasWaitFrames: 30,
+          includeShadow
+        });
+      }
+      if (typeof onFrame === "function") {
+        await onFrame(canvas, i);
+      }
     }
-    while (inFlight > 0) {
-      await new Promise((r) => setTimeout(r, 20));
+    return { ok: true };
+  } finally {
+    vt.restore();
+    debugSnapshot("virtualTimeCapture end");
+  }
+}
+async function virtualTimeCaptureFromStart({
+  fps = 60,
+  // caller provides a start hook (e.g. import(entry))
+  start = null,
+  canvasSelector = "canvas",
+  includeShadow = true,
+  canvasWaitFrames = 600,
+  hookDateNow = true,
+  hookPerformanceNow = true,
+  hookTimers = true,
+  frameCount = 60,
+  onFrame = null
+} = {}) {
+  debugSnapshot("virtualTimeCaptureFromStart begin");
+  const vt = installVirtualTime({
+    fps,
+    hookDateNow,
+    hookPerformanceNow,
+    hookTimers
+  });
+  try {
+    if (typeof start === "function") {
+      await start();
     }
-    await exporter.finalize();
+    let canvas = await resolveCanvasWithWaitDeep({
+      vt,
+      selector: canvasSelector || "canvas",
+      canvasWaitFrames,
+      includeShadow
+    });
+    for (let i = 0; i < frameCount; i++) {
+      vt.step(1);
+      if (!(canvas instanceof HTMLCanvasElement) || !canvas.isConnected) {
+        canvas = await resolveCanvasWithWaitDeep({
+          vt,
+          selector: canvasSelector || "canvas",
+          canvasWaitFrames: 30,
+          includeShadow
+        });
+      }
+      if (typeof onFrame === "function") {
+        await onFrame(canvas, i);
+      }
+    }
+    return { ok: true };
   } finally {
-    worker.terminate();
     vt.restore();
+    debugSnapshot("virtualTimeCaptureFromStart end");
   }
 }
 
@@ -510,5 +751,6 @@ export {
   createFsExporter,
   createZipExporter,
   startLiveCapture,
-  virtualTimeCapture
+  virtualTimeCapture,
+  virtualTimeCaptureFromStart
 };