@higgsfield/video-editor-mcp 1.0.2 → 1.0.4

package/node_modules/@higgsfield/higgsedit/dist/capture-page.js

@@ -36814,9 +36814,17 @@ function invert(m) {
   return [m[3] * id, -m[1] * id, -m[2] * id, m[0] * id, (m[2] * m[5] - m[3] * m[4]) * id, (m[1] * m[4] - m[0] * m[5]) * id];
 }
 var sceneFps = (scene) => scene?.get(SceneConfig)?.fps ?? DEFAULT_FPS;
+// Capture selection scopes composition and pixels, but root timing stays in the
+// ordinary editor's stage clock, independent of the selected scene's own fps.
+var captureSceneIds = new WeakMap();
+function stageFps(world) {
+  const stage = findStage(world);
+  return sceneFps(stage ? childrenOf(stage).find((e) => e.get(Node).tag === "scene") : undefined);
+}
 function rootScenes(world) {
   const stage = findStage(world);
-  return stage ? childrenOf(stage).filter((e) => e.get(Node).tag === "scene") : [];
+  const sceneId = captureSceneIds.get(world);
+  return stage ? childrenOf(stage).filter((e) => e.get(Node).tag === "scene" && (sceneId === undefined || e.get(Node).key === sceneId || e.get(Node).id === sceneId)) : [];
 }
 function span(world, entity, fps) {
   const synced = syncedPlacement(world, entity, fps, SYNC_CLOCK);
@@ -36855,7 +36863,7 @@ function span(world, entity, fps) {
 }
 function fpsUnder(world, parent) {
   for (let e = parent; e; e = parentOf(e)) if (e.get(Node).tag === "scene") return sceneFps(e);
-  return sceneFps(rootScenes(world)[0]);
+  return stageFps(world);
 }
 var SYNC_CLOCK = { span, fpsUnder, speed: mediaSpeed };
 function sourceInOf(world, entity, fps) {
@@ -36869,7 +36877,7 @@ function localTime(world, entity, time) {
   const chain = [];
   for (let e = entity; e && e.get(Node).tag !== "stage"; e = parentOf(e)) chain.unshift(e);
   let clock = time;
-  let fps = sceneFps(rootScenes(world)[0]);
+  let fps = stageFps(world);
   for (const e of chain) {
     const start = span(world, e, fps).start;
     const tag2 = e.get(Node).tag;
@@ -36885,7 +36893,8 @@ function composition(world) {
   const config = scene?.get(SceneConfig);
   const fps = sceneFps(scene);
   let duration = 0;
-  for (const s of scenes) duration = Math.max(duration, span(world, s, fps).end);
+  const rootFps = stageFps(world);
+  for (const s of scenes) duration = Math.max(duration, span(world, s, rootFps).end);
   return {
     scene,
     width: config?.width ?? DEFAULT_SCENE.width,
@@ -37040,11 +37049,14 @@ function textPivot(entity, text) {
   const fallback = text.x0 === 0 ? 0 : align === "center" ? 0.5 : 1;
   return [text.x0 + num3(resolved(entity, "anchorX"), fallback) * text.width, num3(resolved(entity, "anchorY"), 0) * text.height];
 }
-function evaluate(world, time) {
+function evaluate(world, time, onlyScene) {
   const comp = composition(world);
+  const sceneConfig = onlyScene?.get(SceneConfig);
+  const sourceFps = stageFps(world);
+  const sourceEnd = onlyScene ? span(world, onlyScene, sourceFps).end : comp.duration;
   const stage = findStage(world);
   if (!stage) return comp;
-  const root = { time, length: comp.duration, fps: comp.fps, matrix: [1, 0, 0, 1, 0, 0], opacity: 1, width: comp.width, height: comp.height, baseWidth: comp.width, baseHeight: comp.height, active: true };
+  const root = { time, length: sourceEnd, fps: sourceFps, matrix: [1, 0, 0, 1, 0, 0], opacity: 1, width: sceneConfig?.width ?? comp.width, height: sceneConfig?.height ?? comp.height, baseWidth: sceneConfig?.width ?? comp.width, baseHeight: sceneConfig?.height ?? comp.height, active: true };
   const timeWalk = (entity, frame, held = false) => {
     const next = timeSystem(world, entity, frame, held);
     const crossings = entity.get(Crossings);
@@ -37054,7 +37066,10 @@ function evaluate(world, time) {
       return;
     }
     const crossing = new Set(crossings?.active.flatMap((c) => [c.left, c.right]));
-    for (const child of childrenOf(entity)) timeWalk(child, next, crossing.has(child));
+    for (const child of childrenOf(entity)) {
+      if (entity === stage && onlyScene && child !== onlyScene) deactivate(child);
+      else timeWalk(child, next, crossing.has(child));
+    }
   };
   timeWalk(stage, root);
   motionSystem(world);
@@ -37070,9 +37085,11 @@ function evaluate(world, time) {
   transformWalk(stage, root);
   return comp;
 }
-function clips(world) {
+function clips(world, onlyScene) {
   const out = [];
   const comp = composition(world);
+  const rootFps = stageFps(world);
+  if (onlyScene) comp.duration = span(world, onlyScene, rootFps).end;
   const visit = (entity, origin, fps, depth3, scene) => {
     const node = entity.get(Node);
     if (node.tag === "textRange" || node.tag === "shaderPaint") return;
@@ -37086,15 +37103,15 @@ function clips(world) {
       visit(child, clock, isScene ? sceneFps(entity) : fps, depth3 + 1, isScene ? node.key : scene);
     }
   };
-  for (const scene of rootScenes(world)) visit(scene, 0, comp.fps, 0, void 0);
+  for (const scene of onlyScene ? [onlyScene] : rootScenes(world)) visit(scene, 0, rootFps, 0, void 0);
   return out;
 }
 function hiddenInTree(entity) {
   for (let e = entity; e; e = parentOf(e)) if (e.get(Visibility)?.hidden === true) return true;
   return false;
 }
-function audioClips(world) {
-  const spans = new Map(clips(world).map((c) => [c.key, c]));
+function audioClips(world, onlyScene) {
+  const spans = new Map(clips(world, onlyScene).map((c) => [c.key, c]));
   const fps = composition(world).fps;
   const out = [];
   for (const e of world.query(Media, Node)) {
@@ -37108,7 +37125,7 @@ function audioClips(world) {
       src: media.src,
       start: clip.start,
       end: clip.end,
-      sourceIn: sourceInOf(world, e, fps),
+      sourceIn: sourceInOf(world, e, onlyScene ? fpsUnder(world, e) : fps),
       volume: media.volume ?? 1,
       fadeIn: Math.max(0, media.fadeIn ?? 0),
       fadeOut: Math.max(0, media.fadeOut ?? 0),
@@ -38585,7 +38602,7 @@ function drawFrame(ctx, world, comp, media, opts) {
   ctx.clearRect(0, 0, opts.origin ? ctx.canvas.width : comp.width * s, opts.origin ? ctx.canvas.height : comp.height * s);
   const stage = findStage(world);
   if (!stage) return;
-  childrenOf(stage).forEach((scene) => drawEntity(ctx, scene, media, opts, true));
+  childrenOf(stage).filter((scene) => !opts.scene || scene === opts.scene).forEach((scene) => drawEntity(ctx, scene, media, opts, true));
   ctx.setTransform(1, 0, 0, 1, 0, 0);
   ctx.globalAlpha = 1;
 }
@@ -40621,6 +40638,17 @@ function mountComponent(component, world, mode = "live", options = {}) {
 var HOLD_TIMEOUT_MS = 3e4;
 var relativeMedia = (src) => src.replace(/^\.\//, "");
 var fontsInUse = (world) => [...usedFonts(world), ...htmlFonts(world)];
+function captureMediaEntities(world, includes) {
+  const needed = new Set(world.query(Media).filter(includes));
+  const targets = new Map(syncLinks(world).filter((link) => !link.problem && link.target).map((link) => [link.entity, link.target]));
+  // Only load timing dependencies of the selected scene, not every sibling scene.
+  // Set iteration includes additions; cycles are bounded by the finite entity set.
+  for (const entity of needed) {
+    const target = targets.get(entity);
+    if (target) needed.add(target);
+  }
+  return needed;
+}
 var Session = class {
   world = createProjectWorld();
   mount;
@@ -40632,6 +40660,18 @@ var Session = class {
   mediaUrl;
   options;
   comp;
+  captureScene;
+  captureIncludes(entity) {
+    if (!this.captureScene) return true;
+    for (let e = entity; e; e = parentOf(e)) if (e === this.captureScene) return true;
+    return false;
+  }
+  captureFonts() {
+    return fontsInUse({ query: (...traits) => this.world.query(...traits).filter((entity) => this.captureIncludes(entity)) });
+  }
+  evaluateCapture(time) {
+    return evaluate(this.world, time, this.captureScene);
+  }
   /** The `@inspect` consts the last load evaluated, with the values it used. */
   inspect = [];
   constructor(options) {
@@ -40662,19 +40702,24 @@ var Session = class {
     const component = evaluateProject(modules, { ...externals, ...this.packages(packages, externals) });
     const t1 = performance.now();
     const world = createProjectWorld();
+    if (this.options.sceneId !== undefined) captureSceneIds.set(world, this.options.sceneId);
     const mount = mountComponent(component, world, this.options.mode === "capture" ? "capture" : "live", { resolveUrl: this.mediaUrl });
     const t2 = performance.now();
     this.mount?.dispose();
     this.world.destroy();
     this.world = world;
     this.mount = mount;
+    if (this.options.sceneId !== undefined) {
+      this.captureScene = rootScenes(world).find((scene) => scene.get(Node).key === this.options.sceneId || scene.get(Node).id === this.options.sceneId);
+      if (!this.captureScene) throw new Error(`unknown scene: ${this.options.sceneId}`);
+    }
     this.inspect = inspect.entries;
     const faces = await fontsLoaded;
     this.projectFamilies = new Set(faces.flatMap((f) => f ? [f.family.replace(/^["']|["']$/g, "").toLowerCase()] : []));
     this.googleFonts.retryFailed();
-    await this.googleFonts.load(fontsInUse(world), this.projectFamilies);
+    await this.googleFonts.load(this.captureFonts(), this.projectFamilies);
     await this.resolveMedia(this.options.mode === "capture");
-    this.comp = evaluate(world, 0);
+    this.comp = this.evaluateCapture(0);
     return {
       composition: { width: this.comp.width, height: this.comp.height, fps: this.comp.fps, duration: this.comp.duration, frames: this.comp.frames },
       clips: clips(world),
@@ -40686,28 +40731,29 @@ var Session = class {
   /** Opens every video and audio source to learn its duration; waits for them when `wait` (capture), else updates later. */
   async resolveMedia(wait2) {
     const durations = this.world.get(MediaInfo).durations;
-    const work = this.world.query(Media).filter((e) => (e.get(Node).tag === "video" || e.get(Node).tag === "audio") && e.get(Media).src).map((e) => {
+    const needed = captureMediaEntities(this.world, (entity) => this.captureIncludes(entity));
+    const work = [...needed].filter((e) => (e.get(Node).tag === "video" || e.get(Node).tag === "audio") && e.get(Media).src).map((e) => {
       const src = e.get(Media).src;
       const handle = e.get(Node).tag === "audio" ? this.media.audio(src) : this.media.video(src);
       return handle.ready.then((facts) => {
         durations.set(src, facts.duration);
       });
     });
-    for (const e of this.world.query(Captions)) {
+    for (const e of this.world.query(Captions).filter((entity) => this.captureIncludes(entity))) {
       const src = e.get(Captions).src;
       if (src) work.push(this.media.transcript(src).ready.then((t) => void durations.set(src, transcriptLength(t))));
     }
-    work.push(this.resolveSyncs());
+    work.push(this.resolveSyncs(needed));
     if (wait2) await Promise.all(work);
     else await Promise.race([Promise.allSettled(work), new Promise((r) => setTimeout(r, 0))]);
   }
   /** Asks the server to measure every `syncTo` pair (it caches them) so the runtime can place those elements. */
-  async resolveSyncs() {
+  async resolveSyncs(needed) {
     const world = this.world;
     const offsets = world.get(MediaInfo).offsets;
     const url2 = this.options.syncUrl ?? `${new URL(this.options.mediaBase, globalThis.location?.href).origin}/__higgsedit/sync`;
     await Promise.all(
-      syncLinks(world).map(async (link) => {
+      syncLinks(world).filter((link) => needed.has(link.entity)).map(async (link) => {
         if (link.problem || !link.src || !link.targetSrc) {
           console.warn(`syncTo on ${link.key}: ${link.problem ?? "nothing to align"}; it keeps its default placement`);
           return;
@@ -40739,22 +40785,21 @@ var Session = class {
   }
   /** Writes the tick for frame `f` (capture mode: a pure function of `f`). */
   tick(frame, opts = {}) {
-    const fps = this.comp?.fps ?? 30;
+    const fps = stageFps(this.world);
     const time = opts.time ?? frame / fps;
     batch(() => this.mount?.tick({ time, frame, delta: opts.delta ?? 1 / fps, playing: opts.playing ?? true }));
-    this.comp = evaluate(this.world, time);
+    this.comp = this.evaluateCapture(time);
     return this.comp;
   }
   /**
    * Frame barrier: holds registered since the tick, exact media for active elements, and
    * fonts; re-checked until no new work appears.
    */
-  async settle(frame) {
+  async settle(frame, time = frame / stageFps(this.world)) {
     const document2 = this.mount?.document;
-    const fps = this.comp?.fps ?? 30;
     for (let round = 0; round < 50; round++) {
       const holds = document2 ? [...document2.holds] : [];
-      const work = Promise.all([...holds, mediaReady(this.world, this.media), this.googleFonts.load(fontsInUse(this.world), this.projectFamilies), globalThis.document?.fonts?.ready]);
+      const work = Promise.all([...holds, mediaReady(this.world, this.media), this.googleFonts.load(this.captureFonts(), this.projectFamilies), globalThis.document?.fonts?.ready]);
       let timer;
       const timeout = new Promise((_, reject) => {
         timer = setTimeout(() => reject(new Error(`frame ${frame}: hold() did not settle within ${HOLD_TIMEOUT_MS / 1e3} s`)), HOLD_TIMEOUT_MS);
@@ -40764,7 +40809,7 @@ var Session = class {
       } finally {
         clearTimeout(timer);
       }
-      this.comp = evaluate(this.world, frame / fps);
+      this.comp = this.evaluateCapture(time);
       if (!document2 || document2.holds.size === 0) {
         await mediaReady(this.world, this.media);
         return;
@@ -40779,7 +40824,7 @@ var Session = class {
       await this.settle(frame);
       drawFrame(ctx, this.world, this.comp, this.media, { mode: "capture", scale });
     } catch (error) {
-      throw withFrame(error, frame, this.comp?.fps ?? 30);
+      throw withFrame(error, frame, stageFps(this.world));
     }
   }
   /** Live mode: draw whatever media is ready now. */
@@ -40802,8 +40847,23 @@ var session;
 var canvas;
 var depth2 = 8;
 var encoder;
+var outputComposition;
+var outputOrigin = 0;
+async function renderOutputFrame(ctx, frame) {
+  if (!outputComposition) return session.renderFrame(ctx, frame);
+  const time = outputOrigin + frame / outputComposition.fps;
+  const authoredFrame = Math.round(time * stageFps(session.world));
+  session.tick(authoredFrame, { time });
+  await session.settle(authoredFrame, time);
+  const source = session.captureScene?.get(SceneConfig) ?? session.comp;
+  const sourceWidth = source.width ?? session.comp.width;
+  const sourceHeight = source.height ?? session.comp.height;
+  const scale = Math.min(outputComposition.width / sourceWidth, outputComposition.height / sourceHeight);
+  const origin = { x: -(outputComposition.width / scale - sourceWidth) / 2, y: -(outputComposition.height / scale - sourceHeight) / 2 };
+  drawFrame(ctx, session.world, session.comp, session.media, { mode: "capture", scale, origin, scene: session.captureScene });
+}
 function context() {
-  const comp = session.comp;
+  const comp = outputComposition ?? session.comp;
   if (!canvas || canvas.width !== comp.width || canvas.height !== comp.height) {
     canvas = new OffscreenCanvas(comp.width, comp.height);
   }
@@ -40817,22 +40877,36 @@ function read(ctx) {
   return image.data;
 }
 var api = {
-  async load({ modules, fonts, packages, mediaBase, depth: d, hostFrames }) {
+  async load({ modules, fonts, packages, mediaBase, depth: d, hostFrames, spec, sceneId }) {
     depth2 = d;
     session = new Session({
       mediaBase,
       mode: "capture",
+      sceneId,
       ...hostFrames ? { makeVideo: (src) => new HostFrameVideo(src, hostFrames) } : {}
     });
-    return session.load(modules, fonts, void 0, packages);
+    const info = await session.load(modules, fonts, void 0, packages);
+    outputComposition = undefined;
+    outputOrigin = 0;
+    if (spec || sceneId !== undefined) {
+      const scene = session.captureScene;
+      const timing = scene ? span(session.world, scene, stageFps(session.world)) : { start: 0, end: info.composition.duration };
+      const config = scene?.get(SceneConfig);
+      outputOrigin = timing.start;
+      const fps = spec?.video.fps ?? config?.fps ?? info.composition.fps;
+      const duration = timing.end - timing.start;
+      outputComposition = { width: spec?.video.width ?? config?.width ?? info.composition.width, height: spec?.video.height ?? config?.height ?? info.composition.height, fps, duration, frames: Math.max(1, Math.round(duration * fps)) };
+      return { ...info, composition: outputComposition, sourceFps: config?.fps ?? info.composition.fps };
+    }
+    return info;
   },
   async png(frame) {
     const ctx = context();
-    await session.renderFrame(ctx, frame);
+    await renderOutputFrame(ctx, frame);
     return toBase64(await canvas.convertToBlob({ type: "image/png" }));
   },
   async sheet(frames, { columns, width }) {
-    const comp = session.comp;
+    const comp = outputComposition ?? session.comp;
     const thumbW = width;
     const thumbH = Math.round(width * comp.height / comp.width);
     const label = 28;
@@ -40843,7 +40917,7 @@ var api = {
     out.fillRect(0, 0, sheet.width, sheet.height);
     for (const [i, frame] of frames.entries()) {
       const ctx = context();
-      await session.renderFrame(ctx, frame);
+      await renderOutputFrame(ctx, frame);
       const x = i % columns * thumbW;
       const y = Math.floor(i / columns) * (thumbH + label);
       out.drawImage(canvas, x, y, thumbW, thumbH);
@@ -40854,12 +40928,12 @@ var api = {
     }
     return toBase64(await sheet.convertToBlob({ type: "image/png" }));
   },
-  audio: () => audioClips(session.world),
+  audio: () => audioClips(session.world, session.captureScene).map((clip) => ({ ...clip, start: clip.start - outputOrigin, end: clip.end - outputOrigin })),
   fontMisses: () => session.fontMisses(),
   async raw(frame, url2) {
     const ctx = context();
     const t0 = performance.now();
-    await session.renderFrame(ctx, frame);
+    await renderOutputFrame(ctx, frame);
     const t1 = performance.now();
     const data = read(ctx);
     const t2 = performance.now();
@@ -40869,17 +40943,17 @@ var api = {
   },
   async digest(frame) {
     const ctx = context();
-    await session.renderFrame(ctx, frame);
+    await renderOutputFrame(ctx, frame);
     const data = read(ctx);
     const hash = await crypto.subtle.digest("SHA-256", data);
     return [...new Uint8Array(hash)].map((b) => b.toString(16).padStart(2, "0")).join("");
   },
   async encodeCheck({ codec, bitrate }) {
-    const comp = session.comp;
+    const comp = outputComposition ?? session.comp;
     return await encodeProblem({ depth: depth2, codec, width: comp.width, height: comp.height, fps: comp.fps, bitrate }) ?? null;
   },
   async encodeStart({ url: url2, codec, quantizer, bitrate }) {
-    const comp = session.comp;
+    const comp = outputComposition ?? session.comp;
     context();
     encoder = await createWebCodecsEncoder(canvas, {
       depth: depth2,
@@ -40898,7 +40972,7 @@ var api = {
   async encodeFrame(frame, index) {
     const ctx = context();
     const t0 = performance.now();
-    await session.renderFrame(ctx, frame);
+    await renderOutputFrame(ctx, frame);
     const t1 = performance.now();
     await encoder.add(index);
     return { renderMs: t1 - t0, encodeMs: performance.now() - t1 };

package/node_modules/@higgsfield/higgsedit/dist/chunk-4D6AXU4B.mjs

@@ -152,7 +152,7 @@ var FontLoadError = class extends Error {
     super(`${fonts}; the frame would draw in a fallback font.`);
   }
 };
-async function openCapture(dir, depth, allowFontFallback = false) {
+async function openCapture(dir, depth, allowFontFallback = false, options = {}) {
   const decoders = /* @__PURE__ */ new Map();
   const sinks = /* @__PURE__ */ new Map();
   let sinkId = 0;
@@ -203,20 +203,30 @@ async function openCapture(dir, depth, allowFontFallback = false) {
     }
   ];
   const server = await startServer(dir, handlers);
-  const browser = await launch();
-  const page = await capturePage(browser, server.origin);
-  const modules = compileProject(readSources(dir));
-  const fonts = fontFiles(dir);
-  const packages = (await bundlePackages(dir)).code;
-  const info = await page.evaluate(
-    ({ modules: modules2, fonts: fonts2, packages: packages2, origin, depth: depth2 }) => globalThis.higgsedit.load({ modules: modules2, fonts: fonts2, packages: packages2, mediaBase: `${origin}/project`, depth: depth2, ...depth2 === 10 ? { hostFrames: `${origin}/__higgsedit/media` } : {} }),
-    { modules, fonts, packages, origin: server.origin, depth }
-  );
+  let browser;
+  let page;
+  let info;
+  try {
+    browser = await launch();
+    page = await capturePage(browser, server.origin);
+    const modules = compileProject(readSources(dir));
+    const fonts = fontFiles(dir);
+    const packages = (await bundlePackages(dir)).code;
+    info = await page.evaluate(
+      ({ modules, fonts, packages, origin, depth, options }) => globalThis.higgsedit.load({ modules, fonts, packages, mediaBase: `${origin}/project`, depth, ...options, ...depth === 10 ? { hostFrames: `${origin}/__higgsedit/media` } : {} }),
+      { modules, fonts, packages, origin: server.origin, depth, options }
+    );
+  } catch (error) {
+    for (const decoder of decoders.values()) decoder.close();
+    try { await browser?.close(); } finally { await server.close(); }
+    throw error;
+  }
   return {
     page,
     browser,
     server,
     composition: info.composition,
+    sourceFps: info.sourceFps ?? info.composition.fps,
     decoders,
     sink(onBody) {
       const id = String(++sinkId);
@@ -231,8 +241,7 @@ async function openCapture(dir, depth, allowFontFallback = false) {
     },
     async close() {
       for (const d of decoders.values()) d.close();
-      await browser.close();
-      await server.close();
+      try { await browser.close(); } finally { await server.close(); }
     }
   };
 }
@@ -251,15 +260,16 @@ var api = (page) => ({
 });
 
 // src/render.ts
-var toFrame = (value, fps, fallback) => {
+var toFrame = (value, fps, fallback, sourceFps = fps) => {
   if (value === void 0) return fallback;
-  const seconds = parseTime(/^-?\d+(\.\d+)?$/.test(value) ? Number(value) : value, fps);
+  const seconds = parseTime(/^-?\d+(\.\d+)?$/.test(value) ? Number(value) : value, sourceFps);
   if (seconds === void 0) throw new Error(`cannot read time "${value}"`);
   return Math.round(seconds * fps);
 };
 var FFMPEG_CODECS = { x264: "libx264", x265: "libx265", videotoolbox: "hevc_videotoolbox" };
 function videoArgs(opts, encoder) {
   const tags = ["-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709", "-color_range", "tv"];
+  const quality = opts.spec?.video.bitrate !== undefined ? ["-b:v", String(opts.spec.video.bitrate)] : ["-crf", String(opts.crf ?? 18)];
   if (encoder === "videotoolbox") {
     return ["-c:v", "hevc_videotoolbox", "-profile:v", opts.depth === 10 ? "main10" : "main", "-q:v", "70", "-tag:v", "hvc1", ...tags];
   }
@@ -269,8 +279,7 @@ function videoArgs(opts, encoder) {
       "libx265",
       "-preset",
       opts.preset ?? "fast",
-      "-crf",
-      String(opts.crf ?? 18),
+      ...quality,
       "-profile:v",
       opts.depth === 10 ? "main10" : "main",
       "-tag:v",
@@ -280,7 +289,7 @@ function videoArgs(opts, encoder) {
       ...tags
     ];
   }
-  return ["-c:v", "libx264", "-preset", opts.preset ?? "medium", "-crf", String(opts.crf ?? 18), ...tags];
+  return ["-c:v", "libx264", "-preset", opts.preset ?? "medium", ...quality, ...tags];
 }
 function gainFilter(clip, from) {
   const len = clip.end - clip.start;
@@ -309,7 +318,7 @@ function rateFilter(clip) {
 async function render(dir, opts) {
   const log = opts.log ?? (() => {
   });
-  const session = await openCapture(dir, opts.depth, opts.allowFontFallback);
+  const session = await openCapture(dir, opts.depth, opts.allowFontFallback, { spec: opts.spec, sceneId: opts.sceneId });
   try {
     return await renderWith(session, dir, opts, log);
   } finally {
@@ -338,6 +347,10 @@ async function audioMix(session, dir, span) {
   return { audio, inputs, filters };
 }
 var AUDIO_CODEC = ["-c:a", "aac", "-b:a", "192k"];
+function audioArgs(opts) {
+  const audio = opts.spec?.audio;
+  return audio ? ["-c:a", "aac", "-b:a", String(audio.bitrate ?? 192000), "-ar", String(audio.sampleRate), "-ac", String(audio.channels)] : AUDIO_CODEC;
+}
 function cancelled() {
   const error = new Error("render cancelled");
   error.name = "RenderCancelledError";
@@ -352,14 +365,14 @@ function progress(opts, log, started, done, count) {
 }
 async function renderWith(session, dir, opts, log) {
   const { width, height, fps, frames: total } = session.composition;
-  const first = toFrame(opts.from, fps, 0);
-  const last = Math.min(total, toFrame(opts.to, fps, total));
+  const first = Math.max(0, toFrame(opts.from, fps, 0, session.sourceFps));
+  const last = Math.min(total, toFrame(opts.to, fps, total, session.sourceFps));
   if (last <= first) throw new Error(`nothing to render between frame ${first} and ${last}`);
   const span = { first, last, count: last - first, t0: first / fps, duration: (last - first) / fps };
   const encoder = await pickEncoder(session, opts, log);
   const out = resolve(opts.out);
   mkdirSync(dirname(out), { recursive: true });
-  const mix = await audioMix(session, dir, span);
+  const mix = opts.spec?.audio === null ? { audio: [], inputs: [], filters: [] } : await audioMix(session, dir, span);
   const started = performance.now();
   const { codec, breakdown } = await (encoder === "webcodecs" ? encodeInPage(session, opts, out, span, mix, log, started) : encodeWithFfmpeg(session, opts, encoder, out, span, mix, log, started)).catch((error) => {
     rmSync(out, { force: true });
@@ -388,11 +401,13 @@ async function pickEncoder(session, opts, log) {
   const encoder = opts.encoder ?? (opts.depth === 10 ? "x265" : "webcodecs");
   if (encoder !== "webcodecs") return encoder;
   const { width, height, fps } = session.composition;
-  const problem = await api(session.page).encodeCheck({ codec: opts.webcodecsCodec ?? "avc", bitrate: fallbackBitrate(width, height, fps) });
+  const codec = opts.spec?.video.codec ?? opts.webcodecsCodec ?? "avc";
+  const problem = await api(session.page).encodeCheck({ codec, bitrate: opts.spec?.video.bitrate ?? fallbackBitrate(width, height, fps) });
   if (!problem) return encoder;
   if (!opts.encoder) {
-    log(`${problem}; encoding with x264`);
-    return "x264";
+    const fallback = codec === "hevc" ? "x265" : "x264";
+    log(`${problem}; encoding with ${fallback}`);
+    return fallback;
   }
   throw new Error(`${problem}; ${opts.depth === 10 ? "render --depth 10 without --encoder webcodecs (ffmpeg x265)" : "render without --encoder webcodecs"}`);
 }
@@ -401,7 +416,7 @@ async function encodeWithFfmpeg(session, opts, codec, out, span, mix, log, start
   const pixFmt = opts.depth === 10 ? "rgbaf16le" : "rgba";
   const outFmt = opts.depth === 10 ? "yuv420p10le" : "yuv420p";
   const filters = [`[0:v]scale=out_color_matrix=bt709:out_range=limited:flags=accurate_rnd+full_chroma_int,format=${outFmt},setparams=color_primaries=bt709:color_trc=bt709:colorspace=bt709:range=tv[v]`, ...mix.filters];
-  const maps = ["-map", "[v]", ...mix.audio.length ? ["-map", "[a]", ...AUDIO_CODEC] : []];
+  const maps = ["-map", "[v]", ...mix.audio.length ? ["-map", "[a]", ...audioArgs(opts)] : []];
   const encoder = ffmpeg(
     [
       "-y",
@@ -476,7 +491,7 @@ async function encodeInPage(session, opts, out, span, mix, log, started) {
       const sink = session.sink(async (position, body) => {
         await file.write(body, 0, body.length, position);
       });
-      await page.encodeStart({ url: sink, codec: opts.webcodecsCodec ?? "avc", quantizer: opts.crf ?? 18, bitrate: fallbackBitrate(width, height, fps) });
+      await page.encodeStart({ url: sink, codec: opts.spec?.video.codec ?? opts.webcodecsCodec ?? "avc", ...opts.spec?.video.bitrate === undefined ? { quantizer: opts.crf ?? 18 } : {}, bitrate: opts.spec?.video.bitrate ?? fallbackBitrate(width, height, fps) });
       for (let f = span.first; f < span.last; f++) {
         if (opts.signal?.aborted) {
           await page.encodeCancel();
@@ -489,13 +504,16 @@ async function encodeInPage(session, opts, out, span, mix, log, started) {
         progress(opts, log, started, f - span.first + 1, span.count);
       }
       ({ codec } = await page.encodeEnd());
+    } catch (error) {
+      await page.encodeCancel().catch(() => {});
+      throw error;
     } finally {
       await file.close();
     }
     const hevc = !codec.startsWith("avc1");
     const retag = `${hevc ? "hevc" : "h264"}_metadata=colour_primaries=1`;
     const tag = hevc ? ["-tag:v", "hvc1"] : [];
-    const audio = mix.audio.length ? ["-filter_complex", mix.filters.join(";"), "-map", "[a]", ...AUDIO_CODEC] : [];
+    const audio = mix.audio.length ? ["-filter_complex", mix.filters.join(";"), "-map", "[a]", ...audioArgs(opts)] : [];
     const muxer = ffmpeg(["-y", "-i", video, ...mix.inputs, "-map", "0:v", "-c:v", "copy", "-bsf:v", retag, ...tag, "-color_primaries", "bt709", ...audio, "-t", span.duration.toFixed(6), "-movflags", "+faststart", out]);
     let stderr = "";
     muxer.stderr.on("data", (d) => stderr += d.toString());