multiplane 0.3.3 → 0.3.7

package/src/alpha.mjs

@@ -1,69 +1,69 @@
-// All weighted operations use linear-light, premultiplied RGBA.
-const linear = Float64Array.from({ length: 256 }, (_, i) => {
-  const x = i / 255;
-  return x <= 0.04045 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
-});
-const clamp = x => Math.max(0, Math.min(1, x));
-const srgb = x => Math.round(255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * x ** (1 / 2.4) - 0.055));
-function premultiply(image) {
-  const data = new Float64Array(image.data.length);
-  for (let p = 0; p < data.length; p += 4) {
-    const a = image.data[p + 3] / 255;
-    for (let c = 0; c < 3; c++) data[p + c] = linear[image.data[p + c]] * a;
-    data[p + 3] = a;
-  }
-  return data;
-}
-function finish(data, width, height) {
-  const bytes = Buffer.alloc(data.length);
-  for (let p = 0; p < data.length; p += 4) {
-    const a = data[p + 3];
-    bytes[p + 3] = Math.round(clamp(a) * 255);
-    // Unpremultiply with the unquantized, unclamped weight, including ringing.
-    if (bytes[p + 3]) for (let c = 0; c < 3; c++) bytes[p + c] = srgb(clamp(data[p + c] / a));
-  }
-  return { width, height, data: bytes };
-}
-export function averageAlpha(images) {
-  const data = new Float64Array(images[0].data.length);
-  for (const image of images) {
-    for (let p = 0; p < data.length; p += 4) {
-      const a = image.data[p + 3] / 255;
-      for (let c = 0; c < 3; c++) data[p + c] += linear[image.data[p + c]] * a / images.length;
-      data[p + 3] += a / images.length;
-    }
-  }
-  return finish(data, images[0].width, images[0].height);
-}
-export function clearHiddenColors(image) {
-  const data = Buffer.from(image.data);
-  for (let p = 0; p < data.length; p += 4) if (!data[p + 3]) data.fill(0, p, p + 3);
-  return { ...image, data };
-}
-const sinc = x => x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
-function weights(input, output, kernel) {
-  const ratio = input / output, support = Math.max(1, ratio);
-  return Array.from({ length: output }, (_, i) => {
-    const center = (i + 0.5) * ratio - 0.5;
-    if (kernel === 'neighbor') return [[Math.max(0, Math.min(input - 1, Math.round(center))), 1]];
-    const result = []; let total = 0;
-    for (let j = Math.ceil(center - 3 * support); j <= Math.floor(center + 3 * support); j++) {
-      const distance = (j - center) / support;
-      const weight = Math.abs(distance) < 3 ? sinc(distance) * sinc(distance / 3) : 0;
-      result.push([Math.max(0, Math.min(input - 1, j)), weight]); total += weight;
-    }
-    return result.map(([j, weight]) => [j, weight / total]);
-  });
-}
-export function resizeAlpha(image, width, height, kernel = 'lanczos') {
-  const input = premultiply(image), horizontal = new Float64Array(width * image.height * 4);
-  const output = new Float64Array(width * height * 4);
-  const wx = weights(image.width, width, kernel), wy = weights(image.height, height, kernel);
-  for (let y = 0; y < image.height; y++) for (let x = 0; x < width; x++) {
-    for (const [source, weight] of wx[x]) for (let c = 0; c < 4; c++) horizontal[(y * width + x) * 4 + c] += input[(y * image.width + source) * 4 + c] * weight;
-  }
-  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
-    for (const [source, weight] of wy[y]) for (let c = 0; c < 4; c++) output[(y * width + x) * 4 + c] += horizontal[(source * width + x) * 4 + c] * weight;
-  }
-  return finish(output, width, height);
-}
+// All weighted operations use linear-light, premultiplied RGBA.
+const linear = Float64Array.from({ length: 256 }, (_, i) => {
+  const x = i / 255;
+  return x <= 0.04045 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4;
+});
+const clamp = x => Math.max(0, Math.min(1, x));
+const srgb = x => Math.round(255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * x ** (1 / 2.4) - 0.055));
+function premultiply(image) {
+  const data = new Float64Array(image.data.length);
+  for (let p = 0; p < data.length; p += 4) {
+    const a = image.data[p + 3] / 255;
+    for (let c = 0; c < 3; c++) data[p + c] = linear[image.data[p + c]] * a;
+    data[p + 3] = a;
+  }
+  return data;
+}
+function finish(data, width, height) {
+  const bytes = Buffer.alloc(data.length);
+  for (let p = 0; p < data.length; p += 4) {
+    const a = data[p + 3];
+    bytes[p + 3] = Math.round(clamp(a) * 255);
+    // Unpremultiply with the unquantized, unclamped weight, including ringing.
+    if (bytes[p + 3]) for (let c = 0; c < 3; c++) bytes[p + c] = srgb(clamp(data[p + c] / a));
+  }
+  return { width, height, data: bytes };
+}
+export function averageAlpha(images) {
+  const data = new Float64Array(images[0].data.length);
+  for (const image of images) {
+    for (let p = 0; p < data.length; p += 4) {
+      const a = image.data[p + 3] / 255;
+      for (let c = 0; c < 3; c++) data[p + c] += linear[image.data[p + c]] * a / images.length;
+      data[p + 3] += a / images.length;
+    }
+  }
+  return finish(data, images[0].width, images[0].height);
+}
+export function clearHiddenColors(image) {
+  const data = Buffer.from(image.data);
+  for (let p = 0; p < data.length; p += 4) if (!data[p + 3]) data.fill(0, p, p + 3);
+  return { ...image, data };
+}
+const sinc = x => x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
+function weights(input, output, kernel) {
+  const ratio = input / output, support = Math.max(1, ratio);
+  return Array.from({ length: output }, (_, i) => {
+    const center = (i + 0.5) * ratio - 0.5;
+    if (kernel === 'neighbor') return [[Math.max(0, Math.min(input - 1, Math.round(center))), 1]];
+    const result = []; let total = 0;
+    for (let j = Math.ceil(center - 3 * support); j <= Math.floor(center + 3 * support); j++) {
+      const distance = (j - center) / support;
+      const weight = Math.abs(distance) < 3 ? sinc(distance) * sinc(distance / 3) : 0;
+      result.push([Math.max(0, Math.min(input - 1, j)), weight]); total += weight;
+    }
+    return result.map(([j, weight]) => [j, weight / total]);
+  });
+}
+export function resizeAlpha(image, width, height, kernel = 'lanczos') {
+  const input = premultiply(image), horizontal = new Float64Array(width * image.height * 4);
+  const output = new Float64Array(width * height * 4);
+  const wx = weights(image.width, width, kernel), wy = weights(image.height, height, kernel);
+  for (let y = 0; y < image.height; y++) for (let x = 0; x < width; x++) {
+    for (const [source, weight] of wx[x]) for (let c = 0; c < 4; c++) horizontal[(y * width + x) * 4 + c] += input[(y * image.width + source) * 4 + c] * weight;
+  }
+  for (let y = 0; y < height; y++) for (let x = 0; x < width; x++) {
+    for (const [source, weight] of wy[y]) for (let c = 0; c < 4; c++) output[(y * width + x) * 4 + c] += horizontal[(source * width + x) * 4 + c] * weight;
+  }
+  return finish(output, width, height);
+}

