multiplane 0.3.6 → 0.3.8

package/src/home-migration.mjs

@@ -1,54 +1,54 @@
-import path from 'node:path';
-import os from 'node:os';
-import { randomUUID } from 'node:crypto';
-import { lstatSync, mkdirSync, openSync, closeSync, copyFileSync, renameSync, unlinkSync } from 'node:fs';
-import { userHome } from './platform.mjs';
-
-const present = file => {
-  try { lstatSync(file); return true; }
-  catch (error) { if (error.code === 'ENOENT') return false; throw error; }
-};
-
-// Use the writers' locks, including the config lock introduced in 038.
-// Publish only complete copies, and recheck the destination under the lock.
-export function migrateUserHome(env = process.env, platform = process.platform, home = os.homedir()) {
-  const result = { migrated: [], warnings: [] };
-  if (platform !== 'win32' || env.MULTIPLANE_HOME) return result;
-  const directory = userHome(env, platform, home);
-  const previous = path.win32.join(env.APPDATA || path.win32.join(env.USERPROFILE || home, 'AppData', 'Roaming'), 'multiplane');
-  if (path.win32.resolve(previous).toLowerCase() === path.win32.resolve(directory).toLowerCase()) return result;
-  for (const [lockName, names] of [['config.json.lock', ['config.json']], ['jobs.lock', ['jobs.jsonl', 'jobs.1.jsonl']]]) {
-    let handle;
-    const lock = path.join(directory, lockName);
-    try {
-      if (!names.some(name => !present(path.join(directory, name)) && present(path.join(previous, name)))) continue;
-      mkdirSync(directory, { recursive: true });
-      const deadline = performance.now() + 10000;
-      for (;;) {
-        try { handle = openSync(lock, 'wx'); break; }
-        catch (error) {
-          if (error.code !== 'EEXIST' || performance.now() >= deadline) throw error;
-          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
-        }
-      }
-      for (const name of names) {
-        const target = path.join(directory, name), source = path.join(previous, name);
-        if (present(target) || !present(source)) continue;
-        const temporary = target + '.' + randomUUID() + '.tmp';
-        try {
-          copyFileSync(source, temporary);
-          renameSync(temporary, target);
-          result.migrated.push({ name, source });
-        } finally { try { unlinkSync(temporary); } catch (error) { if (error.code !== 'ENOENT') throw error; } }
-      }
-    } catch {
-      result.warnings.push({ code: 'home_unavailable', message: 'User directory migration could not be completed.' });
-    } finally {
-      if (handle !== undefined) {
-        closeSync(handle);
-        try { unlinkSync(lock); } catch { result.warnings.push({ code: 'home_unavailable', message: 'User directory migration lock could not be removed.' }); }
-      }
-    }
-  }
-  return result;
-}
+import path from 'node:path';
+import os from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { lstatSync, mkdirSync, openSync, closeSync, copyFileSync, renameSync, unlinkSync } from 'node:fs';
+import { userHome } from './platform.mjs';
+
+const present = file => {
+  try { lstatSync(file); return true; }
+  catch (error) { if (error.code === 'ENOENT') return false; throw error; }
+};
+
+// Use the writers' locks, including the config lock introduced in 038.
+// Publish only complete copies, and recheck the destination under the lock.
+export function migrateUserHome(env = process.env, platform = process.platform, home = os.homedir()) {
+  const result = { migrated: [], warnings: [] };
+  if (platform !== 'win32' || env.MULTIPLANE_HOME) return result;
+  const directory = userHome(env, platform, home);
+  const previous = path.win32.join(env.APPDATA || path.win32.join(env.USERPROFILE || home, 'AppData', 'Roaming'), 'multiplane');
+  if (path.win32.resolve(previous).toLowerCase() === path.win32.resolve(directory).toLowerCase()) return result;
+  for (const [lockName, names] of [['config.json.lock', ['config.json']], ['jobs.lock', ['jobs.jsonl', 'jobs.1.jsonl']]]) {
+    let handle;
+    const lock = path.join(directory, lockName);
+    try {
+      if (!names.some(name => !present(path.join(directory, name)) && present(path.join(previous, name)))) continue;
+      mkdirSync(directory, { recursive: true });
+      const deadline = performance.now() + 10000;
+      for (;;) {
+        try { handle = openSync(lock, 'wx'); break; }
+        catch (error) {
+          if (error.code !== 'EEXIST' || performance.now() >= deadline) throw error;
+          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 25);
+        }
+      }
+      for (const name of names) {
+        const target = path.join(directory, name), source = path.join(previous, name);
+        if (present(target) || !present(source)) continue;
+        const temporary = target + '.' + randomUUID() + '.tmp';
+        try {
+          copyFileSync(source, temporary);
+          renameSync(temporary, target);
+          result.migrated.push({ name, source });
+        } finally { try { unlinkSync(temporary); } catch (error) { if (error.code !== 'ENOENT') throw error; } }
+      }
+    } catch {
+      result.warnings.push({ code: 'home_unavailable', message: 'User directory migration could not be completed.' });
+    } finally {
+      if (handle !== undefined) {
+        closeSync(handle);
+        try { unlinkSync(lock); } catch { result.warnings.push({ code: 'home_unavailable', message: 'User directory migration lock could not be removed.' }); }
+      }
+    }
+  }
+  return result;
+}

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'));
@@ -28,7 +28,7 @@ export async function hostedAvailable(command, options, env = process.env) {
 }
 
 export function hostedEnvironment(env) {
-  const allowed = /^(PATH|MULTIPLANE_.*|ELECTRON_RUN_AS_NODE|HTTPS?_PROXY|ALL_PROXY|NO_PROXY|TEMP|TMP|TMPDIR|HOME|USERPROFILE|APPDATA|LOCALAPPDATA|SystemRoot|ComSpec|PATHEXT|LANG|LC_.*)$/i;
+  const allowed = /^(PATH|MULTIPLANE_.*|ELECTRON_RUN_AS_NODE|HTTPS?_PROXY|ALL_PROXY|NO_PROXY|TEMP|TMP|TMPDIR|HOME|USERPROFILE|APPDATA|LOCALAPPDATA|SystemRoot|ComSpec|PATHEXT|LANG|LC_.*)$/i;
   const secret = /TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|AUTH|BEARER|COOKIE|SESSION|API_?KEY|PRIVATE_?KEY|ACCESS_?KEY/i;
   return Object.fromEntries(Object.entries(env).filter(([key, value]) => {
     if (value === undefined || !allowed.test(key) || secret.test(key)) return false;
@@ -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);