multiplane 0.3.3 → 0.3.7

package/src/post.mjs

@@ -45,17 +45,19 @@ export async function resizeImage(image, width, height, upscale) {
 }
 export function resolveQuality(options = {}) {
   const quality = options.quality ?? (options.draft ? 'draft' : 'standard');
-  if (!['draft', 'standard', 'high'].includes(quality) || (options.draft && quality !== 'draft')) throw invalidOption('--quality', 'Quality must be draft, standard or high, and agree with --draft.');
+  if (!['draft', 'fast', 'standard', 'high'].includes(quality) || (options.draft && quality !== 'draft')) throw invalidOption('--quality', 'Quality must be draft, fast, standard or high, and agree with --draft.');
   return quality;
 }
 
 export function resolvePost(options = {}, post = {}) {
   const quality = resolveQuality(options);
   if (options['no-post']) return { motionBlur: 1, maxMotionBlur: 1, shutter: 0.5, grain: 0 };
-  const motionBlur = number(options['motion-blur'] ?? post.motionBlur ?? 1, 'motionBlur', { positive: true });
+  let motionBlur = number(options['motion-blur'] ?? post.motionBlur ?? 1, 'motionBlur', { positive: true });
   if (!Number.isSafeInteger(motionBlur)) throw invalidOption('motionBlur', 'motionBlur must be a positive integer.');
-  const maxMotionBlur = number(quality === 'draft' ? 1 : options['max-motion-blur'] ?? post.maxMotionBlur ?? (quality === 'high' ? 256 : 64), 'maxMotionBlur', { positive: true });
+  const maxMotionBlur = number(quality === 'draft' ? 1 : options['max-motion-blur'] ?? post.maxMotionBlur ?? (quality === 'high' ? 256 : quality === 'fast' ? 16 : 32), 'maxMotionBlur', { positive: true });
   if (!Number.isSafeInteger(maxMotionBlur)) throw invalidOption('maxMotionBlur', 'maxMotionBlur must be a positive integer.');
+  // Preserve explicit bases and fixed sampling before applying the preset cap.
+  if ((quality === 'standard' || quality === 'fast') && options['motion-blur'] == null && maxMotionBlur > motionBlur) motionBlur = Math.min(motionBlur, 4);
   // TODO(design): Document max <= base as disabling upward adaptation, including draft overrides.
   return { motionBlur, maxMotionBlur, shutter: number(options.shutter ?? post.shutter ?? 0.5, 'shutter'), grain: number(options.grain ?? post.grain ?? 0, 'grain') };
 }