package/src/artifacts.mjs

@@ -1,61 +1,61 @@
-import { constants } from 'node:fs';
-import { copyFile, rm, writeFile, access, rename, mkdtemp, mkdir } from 'node:fs/promises';
-import path from 'node:path';
-import { MultiplaneError } from './errors.mjs';
-
-const outputError = (error, file) => {
-  if (error.code === 'EEXIST') throw new MultiplaneError('output_exists', undefined, { details: { path: file }, hint: 'Choose a new output path.' });
-  throw error;
-};
-export async function requireNewOutput(file) {
-  try { await access(file); }
-  catch (error) { if (error.code === 'ENOENT') return; throw error; }
-  throw new MultiplaneError('output_exists', undefined, { details: { path: file }, hint: 'Choose a new output path.' });
-}
-export async function writeArtifact(file, bytes) {
-  try { await writeFile(file, bytes, { flag: 'wx' }); }
-  catch (error) { outputError(error, file); }
-}
-export async function publishVideo(temporary, file, overwrite = false) {
-  if (overwrite) { await rename(temporary, file); return; }
-  try { await copyFile(temporary, file, constants.COPYFILE_EXCL); }
-  catch (error) { outputError(error, file); }
-  await rm(temporary);
-}
-
-// Build a replacement directory in isolation; publish only after the whole command succeeds.
-export async function directoryOutput(events, action) {
-  const target = events.options.out;
-  await mkdir(path.dirname(target), { recursive: true });
-  const temporary = await mkdtemp(target + '.partial-');
-  const backup = temporary + '.previous';
-  const artifacts = [], artifact = events.artifact;
-  const relocate = value => {
-    if (typeof value === 'string' && value.startsWith(temporary + path.sep)) return target + value.slice(temporary.length);
-    if (Array.isArray(value)) return value.map(relocate);
-    if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, relocate(v)]));
-    return value;
-  };
-  events.options.out = temporary;
-  events.artifact = (file, kind) => artifacts.push([file, kind]);
-  let saved = false, committed = false, keepTemporary = false;
-  try {
-    const data = await action(events);
-    events.check();
-    try { await rename(target, backup); saved = true; } catch (error) { if (error.code !== 'ENOENT') throw error; }
-    try { await rename(temporary, target); }
-    catch (error) { const restore = saved; saved = false; if (restore) await rename(backup, target); throw error; }
-    committed = true;
-    for (const [file, kind] of artifacts) artifact(relocate(file), kind);
-    return relocate(data);
-  } catch (error) {
-    // Keep completed diagnostic artifacts addressable when verification fails.
-    keepTemporary = artifacts.length > 0;
-    if (keepTemporary && !committed) for (const [file, kind] of artifacts) artifact(file, kind);
-    throw error;
-  } finally {
-    events.options.out = target; events.artifact = artifact;
-    if (!keepTemporary) await rm(temporary, { recursive: true, force: true });
-    if (saved && committed) await rm(backup, { recursive: true, force: true });
-  }
-}
+import { constants } from 'node:fs';
+import { copyFile, rm, writeFile, access, rename, mkdtemp, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { MultiplaneError } from './errors.mjs';
+
+const outputError = (error, file) => {
+  if (error.code === 'EEXIST') throw new MultiplaneError('output_exists', undefined, { details: { path: file }, hint: 'Choose a new output path.' });
+  throw error;
+};
+export async function requireNewOutput(file) {
+  try { await access(file); }
+  catch (error) { if (error.code === 'ENOENT') return; throw error; }
+  throw new MultiplaneError('output_exists', undefined, { details: { path: file }, hint: 'Choose a new output path.' });
+}
+export async function writeArtifact(file, bytes) {
+  try { await writeFile(file, bytes, { flag: 'wx' }); }
+  catch (error) { outputError(error, file); }
+}
+export async function publishVideo(temporary, file, overwrite = false) {
+  if (overwrite) { await rename(temporary, file); return; }
+  try { await copyFile(temporary, file, constants.COPYFILE_EXCL); }
+  catch (error) { outputError(error, file); }
+  await rm(temporary);
+}
+
+// Build a replacement directory in isolation; publish only after the whole command succeeds.
+export async function directoryOutput(events, action) {
+  const target = events.options.out;
+  await mkdir(path.dirname(target), { recursive: true });
+  const temporary = await mkdtemp(target + '.partial-');
+  const backup = temporary + '.previous';
+  const artifacts = [], artifact = events.artifact;
+  const relocate = value => {
+    if (typeof value === 'string' && value.startsWith(temporary + path.sep)) return target + value.slice(temporary.length);
+    if (Array.isArray(value)) return value.map(relocate);
+    if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, relocate(v)]));
+    return value;
+  };
+  events.options.out = temporary;
+  events.artifact = (file, kind) => artifacts.push([file, kind]);
+  let saved = false, committed = false, keepTemporary = false;
+  try {
+    const data = await action(events);
+    events.check();
+    try { await rename(target, backup); saved = true; } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    try { await rename(temporary, target); }
+    catch (error) { const restore = saved; saved = false; if (restore) await rename(backup, target); throw error; }
+    committed = true;
+    for (const [file, kind] of artifacts) artifact(relocate(file), kind);
+    return relocate(data);
+  } catch (error) {
+    // Keep completed diagnostic artifacts addressable when verification fails.
+    keepTemporary = artifacts.length > 0;
+    if (keepTemporary && !committed) for (const [file, kind] of artifacts) artifact(file, kind);
+    throw error;
+  } finally {
+    events.options.out = target; events.artifact = artifact;
+    if (!keepTemporary) await rm(temporary, { recursive: true, force: true });
+    if (saved && committed) await rm(backup, { recursive: true, force: true });
+  }
+}

