multiplane 0.3.7 → 0.3.10

package/README.en.md

@@ -11,7 +11,7 @@ A local, headless HTML video renderer for AI agents. **A shot is an ordinary web
 
 <img src="https://raw.githubusercontent.com/LBEILC/Multiplane/main/docs/images/hero.webp" width="720" alt="3D cards rendered by Multiplane, with depth of field and motion blur">
 
-> Version `0.3.0`. The full test suite passes in CI on Windows, macOS and Linux; Windows has also been verified on a real machine. Interfaces may still change before 1.0.
+> Version `0.3.8` (the latest version is on the [Releases page](https://github.com/LBEILC/Multiplane/releases)). The full test suite passes in CI on Windows, macOS and Linux; Windows has also been verified on a real machine. Interfaces may still change before 1.0.
 
 The name comes from Disney's multiplane camera: flat artwork placed at different depths, photographed frame by frame with real depth of field. Here, this corresponds to layered web content, a 3D card layer, and accumulated depth of field.
 
@@ -127,11 +127,16 @@ For the full contract, patterns that break determinism, and 3D layer usage, see
 | `multiplane status <job>` | View job status |
 | `multiplane cancel <job>` | Stop a job |
 | `multiplane wait <job>` | Wait for a job to finish and print its events, for example after an agent session restarts |
+| `multiplane resume <job>` | Continue an interrupted render from where it stopped |
 | `multiplane config get\|set\|unset` | Read or change the user config |
 | `multiplane skill status\|install\|remove` | Install, update or remove the agent skill for Claude Code and Codex |
 
 Shot paths are relative to the resource root `--root` (the current directory by default). Each run has its own job directory, `out/jobs/<jobId>/`. Without `--out`, artifacts are written there (video, `stills/`, `verify/`), so runs do not overwrite each other. See `artifacts` in the result for the final paths. `--out` sets the output location. An existing target is rejected unless `--overwrite` is given. `render`, `stills`, and `verify` automatically run `lint` before starting and stop on errors. Use `--no-lint` to skip it. `npx multiplane <command> --help` lists all options for that command.
 
+`render` encodes in segments of about 10 seconds and keeps each one on disk as soon as it is done. If a render stops part way (the process is killed, the machine crashes or loses power, the browser keeps crashing, or you stop it), `multiplane resume <job>` skips the segments already encoded, renders the rest and joins them without re-encoding; the frames are identical to an uninterrupted render. A resume keeps all of the original job's options. It is refused (`resume_unavailable`, with the reason) when a file the shot loaded or the audio file has changed, or the Multiplane, Chromium or FFmpeg version, the raster mode or the encoder differs, so a film is never joined from mismatched parts; a different GPU or driver only produces a warning (`resume_renderer_changed`). `multiplane status` reports whether a job can be resumed and how many frames are done. See section 6.1 of the protocol.
+
+A stuck browser does not stall a render forever. If a worker holds frames but delivers none for `max(120 seconds, 10 × the slowest frame so far)`, its browser is closed and relaunched, the frame is rendered again from scratch (with the same pixels), and a `worker_stalled` warning is reported. Each frame is retried at most twice; a third stall ends the job with `browser_crashed`. Segments already encoded are kept, so the job can be resumed.
+
 Common `render` options:
 
 | Option | Meaning |
@@ -269,20 +274,26 @@ npm install three@0.180.0
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/LBEILC/Multiplane/main/docs/images/app-jobs-en-dark.png">
-  <img src="https://raw.githubusercontent.com/LBEILC/Multiplane/main/docs/images/app-jobs-en-light.png" width="800" alt="The Jobs page of the Multiplane desktop app: a running job, a queued job and a live preview frame">
+  <img src="https://raw.githubusercontent.com/LBEILC/Multiplane/main/docs/images/app-jobs-en-light.png" width="800" alt="The Jobs page of the Multiplane desktop app: running, queued and resumable jobs on the left, and the Timeline tab of the selected job on the right, listing how long each phase took and the events">
 </picture>
 
 
-- **Jobs**: list render, stills, and check jobs across projects, show progress and preview frames in real time, view finished videos, contact sheets, and diff images from failed checks, and stop running jobs.
-- **Environment**: check whether the browser, GPU rasterization, FFmpeg, and other requirements are ready. Install and update the Multiplane skill for Claude Code (`~/.claude/skills/`) and Codex (`~/.agents/skills/`), without directly overwriting user modifications.
+- **Jobs**: list render, stills, and check jobs across projects, show progress and preview frames in real time, and stop running jobs. Opening a job shows four tabs:
+  - **Preview**: finished videos play in a frame-accurate player: step one frame at a time, jump between cuts, and read the exact frame number and timecode. Any frame opens in a viewer that zooms to actual pixels, and when a determinism check fails, the reference, actual and difference images can be compared side by side or by flickering between them.
+  - **Summary**: the output, whether it was verified, and the picture, post-processing, performance and environment at a glance.
+  - **Timeline**: how long each phase took, with the events and warnings along the way.
+  - **Options**: the settings the job actually used, in plain words, which can be copied as a command.
+- **Resume**: a failed or stopped render that can continue shows **Resume** with the frames already done, and the new job links back to the original. When resuming is refused, the app explains why, for example which files changed. With hosting on, the app also takes over an agent's `resume` requests.
+- **Tray popover**: on Windows and macOS, clicking the tray icon opens a small panel with running, queued and recently finished jobs. The tray icon and the taskbar button show render progress. Linux keeps the system menu.
+- **Environment**: check whether the browser, GPU rasterization, FFmpeg, and other requirements are ready; on first use, **Install browser** here downloads Chromium. Install and update the Multiplane skill for Claude Code (`~/.claude/skills/`) and Codex (`~/.agents/skills/`), without directly overwriting user modifications.
 - **Settings**: write the user config `config.json` described above.
 - **Hosted renders** (off by default): when turned on in Settings, renders started by an agent are run by the app instead of the agent's session, so they keep going when the session ends. One hosted render runs at a time and the rest wait in a queue. The agent's command and output stay the same, and `multiplane wait <job>` picks a job up again after a session restarts. With hosting on, closing the window keeps the app in the system tray. See section 11 of the protocol.
-- **Updates**: the app checks GitHub for a new release at startup and once a day (can be turned off). On Windows it downloads and installs the update in the app; on macOS and Linux it links to the download page.
+- **Updates**: the app checks GitHub for a new release at startup and once a day (can be turned off). On Windows it downloads and installs the update in the app; on macOS and Linux it links to the download page. The About page lists what changed in each version since the one installed, in the interface language.
 - The interface is in English and Simplified Chinese. It follows the system language and can be switched in Settings.
 
 It communicates with the renderer only through the files and commands in [`docs/protocol.md`](https://github.com/LBEILC/Multiplane/blob/main/docs/protocol.md). It is not required for rendering: agents can render from the command line without it.
 
-Download an installer from the [Releases page](https://github.com/LBEILC/Multiplane/releases). The installers bundle a renderer of the same version, so the app works without a separate Node.js install. That renderer is also available as a command: `multiplane.cmd` in the install directory on Windows, `Multiplane.app/Contents/Resources/bin/multiplane` on macOS, and `Multiplane-<version>-x86_64.AppImage --multiplane-cli` on Linux. The Environment page shows the exact path when `multiplane` is not on PATH. FFmpeg is not bundled (see above), and Chromium is downloaded on first use from the Environment page.
+Download an installer from the [Releases page](https://github.com/LBEILC/Multiplane/releases). The installers bundle a renderer of the same version, so the app works without a separate Node.js install. That renderer is also available as a command: `multiplane.cmd` in the install directory on Windows, `Multiplane.app/Contents/Resources/bin/multiplane` on macOS, and `Multiplane-<version>-x86_64.AppImage --multiplane-cli` on Linux. The Environment page shows the exact path when `multiplane` is not on PATH. FFmpeg is not bundled (see above; install one with libx264 support), and Chromium is downloaded on first use with **Install browser** on the Environment page.
 
 | System | Package | First launch (the packages are not code-signed) |
 |---|---|---|

package/README.md

@@ -11,7 +11,7 @@
 
 <img src="https://raw.githubusercontent.com/LBEILC/Multiplane/main/docs/images/hero.webp" width="720" alt="Multiplane 渲染的三维卡片：景深虚化与运动模糊">
 
-> 当前版本 `0.3.0`。完整测试在 Windows、macOS、Linux 三个平台的 CI 上全部通过；Windows 另在真机上验证过。1.0 之前接口仍可能调整。
+> 当前版本 `0.3.8`（最新版本见 [Releases 页面](https://github.com/LBEILC/Multiplane/releases)）。完整测试在 Windows、macOS、Linux 三个平台的 CI 上全部通过；Windows 另在真机上验证过。1.0 之前接口仍可能调整。
 
 名字来自迪士尼的多层摄影台（multiplane camera）：一层层平面画稿放在不同深度、逐帧拍摄、带真实景深。对应这里的多层网页画面、三维卡片层和累积景深。
 
@@ -127,11 +127,16 @@ Shot.define({
 | `multiplane status <job>` | 查看作业状态 |
 | `multiplane cancel <job>` | 停止作业 |
 | `multiplane wait <job>` | 等一个作业结束并输出它的事件，例如 agent 会话重启之后 |
+| `multiplane resume <job>` | 中断的渲染从停下的地方接着渲 |
 | `multiplane config get\|set\|unset` | 读取或修改用户配置 |
 | `multiplane skill status\|install\|remove` | 给 Claude Code 和 Codex 安装、更新、移除 agent skill |
 
 镜头路径相对资源根 `--root`（默认当前目录）。每次运行都有自己的作业目录 `out/jobs/<jobId>/`，不给 `--out` 时产物就写在里面（视频、`stills/`、`verify/`），多次运行互不覆盖；最终路径见结果里的 `artifacts`。`--out` 指定输出位置，目标已存在时会拒绝覆盖，加 `--overwrite` 才替换。`render`、`stills`、`verify` 启动前自动跑 `lint`，有 error 就停下，`--no-lint` 跳过。`npx multiplane <command> --help` 列出该命令的全部参数。
 
+`render` 按约 10 秒一段编码，每段编完就落盘。渲染中途停下（进程被杀、死机、断电、浏览器反复崩溃、手动停止）后，`multiplane resume <job>` 会跳过已经编好的段、只渲剩下的，最后不重新编码地拼成成片，画面与一次渲完的逐帧相同。续传沿用原作业的全部参数；镜头加载过的文件或音频文件改了，或 Multiplane、Chromium、FFmpeg 的版本、光栅模式、编码器变了，会拒绝续传（`resume_unavailable`，并说明是哪一项），以免拼出前后不一致的片子；只是显卡或驱动不同，则只给出警告（`resume_renderer_changed`）。`multiplane status` 会告诉你一个作业能不能续传、已经渲完多少帧。见协议第 6.1 节。
+
+浏览器卡住时，渲染也不会一直挂着：某个进程拿着帧、却在 `max(120 秒, 此前最慢一帧耗时的 10 倍)` 内一帧都交不出来时，会关掉它的浏览器、重新启动，并把那一帧从头重渲（像素相同），同时报 `worker_stalled` 警告。每一帧最多重试两次，第三次再卡住，作业以 `browser_crashed` 结束；已经编好的段会保留，之后可以用 `resume` 接着渲。
+
 `render` 的常用参数：
 
 | 参数 | 含义 |
@@ -269,20 +274,26 @@ npm install three@0.180.0
 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/LBEILC/Multiplane/main/docs/images/app-jobs-zh-dark.png">
-  <img src="https://raw.githubusercontent.com/LBEILC/Multiplane/main/docs/images/app-jobs-zh-light.png" width="800" alt="Multiplane 桌面软件的作业页：进行中的作业、排队中的作业和实时预览帧">
+  <img src="https://raw.githubusercontent.com/LBEILC/Multiplane/main/docs/images/app-jobs-zh-light.png" width="800" alt="Multiplane 桌面软件的作业页：左边是进行中、排队中和可继续渲染的作业，右边是所选作业的“过程”标签，列出各阶段用时和事件">
 </picture>
 
 
-- **作业**：列出各项目里的渲染、抽帧、检查作业，实时显示进度和预览帧，查看成片、联系表和检查不通过时的差异图，可以停止进行中的作业。
-- **环境**：检查浏览器、GPU 光栅、FFmpeg 等是否就绪；给 Claude Code（`~/.claude/skills/`）和 Codex（`~/.agents/skills/`）安装、更新 Multiplane 的 skill，自己改过的不会被直接覆盖。
+- **作业**：列出各项目里的渲染、抽帧、检查作业，实时显示进度和预览帧，可以停止进行中的作业。点开一个作业，详情分四个标签：
+  - **预览**：成片在逐帧播放器里播放，可以一帧一帧地走、在切点之间跳转，并显示准确的帧号和时间码；任意一帧都能单独打开，放大到实际像素。确定性检查不通过时，参考图、实际图和差异图可以并排看，也可以闪烁对比。
+  - **概览**：产物、成品是否核对过，以及画面、后期、性能、环境一目了然。
+  - **过程**：每个阶段用了多久，以及过程中的事件和警告。
+  - **参数**：用平白的话列出这次作业实际生效的参数，可以复制成命令。
+- **继续渲染**：失败或被停止、又能接着渲的渲染，会显示“继续渲染”和已经完成的帧数；新作业会链回原作业。不能接着渲时（例如镜头用到的文件变了），软件会说明原因。开启托管后，软件也会接管 agent 发起的 `resume`。
+- **托盘弹窗**：在 Windows 和 macOS 上点托盘图标，会打开一个小面板，列出进行中、排队中和最近完成的作业；托盘图标和任务栏按钮会显示渲染进度。Linux 上仍是系统菜单。
+- **环境**：检查浏览器、GPU 光栅、FFmpeg 等是否就绪，首次使用时在这里点“安装浏览器”下载 Chromium；给 Claude Code（`~/.claude/skills/`）和 Codex（`~/.agents/skills/`）安装、更新 Multiplane 的 skill，自己改过的不会被直接覆盖。
 - **设置**：写入上文的用户配置 `config.json`。
 - **托管渲染**（默认关闭）：在设置里开启后，agent 发起的渲染改由软件执行，不再挂在 agent 的会话上，会话结束也会照常做完。一次只执行一个托管渲染，其余排队。agent 的命令和输出不变；会话重启后用 `multiplane wait <job>` 接上之前的作业。开启托管后，关闭窗口时软件留在系统托盘。见协议第 11 节。
-- **更新**：启动时和之后每天检查一次 GitHub 上的新版本（可以关闭）。Windows 上在软件里下载并安装；macOS 和 Linux 上打开下载页。
+- **更新**：启动时和之后每天检查一次 GitHub 上的新版本（可以关闭）。Windows 上在软件里下载并安装；macOS 和 Linux 上打开下载页。“关于”页会按界面语言列出从已安装版本起每个版本的更新内容。
 - 界面有英文和简体中文，默认跟随系统语言，也可以在设置里切换。
 
 它只通过 [`docs/protocol.zh-CN.md`](https://github.com/LBEILC/Multiplane/blob/main/docs/protocol.zh-CN.md) 的文件和命令行与渲染器打交道，不是渲染的必需品：不装它，agent 照样可以用命令行渲染。
 
-从 [Releases 页面](https://github.com/LBEILC/Multiplane/releases) 下载安装包。安装包里带一份同版本的渲染器，不需要另装 Node.js。这份渲染器也可以当命令用：Windows 为安装目录下的 `multiplane.cmd`，macOS 为 `Multiplane.app/Contents/Resources/bin/multiplane`，Linux 为 `Multiplane-<版本>-x86_64.AppImage --multiplane-cli`。PATH 里找不到 `multiplane` 时，环境页会显示完整路径。FFmpeg 不随包提供（见上文），Chromium 在环境页首次使用时下载。
+从 [Releases 页面](https://github.com/LBEILC/Multiplane/releases) 下载安装包。安装包里带一份同版本的渲染器，不需要另装 Node.js。这份渲染器也可以当命令用：Windows 为安装目录下的 `multiplane.cmd`，macOS 为 `Multiplane.app/Contents/Resources/bin/multiplane`，Linux 为 `Multiplane-<版本>-x86_64.AppImage --multiplane-cli`。PATH 里找不到 `multiplane` 时，环境页会显示完整路径。FFmpeg 不随包提供（见上文，需要自己安装一个支持 libx264 的），Chromium 在环境页首次使用时点“安装浏览器”下载。
 
 | 系统 | 安装包 | 首次打开（安装包没有代码签名） |
 |---|---|---|

package/bin/multiplane

@@ -1,16 +1,13 @@
 #!/usr/bin/env node
-import { renderShot, stillsShot, verifyShot, inspectShot, lintShot, doctor, statusJob, cancelJob } from '../src/index.mjs';
-import { benchmark } from '../src/benchmark.mjs';
-import { serve } from '../src/serve.mjs';
-import { setup } from '../src/setup.mjs';
-import { postArgs, scaleArgs } from '../src/post.mjs';
-import { createEvents, version } from '../src/events.mjs';
+import { readFileSync } from 'node:fs';
 import { asError, invalidOption } from '../src/errors.mjs';
-import { waitJob } from '../src/jobs.mjs';
 import { claimExecutor, resultExitCode } from '../src/hosted.mjs';
 import { fileURLToPath } from 'node:url';
 
 const args = process.argv.slice(2), json = args.includes('--json');
+// Keep CLI flag metadata independent of the rendering implementation.
+const postArgs = ['quality', 'motion-blur', 'max-motion-blur', 'shutter', 'grain', 'no-post', 'adaptive-blur'];
+const scaleArgs = ['scale', 'render-scale', 'upscale'];
 const common = [...postArgs, ...scaleArgs, 'static-reuse', 'no-static-reuse', 'alpha', 'fps', 'raster', 'root', 'job-dir', 'no-lint', 'overwrite', 'no-hosted', 'job-dir-exact', 'hosted-executor'];
 const allowed = {
   inspect: ['root', 'fps', 'no-lint'], serve: ['root', 'port'],
@@ -19,6 +16,7 @@ const allowed = {
   benchmark: ['raster', 'max-workers'], config: [], skill: ['host', 'force', 'expect'],
   lint: ['root'], doctor: ['ffmpeg', 'raster'], status: ['job-dir'], cancel: ['job-dir', 'wait'],
   wait: ['job-dir', 'timeout'],
+  resume: ['job-dir', 'workers', 'no-hosted', 'job-dir-exact', 'hosted-executor'],
 };
 // Internal flags used by the desktop app to start hosted executors; not listed in help.
 const internal = ['job-dir-exact', 'hosted-executor'];
@@ -35,17 +33,18 @@ const onEvent = event => {
 };
 let command = args[0] ?? 'doctor';
 try {
-  const executor = ['render', 'stills', 'verify'].includes(command) && args.includes('--hosted-executor');
+  const executor = ['render', 'stills', 'verify', 'resume'].includes(command) && args.includes('--hosted-executor');
   const exactIndex = args.indexOf('--job-dir-exact');
   const lostClaim = executor && (exactIndex < 0 || !args[exactIndex + 1]
     || !await claimExecutor(args[exactIndex + 1], command));
   const onBytes = bytes => new Promise((resolve, reject) => process.stdout.write(bytes, error => error ? reject(error) : resolve()));
   if (lostClaim) { process.exitCode = 0; }
-  else if (args.length === 1 && args[0] === '--version') console.log(version);
+  else if (args.length === 1 && args[0] === '--version') console.log(JSON.parse(readFileSync(new URL('../package.json', import.meta.url))).version);
   else if (args.length === 0 || args[0] === '--help') {
     console.log('Usage: multiplane <render|stills|verify|inspect|lint> <shot.html> [--json] [--option value]\n'
       + '       multiplane serve [--root directory] [--port number] [--json]\n'
       + '       multiplane <status|cancel> <jobId|jobDir> [--json] [--wait seconds]\n'
+      + '       multiplane resume <jobId|jobDir> [--json] [--workers n] [--job-dir directory] [--no-hosted]\n'
       + '       multiplane wait <jobId|jobDir> [--json] [--timeout seconds]\n'
       + '       multiplane benchmark [--json] [--raster gpu|software] [--max-workers n]\n'
       + '       multiplane doctor [--json] [--ffmpeg path]\n'
@@ -56,11 +55,13 @@ try {
     if (args.includes('--help')) console.log(command === 'config'
       ? 'Usage: multiplane config <get [key]|set key value|unset key> [--json]\nKeys: ffmpeg jobsDir raster encoder workers hosted'
       : 'Usage: multiplane skill <status|install|remove> [--host claude|codex|all] [--force] [--expect signature] [--json]\nInstall and remove require --host.');
-    else await setup(command, args.slice(1), onEvent);
+    // TODO(design): setup/jobs still transitively load rendering through src/events.mjs.
+    // Removing those dependencies requires extending task 083's read-only src scope.
+    else { const { setup } = await import('../src/setup.mjs'); await setup(command, args.slice(1), onEvent); }
   } else {
     if (!allowed[command]) throw invalidOption('command', 'Unknown command: ' + command);
     if (args.includes('--help')) {
-      console.log('Usage: multiplane ' + command + (['doctor', 'serve', 'benchmark'].includes(command) ? '' : ['status', 'cancel', 'wait'].includes(command) ? ' <jobId|jobDir>' : ' <shot.html>') + ' [options]\nOptions: --json --help ' + listed(allowed[command]).map(f => '--' + f + (['static-reuse', 'no-static-reuse', 'overwrite', 'no-lint', 'no-post', 'alpha', 'draft', 'no-hosted', 'hosted-executor'].includes(f) ? '' : ' <value>')).join(' '));
+      console.log('Usage: multiplane ' + command + (['doctor', 'serve', 'benchmark'].includes(command) ? '' : ['status', 'cancel', 'wait', 'resume'].includes(command) ? ' <jobId|jobDir>' : ' <shot.html>') + ' [options]\nOptions: --json --help ' + listed(allowed[command]).map(f => '--' + f + (['static-reuse', 'no-static-reuse', 'overwrite', 'no-lint', 'no-post', 'alpha', 'draft', 'no-hosted', 'hosted-executor'].includes(f) ? '' : ' <value>')).join(' '));
     } else {
       const needsTarget = !['doctor', 'serve', 'benchmark'].includes(command);
       const target = needsTarget ? args[1] : undefined;
@@ -78,14 +79,23 @@ try {
       delete options.json;
       if (options['job-dir-exact'] && !executor) throw invalidOption('--job-dir-exact', '--job-dir-exact requires --hosted-executor.');
       options.onEvent = executor ? undefined : onEvent;
-      if (['render', 'stills', 'verify'].includes(command) && !executor) options._hostedCLI = {
+      if (['render', 'stills', 'verify', 'resume'].includes(command) && !executor) options._hostedCLI = {
         args: args.slice(1).filter(arg => arg !== '--json'), bin: fileURLToPath(import.meta.url), onBytes,
       };
       if (command === 'wait') {
+        const { waitJob } = await import('../src/jobs.mjs');
         const result = await waitJob(target, { ...options, onEvent: json ? undefined : onEvent, onBytes: json ? onBytes : undefined });
         reported = true; process.exitCode = resultExitCode(result);
       } else {
-        const action = { render: renderShot, stills: stillsShot, verify: verifyShot, inspect: inspectShot, serve, lint: lintShot, doctor, benchmark, status: statusJob, cancel: cancelJob }[command];
+        let action;
+        if (command === 'lint') {
+          const { runCommand } = await import('../src/events.mjs');
+          const { checkLint } = await import('../src/lint.mjs');
+          action = (shot, options) => runCommand('lint', shot, options, events => checkLint(shot, events.options, events), false);
+        } else {
+          const [module, name] = { render: ['render', 'renderShot'], stills: ['stills', 'stillsShot'], verify: ['verify', 'verifyShot'], inspect: ['inspect', 'inspectShot'], serve: ['serve', 'serve'], doctor: ['doctor', 'doctor'], benchmark: ['benchmark', 'benchmark'], status: ['jobs', 'statusJob'], cancel: ['jobs', 'cancelJob'], resume: ['resume', 'resumeRender'] }[command];
+          action = (await import(`../src/${module}.mjs`))[name];
+        }
         const result = needsTarget ? await action(target, options) : await action(options);
         if (result?.ok !== undefined) { reported = true; process.exitCode = resultExitCode(result); }
       }
@@ -93,6 +103,6 @@ try {
   }
 } catch (failure) {
   const error = asError(failure);
-  if (!reported) createEvents(command, null, { onEvent }).finish({}, error);
+  if (!reported) { const { createEvents } = await import('../src/events.mjs'); createEvents(command, null, { onEvent }).finish({}, error); }
   process.exitCode = error.exitCode;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "multiplane",
-  "version": "0.3.7",
+  "version": "0.3.10",
   "type": "module",
   "license": "Apache-2.0",
   "publishConfig": {
@@ -40,7 +40,8 @@
     "export:public": "node tools/export-public.mjs",
     "release:check": "node tools/release-check.mjs",
     "bench": "node tools/bench/run.mjs",
-    "test:full": "node --import ./tests/test-home.mjs tools/test-suite.mjs --full"
+    "test:full": "node --import ./tests/test-home.mjs tools/test-suite.mjs --full",
+    "release": "node tools/release.mjs"
   },
   "dependencies": {
     "acorn": "8.15.0",

package/skills/multiplane/SKILL.md

@@ -171,6 +171,7 @@ Use `--json` with any command. Resolve shot paths relative to `--root` (the curr
 | `multiplane status <job>` | View job status | — |
 | `multiplane cancel <job>` | Stop a job | `--wait` (seconds) |
 | `multiplane wait <job>` | Wait for a job started earlier and print its events | `--timeout` (seconds) |
+| `multiplane resume <job>` | Continue an interrupted render; already encoded segments are reused | `--workers` |
 
 Use `--out`, `--overwrite`, and `--no-lint` (skip automatic lint) with `stills`, `verify`, or `render`. Run `multiplane <command> --help` to list all options for that command.
 
@@ -210,6 +211,8 @@ With `--json`, stdout contains one JSON event per line. **The last line is alway
 
 ## Long renders
 
-Rendering may take a long time. Each run creates a job directory, `out/jobs/<jobId>/` (`jobId` appears in both the `start` event and the `result`). Read `status.json` for the latest progress snapshot and `events.jsonl` for the full event stream. To stop a job, run `multiplane cancel <jobId>` or create a file named `stop` in its job directory.
+Rendering may take a long time, often longer than the timeout of your shell or command tool. When the tool lets you, give `render` a timeout long enough for the whole render or run it in the background; if the command is cut off, the job's process usually dies with it, so do not start the same render again: check it with `multiplane status <jobId> --json` and continue it with `multiplane resume` (see below). Each run creates a job directory, `out/jobs/<jobId>/` (`jobId` appears in both the `start` event and the `result`). Read `status.json` for the latest progress snapshot and `events.jsonl` for the full event stream. To stop a job, run `multiplane cancel <jobId>` or create a file named `stop` in its job directory.
 
 If the user turned on hosting in the desktop app, the app runs the render and it keeps going after your session ends. Nothing changes in how you call the command; stderr says the job was handed over, and `status.json` may show `queued` while another hosted job runs. When a session resumes and you started a job earlier but never saw its `result`, run `multiplane wait <jobId> --json` to get its events and exit code instead of starting it again. Use `--no-hosted` only when the user asks for a render that should not go through the app.
+
+A `render` that ended without succeeding (`failed` or `cancelled`, or a job whose process disappeared, for example after a crash or reboot) can usually be continued instead of rendered again: run `multiplane resume <jobId> --json`. It reuses the segments already encoded (about 10 seconds each), renders the rest with the original options and output path, and produces the same frames as an uninterrupted render. It is a new job; its `result` carries `resumedFrom` and `resume.framesReused`. `multiplane status <jobId> --json` shows `data.resume.available` and how many frames are done. If it fails with `resume_unavailable`, read `details.reason`: `inputs_changed` or `environment_changed` means start a fresh `render` (do this deliberately, for example after you edited the shot); `running` means the job, or another resume, is still going, so `wait` for it; `missing_manifest` means the job predates segments. Only `--workers` can change on resume. A `resume_renderer_changed` warning (a different GPU or driver) needs no action.

package/src/artifacts.mjs

@@ -1,5 +1,4 @@
-import { constants } from 'node:fs';
-import { copyFile, rm, writeFile, access, rename, mkdtemp, mkdir } from 'node:fs/promises';
+import { link, rm, writeFile, access, rename, mkdtemp, mkdir } from 'node:fs/promises';
 import path from 'node:path';
 import { MultiplaneError } from './errors.mjs';
 
@@ -16,11 +15,19 @@ 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);
+export async function publishVideo(temporary, file, overwrite = false, { linkFile = link, move = rename, remove = rm } = {}) {
+  if (overwrite) { await move(temporary, file); return; }
+  try { await linkFile(temporary, file); }
+  catch (error) {
+    if (!['ENOTSUP', 'EOPNOTSUPP', 'ENOSYS', 'EPERM'].includes(error.code)) outputError(error, file);
+    // The temporary video is in the output directory, so rename publishes it whole.
+    // Accept the short race between checking the target and renaming.
+    await requireNewOutput(file);
+    try { await move(temporary, file); }
+    catch (moveError) { outputError(moveError, file); }
+    return;
+  }
+  await remove(temporary);
 }
 
 // Build a replacement directory in isolation; publish only after the whole command succeeds.

package/src/capture-watchdog.mjs

@@ -0,0 +1,29 @@
+// Wall time controls recovery only; it never enters frame generation.
+export function createCaptureWatchdog(slots, onStall, { minimumMs = 120000, now = () => performance.now() } = {}) {
+  let longestFrameMs = 0, stopped = false;
+  const check = () => {
+    if (stopped) return;
+    const time = now(), threshold = Math.max(minimumMs, longestFrameMs * 10);
+    for (const [worker, slot] of slots.entries()) {
+      if (!slot.job || slot.recovering || time - slot.lastDelivery < threshold) continue;
+      slot.recovering = true;
+      onStall(slot, { worker, frame: slot.frame ?? slot.job.first, waitedSeconds: (time - slot.lastDelivery) / 1000 });
+    }
+  };
+  const timer = setInterval(check, Math.min(1000, Math.max(10, minimumMs / 4)));
+  timer.unref();
+  return {
+    check,
+    completed(slot) {
+      const time = now();
+      if (slot.frameStarted !== undefined) longestFrameMs = Math.max(longestFrameMs, time - slot.frameStarted);
+      slot.lastDelivery = time;
+    },
+    recovered(slot) {
+      slot.recovering = false;
+      slot.lastDelivery = now();
+      slot.frameStarted = slot.lastDelivery;
+    },
+    stop() { stopped = true; clearInterval(timer); },
+  };
+}

package/src/capture.mjs

@@ -175,7 +175,7 @@ async function openShotOnce(shot, scale = 1, options = {}) {
         return { png: measured };
     };
     return {
-      page, browser, server, ...metadata, alpha, beginFrame, timings,
+      page, browser, server, ...metadata, alpha, beginFrame, timings, _inspectSample: draw,
       get sampleContextUsed() { return sampleContextUsed; },
       get motionProbeUsed() { return motionProbeUsed; },
       get dofSamples() { return dofSamples; },
@@ -195,13 +195,13 @@ async function openShotOnce(shot, scale = 1, options = {}) {
 // Recovery belongs to a complete output frame, never to an individual blur sample.
 export async function openShot(shot, scale = 1, options = {}) {
   const budget = options._browserRecovery ?? recoveryBudget();
-  let current, closed = false;
-  const recover = async (error, t) => {
+  let current, closed = false, stalled;
+  const recover = async (error, t, stallAttempt) => {
     options.check?.();
     if (closed) throw error;
     const failure = crashedError(error, t);
-    if (Atomics.load(budget, 0) >= MAX_BROWSER_RESTARTS) throw failure;
-    const attempt = Atomics.add(budget, 0, 1) + 1;
+    if (!stallAttempt && Atomics.load(budget, 0) >= MAX_BROWSER_RESTARTS) throw failure;
+    const attempt = stallAttempt ?? Atomics.add(budget, 0, 1) + 1;
     if (attempt > MAX_BROWSER_RESTARTS) throw failure;
     await current?.close().catch(() => {});
     try { current = await openShotOnce(shot, scale, options); }
@@ -211,7 +211,8 @@ export async function openShot(shot, scale = 1, options = {}) {
       restarted.details = { ...failure.details, ...restarted.details };
       throw restarted;
     }
-    options.onWarning?.({ code: 'browser_restarted', message: 'Browser restarted; retrying the affected frame.', details: { ...failure.details, attempt } });
+    if (!stallAttempt) options.onWarning?.({ code: 'browser_restarted', message: 'Browser restarted; retrying the affected frame.', details: { ...failure.details, attempt } });
+    options.onRecovered?.();
   };
   try { current = await openShotOnce(shot, scale, options); }
   catch (error) { if (error.code !== 'browser_crashed') throw error; await recover(error); }
@@ -224,13 +225,28 @@ export async function openShot(shot, scale = 1, options = {}) {
     get dofSamples() { return current.dofSamples; },
     ...(current.observe ? { observe: (...args) => current.observe(...args) } : {}),
     beginFrame: (...args) => current.beginFrame(...args),
+    _inspectSample: (...args) => current._inspectSample(...args),
     frame: (...args) => current.frame(...args),
     ...(current.blurAt ? { blurAt: (...args) => current.blurAt(...args) } : {}),
+    // Closing the owned browser interrupts a blocked evaluate/CDP screenshot.
+    // Let the complete post frame unwind before retrying any of its samples.
+    async stall(details) {
+      if (closed || stalled) return;
+      stalled = new MultiplaneError('browser_crashed', 'Rendering worker stopped delivering frames.', { details });
+      await current.close();
+    },
     async retryFrame(t, operation) {
+      let stallAttempts = 0;
       for (;;) {
         try { return await operation(); }
         catch (error) {
           options.check?.();
+          if (!closed && stalled) {
+            const failure = stalled; stalled = undefined;
+            if (stallAttempts >= MAX_BROWSER_RESTARTS) throw failure;
+            await recover(failure, t, ++stallAttempts);
+            continue;
+          }
           if (closed || !current.isCrash(error)) throw error;
           await recover(error, t);
         }

package/src/errors.mjs

@@ -18,6 +18,7 @@ export const errorCodes = Object.freeze(Object.fromEntries([
   [3, 'skill_changed', 'The installed skill changed since inspection.'],
   [3, 'unsupported_node', 'Node 24 or newer is required.'],
   [2, 'invalid_option', 'Invalid option.'],
+  [2, 'resume_unavailable', 'This render cannot be resumed.'],
   [2, 'invalid_scale', 'Scale must produce positive even integer dimensions.'],
   [2, 'output_exists', 'Output already exists.'],
   [3, 'ffmpeg_not_found', 'FFmpeg was not found.'],

package/src/events.mjs

@@ -105,6 +105,7 @@ export function createEvents(command, shot, options = {}, job = false, deferStar
   if (!options._hostedCLI) monitor();
   return {
     directory, jobId, emit, warning, artifacts, options, monitor,
+    ...(options._resume ? { resumeData: { resumedFrom: options._resume.jobId, resume: { segmentsReused: 0, framesReused: 0 } } } : {}),
     // TODO(design): Document memoryBytes in status.json (latest sample, null on failure).
     memory(bytes) { state.memoryBytes = bytes; state.updatedAt = new Date().toISOString(); save(); },
     preview(frame) { state.previewFrame = frame; state.updatedAt = new Date().toISOString(); save(); },
@@ -113,7 +114,8 @@ export function createEvents(command, shot, options = {}, job = false, deferStar
       if (deferStart && !resolved) { save(); return; }
       startedEvent = true;
       const { onEvent, _preview, _resources, _probeVideo, _inspectFFmpeg, _hostedCLI, ...effective } = options;
-      emit('start', { version, shot, ...(jobId ? { jobId } : {}), options: effective, ...(this.workersSource ? { workersSource: this.workersSource } : {}) });
+      for (const key of Object.keys(effective)) if (key.startsWith('_')) delete effective[key];
+      emit('start', { ...this.resumeData, version, shot, ...(jobId ? { jobId } : {}), options: effective, ...(this.workersSource ? { workersSource: this.workersSource } : {}) });
       index('start', { command, shot, pid: process.pid });
       for (const [type, fields] of pendingEvents.splice(0)) emit(type, fields);
     },
@@ -129,7 +131,7 @@ export function createEvents(command, shot, options = {}, job = false, deferStar
       if (deferStart) this.start(true);
       const result = { command, ok: !error, code: error?.code ?? null, message: error?.message ?? null,
         ...(error?.hint ? { hint: error.hint } : {}), ...(error?.details ? { details: error.details } : {}),
-        artifacts, elapsedMs: Math.round(performance.now() - started), ...(jobId ? { jobId } : {}), data };
+        artifacts, elapsedMs: Math.round(performance.now() - started), ...(jobId ? { jobId } : {}), data: this.resumeData ? { ...this.resumeData, ...data } : data };
       index('end', { state: !error ? 'succeeded' : error.code === 'cancelled' ? 'cancelled' : 'failed' });
       emit('result', result);
       return result;
@@ -142,7 +144,7 @@ export async function runCommand(command, shot, options, action, job = true) {
   let events, resources, linted = false;
   try {
     const explicit = options;
-    const user = loadUserConfig(command, options);
+    const user = options._effectiveOptions ? { options: { ...options }, config: { applied: [] }, warnings: [] } : loadUserConfig(command, options);
     options = user.options;
     if (['render', 'stills', 'verify'].includes(command)) {
       options.quality = resolveQuality(options);
@@ -192,7 +194,7 @@ export async function runCommand(command, shot, options, action, job = true) {
       if (!options['no-lint']) { await checkLint(shot, events.options, events); linted = true; }
       events.start();
       const request = { schema: 'multiplane/1', jobId: events.jobId, jobDir: events.directory,
-        command, args: options._hostedCLI.args, cwd: process.cwd(), node: process.execPath,
+        command: options._resume ? 'resume' : command, args: options._hostedCLI.args, cwd: process.cwd(), node: process.execPath,
         bin: options._hostedCLI.bin, env: hostedEnvironment(process.env), at: new Date().toISOString() };
       const ownership = await handoff(request);
       if (ownership.hosted) {
@@ -210,7 +212,7 @@ export async function runCommand(command, shot, options, action, job = true) {
       resources = createResourceSampler({ enabled: options._resources !== false, onSample: events.memory });
       events.resources = resources;
     }
-    if (options.draft) {
+    if (options.draft && !options._effectiveOptions) {
       // Keep lint and cancellation active before the dimension-only draft probe.
       if (!linted && !options['no-lint']) {
         const { findings, data } = await scanShot(shot, events.options);

package/src/hosted.mjs

@@ -18,7 +18,7 @@ async function move(from, to) {
 }
 
 export async function hostedAvailable(command, options, env = process.env) {
-  if (!['render', 'stills', 'verify'].includes(command) || !options._hostedCLI || options.hosted !== true
+  if (!['render', 'stills', 'verify', 'resume'].includes(command) || !options._hostedCLI || options.hosted !== true
     || options['no-hosted'] || options['hosted-executor'] || env.MULTIPLANE_HOSTED === '0') return false;
   try {
     const app = await json(path.join(userHome(env), 'app.json'));
@@ -84,7 +84,7 @@ export async function handoff(request, { home = userHome(), timeout = 5000, star
 // Claim before loading config, creating status, linting or opening output files.
 export async function claimExecutor(jobDir, command) {
   try {
-    if (!path.isAbsolute(jobDir) || !['render', 'stills', 'verify'].includes(command)) return false;
+    if (!path.isAbsolute(jobDir) || !['render', 'stills', 'verify', 'resume'].includes(command)) return false;
     const jobId = path.basename(jobDir), base = hostedBase(jobId);
     const request = await json(base + '.claimed.json');
     if (request?.schema !== schema || request.jobId !== jobId || request.command !== command

package/src/index.mjs

@@ -1,4 +1,5 @@
 export { renderShot } from './render.mjs';
+export { resumeRender } from './resume.mjs';
 export { stillsShot } from './stills.mjs';
 export { verifyShot } from './verify.mjs';
 export { openShot } from './capture.mjs';

package/src/input-records.mjs

@@ -0,0 +1,33 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { readFile, stat } from 'node:fs/promises';
+
+// Servers inherit the render's context; unrelated inspect/serve calls do not.
+export const inputRecords = new AsyncLocalStorage();
+const largeFiles = new WeakMap();
+export const digest = bytes => createHash('sha256').update(bytes).digest('hex');
+export async function fileDigest(file) {
+  const hash = createHash('sha256');
+  for await (const bytes of createReadStream(file)) hash.update(bytes);
+  return hash.digest('hex');
+}
+export async function recordInput(file) {
+  const record = inputRecords.getStore();
+  if (!record) return;
+  const info = await stat(file);
+  // Large media stays streamed. Cache only its digest, never its body.
+  if (info.size > 1024 * 1024) {
+    let cache = largeFiles.get(record);
+    if (!cache) largeFiles.set(record, cache = new Map());
+    const previous = cache.get(file);
+    const sha256 = previous?.size === info.size && previous.mtimeMs === info.mtimeMs
+      ? previous.sha256 : await fileDigest(file);
+    cache.set(file, { size: info.size, mtimeMs: info.mtimeMs, sha256 });
+    record(file, { bytes: info.size, sha256 });
+    return;
+  }
+  const bytes = await readFile(file);
+  record(file, { bytes: bytes.length, sha256: digest(bytes) });
+  return bytes;
+}

package/src/jobs.mjs

@@ -6,8 +6,9 @@ import { MultiplaneError, invalidOption } from './errors.mjs';
 import { number } from './capture.mjs';
 import { followJob } from './hosted.mjs';
 import { loadUserConfig } from './user-home.mjs';
+import { resumeStatus } from './segments.mjs';
 
-const resolveJob = (target, options) => path.isAbsolute(target) || /[\\/]/.test(target) ? path.resolve(target) : path.join(jobDirectory(options), target);
+export const resolveJob = (target, options) => path.isAbsolute(target) || /[\\/]/.test(target) ? path.resolve(target) : path.join(jobDirectory(options), target);
 export async function readStatus(target, options = {}) {
   let status;
   try { status = JSON.parse(await readFile(path.join(resolveJob(target, options), 'status.json'), 'utf8')); }
@@ -25,6 +26,7 @@ export async function readStatus(target, options = {}) {
       }
     }
   }
+  if (status.command === 'render') status.resume = resumeStatus(status, resolveJob(target, options));
   return status;
 }
 export const statusJob = (target, options = {}) => runCommand('status', null, options, events => readStatus(target, events.options), false);

package/src/post.mjs

@@ -329,11 +329,25 @@ export function createPostCapture(capture, options = {}, fps = capture.fps) {
       let png, result, usedSamples = motionBlur;
       if (candidate && !verifyReuse) { ({ png, image: result, usedSamples } = previousRaw); }
       else if (upward) {
+        // TODO(design): Half-size probes need a compatible decision policy;
+        // halving the raster and displacement threshold changes refinement.
         // 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);
+        // Stop as soon as motion is established. Retain exact full-size still
+        // checks, and reuse every matching time without changing the final grid.
+        await sampleMany([t, endpoints[0]], true);
         const centerProbe = cache.get(t);
-        const still = endpoints.every(time => cache.get(time).image.data.equals(centerProbe.image.data));
+        let still = cache.get(endpoints[0]).image.data.equals(centerProbe.image.data);
+        if (still) {
+          await sampleMany([endpoints[1]], true);
+          still = cache.get(endpoints[1]).image.data.equals(centerProbe.image.data);
+        } else if (capture._inspectSample) {
+          // Preserve conditional sampleContext reads at the skipped endpoint.
+          const start = performance.now();
+          await capture._inspectSample(endpoints[1], context(false, endpoints[1]));
+          stats.captureMs += performance.now() - start;
+          contextUsed ||= capture.sampleContextUsed === true;
+        }
         let legacy = contextUsed;
         let grid = legacy ? times : grids.get(motionBlur);
         if (still) {
@@ -400,6 +414,8 @@ export function createPostCapture(capture, options = {}, fps = capture.fps) {
       if (!(candidate && !verifyReuse)) {
         // Only lens-dependent probe captures need replacing. DOM captures and
         // final hook captures remain reusable at the same time and context.
+        // TODO(design): Zero aperture still has interleaved projection jitter;
+        // reusing its probes requires an approved change to that pattern.
         if (motionProbeUsed && !finalCapture) {
           finalCapture = true;
           dofMotionSamples = new Set(selectedTimes).size;