multiplane 0.3.6 → 0.3.7

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

@@ -221,17 +221,17 @@ export async function runCommand(command, shot, options, action, job = true) {
         }
       }
       const normalized = { ...Object.fromEntries(Object.keys(explicit).filter(key => key !== '_hostedCLI').map(key => [key, options[key]])), draft: true };
-      Object.assign(events.options, await applyDraft(command, shot, normalized, options, {
+      Object.assign(events.options, await applyDraft(command, shot, normalized, options, {
         check: events.check,
         onBrowser: browser => {
           const unsubscribe = events.onCancel(() => browser.close());
           browser.once('disconnected', unsubscribe);
           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);
+      }));
+      // 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;
+}

package/src/format.mjs

@@ -1,27 +1,27 @@
-import path from 'node:path';
-import { MultiplaneError, invalidOption } from './errors.mjs';
-import { encoderArgs } from './encoder.mjs';
-
-export function resolveFormat(options = {}) {
-  const extension = path.extname(options.out ?? '').slice(1).toLowerCase();
-  const formats = ['mp4', 'webm', 'mov'];
-  const format = options.format ?? (formats.includes(extension) ? extension : 'mp4');
-  if (!formats.includes(format)) throw invalidOption('--format', '--format must be mp4, webm or mov.');
-  // TODO(design): Document rejection of unknown output extensions as well as conflicts.
-  if (extension && extension !== format) throw invalidOption('--out', '--out extension must match --format.');
-  if (format !== 'mp4' && options.encoder !== undefined) throw invalidOption('--encoder', '--encoder only applies to mp4; omit it for webm or mov.');
-  // TODO(design): Define bitrate controls for the fixed-codec formats if needed.
-  if (format !== 'mp4' && options['max-bitrate'] !== undefined) throw invalidOption('--max-bitrate', '--max-bitrate currently only applies to mp4.');
-  if (format === 'mp4' && options.alpha) throw new MultiplaneError('invalid_option', 'MP4 does not support alpha.', { details: { option: '--alpha' }, hint: 'Use --format webm or --format mov and a matching --out extension.' });
-  return format;
-}
-
-export function videoEncoding(options) {
-  const { format, alpha } = options;
-  if (format === 'webm') {
-    // TODO(design): Document the fixed VP9 quality preset and audio codec.
-    return { encoder: 'libvpx-vp9', args: ['-c:v', 'libvpx-vp9', '-crf', alpha ? '0' : '16', '-b:v', '0', '-auto-alt-ref', '0', ...(alpha ? ['-lossless', '1'] : [])], pixelFormat: alpha ? 'yuva420p' : 'yuv420p', mux: [], audio: ['-c:a', 'libopus', '-b:a', '320k', '-ac', '2'] };
-  }
-  if (format === 'mov') return { encoder: 'prores_ks', args: ['-c:v', 'prores_ks', '-profile:v', '4'], pixelFormat: alpha ? 'yuva444p10le' : 'yuv444p10le', mux: ['-movflags', '+faststart'], audio: ['-c:a', 'aac', '-b:a', '320k', '-ac', '2'] };
-  return { encoder: options.encoder ?? 'x264', args: encoderArgs(options.encoder ?? 'x264', undefined, options['max-bitrate']), pixelFormat: 'yuv420p', mux: ['-movflags', '+faststart'], audio: ['-c:a', 'aac', '-b:a', '320k', '-ac', '2'] };
-}
+import path from 'node:path';
+import { MultiplaneError, invalidOption } from './errors.mjs';
+import { encoderArgs } from './encoder.mjs';
+
+export function resolveFormat(options = {}) {
+  const extension = path.extname(options.out ?? '').slice(1).toLowerCase();
+  const formats = ['mp4', 'webm', 'mov'];
+  const format = options.format ?? (formats.includes(extension) ? extension : 'mp4');
+  if (!formats.includes(format)) throw invalidOption('--format', '--format must be mp4, webm or mov.');
+  // TODO(design): Document rejection of unknown output extensions as well as conflicts.
+  if (extension && extension !== format) throw invalidOption('--out', '--out extension must match --format.');
+  if (format !== 'mp4' && options.encoder !== undefined) throw invalidOption('--encoder', '--encoder only applies to mp4; omit it for webm or mov.');
+  // TODO(design): Define bitrate controls for the fixed-codec formats if needed.
+  if (format !== 'mp4' && options['max-bitrate'] !== undefined) throw invalidOption('--max-bitrate', '--max-bitrate currently only applies to mp4.');
+  if (format === 'mp4' && options.alpha) throw new MultiplaneError('invalid_option', 'MP4 does not support alpha.', { details: { option: '--alpha' }, hint: 'Use --format webm or --format mov and a matching --out extension.' });
+  return format;
+}
+
+export function videoEncoding(options) {
+  const { format, alpha } = options;
+  if (format === 'webm') {
+    // TODO(design): Document the fixed VP9 quality preset and audio codec.
+    return { encoder: 'libvpx-vp9', args: ['-c:v', 'libvpx-vp9', '-crf', alpha ? '0' : '16', '-b:v', '0', '-auto-alt-ref', '0', ...(alpha ? ['-lossless', '1'] : [])], pixelFormat: alpha ? 'yuva420p' : 'yuv420p', mux: [], audio: ['-c:a', 'libopus', '-b:a', '320k', '-ac', '2'] };
+  }
+  if (format === 'mov') return { encoder: 'prores_ks', args: ['-c:v', 'prores_ks', '-profile:v', '4'], pixelFormat: alpha ? 'yuva444p10le' : 'yuv444p10le', mux: ['-movflags', '+faststart'], audio: ['-c:a', 'aac', '-b:a', '320k', '-ac', '2'] };
+  return { encoder: options.encoder ?? 'x264', args: encoderArgs(options.encoder ?? 'x264', undefined, options['max-bitrate']), pixelFormat: 'yuv420p', mux: ['-movflags', '+faststart'], audio: ['-c:a', 'aac', '-b:a', '320k', '-ac', '2'] };
+}

package/src/frame-rate.mjs

@@ -1,28 +1,28 @@
-import { invalidOption } from './errors.mjs';
-
-// Encoding time only: capture and post-processing must keep the requested fps.
-// Snap NTSC shorthand within 0.0001 fps of n * 1000 / 1001. Otherwise round
-// to six decimal places (at most 0.0000005 fps error) and reduce the fraction.
-// FFmpeg's AVRational stores both terms as signed 32-bit integers.
-export function frameRate(fps) {
-  if (!Number.isFinite(fps) || fps <= 0) throw invalidOption('--fps', '--fps must be positive and finite.');
-  const nominal = Math.round(fps * 1001 / 1000);
-  let numerator, denominator;
-  if (nominal > 0 && Math.abs(fps - nominal * 1000 / 1001) <= 0.0001) {
-    numerator = nominal * 1000;
-    denominator = 1001;
-  } else {
-    numerator = Math.round(fps * 1e6);
-    denominator = 1e6;
-  }
-  if (!Number.isSafeInteger(numerator) || numerator <= 0) throw invalidOption('--fps', 'Frame rate cannot be represented at micro-fps precision.');
-  let a = numerator, b = denominator;
-  while (b) [a, b] = [b, a % b];
-  numerator /= a; denominator /= a;
-  if (numerator > 2147483647) throw invalidOption('--fps', 'Frame rate exceeds FFmpeg rational precision.');
-  return {
-    numerator, denominator, argument: `${numerator}/${denominator}`,
-    fps: numerator / denominator,
-    seconds: frames => frames * denominator / numerator,
-  };
-}
+import { invalidOption } from './errors.mjs';
+
+// Encoding time only: capture and post-processing must keep the requested fps.
+// Snap NTSC shorthand within 0.0001 fps of n * 1000 / 1001. Otherwise round
+// to six decimal places (at most 0.0000005 fps error) and reduce the fraction.
+// FFmpeg's AVRational stores both terms as signed 32-bit integers.
+export function frameRate(fps) {
+  if (!Number.isFinite(fps) || fps <= 0) throw invalidOption('--fps', '--fps must be positive and finite.');
+  const nominal = Math.round(fps * 1001 / 1000);
+  let numerator, denominator;
+  if (nominal > 0 && Math.abs(fps - nominal * 1000 / 1001) <= 0.0001) {
+    numerator = nominal * 1000;
+    denominator = 1001;
+  } else {
+    numerator = Math.round(fps * 1e6);
+    denominator = 1e6;
+  }
+  if (!Number.isSafeInteger(numerator) || numerator <= 0) throw invalidOption('--fps', 'Frame rate cannot be represented at micro-fps precision.');
+  let a = numerator, b = denominator;
+  while (b) [a, b] = [b, a % b];
+  numerator /= a; denominator /= a;
+  if (numerator > 2147483647) throw invalidOption('--fps', 'Frame rate exceeds FFmpeg rational precision.');
+  return {
+    numerator, denominator, argument: `${numerator}/${denominator}`,
+    fps: numerator / denominator,
+    seconds: frames => frames * denominator / numerator,
+  };
+}

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

@@ -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;