package/src/browser-recovery.mjs

@@ -1,26 +1,26 @@
-import { MultiplaneError } from './errors.mjs';
-
-export const MAX_BROWSER_RESTARTS = 2;
-export const recoveryBudget = () => new Int32Array(new SharedArrayBuffer(4));
-
-// Playwright includes bounded browser logs on transport errors. Never retain the
-// launch command (which also contains local profile paths) in public diagnostics.
-export function crashDetails(error, t) {
-  const messages = [], seen = new Set();
-  for (let e = error; e && !seen.has(e); e = e.cause) { seen.add(e); messages.push(e.message ?? String(e)); }
-  const log = messages.join('\n');
-  const exit = log.match(/process did exit: exitCode=([^,\s]+), signal=([^\s>]+)/);
-  const stderr = log.split(/\r?\n/).filter(line => /\[err\]/.test(line) && !line.includes('<launching>')).slice(-20).join('\n').slice(-4000);
-  return { ...(t === undefined ? {} : { t }), reason: (messages.at(-1) ?? 'Browser closed unexpectedly').split(/\r?\n/)[0].slice(0, 500),
-    ...(exit ? { exitCode: exit[1] === 'null' ? null : Number(exit[1]), signal: exit[2] === 'null' ? null : exit[2] } : {}),
-    ...(stderr ? { stderr } : {}) };
-}
-
-export function browserClosed(error, browser, page, crashed = false) {
-  if (error?.code === 'render_threw' || error?.code === 'cancelled') return false;
-  return crashed || page?.isClosed() || (browser && !browser.isConnected())
-    || /Target (?:page, context or browser|closed)|(?:Page|Browser|Connection|Session) closed|Page crashed|Target crashed|browser has disconnected/i.test(error?.message ?? '')
-    || (error?.cause && browserClosed(error.cause, browser, page, crashed));
-}
-
-export const crashedError = (error, t) => new MultiplaneError('browser_crashed', undefined, { cause: error, details: crashDetails(error, t) });
+import { MultiplaneError } from './errors.mjs';
+
+export const MAX_BROWSER_RESTARTS = 2;
+export const recoveryBudget = () => new Int32Array(new SharedArrayBuffer(4));
+
+// Playwright includes bounded browser logs on transport errors. Never retain the
+// launch command (which also contains local profile paths) in public diagnostics.
+export function crashDetails(error, t) {
+  const messages = [], seen = new Set();
+  for (let e = error; e && !seen.has(e); e = e.cause) { seen.add(e); messages.push(e.message ?? String(e)); }
+  const log = messages.join('\n');
+  const exit = log.match(/process did exit: exitCode=([^,\s]+), signal=([^\s>]+)/);
+  const stderr = log.split(/\r?\n/).filter(line => /\[err\]/.test(line) && !line.includes('<launching>')).slice(-20).join('\n').slice(-4000);
+  return { ...(t === undefined ? {} : { t }), reason: (messages.at(-1) ?? 'Browser closed unexpectedly').split(/\r?\n/)[0].slice(0, 500),
+    ...(exit ? { exitCode: exit[1] === 'null' ? null : Number(exit[1]), signal: exit[2] === 'null' ? null : exit[2] } : {}),
+    ...(stderr ? { stderr } : {}) };
+}
+
+export function browserClosed(error, browser, page, crashed = false) {
+  if (error?.code === 'render_threw' || error?.code === 'cancelled') return false;
+  return crashed || page?.isClosed() || (browser && !browser.isConnected())
+    || /Target (?:page, context or browser|closed)|(?:Page|Browser|Connection|Session) closed|Page crashed|Target crashed|browser has disconnected/i.test(error?.message ?? '')
+    || (error?.cause && browserClosed(error.cause, browser, page, crashed));
+}
+
+export const crashedError = (error, t) => new MultiplaneError('browser_crashed', undefined, { cause: error, details: crashDetails(error, t) });

