aivee 0.0.0-stage → 0.1.0-dev.59872e1

package/src/project/create.mjs

@@ -0,0 +1,100 @@
+import { copyFileSync, existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { createRequire } from 'node:module';
+import { resolveCanvasPreset } from './presets.mjs';
+import { DEFAULT_SOURCE_FIT, validateSourceFit } from '../timeline/source-fit.mjs';
+import { createProjectTimeline } from '../timeline/project.mjs';
+import { normalizeFrameRate } from '../media/frame-rate.mjs';
+import { DEFAULT_PROJECT_BACKGROUND_COLOR, validateProjectBackgroundColor } from '../timeline/background.mjs';
+
+const require = createRequire(import.meta.url);
+
+export function createVideoProject(root, slug, options = {}) {
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug)) {
+    throw new TypeError('Use a lowercase kebab-case slug, not a path.');
+  }
+  const { fps: requestedFps = 30, durationSeconds = 10, sourceFit = DEFAULT_SOURCE_FIT, backgroundColor = DEFAULT_PROJECT_BACKGROUND_COLOR } = options;
+  if (options.preset !== undefined && (options.width !== undefined || options.height !== undefined)) {
+    throw new TypeError('Choose a canvas preset or custom width and height, not both.');
+  }
+  const preset = options.preset === undefined ? undefined : resolveCanvasPreset(options.preset);
+  const width = preset?.width ?? options.width ?? 1920;
+  const height = preset?.height ?? options.height ?? 1080;
+  validateSourceFit(sourceFit, 'sourceFit');
+  validateProjectBackgroundColor(backgroundColor, 'backgroundColor');
+  if (![width, height].every((value) => Number.isSafeInteger(value) && value > 0)) {
+    throw new TypeError('Width and height must be positive integers.');
+  }
+  const fps = normalizeFrameRate(requestedFps);
+  if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) {
+    throw new TypeError('durationSeconds must be a positive number.');
+  }
+  const projectPath = resolve(root, 'video-projects', slug);
+  if (existsSync(projectPath)) throw new Error(`Project already exists: ${slug}`);
+  const projectsPath = join(root, 'video-projects');
+
+  const project = {
+    schemaVersion: 1,
+    id: slug,
+    name: slug,
+    width,
+    height,
+    fps,
+    durationSeconds,
+    sourceFit,
+    backgroundColor,
+    ...(preset ? { canvasPreset: preset.id } : {}),
+  };
+  const directories = ['assets', 'transcripts', 'edits', 'compositions', 'renders'];
+  mkdirSync(projectsPath, { recursive: true });
+  mkdirSync(projectPath);
+  try {
+    for (const directory of directories) mkdirSync(join(projectPath, directory));
+    const gsapPath = join(dirname(require.resolve('gsap')), 'gsap.min.js');
+    copyFileSync(gsapPath, join(projectPath, 'assets', 'gsap.min.js'));
+    writeFileSync(join(projectPath, 'meta.json'), `${JSON.stringify(project, null, 2)}\n`, { flag: 'wx' });
+    writeFileSync(join(projectPath, 'hyperframes.json'), `${JSON.stringify({
+      '$schema': 'https://hyperframes.heygen.com/schema/hyperframes.json',
+      paths: { blocks: 'compositions', components: 'compositions/components', assets: 'assets' },
+    }, null, 2)}\n`, { flag: 'wx' });
+    writeFileSync(join(projectPath, 'index.html'), starterHtml(project), { flag: 'wx' });
+    writeFileSync(join(projectPath, 'timeline.json'), `${JSON.stringify(createProjectTimeline(projectPath), null, 2)}\n`, { flag: 'wx' });
+  } catch (error) {
+    rmSync(projectPath, { recursive: true, force: true });
+    throw error;
+  }
+  return projectPath;
+}
+
+function starterHtml({ name, width, height, durationSeconds, backgroundColor }) {
+  const background = backgroundColor ?? 'transparent';
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=${width}, initial-scale=1">
+  <title>${escapeHtml(name)}</title>
+  <link rel="icon" href="data:,">
+  <style>html,body,#root{box-sizing:border-box;margin:0;width:${width}px;height:${height}px}body{background:${background};color:#f5f5f5;font:48px system-ui,sans-serif}#root{display:grid;place-items:center}</style>
+  <script src="assets/gsap.min.js"></script>
+</head>
+<body>
+  <div id="root" data-composition-id="root" data-start="0" data-duration="${durationSeconds}" data-width="${width}" data-height="${height}">
+    <div id="title" class="clip" data-start="0" data-duration="${durationSeconds}" data-track-index="0">${escapeHtml(name)}</div>
+  </div>
+  <script>
+    const timeline = gsap.timeline({ paused: true });
+    timeline.from('#title', { opacity: 0, y: 24, duration: 0.8, ease: 'power2.out' });
+    window.__timelines = window.__timelines || {};
+    window.__timelines.root = timeline;
+  </script>
+</body>
+</html>
+`;
+}
+
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (character) => ({
+    '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
+  })[character]);
+}

package/src/project/presets.mjs

@@ -0,0 +1,44 @@
+const presets = [
+  {
+    id: 'vertical',
+    aspectRatio: '9:16',
+    width: 1080,
+    height: 1920,
+    platforms: ['TikTok', 'Instagram Reels and Stories', 'Facebook Reels and Stories', 'YouTube Shorts'],
+  },
+  {
+    id: 'portrait-feed',
+    aspectRatio: '4:5',
+    width: 1080,
+    height: 1350,
+    platforms: ['Instagram feed', 'LinkedIn feed'],
+  },
+  {
+    id: 'square',
+    aspectRatio: '1:1',
+    width: 1080,
+    height: 1080,
+    platforms: ['TikTok', 'Instagram feed', 'LinkedIn feed'],
+  },
+  {
+    id: 'landscape',
+    aspectRatio: '16:9',
+    width: 1920,
+    height: 1080,
+    platforms: ['YouTube', 'LinkedIn feed'],
+  },
+].map((preset) => Object.freeze({ ...preset, platforms: Object.freeze(preset.platforms) }));
+
+export const CANVAS_PRESETS = Object.freeze(presets);
+
+export function listCanvasPresets() {
+  return CANVAS_PRESETS;
+}
+
+export function resolveCanvasPreset(id) {
+  const preset = CANVAS_PRESETS.find((candidate) => candidate.id === id);
+  if (!preset) {
+    throw new TypeError(`Unknown canvas preset "${id}". Available presets: ${CANVAS_PRESETS.map(({ id: name }) => name).join(', ')}.`);
+  }
+  return preset;
+}

package/src/render/checkpoints.mjs

@@ -0,0 +1,192 @@
+import { createHash } from 'node:crypto';
+import { constants as fsConstants, createReadStream } from 'node:fs';
+import { copyFile, lstat, mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { basename, dirname, join, relative, resolve, sep } from 'node:path';
+
+const CHECKPOINT_VERSION = 1;
+const EXCLUDED_DIRECTORIES = new Set(['.git', '.aive-checkpoints', 'node_modules', 'renders']);
+
+export async function fingerprintRenderProject(projectPath, profile) {
+  const root = resolve(projectPath);
+  const hash = createHash('sha256');
+  hash.update(JSON.stringify(profile));
+  const files = await collectFiles(root);
+  for (const file of files) {
+    const relativePath = relative(root, file).split(sep).join('/');
+    hash.update(`\0${relativePath}\0`);
+    for await (const chunk of createReadStream(file)) hash.update(chunk);
+  }
+  return hash.digest('hex');
+}
+
+export async function prepareRenderCheckpoint(outputPath, fingerprint, options = {}) {
+  const maxBytes = options.maxBytes ?? 8 * 1024 ** 3;
+  const maxAgeHours = options.maxAgeHours ?? 72;
+  validateCheckpointLimits(maxBytes, maxAgeHours);
+  const root = join(dirname(resolve(outputPath)), '.aive-checkpoints');
+  await pruneExpiredRenderCheckpoints(root, maxAgeHours);
+  const id = createHash('sha256').update(`${basename(outputPath)}\0${fingerprint}`).digest('hex');
+  const directory = join(root, id);
+  await assertSafeCheckpointDirectory(root, directory);
+  const artifact = join(directory, `capture.${extension(outputPath)}`);
+  const manifest = join(directory, 'checkpoint.json');
+  return { root, id, directory, artifact, manifest, fingerprint, maxBytes, maxAgeHours };
+}
+
+export async function restoreRenderCheckpoint(checkpoint) {
+  await assertSafeCheckpointDirectory(checkpoint.root, checkpoint.directory);
+  let record;
+  try {
+    const parsed = JSON.parse(await readFile(checkpoint.manifest, 'utf8'));
+    const info = await lstat(checkpoint.artifact);
+    if (info.isSymbolicLink() || !info.isFile() || info.size <= 0 || info.size > checkpoint.maxBytes || parsed.sizeBytes !== info.size
+        || parsed.version !== CHECKPOINT_VERSION || parsed.fingerprint !== checkpoint.fingerprint
+        || parsed.artifact !== basename(checkpoint.artifact) || !Number.isFinite(parsed.createdAt)
+        || Date.now() - parsed.createdAt > checkpoint.maxAgeHours * 60 * 60 * 1000) {
+      await rm(checkpoint.directory, { recursive: true, force: true });
+      return undefined;
+    }
+    record = parsed;
+    if (await hashFile(checkpoint.artifact) !== record.sha256) {
+      await rm(checkpoint.directory, { recursive: true, force: true });
+      return undefined;
+    }
+    return checkpoint.artifact;
+  } catch (error) {
+    if (error.code === 'ENOENT' || error instanceof SyntaxError) await rm(checkpoint.directory, { recursive: true, force: true });
+    return undefined;
+  }
+}
+
+export async function saveRenderCheckpoint(checkpoint, completedArtifact) {
+  await assertSafeCheckpointDirectory(checkpoint.root, checkpoint.directory);
+  const info = await stat(completedArtifact);
+  if (!info.isFile() || info.size <= 0) throw new Error('Cannot checkpoint an empty render artifact.');
+  if (info.size > checkpoint.maxBytes) {
+    await rm(checkpoint.directory, { recursive: true, force: true });
+    return undefined;
+  }
+  await mkdir(checkpoint.directory, { recursive: true, mode: 0o700 });
+  const temporaryArtifact = `${checkpoint.artifact}.tmp`;
+  const temporaryManifest = `${checkpoint.manifest}.tmp`;
+  try {
+    await rm(temporaryArtifact, { force: true });
+    await rm(temporaryManifest, { force: true });
+    await copyFile(completedArtifact, temporaryArtifact);
+    const record = {
+      version: CHECKPOINT_VERSION,
+      fingerprint: checkpoint.fingerprint,
+      artifact: basename(checkpoint.artifact),
+      sizeBytes: info.size,
+      sha256: await hashFile(temporaryArtifact),
+      createdAt: Date.now(),
+    };
+    await writeFile(temporaryManifest, `${JSON.stringify(record, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+    await copyFile(temporaryArtifact, checkpoint.artifact, fsConstants.COPYFILE_EXCL);
+    await rm(temporaryArtifact, { force: true });
+    await copyFile(temporaryManifest, checkpoint.manifest, fsConstants.COPYFILE_EXCL);
+    await rm(temporaryManifest, { force: true });
+    return checkpoint.artifact;
+  } catch (error) {
+    await rm(temporaryArtifact, { force: true });
+    await rm(temporaryManifest, { force: true });
+    throw error;
+  }
+}
+
+export async function removeRenderCheckpoint(checkpoint) {
+  await assertSafeCheckpointDirectory(checkpoint.root, checkpoint.directory);
+  await rm(checkpoint.directory, { recursive: true, force: true });
+}
+
+export async function pruneExpiredRenderCheckpoints(rootPath, maxAgeHours = 72) {
+  const root = resolve(rootPath);
+  const rootInfo = await lstatIfPresent(root);
+  if (rootInfo && (rootInfo.isSymbolicLink() || !rootInfo.isDirectory())) {
+    throw new TypeError('Render checkpoint root must be a real directory, not a symbolic link.');
+  }
+  let entries;
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === 'ENOENT') return;
+    throw error;
+  }
+  const expireBefore = Date.now() - maxAgeHours * 60 * 60 * 1000;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const directory = join(root, entry.name);
+    try {
+      const record = JSON.parse(await readFile(join(directory, 'checkpoint.json'), 'utf8'));
+      if (!Number.isFinite(record.createdAt) || record.createdAt < expireBefore) {
+        await rm(directory, { recursive: true, force: true });
+      }
+    } catch {
+      await rm(directory, { recursive: true, force: true });
+    }
+  }
+}
+
+async function assertSafeCheckpointDirectory(rootPath, directoryPath) {
+  const root = resolve(rootPath);
+  const directory = resolve(directoryPath);
+  if (dirname(directory) !== root) throw new TypeError('Render checkpoint directory must be directly inside its checkpoint root.');
+  const rootInfo = await lstatIfPresent(root);
+  if (rootInfo && (rootInfo.isSymbolicLink() || !rootInfo.isDirectory())) {
+    throw new TypeError('Render checkpoint root must be a real directory, not a symbolic link.');
+  }
+  const directoryInfo = await lstatIfPresent(directory);
+  if (directoryInfo && (directoryInfo.isSymbolicLink() || !directoryInfo.isDirectory())) {
+    throw new TypeError('Render checkpoint directory must be a real directory, not a symbolic link.');
+  }
+}
+
+async function lstatIfPresent(path) {
+  try {
+    return await lstat(path);
+  } catch (error) {
+    if (error.code === 'ENOENT') return undefined;
+    throw error;
+  }
+}
+
+export function validateCheckpointLimits(maxBytes, maxAgeHours) {
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1024 * 1024 || maxBytes > 100 * 1024 ** 3) {
+    throw new TypeError('checkpointMaxBytes must be an integer from 1048576 to 107374182400.');
+  }
+  if (!Number.isSafeInteger(maxAgeHours) || maxAgeHours < 1 || maxAgeHours > 720) {
+    throw new TypeError('checkpointMaxAgeHours must be an integer from 1 to 720.');
+  }
+}
+
+async function collectFiles(root) {
+  const files = [];
+  const visit = async (directory) => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      const path = join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        const target = await stat(path);
+        if (target.isFile()) files.push(path);
+        else if (target.isDirectory()) throw new Error(`Cannot fingerprint a project containing a linked directory: ${relative(root, path)}`);
+      }
+      if (entry.isDirectory()) {
+        if (!EXCLUDED_DIRECTORIES.has(entry.name)) await visit(path);
+      } else if (entry.isFile()) files.push(path);
+    }
+  };
+  await visit(root);
+  return files;
+}
+
+async function hashFile(path) {
+  const hash = createHash('sha256');
+  for await (const chunk of createReadStream(path)) hash.update(chunk);
+  return hash.digest('hex');
+}
+
+function extension(path) {
+  const value = basename(path).split('.').at(-1).toLowerCase();
+  return /^[a-z0-9]{1,8}$/.test(value) ? value : 'bin';
+}