@@ -254,13 +256,15 @@ export function createPostCapture(capture, options = {}, fps = capture.fps) {
       const grids = upward ? nestedSampleGrids(t, fps, capture.duration, capture.cuts, post) : null;
       const endpoints = sampleTimes(t, fps, capture.duration, capture.cuts, { motionBlur: 2, shutter: post.shutter * 2 });
       const times = sampleTimes(t, fps, capture.duration, capture.cuts, { ...post, motionBlur: upward ? Math.max(2, motionBlur) : motionBlur });
+      // Clipped or zero-width shutters may contain fewer unique temporal samples.
+      const motionBlurBase = new Set(upward ? grids.get(motionBlur) : times).size;
       let candidate = false, uniform = motionBlur === 1, observedTime;
       if (enabled && !Atomics.load(state, 0)) {
         const probes = [...new Set(motionBlur === 1 && !upward ? [t] : [...endpoints, ...times, t])].sort((a, b) => a - b);
         const changes = [];
         const observeStart = performance.now();
         for (const time of probes) {
-          changes.push(await capture.observe(time, { motionBlur }));
+          changes.push(await capture.observe(time, { motionBlur, motionBlurBase }));
           observedTime = time;
           if (changes.at(-1)) break;
         }
@@ -272,17 +276,25 @@ export function createPostCapture(capture, options = {}, fps = capture.fps) {
       }
       const verifyReuse = candidate && (audit || previousRaw.run === 0 || frame % REUSE_INTERVAL === 0);
       const cache = new Map();
-      let contextUsed = false;
+      let contextUsed = false, motionProbeUsed = false;
+      let finalCapture = hooked || motionBlur === 1;
+      let selectedTimes = times;
+      let dofMotionSamples = new Set(times).size;
+      const context = (observed, time) => ({ motionBlur, motionBlurBase, observed,
+        motionProbeTime: finalCapture ? undefined : t,
+        dofMotionSamples: finalCapture ? dofMotionSamples : undefined,
+        dofMotionIndex: finalCapture ? [...new Set(selectedTimes)].sort((a, b) => a - b).indexOf(time) : undefined });
       const sample = async (time, reuse = false) => {
         if (!cache.has(time)) {
           const start = performance.now();
-          const observed = time === observedTime;
+          const observed = time === observedTime && !(motionBlur > 1 && capture.motionProbeUsed);
           observedTime = undefined;
-          const png = await capture.frame(time, { motionBlur, observed });
+          const png = await capture.frame(time, context(observed, time));
           contextUsed ||= capture.sampleContextUsed === true;
+          motionProbeUsed ||= capture.motionProbeUsed === true;
           stats.captureMs += performance.now() - start;
           stats.samples++;
-          cache.set(time, { png, image: post.motionBlur > 1 || upward || post.grain > 0 ? await decode(png, reuse) : null });
+          cache.set(time, { png, dofSamples: capture.dofSamples ?? 0, probe: capture.motionProbeUsed === true && !finalCapture, image: post.motionBlur > 1 || upward || post.grain > 0 ? await decode(png, reuse) : null });
         }
         return cache.get(time);
       };
@@ -294,20 +306,22 @@ export function createPostCapture(capture, options = {}, fps = capture.fps) {
           return;
         }
         const begin = async time => {
-          const start = performance.now(), observed = time === observedTime;
+          const start = performance.now(), observed = time === observedTime && !(motionBlur > 1 && capture.motionProbeUsed);
           observedTime = undefined;
-          const pending = await capture.beginFrame(time, { motionBlur, observed });
+          const pending = await capture.beginFrame(time, context(observed, time));
           contextUsed ||= capture.sampleContextUsed === true;
+          motionProbeUsed ||= capture.motionProbeUsed === true;
           const png = pending.png.then(buffer => { stats.captureMs += performance.now() - start; return buffer; });
           png.catch(() => {});
-          return { png };
+          return { png, dofSamples: capture.dofSamples ?? 0, probe: capture.motionProbeUsed === true && !finalCapture };
         };
         let pending = await begin(missing[0]);
         for (let i = 0; i < missing.length; i++) {
           const png = await pending.png;
+          const { dofSamples, probe } = pending;
           const next = i + 1 < missing.length ? await begin(missing[i + 1]) : null;
           stats.samples++;
-          cache.set(missing[i], { png, image: await decode(png, reuse) });
+          cache.set(missing[i], { png, dofSamples, probe, image: await decode(png, reuse) });
           pending = next;
         }
       };
@@ -315,7 +329,7 @@ export function createPostCapture(capture, options = {}, fps = capture.fps) {
       let png, result, usedSamples = motionBlur;
       if (candidate && !verifyReuse) { ({ png, image: result, usedSamples } = previousRaw); }
       else if (upward) {
-        // Calibrated in capture raster pixels: about 2px for standard, 1px for high.
+        // Calibrated in capture raster pixels: about 2px for fast/standard, 1px for high.
         const threshold = resolveQuality(options) === 'high' ? 1 : 2;
         await sampleMany([...endpoints, t], true);
         const centerProbe = cache.get(t);
@@ -323,7 +337,7 @@ export function createPostCapture(capture, options = {}, fps = capture.fps) {
         let legacy = contextUsed;
         let grid = legacy ? times : grids.get(motionBlur);
         if (still) {
-          png = centerProbe.png; result = centerProbe.image; usedSamples = 1;
+          png = centerProbe.png; result = centerProbe.image; usedSamples = 1; selectedTimes = [t];
           stats.staticFrames++; stats.adaptiveFrames++;
         } else {
           if (legacy) cache.clear();
@@ -338,13 +352,16 @@ export function createPostCapture(capture, options = {}, fps = capture.fps) {
             const images = grid.map(time => cache.get(time).image), center = cache.get(t);
             const identical = images.every(image => image.data.equals(center.image.data));
             if (identical) {
-              png = center.png; result = center.image; usedSamples = 1;
+              png = center.png; result = center.image; usedSamples = 1; selectedTimes = [t];
               stats.staticFrames++; stats.adaptiveFrames++; break;
             }
             let difference = 0;
-            for (let i = 1; i < images.length && difference <= threshold; i++) difference = Math.max(difference, localMotionDifference(images[i - 1], images[i], alpha, threshold));
+            for (let i = 1; i < images.length && difference <= threshold; i++) {
+              // All decision images share the output frame's fixed lens phase.
+              difference = Math.max(difference, localMotionDifference(images[i - 1], images[i], alpha, threshold));
+            }
             if (difference <= threshold || motionBlur >= post.maxMotionBlur) {
-              usedSamples = motionBlur;
+              usedSamples = motionBlur; selectedTimes = grid;
               result = timed('averageMs', () => average(images)); break;
             }
             motionBlur = Math.min(post.maxMotionBlur, motionBlur * 2);
@@ -353,7 +370,7 @@ export function createPostCapture(capture, options = {}, fps = capture.fps) {
             grid = legacy ? sampleTimes(t, fps, capture.duration, capture.cuts, { ...post, motionBlur }) : grids.get(motionBlur);
           }
         }
-      } else if (motionBlur === 1) ({ png, image: result } = await sample(t));
+      } else if (motionBlur === 1) { selectedTimes = [t]; ({ png, image: result } = await sample(t)); }
       else if (hooked) {
         await sampleMany(times);
         result = timed('averageMs', () => average(times.map(time => cache.get(time).image)));
@@ -362,7 +379,7 @@ export function createPostCapture(capture, options = {}, fps = capture.fps) {
         const first = cache.get(times[0]), last = cache.get(times.at(-1));
         const identical = first.image.data === last.image.data || first.image.data.equals(last.image.data);
         if (identical || (!alpha && imageDifference(first.image, last.image) < adaptive)) {
-          png = first.png; result = first.image; usedSamples = 1; stats.adaptiveFrames++;
+          png = first.png; result = first.image; usedSamples = 1; selectedTimes = [times[0]]; stats.adaptiveFrames++;
           if (identical) stats.staticFrames++;
         } else {
           await sampleMany(times);
@@ -372,13 +389,29 @@ export function createPostCapture(capture, options = {}, fps = capture.fps) {
         await sampleMany([times[0], times.at(-1), t]);
         const first = cache.get(times[0]), last = cache.get(times.at(-1)), center = cache.get(t);
         if (first.image.data.equals(last.image.data) && first.image.data.equals(center.image.data)) {
-          png = center.png; result = center.image; usedSamples = 1; stats.staticFrames++;
+          png = center.png; result = center.image; usedSamples = 1; selectedTimes = [t]; stats.staticFrames++;
         } else {
           await sampleMany(times);
           const images = times.map(time => cache.get(time).image);
           result = timed('averageMs', () => average(images));
         }
       }
+      let usedDofSamples = previousRaw?.usedDofSamples ?? 0;
+      if (!(candidate && !verifyReuse)) {
+        // Only lens-dependent probe captures need replacing. DOM captures and
+        // final hook captures remain reusable at the same time and context.
+        if (motionProbeUsed && !finalCapture) {
+          finalCapture = true;
+          dofMotionSamples = new Set(selectedTimes).size;
+          for (const [time, item] of cache) if (item.probe) cache.delete(time);
+          observedTime = undefined;
+          await sampleMany(selectedTimes, true);
+          const images = selectedTimes.map(time => cache.get(time).image);
+          png = selectedTimes.length === 1 ? cache.get(selectedTimes[0]).png : undefined;
+          result = selectedTimes.length === 1 ? images[0] : timed('averageMs', () => average(images));
+        }
+        usedDofSamples = [...new Set(selectedTimes)].reduce((sum, time) => sum + (cache.get(time)?.dofSamples ?? 0), 0);
+      }
       if (verifyReuse) {
         stats.auditMs += performance.now() - auditStart;
         Atomics.add(state, 2, 1);
@@ -394,9 +427,10 @@ export function createPostCapture(capture, options = {}, fps = capture.fps) {
       if (candidate && !verifyReuse) Atomics.add(state, 1, 1);
       // Keep a decoded raw reference as well; never retain a transferable output buffer.
       if (enabled && options.transport === 'raw') result ??= await decode(png);
-      previousRaw = { t, frame, motionBlur, uniform, png, image: result, usedSamples, run: candidate ? previousRaw.run + 1 : 0 };
+      previousRaw = { t, frame, motionBlur, uniform, png, image: result, usedSamples, usedDofSamples, run: candidate ? previousRaw.run + 1 : 0 };
       // Contributing temporal samples, excluding probes and failed attempts.
       api.lastBlurSamples = usedSamples;
+      api.lastDofSamples = usedDofSamples;
       stats.frames++;
       if (sizes.renderScale !== sizes.scale) {
         result ??= await decode(png);

package/src/preview.mjs

@@ -1,23 +1,23 @@
-import path from 'node:path';
-import { writeFile, rename, rm } from 'node:fs/promises';
-import sharp from 'sharp';
-
-export function createPreview(events, width, height, { enabled = true, now = () => performance.now() } = {}) {
-  let last = -Infinity, failed = false;
-  return async (pixels, frame) => {
-    if (!enabled || failed || now() - last < 2000) return;
-    const file = path.join(events.directory, 'preview.png'), temporary = file + '.tmp';
-    try {
-      const png = await sharp(pixels, { raw: { width, height, channels: 4 } })
-        .resize({ width: 480, height: 480, fit: 'inside', withoutEnlargement: true }).png().toBuffer();
-      await writeFile(temporary, png);
-      await rename(temporary, file);
-      events.preview(frame);
-      last = now();
-    } catch {
-      failed = true;
-      await rm(temporary, { force: true }).catch(() => {});
-      events.warning({ code: 'preview_failed', message: 'Preview could not be written; further preview updates are disabled.' });
-    }
-  };
-}
+import path from 'node:path';
+import { writeFile, rename, rm } from 'node:fs/promises';
+import sharp from 'sharp';
+
+export function createPreview(events, width, height, { enabled = true, now = () => performance.now() } = {}) {
+  let last = -Infinity, failed = false;
+  return async (pixels, frame) => {
+    if (!enabled || failed || now() - last < 2000) return;
+    const file = path.join(events.directory, 'preview.png'), temporary = file + '.tmp';
+    try {
+      const png = await sharp(pixels, { raw: { width, height, channels: 4 } })
+        .resize({ width: 480, height: 480, fit: 'inside', withoutEnlargement: true }).png().toBuffer();
+      await writeFile(temporary, png);
+      await rename(temporary, file);
+      events.preview(frame);
+      last = now();
+    } catch {
+      failed = true;
+      await rm(temporary, { force: true }).catch(() => {});
+      events.warning({ code: 'preview_failed', message: 'Preview could not be written; further preview updates are disabled.' });
+    }
+  };
+}

package/src/process.mjs

@@ -1,9 +1,9 @@
-// FFmpeg has no descendants; wait for its streams to close before cleaning files.
-export function stopChild(child, graceMs = 2000) {
-  return new Promise(resolve => {
-    if (child.exitCode !== null || child.signalCode !== null) { resolve(); return; }
-    const timer = setTimeout(() => child.kill('SIGKILL'), graceMs);
-    child.once('close', () => { clearTimeout(timer); resolve(); });
-    child.kill('SIGTERM');
-  });
-}
+// FFmpeg has no descendants; wait for its streams to close before cleaning files.
+export function stopChild(child, graceMs = 2000) {
+  return new Promise(resolve => {
+    if (child.exitCode !== null || child.signalCode !== null) { resolve(); return; }
+    const timer = setTimeout(() => child.kill('SIGKILL'), graceMs);
+    child.once('close', () => { clearTimeout(timer); resolve(); });
+    child.kill('SIGTERM');
+  });
+}

package/src/render-pool.mjs

@@ -12,11 +12,12 @@ export function defaultWorkers(scale = 1, hardware = {}) {
   return Math.max(1, Math.min(12, Math.floor(cores / 2), Math.floor((free - 2 * 1024 ** 3) / workerBytes)));
 }
 
-export function createRenderPool(shot, options, fps, workers, size, onWarning) {
+export function createRenderPool(shot, options, fps, workers, size, onWarning, onCaptured) {
   options = { ...options, _browserRecovery: options._browserRecovery ?? recoveryBudget() };
   reuseState(options);
   const slots = [], stats = { frames: 0, samples: 0, staticFrames: 0 };
-  const histogram = {};
+  const histogram = {}, dofHistogram = {};
+  const captured = new Set();
   let failure;
   for (let i = 0; i < workers; i++) {
     const worker = new Worker(new URL('./render-worker.mjs', import.meta.url), { workerData: { shot, options, fps, size } });
@@ -28,6 +29,13 @@ export function createRenderPool(shot, options, fps, workers, size, onWarning) {
     slot.ready = new Promise((resolve, reject) => { slot.pending = { resolve, reject }; });
     slot.ready.catch(() => {});
     worker.on('message', message => {
+      if (message.type === 'captured') {
+        if (!captured.has(message.frame)) {
+          captured.add(message.frame);
+          try { onCaptured?.(captured.size); } catch (error) { fail(error); }
+        }
+        return;
+      }
       if (message.type === 'warning') { onWarning?.(message.warning); return; }
       if (message.type === 'failure') { fail(new MultiplaneError(message.code ?? 'worker_crashed', message.error, { details: message.details, hint: message.hint })); return; }
       const pending = slot.pending; slot.pending = null;
@@ -44,6 +52,7 @@ export function createRenderPool(shot, options, fps, workers, size, onWarning) {
   const api = {
     stats,
     get blurSamples() { return blurSampleReport(histogram); },
+    get dofSamples() { return blurSampleReport(dofHistogram); },
     get staticReuse() { return reuseReport(options); },
     progress: () => `Samples: ${stats.samples}; static: ${stats.staticFrames}; adaptive: ${stats.adaptiveFrames ?? 0}; hooks: ${stats.hookFrames ?? 0}`,
     async *frames(first, end) {
@@ -69,9 +78,10 @@ export function createRenderPool(shot, options, fps, workers, size, onWarning) {
         if (options.transport === 'raw') schedule(slot);
         // Worker audits have already replaced invalid frames in this batch.
         for (const [i, png] of batch.frames.entries()) {
-          const count = batch.blurSamples[i];
+          const count = batch.blurSamples[i], dofCount = batch.dofSamples[i];
+          dofHistogram[dofCount] = (dofHistogram[dofCount] ?? 0) + 1;
           histogram[count] = (histogram[count] ?? 0) + 1;
-          yield { frame: batch.first + i, png, hash: batch.hashes?.[i], blurSamples: count };
+          yield { frame: batch.first + i, png, hash: batch.hashes?.[i], blurSamples: count, dofSamples: dofCount };
         }
         if (options.transport !== 'raw') schedule(slot);
       }
@@ -86,8 +96,8 @@ export function createRenderPool(shot, options, fps, workers, size, onWarning) {
     },
   };
   const frames = api.frames.bind(api);
-  api.frames = async function* (first, end, onCaptured) {
-    for await (const item of frames(first, end)) { await onCaptured?.(item); yield item; }
+  api.frames = async function* (first, end, onDelivered) {
+    for await (const item of frames(first, end)) { await onDelivered?.(item); yield item; }
   };
   return api;
 }

package/src/render-worker.mjs

@@ -25,12 +25,13 @@ try {
     if (closing) return;
     running = true;
     try {
-      const frames = [], hashes = [], blurSamples = [], before = { ...processed.stats };
+      const frames = [], hashes = [], blurSamples = [], dofSamples = [], before = { ...processed.stats };
       const source = async function* (first, end) {
         for (let index = first; index < end && !closing; index++) {
           const frame = message.first + index;
           const png = await processed.frame(frame / workerData.fps, frame, index === end - 1);
-          yield { png, hash: processed.lastHash, blurSamples: processed.lastBlurSamples };
+          parentPort.postMessage({ type: 'captured', frame });
+          yield { png, hash: processed.lastHash, blurSamples: processed.lastBlurSamples, dofSamples: processed.lastDofSamples };
         }
       };
       // RAW post output already owns an independent buffer. Keep it until the
@@ -41,10 +42,11 @@ try {
           ? new Uint8Array(result.buffer) : Uint8Array.from(result);
         frames.push(png);
         blurSamples.push(item.blurSamples);
+        dofSamples.push(item.dofSamples);
         if (workerData.options.verify) hashes.push(item.hash);
       }
       const stats = Object.fromEntries(Object.entries(processed.stats).map(([key, value]) => [key, value - before[key]]));
-      if (!closing) parentPort.postMessage({ type: 'frames', first: message.first, frames, hashes, blurSamples, stats }, frames.map(f => f.buffer));
+      if (!closing) parentPort.postMessage({ type: 'frames', first: message.first, frames, hashes, blurSamples, dofSamples, stats }, frames.map(f => f.buffer));
     } catch (error) {
       sendFailure(error); closing = true;
     } finally {

package/src/render.mjs

@@ -1,4 +1,4 @@
-import { readBenchmark, validBenchmark, benchmarkMachine, selectWorkers, classifyShot } from './workers.mjs';
+import { readBenchmark, benchmarkMachine, selectWorkers, classifyShot } from './workers.mjs';
 import { recoveryBudget } from './browser-recovery.mjs';
 import path from 'node:path';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
@@ -59,10 +59,10 @@ export async function renderShot(shot, options = {}) {
       capture = await openShot(shot, renderScale, { ...options, onWarning: events.warning, check: events.check, onBrowser: observeBrowser(events, ffmpegInfo) });
       const record = ['option', 'config'].includes(events.workersSource) ? null : readBenchmark();
       let machine, type;
+      if (!['option', 'config'].includes(events.workersSource)) type = await classifyShot(capture);
       if (record) {
         try {
           machine = benchmarkMachine(await environment(capture.browser), options.raster);
-          if (validBenchmark(record, machine)) type = await classifyShot(capture);
         } catch { /* Optional tuning must not prevent an otherwise valid render. */ }
       }
       const selection = selectWorkers({ workers: options.workers, source: events.workersSource, record, machine, type,
@@ -94,7 +94,8 @@ export async function renderShot(shot, options = {}) {
       events.resources.setWorkers(actualWorkers);
       const started = performance.now();
       const frameHashes = process.env.RENDER_FRAME_HASHES ? [] : null;
-      pool = createRenderPool(shot, options, fps, actualWorkers, { width, height }, events.warning);
+      pool = createRenderPool(shot, options, fps, actualWorkers, { width, height }, events.warning,
+        done => events.progress('capture', done, total));
       events.onCancel(() => pool?.cancel());
       await mkdir(path.dirname(out), { recursive: true });
       events.check();
@@ -122,7 +123,6 @@ export async function renderShot(shot, options = {}) {
       for await (const { frame, png } of pool.frames(first, end, async ({ frame, png }) => {
         events.check();
         await preview(png, frame);
-        events.progress('capture', frame - first + 1, total);
       })) {
         events.check();
         if (failure) throw new MultiplaneError('encode_failed', undefined, { cause: failure });
@@ -149,7 +149,7 @@ export async function renderShot(shot, options = {}) {
       if (frameHashes) await writeFile(process.env.RENDER_FRAME_HASHES, JSON.stringify(frameHashes, null, 2));
       if (process.env.RENDER_PROFILE) await writeFile(process.env.RENDER_PROFILE, JSON.stringify({elapsed,frames:total,workers:actualWorkers,options,stats:pool.stats,encoderWriteMs,encoderDrainMs,outputCheckMs},null,2));
       events.artifact(out, 'video');
-      result = { staticReuse: pool.staticReuse, blurSamples: pool.blurSamples, output: out, frames: framesSent, fps, from, to, width: width * scale, height: height * scale, encoder: encoding.encoder, format: options.format, alpha: options.alpha, post: { ...processed.post, adaptiveBlur: Number(options['adaptive-blur'] ?? 0.5) }, renderScale, scale, outputCheck };
+      result = { staticReuse: pool.staticReuse, blurSamples: pool.blurSamples, dofSamples: pool.dofSamples, output: out, frames: framesSent, fps, from, to, width: width * scale, height: height * scale, encoder: encoding.encoder, format: options.format, alpha: options.alpha, post: { ...processed.post, adaptiveBlur: Number(options['adaptive-blur'] ?? 0.5) }, renderScale, scale, outputCheck };
     } finally { await cleanup(); }
 
     return options.draft ? { ...result, draft: true } : result;

package/src/resource-path.mjs

@@ -1,29 +1,29 @@
-import path from 'node:path';
-import { realpath } from 'node:fs';
-import { promisify } from 'node:util';
-
-const nativeRealpath = promisify(realpath.native);
-
-// Resolve aliases (including Windows 8.3 names) even for missing descendants.
-export async function normalizeResourcePath(file) {
-  const absolute = path.resolve(file);
-  try { return await nativeRealpath(absolute); }
-  catch (error) {
-    if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error;
-    const parent = path.dirname(absolute);
-    if (parent === absolute) return absolute;
-    return path.join(await normalizeResourcePath(parent), path.basename(absolute));
-  }
-}
-
-export function relativeResourcePath(root, target, platform = process.platform) {
-  const paths = platform === 'win32' ? path.win32 : path.posix;
-  return paths.relative(platform === 'win32' ? root.toLowerCase() : root,
-    platform === 'win32' ? target.toLowerCase() : target);
-}
-
-export async function isInsideResourceRoot(root, target) {
-  const [base, file] = await Promise.all([normalizeResourcePath(root), normalizeResourcePath(target)]);
-  const relative = relativeResourcePath(base, file);
-  return relative !== '..' && !relative.startsWith('..' + path.sep) && !path.isAbsolute(relative);
-}
+import path from 'node:path';
+import { realpath } from 'node:fs';
+import { promisify } from 'node:util';
+
+const nativeRealpath = promisify(realpath.native);
+
+// Resolve aliases (including Windows 8.3 names) even for missing descendants.
+export async function normalizeResourcePath(file) {
+  const absolute = path.resolve(file);
+  try { return await nativeRealpath(absolute); }
+  catch (error) {
+    if (error.code !== 'ENOENT' && error.code !== 'ENOTDIR') throw error;
+    const parent = path.dirname(absolute);
+    if (parent === absolute) return absolute;
+    return path.join(await normalizeResourcePath(parent), path.basename(absolute));
+  }
+}
+
+export function relativeResourcePath(root, target, platform = process.platform) {
+  const paths = platform === 'win32' ? path.win32 : path.posix;
+  return paths.relative(platform === 'win32' ? root.toLowerCase() : root,
+    platform === 'win32' ? target.toLowerCase() : target);
+}
+
+export async function isInsideResourceRoot(root, target) {
+  const [base, file] = await Promise.all([normalizeResourcePath(root), normalizeResourcePath(target)]);
+  const relative = relativeResourcePath(base, file);
+  return relative !== '..' && !relative.startsWith('..' + path.sep) && !path.isAbsolute(relative);
+}

package/src/resources.mjs

@@ -1,27 +1,27 @@
-import { cpus } from 'node:os';
-import { createProcessTreeReader } from './platform.mjs';
-
-// Diagnostics only: never pass these values to frame generation.
-export function createResourceSampler({ sample, intervalMs = 1000, onSample = () => {}, enabled = true } = {}) {
-  const reader = !sample && enabled ? createProcessTreeReader() : undefined;
-  sample ??= reader?.sample;
-  let pending, timer, stopped = false, peakMemoryBytes = null, memorySamples = 0, workers = 1;
-  const take = () => {
-    if (pending || stopped || !enabled) return pending ?? Promise.resolve();
-    clearTimeout(timer);
-    pending = (async () => {
-      let bytes = null;
-      try { const value = await sample(); if (Number.isSafeInteger(value) && value > 0) bytes = value; } catch {}
-      if (bytes !== null) { peakMemoryBytes = Math.max(peakMemoryBytes ?? 0, bytes); memorySamples++; }
-      try { onSample(bytes); } catch {}
-    })().finally(() => { pending = undefined; if (!stopped) { timer = setTimeout(take, intervalMs); timer.unref(); } });
-    return pending;
-  };
-  void take();
-  return {
-    sample: take,
-    setWorkers(value) { workers = value; },
-    snapshot: () => ({ peakMemoryBytes, memorySamples, workers, cpuCount: cpus().length || null }),
-    async stop() { stopped = true; clearTimeout(timer); await pending; await reader?.close(); },
-  };
-}
+import { cpus } from 'node:os';
+import { createProcessTreeReader } from './platform.mjs';
+
+// Diagnostics only: never pass these values to frame generation.
+export function createResourceSampler({ sample, intervalMs = 1000, onSample = () => {}, enabled = true } = {}) {
+  const reader = !sample && enabled ? createProcessTreeReader() : undefined;
+  sample ??= reader?.sample;
+  let pending, timer, stopped = false, peakMemoryBytes = null, memorySamples = 0, workers = 1;
+  const take = () => {
+    if (pending || stopped || !enabled) return pending ?? Promise.resolve();
+    clearTimeout(timer);
+    pending = (async () => {
+      let bytes = null;
+      try { const value = await sample(); if (Number.isSafeInteger(value) && value > 0) bytes = value; } catch {}
+      if (bytes !== null) { peakMemoryBytes = Math.max(peakMemoryBytes ?? 0, bytes); memorySamples++; }
+      try { onSample(bytes); } catch {}
+    })().finally(() => { pending = undefined; if (!stopped) { timer = setTimeout(take, intervalMs); timer.unref(); } });
+    return pending;
+  };
+  void take();
+  return {
+    sample: take,
+    setWorkers(value) { workers = value; },
+    snapshot: () => ({ peakMemoryBytes, memorySamples, workers, cpuCount: cpus().length || null }),
+    async stop() { stopped = true; clearTimeout(timer); await pending; await reader?.close(); },
+  };
+}

package/src/runtime/camera.js

@@ -1,37 +1,37 @@
-(function () {
-  const E = Shot.ease;
-
-  function interp(a, b, k) {
-    const s = a.s * Math.pow(b.s / a.s, k);
-    if (b.s >= a.s) {
-      const px = (b.f[0] - a.f[0]) * a.s * (1 - k);
-      const py = (b.f[1] - a.f[1]) * a.s * (1 - k);
-      return { f: [b.f[0] - px / s, b.f[1] - py / s], s };
-    }
-    const px = (a.f[0] - b.f[0]) * b.s * k;
-    const py = (a.f[1] - b.f[1]) * b.s * k;
-    return { f: [a.f[0] - px / s, a.f[1] - py / s], s };
-  }
-
-  function track(keys) {
-    function at(t) {
-      if (t <= keys[0].t) return { f: keys[0].f, s: keys[0].s };
-      for (let i = 1; i < keys.length; i++) {
-        const a = keys[i - 1], b = keys[i];
-        if (b.t === a.t) continue;
-        if (t < b.t) return interp(a, b, (b.ease || E.inOutCubic)((t - a.t) / (b.t - a.t)));
-      }
-      const z = keys[keys.length - 1];
-      return { f: z.f, s: z.s };
-    }
-    return {
-      at,
-      apply(node, t, w = Shot.size.w, h = Shot.size.h) {
-        const { f, s } = at(t);
-        node.setAttribute('transform', `translate(${w / 2} ${h / 2}) scale(${s}) translate(${-f[0]} ${-f[1]})`);
-      },
-    };
-  }
-
-  window.Camera = { track, linear: k => k };
-})();
+(function () {
+  const E = Shot.ease;
+
+  function interp(a, b, k) {
+    const s = a.s * Math.pow(b.s / a.s, k);
+    if (b.s >= a.s) {
+      const px = (b.f[0] - a.f[0]) * a.s * (1 - k);
+      const py = (b.f[1] - a.f[1]) * a.s * (1 - k);
+      return { f: [b.f[0] - px / s, b.f[1] - py / s], s };
+    }
+    const px = (a.f[0] - b.f[0]) * b.s * k;
+    const py = (a.f[1] - b.f[1]) * b.s * k;
+    return { f: [a.f[0] - px / s, a.f[1] - py / s], s };
+  }
+
+  function track(keys) {
+    function at(t) {
+      if (t <= keys[0].t) return { f: keys[0].f, s: keys[0].s };
+      for (let i = 1; i < keys.length; i++) {
+        const a = keys[i - 1], b = keys[i];
+        if (b.t === a.t) continue;
+        if (t < b.t) return interp(a, b, (b.ease || E.inOutCubic)((t - a.t) / (b.t - a.t)));
+      }
+      const z = keys[keys.length - 1];
+      return { f: z.f, s: z.s };
+    }
+    return {
+      at,
+      apply(node, t, w = Shot.size.w, h = Shot.size.h) {
+        const { f, s } = at(t);
+        node.setAttribute('transform', `translate(${w / 2} ${h / 2}) scale(${s}) translate(${-f[0]} ${-f[1]})`);
+      },
+    };
+  }
+
+  window.Camera = { track, linear: k => k };
+})();

package/src/runtime/shot.css

@@ -1,9 +1,9 @@
-html, body { margin: 0; height: 100%; overflow: hidden; background: var(--multiplane-page-background, #000); }
-#stage {
-  position: absolute; left: 0; top: 0;
-  width: 1920px; height: 1080px;
-  transform-origin: 0 0;
-  overflow: hidden;
-  background: var(--paper, #fff);
-}
-#stage > svg { display: block; }
+html, body { margin: 0; height: 100%; overflow: hidden; background: var(--multiplane-page-background, #000); }
+#stage {
+  position: absolute; left: 0; top: 0;
+  width: 1920px; height: 1080px;
+  transform-origin: 0 0;
+  overflow: hidden;
+  background: var(--paper, #fff);
+}
+#stage > svg { display: block; }

package/src/server.mjs

@@ -61,7 +61,13 @@ export async function startServer(port = 0, root = process.cwd()) {
       }
       let target = path.resolve(resourceRoot, `.${resourcePath}`);
       if (!await isInsideResourceRoot(resourceRoot, target)) { res.writeHead(403); return res.end(); }
-      if ((await stat(target)).isDirectory()) target = path.join(target, 'index.html');
+      let targetInfo;
+      try { targetInfo = await stat(target); }
+      catch (error) {
+        if (pathname === '/favicon.ico' && error.code === 'ENOENT') { res.writeHead(204); return res.end(); }
+        throw error;
+      }
+      if (targetInfo.isDirectory()) target = path.join(target, 'index.html');
       target = await normalizeResourcePath(target);
       if (!await isInsideResourceRoot(resourceBase, target)) { res.writeHead(403); return res.end(); }
       const info = await stat(target);