package/src/capture.mjs

@@ -119,10 +119,10 @@ async function openShotOnce(shot, scale = 1, options = {}) {
     }
     if (alpha && cdp) await cdp.send('Emulation.setDefaultBackgroundColorOverride', { color: { r: 0, g: 0, b: 0, a: 0 } });
     const timings = { renderCallMs: 0, screenshotMs: 0 };
-    let closing, sampleContextUsed = false;
-    const draw = async (t, { motionBlur = 1 } = {}) => {
+    let closing, sampleContextUsed = false, motionProbeUsed = false, dofSamples = 0;
+    const draw = async (t, { motionBlur = 1, motionBlurBase = motionBlur, motionProbeTime, dofMotionSamples, dofMotionIndex } = {}) => {
         const renderStart = performance.now();
-        const changed = await page.evaluate(({ t, motionBlur, alpha }) => {
+        const changed = await page.evaluate(({ t, motionBlur, motionBlurBase, motionProbeTime, dofMotionSamples, dofMotionIndex, alpha }) => {
           globalThis.__multiplaneStatic?.suspend();
           if (alpha) document.documentElement.style.setProperty('--multiplane-page-background', 'transparent');
           const stage = document.querySelector('#stage');
@@ -135,17 +135,23 @@ async function openShotOnce(shot, scale = 1, options = {}) {
           globalThis.__multiplaneStatic?.resume();
           const previous = SHOT.sampleContext;
           let contextUsed = false;
-          SHOT.sampleContext = { time: t, get motionBlur() { contextUsed = true; return motionBlur; } };
+          // TODO(design): Document motionBlurBase, stable across nested refinements.
+          SHOT.sampleContext = { time: t, motionBlurBase, get motionBlur() { contextUsed = true; return motionBlur; } };
           let failure;
+          // Private renderer/layer handshake; never part of the shot contract.
+          const probe = globalThis.__multiplaneMotionProbe = { time: motionProbeTime, used: false, motionSamples: dofMotionSamples, motionIndex: dofMotionIndex, samples: 0 };
           try { SHOT.render(t); } catch (error) { failure = String(error?.message ?? error); } finally {
+            delete globalThis.__multiplaneMotionProbe;
             if (previous === undefined) delete SHOT.sampleContext;
             else SHOT.sampleContext = previous;
           }
           stage.getBoundingClientRect();
           const changed = globalThis.__multiplaneStatic?.read() ?? true;
-          return { failure, contextUsed, changed, reason: globalThis.__multiplaneStatic?.reason };
-        }, { t, motionBlur, alpha }).then(({ failure, changed, contextUsed, reason }) => {
+          return { failure, contextUsed, probeUsed: probe.used, dofSamples: probe.samples, changed, reason: globalThis.__multiplaneStatic?.reason };
+        }, { t, motionBlur, motionBlurBase, motionProbeTime, dofMotionSamples, dofMotionIndex, alpha }).then(({ failure, changed, contextUsed, probeUsed, dofSamples: count, reason }) => {
           sampleContextUsed = contextUsed;
+          motionProbeUsed = probeUsed;
+          dofSamples = count;
           const index = observationReasons.indexOf(reason);
           if (index >= 0) Atomics.add(reuseState(options), index + 4, 1);
           if (failure !== undefined) throw new MultiplaneError('render_threw', undefined, { details: { t, reason: failure } });
@@ -171,6 +177,8 @@ async function openShotOnce(shot, scale = 1, options = {}) {
     return {
       page, browser, server, ...metadata, alpha, beginFrame, timings,
       get sampleContextUsed() { return sampleContextUsed; },
+      get motionProbeUsed() { return motionProbeUsed; },
+      get dofSamples() { return dofSamples; },
       ...(reuseEnabled(options) ? { observe: draw } : {}),
       isCrash: error => browserClosed(error, browser, page, crashed),
       ...(metadata.hasBlurAt ? { blurAt: async t => {
@@ -212,6 +220,8 @@ export async function openShot(shot, scale = 1, options = {}) {
     get page() { return current.page; },
     get browser() { return current.browser; },
     get sampleContextUsed() { return current.sampleContextUsed; },
+    get motionProbeUsed() { return current.motionProbeUsed; },
+    get dofSamples() { return current.dofSamples; },
     ...(current.observe ? { observe: (...args) => current.observe(...args) } : {}),
     beginFrame: (...args) => current.beginFrame(...args),
     frame: (...args) => current.frame(...args),

package/src/encoder.mjs

@@ -1,16 +1,16 @@
-import { invalidOption } from './errors.mjs';
-export const encoders = ['x264', 'nvenc-h264', 'nvenc-hevc'];
-
-export function encoderArgs(name = 'x264', quality, maxMbps) {
-  if (!encoders.includes(name)) throw invalidOption('--encoder', '--encoder must be x264, nvenc-h264 or nvenc-hevc.');
-  if (maxMbps !== undefined && !(Number.isFinite(maxMbps) && maxMbps > 0)) throw invalidOption('--max-bitrate', '--max-bitrate must be positive (Mbps).');
-  const cap = maxMbps ? ['-maxrate', `${maxMbps}M`, '-bufsize', `${maxMbps * 2}M`] : [];
-  if (name === 'x264') return ['-c:v', 'libx264', '-profile:v', 'high', '-crf', '16', ...cap];
-  quality ??= name === 'nvenc-hevc' ? 20 : 21;
-  if (!Number.isInteger(quality) || quality < 1 || quality > 51) throw invalidOption('NVENC', 'NVENC CQ must be an integer from 1 to 51.');
-  return ['-c:v', name === 'nvenc-h264' ? 'h264_nvenc' : 'hevc_nvenc',
-    '-preset', 'p7', '-tune', 'hq', '-rc', 'vbr', '-cq', String(quality), '-b:v', '0',
-    ...(maxMbps ? cap : ['-qmin', '0', '-qmax', String(Math.min(51, quality + 2))]),
-    '-multipass', 'fullres', '-spatial-aq', '1', '-temporal-aq', '1', '-rc-lookahead', '32', '-bf', '3',
-    ...(name === 'nvenc-h264' ? ['-profile:v', 'high'] : ['-tag:v', 'hvc1'])];
-}
+import { invalidOption } from './errors.mjs';
+export const encoders = ['x264', 'nvenc-h264', 'nvenc-hevc'];
+
+export function encoderArgs(name = 'x264', quality, maxMbps) {
+  if (!encoders.includes(name)) throw invalidOption('--encoder', '--encoder must be x264, nvenc-h264 or nvenc-hevc.');
+  if (maxMbps !== undefined && !(Number.isFinite(maxMbps) && maxMbps > 0)) throw invalidOption('--max-bitrate', '--max-bitrate must be positive (Mbps).');
+  const cap = maxMbps ? ['-maxrate', `${maxMbps}M`, '-bufsize', `${maxMbps * 2}M`] : [];
+  if (name === 'x264') return ['-c:v', 'libx264', '-profile:v', 'high', '-crf', '16', ...cap];
+  quality ??= name === 'nvenc-hevc' ? 20 : 21;
+  if (!Number.isInteger(quality) || quality < 1 || quality > 51) throw invalidOption('NVENC', 'NVENC CQ must be an integer from 1 to 51.');
+  return ['-c:v', name === 'nvenc-h264' ? 'h264_nvenc' : 'hevc_nvenc',
+    '-preset', 'p7', '-tune', 'hq', '-rc', 'vbr', '-cq', String(quality), '-b:v', '0',
+    ...(maxMbps ? cap : ['-qmin', '0', '-qmax', String(Math.min(51, quality + 2))]),
+    '-multipass', 'fullres', '-spatial-aq', '1', '-temporal-aq', '1', '-rc-lookahead', '32', '-bf', '3',
+    ...(name === 'nvenc-h264' ? ['-profile:v', 'high'] : ['-tag:v', 'hvc1'])];
+}

package/src/environment.mjs

@@ -1,56 +1,56 @@
-import { chromium } from 'playwright';
-import { browserOptions, browserHint } from './platform.mjs';
-import { MultiplaneError } from './errors.mjs';
-export async function launchBrowser(options = {}, launcher = chromium, platform = process.platform) {
-  let browser;
-  try {
-    try {
-      browser = await launcher.launch(browserOptions(options.raster ?? 'gpu', options, platform));
-      if (platform !== 'linux' || options.raster === 'software' || (await environment(browser)).gpu.hardware) return browser;
-      await browser.close(); browser = undefined;
-    } catch (error) {
-      await browser?.close(); browser = undefined;
-      if (platform !== 'linux' || options.raster === 'software' || /Executable doesn't exist/.test(error.message)) throw error;
-    }
-    // ANGLE can launch without a working GL device on a headless Linux host.
-    // Relaunch with SwiftShader so WebGL shots remain usable and repeatable.
-    return await launcher.launch(browserOptions('software', options, platform));
-  } catch (cause) { throw new MultiplaneError(/Executable doesn't exist/.test(cause.message) ? 'browser_not_installed' : 'browser_launch_failed', undefined,
-    { cause, hint: browserHint(/Executable doesn't exist/.test(cause.message), platform), details: { reason: cause.message.split(/\r?\n/)[0] } }); }
-}
-export async function environment(browser, ffmpeg = null) {
-  const session = await browser.newBrowserCDPSession();
-  try {
-    const { gpu } = await session.send('SystemInfo.getInfo');
-    const renderer = gpu.auxAttributes?.glRenderer ?? gpu.devices?.[0]?.deviceString ?? 'unknown';
-    return { node: process.version, platform: process.platform, chromium: browser.version(),
-      gpu: { renderer, hardware: !/swiftshader|llvmpipe|software|unknown/i.test(renderer) }, ffmpeg };
-  } finally { await session.detach(); }
-}
-export async function loaded(events, capture, ffmpeg = null) {
-  events.options.alpha = capture.alpha;
-  events.start(true);
-  const { width, height, duration, fps, cuts, post } = capture;
-  events.emit('shot', { width, height, duration, fps, cuts, post });
-  events.check();
-}
-
-export function warnGpuFallback(events, info, options = {}) {
-  if ((options.raster ?? 'gpu') === 'gpu' && !info.gpu.hardware) {
-    events.emit('warning', { code: 'gpu_software_fallback', message: 'Hardware GPU rasterization is unavailable.' });
-  }
-}
-
-export const observeBrowser = (events, ffmpeg = null) => {
-  let observed = false;
-  return async browser => {
-    const unsubscribe = events.onCancel(() => browser.close());
-    browser.once('disconnected', unsubscribe);
-    events.check();
-    if (observed) return;
-    const info = await environment(browser, ffmpeg);
-    observed = true;
-    events.emit('environment', info);
-    warnGpuFallback(events, info, events.options);
-  };
-};
+import { chromium } from 'playwright';
+import { browserOptions, browserHint } from './platform.mjs';
+import { MultiplaneError } from './errors.mjs';
+export async function launchBrowser(options = {}, launcher = chromium, platform = process.platform) {
+  let browser;
+  try {
+    try {
+      browser = await launcher.launch(browserOptions(options.raster ?? 'gpu', options, platform));
+      if (platform !== 'linux' || options.raster === 'software' || (await environment(browser)).gpu.hardware) return browser;
+      await browser.close(); browser = undefined;
+    } catch (error) {
+      await browser?.close(); browser = undefined;
+      if (platform !== 'linux' || options.raster === 'software' || /Executable doesn't exist/.test(error.message)) throw error;
+    }
+    // ANGLE can launch without a working GL device on a headless Linux host.
+    // Relaunch with SwiftShader so WebGL shots remain usable and repeatable.
+    return await launcher.launch(browserOptions('software', options, platform));
+  } catch (cause) { throw new MultiplaneError(/Executable doesn't exist/.test(cause.message) ? 'browser_not_installed' : 'browser_launch_failed', undefined,
+    { cause, hint: browserHint(/Executable doesn't exist/.test(cause.message), platform), details: { reason: cause.message.split(/\r?\n/)[0] } }); }
+}
+export async function environment(browser, ffmpeg = null) {
+  const session = await browser.newBrowserCDPSession();
+  try {
+    const { gpu } = await session.send('SystemInfo.getInfo');
+    const renderer = gpu.auxAttributes?.glRenderer ?? gpu.devices?.[0]?.deviceString ?? 'unknown';
+    return { node: process.version, platform: process.platform, chromium: browser.version(),
+      gpu: { renderer, hardware: !/swiftshader|llvmpipe|software|unknown/i.test(renderer) }, ffmpeg };
+  } finally { await session.detach(); }
+}
+export async function loaded(events, capture, ffmpeg = null) {
+  events.options.alpha = capture.alpha;
+  events.start(true);
+  const { width, height, duration, fps, cuts, post } = capture;
+  events.emit('shot', { width, height, duration, fps, cuts, post });
+  events.check();
+}
+
+export function warnGpuFallback(events, info, options = {}) {
+  if ((options.raster ?? 'gpu') === 'gpu' && !info.gpu.hardware) {
+    events.emit('warning', { code: 'gpu_software_fallback', message: 'Hardware GPU rasterization is unavailable.' });
+  }
+}
+
+export const observeBrowser = (events, ffmpeg = null) => {
+  let observed = false;
+  return async browser => {
+    const unsubscribe = events.onCancel(() => browser.close());
+    browser.once('disconnected', unsubscribe);
+    events.check();
+    if (observed) return;
+    const info = await environment(browser, ffmpeg);
+    observed = true;
+    events.emit('environment', info);
+    warnGpuFallback(events, info, events.options);
+  };
+};

package/src/events.mjs

@@ -229,6 +229,9 @@ export async function runCommand(command, shot, options, action, job = true) {
           events.check();
         },
       }));
+      // Draft merges explicit options again; retain the absolute output path
+      // required by atomic directory publication and artifact relocation.
+      events.options.out = path.resolve(events.options.out);
     }
     events.start();
     for (const warning of user.warnings) events.warning(warning);

package/src/ffmpeg.mjs

@@ -1,32 +1,32 @@
-import { spawn } from 'node:child_process';
-import { MultiplaneError } from './errors.mjs';
-import { ffmpegName, ffmpegHint } from './platform.mjs';
-
-export function ffmpegOutput(executable, args, env = process.env) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(executable, args, { env, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
-    const timer = setTimeout(() => child.kill('SIGKILL'), 15000);
-    child.once('close', () => clearTimeout(timer));
-    child.once('error', () => clearTimeout(timer));
-    let output = '';
-    child.stdout.on('data', bytes => { output += bytes; });
-    child.stderr.on('data', bytes => { output += bytes; });
-    child.once('error', reject);
-    child.once('close', code => code === 0 ? resolve(output) : reject(new Error(`FFmpeg exited with code ${code}.`)));
-  });
-}
-export async function inspectFFmpeg(explicit, env = process.env, encoder, output = ffmpegOutput) {
-  const executable = explicit ?? env.MULTIPLANE_FFMPEG ?? ffmpegName();
-  try {
-    const version = (await output(executable, ['-version'], env)).split(/\r?\n/)[0];
-    if (encoder && !new RegExp(`\\b${encoder}\\b`).test(await output(executable, ['-encoders'], env))) throw new Error(`Missing encoder: ${encoder}`);
-    return { path: executable, version };
-  } catch (cause) {
-    throw new MultiplaneError(cause.code === 'ENOENT' ? 'ffmpeg_not_found' : 'ffmpeg_unusable', undefined,
-      { cause, hint: cause.message.startsWith('Missing encoder:') ? `${cause.message}. Use an FFmpeg build that includes it.` : ffmpegHint(), details: { reason: cause.message } });
-  }
-}
-
-export async function resolveFFmpeg(explicit, env = process.env) {
-  return (await inspectFFmpeg(explicit, env)).path;
-}
+import { spawn } from 'node:child_process';
+import { MultiplaneError } from './errors.mjs';
+import { ffmpegName, ffmpegHint } from './platform.mjs';
+
+export function ffmpegOutput(executable, args, env = process.env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(executable, args, { env, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    const timer = setTimeout(() => child.kill('SIGKILL'), 15000);
+    child.once('close', () => clearTimeout(timer));
+    child.once('error', () => clearTimeout(timer));
+    let output = '';
+    child.stdout.on('data', bytes => { output += bytes; });
+    child.stderr.on('data', bytes => { output += bytes; });
+    child.once('error', reject);
+    child.once('close', code => code === 0 ? resolve(output) : reject(new Error(`FFmpeg exited with code ${code}.`)));
+  });
+}
+export async function inspectFFmpeg(explicit, env = process.env, encoder, output = ffmpegOutput) {
+  const executable = explicit ?? env.MULTIPLANE_FFMPEG ?? ffmpegName();
+  try {
+    const version = (await output(executable, ['-version'], env)).split(/\r?\n/)[0];
+    if (encoder && !new RegExp(`\\b${encoder}\\b`).test(await output(executable, ['-encoders'], env))) throw new Error(`Missing encoder: ${encoder}`);
+    return { path: executable, version };
+  } catch (cause) {
+    throw new MultiplaneError(cause.code === 'ENOENT' ? 'ffmpeg_not_found' : 'ffmpeg_unusable', undefined,
+      { cause, hint: cause.message.startsWith('Missing encoder:') ? `${cause.message}. Use an FFmpeg build that includes it.` : ffmpegHint(), details: { reason: cause.message } });
+  }
+}
+
+export async function resolveFFmpeg(explicit, env = process.env) {
+  return (await inspectFFmpeg(explicit, env)).path;
+}