package/src/render/formats.mjs

@@ -0,0 +1,163 @@
+const EXTENSIONS = new Map([
+  ['.mp4', 'mp4'],
+  ['.webm', 'webm'],
+  ['.mov', 'mov'],
+  ['.gif', 'gif'],
+]);
+
+export function resolveRenderFormat(outputPath, requestedFormat) {
+  if (requestedFormat === 'png-sequence') return 'png-sequence';
+  const extension = outputPath ? outputPath.slice(outputPath.lastIndexOf('.')).toLowerCase() : undefined;
+  const inferred = EXTENSIONS.get(extension);
+  const format = requestedFormat ?? inferred ?? 'mp4';
+  if (!['mp4', 'webm', 'mov', 'gif', 'png-sequence'].includes(format)) {
+    throw new TypeError('Format must be mp4, webm, mov, gif, or png-sequence.');
+  }
+  if (requestedFormat && inferred && requestedFormat !== inferred) {
+    throw new TypeError(`Output extension ${extension} does not match requested ${requestedFormat} format.`);
+  }
+  if (outputPath && extension && !inferred) throw new TypeError(`Unsupported render output extension: ${extension}`);
+  const resolvedExtension = `.${format}`;
+  if (outputPath && format !== 'png-sequence' && extension !== resolvedExtension) {
+    throw new TypeError(`Render output for ${format} must use the ${resolvedExtension} extension.`);
+  }
+  return format;
+}
+
+export function resolveEncoderArgs(format, options = {}) {
+  const encoder = resolveVideoEncoder(format, options);
+  if (encoder.codec) return [];
+  if (encoder.crf !== undefined) return ['--crf', String(encoder.crf)];
+  if (encoder.videoBitrate !== undefined) return ['--video-bitrate', encoder.videoBitrate];
+  return [];
+}
+
+export function resolveColorProfile(profile, format) {
+  if (profile === undefined) return undefined;
+  if (profile === 'hdr10' && !['mp4', 'mov'].includes(format)) {
+    throw new TypeError(`The hdr10 color profile requires MP4 or MOV output, not ${format}.`);
+  }
+  if (!['mp4', 'mov', 'webm'].includes(format)) {
+    throw new TypeError(`Color profiles are supported for MP4, MOV, and WebM output, not ${format}.`);
+  }
+  const profiles = {
+    'rec709': {
+      id: 'rec709',
+      filter: 'colorspace=iall=bt709:space=bt709:primaries=bt709:trc=bt709:range=tv',
+      colorSpace: 'bt709',
+      colorTransfer: 'bt709',
+      colorPrimaries: 'bt709',
+      colorRange: 'tv',
+      requiredFilter: 'colorspace',
+    },
+    'rec2020-sdr': {
+      id: 'rec2020-sdr',
+      filter: 'colorspace=iall=bt709:space=bt2020nc:primaries=bt2020:trc=bt709:range=tv',
+      colorSpace: 'bt2020nc',
+      colorTransfer: 'bt709',
+      colorPrimaries: 'bt2020',
+      colorRange: 'tv',
+      requiredFilter: 'colorspace',
+    },
+    hdr10: {
+      id: 'hdr10',
+      filter: 'zscale=pin=bt709:tin=bt709:min=bt709:rin=tv:p=bt2020:t=smpte2084:m=bt2020nc:r=tv:npl=203,format=yuv420p10le',
+      colorSpace: 'bt2020nc',
+      colorTransfer: 'smpte2084',
+      colorPrimaries: 'bt2020',
+      colorRange: 'tv',
+      pixelFormat: 'yuv420p10le',
+      requiredFilter: 'zscale',
+      masteringDisplay: 'G(8500,39850)B(6550,2300)R(35400,14600)WP(15635,16450)L(10000000,1)',
+      contentLightLevel: '203,203',
+    },
+  };
+  const resolved = profiles[profile];
+  if (!resolved) throw new TypeError(`Unsupported colorProfile ${String(profile)}; choose rec709, rec2020-sdr, or hdr10.`);
+  return resolved;
+}
+
+export function resolveProfileEncoder(format, encoder, colorProfile) {
+  if (colorProfile?.id === 'hdr10') {
+    if (encoder.codec && encoder.codecId !== 'h265') {
+      throw new TypeError('The hdr10 color profile requires the h265 codec.');
+    }
+    return encoder.codec ? encoder : { ...encoder, codecId: 'h265', codec: 'libx265' };
+  }
+  if (encoder.codec) return encoder;
+  const codecId = format === 'webm' ? 'vp9' : 'h264';
+  const codec = format === 'webm' ? 'libvpx-vp9' : 'libx264';
+  return { ...encoder, codecId, codec };
+}
+
+export function resolveVideoEncoder(format, options = {}) {
+  if (!options || typeof options !== 'object' || Array.isArray(options)) throw new TypeError('Render options must be an object.');
+  for (const field of Object.keys(options)) if (!['codec', 'crf', 'videoBitrate'].includes(field)) throw new TypeError(`Unsupported encoder option: ${field}.`);
+  if (options.crf !== undefined && options.videoBitrate !== undefined) throw new TypeError('Choose either crf or videoBitrate, not both.');
+
+  const codecs = format === 'webm'
+    ? { vp9: 'libvpx-vp9' }
+    : format === 'mov'
+      ? { h264: 'libx264', h265: 'libx265', prores: 'prores_ks' }
+      : format === 'mp4'
+        ? { h264: 'libx264', h265: 'libx265' }
+        : {};
+  if (options.codec !== undefined && (typeof options.codec !== 'string' || codecs[options.codec] === undefined)) {
+    throw new TypeError(`Render codec is unsupported for ${format}; choose one of: ${Object.keys(codecs).join(', ') || 'none'}.`);
+  }
+
+  if (options.crf !== undefined) {
+    if (!['mp4', 'mov', 'webm'].includes(format)) throw new TypeError(`CRF control is not supported for ${format} output.`);
+    const maximum = options.codec === 'vp9' || (format === 'webm' && options.codec === undefined) ? 63 : 51;
+    if (options.codec === 'prores'
+        || !Number.isSafeInteger(options.crf) || options.crf < 0 || options.crf > maximum) {
+      throw new TypeError(`Render crf must be an integer from 0 to ${maximum} for ${options.codec ?? format}.`);
+    }
+  }
+  if (options.videoBitrate !== undefined && (!['mp4', 'mov', 'webm'].includes(format)
+      || options.codec === 'prores'
+      || typeof options.videoBitrate !== 'string'
+      || !/^(?:[1-9]\d{0,5})(?:\.\d{1,2})?[KMG]?$/.test(options.videoBitrate))) {
+    throw new TypeError('Render videoBitrate must be a positive bitrate such as 800K, 5M, or 1.5M on a bitrate-based encoder.');
+  }
+
+  return {
+    ...(options.codec ? { codec: codecs[options.codec], codecId: options.codec } : {}),
+    ...(options.crf !== undefined ? { crf: options.crf } : {}),
+    ...(options.videoBitrate !== undefined ? { videoBitrate: options.videoBitrate } : {}),
+  };
+}
+
+export function resolveRenderControlArgs(options = {}) {
+  if (!options || typeof options !== 'object' || Array.isArray(options)) throw new TypeError('Render options must be an object.');
+  for (const field of Object.keys(options)) {
+    if (!['format', 'encoder', 'colorProfile', 'workers', 'lowMemoryMode', 'timeoutSeconds', 'resumeCheckpoint', 'checkpointMaxBytes', 'checkpointMaxAgeHours'].includes(field)) throw new TypeError(`Unsupported render option: ${field}.`);
+  }
+  if (options.workers !== undefined
+      && options.workers !== 'auto'
+      && (!Number.isSafeInteger(options.workers) || options.workers < 1 || options.workers > 64)) {
+    throw new TypeError('Render workers must be auto or an integer from 1 to 64.');
+  }
+  if (options.lowMemoryMode !== undefined && typeof options.lowMemoryMode !== 'boolean') {
+    throw new TypeError('Render lowMemoryMode must be a boolean.');
+  }
+  if (options.timeoutSeconds !== undefined
+      && (!Number.isSafeInteger(options.timeoutSeconds) || options.timeoutSeconds < 1 || options.timeoutSeconds > 86_400)) {
+    throw new TypeError('Render timeoutSeconds must be an integer from 1 to 86400.');
+  }
+  if (options.resumeCheckpoint !== undefined && typeof options.resumeCheckpoint !== 'boolean') {
+    throw new TypeError('Render resumeCheckpoint must be a boolean.');
+  }
+  if (options.checkpointMaxBytes !== undefined
+      && (!Number.isSafeInteger(options.checkpointMaxBytes) || options.checkpointMaxBytes < 1024 * 1024 || options.checkpointMaxBytes > 100 * 1024 ** 3)) {
+    throw new TypeError('checkpointMaxBytes must be an integer from 1048576 to 107374182400.');
+  }
+  if (options.checkpointMaxAgeHours !== undefined
+      && (!Number.isSafeInteger(options.checkpointMaxAgeHours) || options.checkpointMaxAgeHours < 1 || options.checkpointMaxAgeHours > 720)) {
+    throw new TypeError('checkpointMaxAgeHours must be an integer from 1 to 720.');
+  }
+  return [
+    ...(options.workers !== undefined ? ['--workers', String(options.workers)] : []),
+    ...(options.lowMemoryMode === true ? ['--low-memory-mode'] : options.lowMemoryMode === false ? ['--no-low-memory-mode'] : []),
+  ];
+}