storyforge 0.5.3 → 0.7.0

package/dist/chunk-M6JAFPDI.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+
+// ../pipeline/src/clip-render/ffmpeg.ts
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+var defaultRunner = (cmd, args, { timeoutMs = 3e5, signal }) => new Promise((resolve, reject) => {
+  const child = spawn(cmd, args, { stdio: ["pipe", "pipe", "pipe"] });
+  let stdout = "";
+  let stderr = "";
+  let timer;
+  const onAbort = () => {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+    reject(new Error(`${cmd} aborted`));
+  };
+  if (signal) {
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  }
+  child.stdout?.on("data", (d) => {
+    stdout += d.toString();
+  });
+  child.stderr?.on("data", (d) => {
+    stderr += d.toString();
+  });
+  child.on("error", (err) => {
+    if (timer) clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+    reject(err);
+  });
+  child.on("close", (code) => {
+    if (timer) clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+    resolve({ code: code ?? -1, stdout, stderr });
+  });
+  timer = setTimeout(() => {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+    reject(new Error(`${cmd} timed out after ${timeoutMs}ms`));
+  }, timeoutMs);
+});
+var activeRunner = defaultRunner;
+function runCmd(cmd, args, opts = {}) {
+  return activeRunner(cmd, args, opts);
+}
+function buildMuxAudioArgs(videoPath, audioPath, outPath) {
+  return [
+    "-y",
+    "-i",
+    videoPath,
+    "-i",
+    audioPath,
+    "-map",
+    "0:v",
+    "-map",
+    "1:a",
+    "-c:v",
+    "copy",
+    "-c:a",
+    "aac",
+    "-shortest",
+    outPath
+  ];
+}
+async function muxAudio(videoPath, audioPath, outPath, opts = {}) {
+  const args = buildMuxAudioArgs(videoPath, audioPath, outPath);
+  const r = await runCmd("ffmpeg", args, opts);
+  if (r.code !== 0) {
+    throw new Error(
+      `ffmpeg mux failed (code ${r.code}): ${r.stderr.split("\n").slice(-5).join(" ")}`
+    );
+  }
+}
+function buildConcatArgs(manifestPath, outPath) {
+  return [
+    "-y",
+    "-f",
+    "concat",
+    "-safe",
+    "0",
+    "-i",
+    manifestPath,
+    "-c",
+    "copy",
+    outPath
+  ];
+}
+async function concatScenes(scenePaths, outPath, opts = {}) {
+  if (scenePaths.length === 0) {
+    throw new Error("concatScenes: at least one scene required");
+  }
+  if (scenePaths.length === 1) {
+    fs.copyFileSync(scenePaths[0], outPath);
+    return outPath;
+  }
+  const manifestPath = path.join(path.dirname(outPath), `concat_${path.basename(outPath)}.txt`);
+  const manifest = scenePaths.map((p) => `file '${p.replace(/'/g, "'\\''")}'`).join("\n") + "\n";
+  fs.writeFileSync(manifestPath, manifest);
+  try {
+    const args = buildConcatArgs(manifestPath, outPath);
+    const r = await runCmd("ffmpeg", args, opts);
+    if (r.code !== 0) {
+      throw new Error(
+        `ffmpeg concat failed (code ${r.code}): ${r.stderr.split("\n").slice(-5).join(" ")}`
+      );
+    }
+  } finally {
+    try {
+      fs.unlinkSync(manifestPath);
+    } catch {
+    }
+  }
+  return outPath;
+}
+function buildNormalizeClipArgs(videoPath, outPath, opts) {
+  const { audioPath, targetWidth, targetHeight, fps = 30 } = opts;
+  const vf = `scale=${targetWidth}:${targetHeight}:force_original_aspect_ratio=decrease,pad=${targetWidth}:${targetHeight}:(ow-iw)/2:(oh-ih)/2:black,fps=${fps},setpts=PTS-STARTPTS`;
+  const af = "loudnorm=I=-14:TP=-1.5:LRA=11,asetpts=PTS-STARTPTS,aresample=44100";
+  const args = ["-y", "-i", videoPath];
+  if (audioPath) args.push("-i", audioPath);
+  args.push(
+    ...audioPath ? ["-map", "0:v", "-map", "1:a"] : [],
+    "-c:v",
+    "libx264",
+    "-preset",
+    "medium",
+    "-crf",
+    "18",
+    "-pix_fmt",
+    "yuv420p",
+    "-vf",
+    vf,
+    "-c:a",
+    "aac",
+    "-b:a",
+    "192k",
+    "-ar",
+    "44100",
+    "-ac",
+    "2",
+    "-af",
+    af,
+    "-shortest",
+    outPath
+  );
+  return args;
+}
+function buildFinalConcatArgs(opts) {
+  const {
+    manifestPath,
+    outPath,
+    watermarkPath,
+    brandAudioPath,
+    brandAudioVolume = 0.1
+  } = opts;
+  const vol = brandAudioVolume.toFixed(3);
+  const encoderTail = [
+    "-c:v",
+    "libx264",
+    "-preset",
+    "slow",
+    "-crf",
+    "8",
+    "-pix_fmt",
+    "yuv420p",
+    "-colorspace",
+    "bt709",
+    "-color_primaries",
+    "bt709",
+    "-color_trc",
+    "bt709",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "192k",
+    outPath
+  ];
+  if (watermarkPath && brandAudioPath) {
+    return [
+      "-y",
+      "-f",
+      "concat",
+      "-safe",
+      "0",
+      "-i",
+      manifestPath,
+      "-i",
+      watermarkPath,
+      "-i",
+      brandAudioPath,
+      "-filter_complex",
+      `[0:v][1:v]overlay=W-w-20:H-h-20,format=yuv420p[vout];[2:a]volume=${vol}[bgm];[0:a][bgm]amix=inputs=2:duration=first:dropout_transition=2[aout]`,
+      "-map",
+      "[vout]",
+      "-map",
+      "[aout]",
+      ...encoderTail
+    ];
+  }
+  if (watermarkPath) {
+    return [
+      "-y",
+      "-f",
+      "concat",
+      "-safe",
+      "0",
+      "-i",
+      manifestPath,
+      "-i",
+      watermarkPath,
+      "-filter_complex",
+      `[0:v][1:v]overlay=W-w-20:H-h-20,format=yuv420p[vout]`,
+      "-map",
+      "[vout]",
+      "-map",
+      "0:a",
+      ...encoderTail
+    ];
+  }
+  if (brandAudioPath) {
+    return [
+      "-y",
+      "-f",
+      "concat",
+      "-safe",
+      "0",
+      "-i",
+      manifestPath,
+      "-i",
+      brandAudioPath,
+      "-filter_complex",
+      `[1:a]volume=${vol}[bgm];[0:a][bgm]amix=inputs=2:duration=first:dropout_transition=2[aout]`,
+      "-map",
+      "0:v",
+      "-map",
+      "[aout]",
+      ...encoderTail
+    ];
+  }
+  return [
+    "-y",
+    "-f",
+    "concat",
+    "-safe",
+    "0",
+    "-i",
+    manifestPath,
+    ...encoderTail
+  ];
+}
+function buildCrossfadeArgs(prevPath, nextPath, outPath, opts = {}) {
+  const { transitionSec = 0.4, fps = 30 } = opts;
+  return [
+    "-y",
+    "-i",
+    prevPath,
+    "-i",
+    nextPath,
+    "-filter_complex",
+    `[0:v][1:v]xfade=transition=fade:duration=${transitionSec}:offset=0[v];[0:a][1:a]acrossfade=d=${transitionSec}[a]`,
+    "-map",
+    "[v]",
+    "-map",
+    "[a]",
+    "-c:v",
+    "libx264",
+    "-preset",
+    "medium",
+    "-crf",
+    "18",
+    "-pix_fmt",
+    "yuv420p",
+    "-r",
+    String(fps),
+    "-c:a",
+    "aac",
+    "-b:a",
+    "192k",
+    outPath
+  ];
+}
+async function probeDuration(mediaPath, opts = {}) {
+  try {
+    const r = await runCmd(
+      "ffprobe",
+      ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", mediaPath],
+      opts
+    );
+    if (r.code !== 0) return null;
+    const parsed = parseFloat(r.stdout.trim());
+    if (!Number.isFinite(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export {
+  runCmd,
+  muxAudio,
+  concatScenes,
+  buildNormalizeClipArgs,
+  buildFinalConcatArgs,
+  buildCrossfadeArgs,
+  probeDuration
+};

package/dist/chunk-NSPRIPOP.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __export,
+  __toESM
+};

package/dist/chunk-U6LFS35L.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+// ../../node_modules/@smithy/protocol-http/dist-es/httpRequest.js
+var HttpRequest = class _HttpRequest {
+  method;
+  protocol;
+  hostname;
+  port;
+  path;
+  query;
+  headers;
+  username;
+  password;
+  fragment;
+  body;
+  constructor(options) {
+    this.method = options.method || "GET";
+    this.hostname = options.hostname || "localhost";
+    this.port = options.port;
+    this.query = options.query || {};
+    this.headers = options.headers || {};
+    this.body = options.body;
+    this.protocol = options.protocol ? options.protocol.slice(-1) !== ":" ? `${options.protocol}:` : options.protocol : "https:";
+    this.path = options.path ? options.path.charAt(0) !== "/" ? `/${options.path}` : options.path : "/";
+    this.username = options.username;
+    this.password = options.password;
+    this.fragment = options.fragment;
+  }
+  static clone(request) {
+    const cloned = new _HttpRequest({
+      ...request,
+      headers: { ...request.headers }
+    });
+    if (cloned.query) {
+      cloned.query = cloneQuery(cloned.query);
+    }
+    return cloned;
+  }
+  static isInstance(request) {
+    if (!request) {
+      return false;
+    }
+    const req = request;
+    return "method" in req && "protocol" in req && "hostname" in req && "path" in req && typeof req["query"] === "object" && typeof req["headers"] === "object";
+  }
+  clone() {
+    return _HttpRequest.clone(this);
+  }
+};
+function cloneQuery(query) {
+  return Object.keys(query).reduce((carry, paramName) => {
+    const param = query[paramName];
+    return {
+      ...carry,
+      [paramName]: Array.isArray(param) ? [...param] : param
+    };
+  }, {});
+}
+
+export {
+  HttpRequest
+};

package/dist/chunk-WVPXYQ2G.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+import {
+  chain
+} from "./chunk-56OB3EDN.js";
+import {
+  getProfileName,
+  loadSharedConfigFiles
+} from "./chunk-C5KB4UV6.js";
+import {
+  CredentialsProviderError
+} from "./chunk-YLY3P6CS.js";
+
+// ../../node_modules/@smithy/querystring-parser/dist-es/index.js
+function parseQueryString(querystring) {
+  const query = {};
+  querystring = querystring.replace(/^\?/, "");
+  if (querystring) {
+    for (const pair of querystring.split("&")) {
+      let [key, value = null] = pair.split("=");
+      key = decodeURIComponent(key);
+      if (value) {
+        value = decodeURIComponent(value);
+      }
+      if (!(key in query)) {
+        query[key] = value;
+      } else if (Array.isArray(query[key])) {
+        query[key].push(value);
+      } else {
+        query[key] = [query[key], value];
+      }
+    }
+  }
+  return query;
+}
+
+// ../../node_modules/@smithy/url-parser/dist-es/index.js
+var parseUrl = (url) => {
+  if (typeof url === "string") {
+    return parseUrl(new URL(url));
+  }
+  const { hostname, pathname, port, protocol, search } = url;
+  let query;
+  if (search) {
+    query = parseQueryString(search);
+  }
+  return {
+    hostname,
+    port: port ? parseInt(port) : void 0,
+    protocol,
+    path: pathname,
+    query
+  };
+};
+
+// ../../node_modules/@smithy/property-provider/dist-es/fromStatic.js
+var fromStatic = (staticValue) => () => Promise.resolve(staticValue);
+
+// ../../node_modules/@smithy/property-provider/dist-es/memoize.js
+var memoize = (provider, isExpired, requiresRefresh) => {
+  let resolved;
+  let pending;
+  let hasResult;
+  let isConstant = false;
+  const coalesceProvider = async () => {
+    if (!pending) {
+      pending = provider();
+    }
+    try {
+      resolved = await pending;
+      hasResult = true;
+      isConstant = false;
+    } finally {
+      pending = void 0;
+    }
+    return resolved;
+  };
+  if (isExpired === void 0) {
+    return async (options) => {
+      if (!hasResult || options?.forceRefresh) {
+        resolved = await coalesceProvider();
+      }
+      return resolved;
+    };
+  }
+  return async (options) => {
+    if (!hasResult || options?.forceRefresh) {
+      resolved = await coalesceProvider();
+    }
+    if (isConstant) {
+      return resolved;
+    }
+    if (requiresRefresh && !requiresRefresh(resolved)) {
+      isConstant = true;
+      return resolved;
+    }
+    if (isExpired(resolved)) {
+      await coalesceProvider();
+      return resolved;
+    }
+    return resolved;
+  };
+};
+
+// ../../node_modules/@smithy/node-config-provider/dist-es/getSelectorName.js
+function getSelectorName(functionString) {
+  try {
+    const constants = new Set(Array.from(functionString.match(/([A-Z_]){3,}/g) ?? []));
+    constants.delete("CONFIG");
+    constants.delete("CONFIG_PREFIX_SEPARATOR");
+    constants.delete("ENV");
+    return [...constants].join(", ");
+  } catch (e) {
+    return functionString;
+  }
+}
+
+// ../../node_modules/@smithy/node-config-provider/dist-es/fromEnv.js
+var fromEnv = (envVarSelector, options) => async () => {
+  try {
+    const config = envVarSelector(process.env, options);
+    if (config === void 0) {
+      throw new Error();
+    }
+    return config;
+  } catch (e) {
+    throw new CredentialsProviderError(e.message || `Not found in ENV: ${getSelectorName(envVarSelector.toString())}`, { logger: options?.logger });
+  }
+};
+
+// ../../node_modules/@smithy/node-config-provider/dist-es/fromSharedConfigFiles.js
+var fromSharedConfigFiles = (configSelector, { preferredFile = "config", ...init } = {}) => async () => {
+  const profile = getProfileName(init);
+  const { configFile, credentialsFile } = await loadSharedConfigFiles(init);
+  const profileFromCredentials = credentialsFile[profile] || {};
+  const profileFromConfig = configFile[profile] || {};
+  const mergedProfile = preferredFile === "config" ? { ...profileFromCredentials, ...profileFromConfig } : { ...profileFromConfig, ...profileFromCredentials };
+  try {
+    const cfgFile = preferredFile === "config" ? configFile : credentialsFile;
+    const configValue = configSelector(mergedProfile, cfgFile);
+    if (configValue === void 0) {
+      throw new Error();
+    }
+    return configValue;
+  } catch (e) {
+    throw new CredentialsProviderError(e.message || `Not found in config files w/ profile [${profile}]: ${getSelectorName(configSelector.toString())}`, { logger: init.logger });
+  }
+};
+
+// ../../node_modules/@smithy/node-config-provider/dist-es/fromStatic.js
+var isFunction = (func) => typeof func === "function";
+var fromStatic2 = (defaultValue) => isFunction(defaultValue) ? async () => await defaultValue() : fromStatic(defaultValue);
+
+// ../../node_modules/@smithy/node-config-provider/dist-es/configLoader.js
+var loadConfig = ({ environmentVariableSelector, configFileSelector, default: defaultValue }, configuration = {}) => {
+  const { signingName, logger } = configuration;
+  const envOptions = { signingName, logger };
+  return memoize(chain(fromEnv(environmentVariableSelector, envOptions), fromSharedConfigFiles(configFileSelector, configuration), fromStatic2(defaultValue)));
+};
+
+export {
+  parseUrl,
+  memoize,
+  loadConfig
+};

package/dist/chunk-YLY3P6CS.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+// ../../node_modules/@smithy/property-provider/dist-es/ProviderError.js
+var ProviderError = class _ProviderError extends Error {
+  name = "ProviderError";
+  tryNextLink;
+  constructor(message, options = true) {
+    let logger;
+    let tryNextLink = true;
+    if (typeof options === "boolean") {
+      logger = void 0;
+      tryNextLink = options;
+    } else if (options != null && typeof options === "object") {
+      logger = options.logger;
+      tryNextLink = options.tryNextLink ?? true;
+    }
+    super(message);
+    this.tryNextLink = tryNextLink;
+    Object.setPrototypeOf(this, _ProviderError.prototype);
+    logger?.debug?.(`@smithy/property-provider ${tryNextLink ? "->" : "(!)"} ${message}`);
+  }
+  static from(error, options = true) {
+    return Object.assign(new this(error.message, options), error);
+  }
+};
+
+// ../../node_modules/@smithy/property-provider/dist-es/CredentialsProviderError.js
+var CredentialsProviderError = class _CredentialsProviderError extends ProviderError {
+  name = "CredentialsProviderError";
+  constructor(message, options = true) {
+    super(message, options);
+    Object.setPrototypeOf(this, _CredentialsProviderError.prototype);
+  }
+};
+
+export {
+  ProviderError,
+  CredentialsProviderError
+};

package/dist/chunk-ZHDWKDF5.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+
+// ../../node_modules/@smithy/is-array-buffer/dist-es/index.js
+var isArrayBuffer = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
+
+// ../../node_modules/@smithy/util-buffer-from/dist-es/index.js
+import { Buffer } from "buffer";
+var fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => {
+  if (!isArrayBuffer(input)) {
+    throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
+  }
+  return Buffer.from(input, offset, length);
+};
+var fromString = (input, encoding) => {
+  if (typeof input !== "string") {
+    throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
+  }
+  return encoding ? Buffer.from(input, encoding) : Buffer.from(input);
+};
+
+// ../../node_modules/@smithy/util-utf8/dist-es/fromUtf8.js
+var fromUtf8 = (input) => {
+  const buf = fromString(input, "utf8");
+  return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+};
+
+// ../../node_modules/@smithy/util-utf8/dist-es/toUtf8.js
+var toUtf8 = (input) => {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+    throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
+  }
+  return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
+};
+
+export {
+  isArrayBuffer,
+  fromArrayBuffer,
+  fromString,
+  fromUtf8,
+  toUtf8
+};

package/dist/{cli-usage-FG3YUG3W.js → cli-usage-G762TREV.js}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunk-NSPRIPOP.js";
 
 // src/cli-usage.ts
 import * as fs from "fs";