@hraness/ghostget 0.17.2

package/src/media/args.ts

@@ -0,0 +1,303 @@
+import { resolve } from "node:path";
+
+export const USAGE = `usage: ghostget media [archive|audio|video|transcript] URL [options]
+       ghostget doctor [--json]
+       ghostget transcriber setup --engine whisper-cpp --model FILE [options]
+       ghostget verify ITEM_DIRECTORY [--json]
+
+commands:
+  ghostget media URL                 save media, separate audio/video, and get a transcript
+  ghostget archive URL               explicit form of the default command
+  ghostget audio URL                 save the source and an audio-only stream-copy derivative
+  ghostget video URL                 save the source and a video-only stream-copy derivative
+  ghostget transcript URL            save a provider transcript, or make one locally when configured
+  ghostget transcriber setup         register an existing local whisper.cpp executable and model
+  ghostget doctor                    inspect built-in HTTP and external media capabilities
+  ghostget verify PATH               recompute and verify every artifact recorded in wrench-media.json
+
+capture options:
+  --output DIRECTORY       library root (default: GHOSTGET_MEDIA_HOME or ~/.local/share/ghostget/media)
+  --lang LANGUAGE          preferred transcript language (default: en)
+  --browser SPEC           explicit yt-dlp browser-cookie source
+  --auth-context NAME      stable private-access realm (required with browser/config)
+  --inherit-yt-dlp-config  opt into ambient yt-dlp configuration and plugins
+  --refresh                re-acquire and append only when retained content changes
+  --json                   emit a stable JSON record
+
+transcriber setup options:
+  --engine whisper-cpp     explicit local engine (currently whisper-cpp)
+  --model FILE             existing local whisper.cpp model; never downloaded by setup
+  --executable FILE        existing whisper-cli (default: discover it on PATH)
+  --replace                replace a different existing transcriber configuration
+  --json                   emit a stable JSON record
+
+Ghostget media archives material you are authorized to access. It does not bypass DRM or access controls.`;
+
+export type CaptureMode = "archive" | "audio" | "video" | "transcript";
+
+interface CommandBase {
+  readonly json: boolean;
+}
+
+export type CliCommand =
+  | ({ readonly kind: "help" } & CommandBase)
+  | ({ readonly kind: "version" } & CommandBase)
+  | ({ readonly kind: "doctor" } & CommandBase)
+  | ({ readonly kind: "verify"; readonly itemDirectory: string } & CommandBase)
+  | ({
+      readonly kind: "transcriber-setup";
+      readonly engine: "whisper-cpp";
+      readonly modelPath: string;
+      readonly executablePath?: string;
+      readonly replace: boolean;
+    } & CommandBase)
+  | ({
+      readonly kind: "capture";
+      readonly mode: CaptureMode;
+      readonly url: string;
+      readonly outputDirectory?: string;
+      readonly language: string;
+      readonly browser?: string;
+      readonly authContext?: string;
+      readonly inheritYtDlpConfig: boolean;
+      readonly refresh: boolean;
+    } & CommandBase);
+
+export type ParseArgsResult =
+  | { readonly ok: true; readonly command: CliCommand }
+  | { readonly ok: false; readonly json: boolean; readonly message: string };
+
+const captureModes = new Set<CaptureMode>(["archive", "audio", "video", "transcript"]);
+const valueOptions = new Set([
+  "--output",
+  "--lang",
+  "--browser",
+  "--auth-context",
+  "--engine",
+  "--model",
+  "--executable",
+]);
+const booleanOptions = new Set(["--json", "--inherit-yt-dlp-config", "--refresh", "--replace"]);
+const transcriberSetupOptions = new Set([
+  "--engine",
+  "--model",
+  "--executable",
+  "--replace",
+  "--json",
+]);
+
+interface ParsedTokens {
+  readonly positionals: readonly string[];
+  readonly options: ReadonlyMap<string, string | true>;
+}
+
+function failure(json: boolean, message: string): ParseArgsResult {
+  return { ok: false, json, message };
+}
+
+function hasControlCharacter(value: string): boolean {
+  for (const character of value) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint !== undefined && (codePoint <= 0x1f || codePoint === 0x7f)) return true;
+  }
+  return false;
+}
+
+function parseTokens(argv: readonly string[]): ParsedTokens | null {
+  const positionals: string[] = [];
+  const options = new Map<string, string | true>();
+  let optionsEnded = false;
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === undefined) return null;
+    if (optionsEnded) {
+      positionals.push(token);
+      continue;
+    }
+    if (token === "--") {
+      optionsEnded = true;
+      continue;
+    }
+    if (!token.startsWith("-")) {
+      positionals.push(token);
+      continue;
+    }
+    if (token === "-h" || token === "--help" || token === "-V" || token === "--version") {
+      if (options.has(token)) return null;
+      options.set(token, true);
+      continue;
+    }
+    if (booleanOptions.has(token)) {
+      if (options.has(token)) return null;
+      options.set(token, true);
+      continue;
+    }
+    if (!valueOptions.has(token) || options.has(token)) return null;
+    const value = argv[index + 1];
+    if (value === undefined || value.startsWith("-") || value.includes("\0")) return null;
+    options.set(token, value);
+    index += 1;
+  }
+  return { positionals, options };
+}
+
+function hasFlag(tokens: ParsedTokens, name: string): boolean {
+  return tokens.options.get(name) === true;
+}
+
+function option(tokens: ParsedTokens, name: string): string | undefined {
+  const value = tokens.options.get(name);
+  return typeof value === "string" ? value : undefined;
+}
+
+function parseSourceUrl(value: string): string | null {
+  if (value.length === 0 || value.length > 8_192 || hasControlCharacter(value)) return null;
+  try {
+    const url = new URL(value);
+    if ((url.protocol !== "https:" && url.protocol !== "http:") || url.username !== "" || url.password !== "") {
+      return null;
+    }
+    return url.href;
+  } catch {
+    return null;
+  }
+}
+
+export function isLiteralLanguageTag(value: string): boolean {
+  const lower = value.toLowerCase();
+  return lower !== "all"
+    && lower !== "live_chat"
+    && /^[A-Za-z0-9]{1,8}(?:-[A-Za-z0-9]{1,8}){0,4}$/u.test(value);
+}
+
+export function isValidBrowserSpec(value: string): boolean {
+  return value.length > 0 && value.length <= 512 && !hasControlCharacter(value);
+}
+
+/** Canonical, non-secret label for one user-declared authorization realm. */
+export function normalizeAuthContextName(value: string): string | null {
+  return /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(value)
+    ? value.toLowerCase()
+    : null;
+}
+
+function validFilesystemOption(value: string): boolean {
+  return value.length > 0 && value.length <= 4_096 && !value.includes("\0") && !hasControlCharacter(value);
+}
+
+function transcriberSetupCommand(tokens: ParsedTokens): ParseArgsResult {
+  const json = hasFlag(tokens, "--json");
+  if ([...tokens.options.keys()].some((name) => !transcriberSetupOptions.has(name))) {
+    return failure(json, "transcriber setup accepts only --engine, --model, --executable, --replace, and --json");
+  }
+  const engine = option(tokens, "--engine");
+  if (engine !== "whisper-cpp") {
+    return failure(json, "transcriber setup requires --engine whisper-cpp");
+  }
+  const model = option(tokens, "--model");
+  if (model === undefined || !validFilesystemOption(model)) {
+    return failure(json, "transcriber setup requires a valid --model filesystem path");
+  }
+  const executable = option(tokens, "--executable");
+  if (executable !== undefined && !validFilesystemOption(executable)) {
+    return failure(json, "--executable must be a valid filesystem path");
+  }
+  return {
+    ok: true,
+    command: {
+      kind: "transcriber-setup",
+      engine,
+      modelPath: resolve(model),
+      ...(executable === undefined ? {} : { executablePath: resolve(executable) }),
+      replace: hasFlag(tokens, "--replace"),
+      json,
+    },
+  };
+}
+
+function captureCommand(tokens: ParsedTokens, mode: CaptureMode, urlValue: string): ParseArgsResult {
+  const json = hasFlag(tokens, "--json");
+  const url = parseSourceUrl(urlValue);
+  if (url === null) return failure(json, "source URL must be HTTP(S) and must not contain credentials");
+  const language = option(tokens, "--lang") ?? "en";
+  if (!isLiteralLanguageTag(language)) return failure(json, "--lang must be a short literal BCP-47-style language tag");
+  const browser = option(tokens, "--browser");
+  if (browser !== undefined && !isValidBrowserSpec(browser)) return failure(json, "--browser must be nonempty, control-free, and at most 512 characters");
+  const inheritYtDlpConfig = hasFlag(tokens, "--inherit-yt-dlp-config");
+  if (browser !== undefined && inheritYtDlpConfig) {
+    return failure(json, "choose either --browser or --inherit-yt-dlp-config, not both");
+  }
+  const rawAuthContext = option(tokens, "--auth-context");
+  const authContext = rawAuthContext === undefined ? undefined : normalizeAuthContextName(rawAuthContext);
+  if (authContext === null) {
+    return failure(json, "--auth-context must be a 1-64 character ASCII name");
+  }
+  const hasPrivateAccess = browser !== undefined || inheritYtDlpConfig;
+  if (hasPrivateAccess && authContext === undefined) {
+    return failure(json, "--browser and --inherit-yt-dlp-config require --auth-context");
+  }
+  if (!hasPrivateAccess && authContext !== undefined) {
+    return failure(json, "--auth-context requires --browser or --inherit-yt-dlp-config");
+  }
+  const output = option(tokens, "--output");
+  if (output !== undefined && (output.length === 0 || output.length > 4_096 || output.includes("\0"))) {
+    return failure(json, "--output must be a nonempty filesystem path");
+  }
+  return {
+    ok: true,
+    command: {
+      kind: "capture",
+      mode,
+      url,
+      language,
+      ...(output === undefined ? {} : { outputDirectory: resolve(output) }),
+      ...(browser === undefined ? {} : { browser }),
+      ...(authContext === undefined ? {} : { authContext }),
+      inheritYtDlpConfig,
+      refresh: hasFlag(tokens, "--refresh"),
+      json,
+    },
+  };
+}
+
+export function parseArgs(argv: readonly string[]): ParseArgsResult {
+  const tokens = parseTokens(argv);
+  const guessedJson = argv.includes("--json");
+  if (tokens === null) return failure(guessedJson, "invalid or duplicate option");
+  const json = hasFlag(tokens, "--json");
+  const wantsHelp = hasFlag(tokens, "-h") || hasFlag(tokens, "--help");
+  const wantsVersion = hasFlag(tokens, "-V") || hasFlag(tokens, "--version");
+  if (wantsHelp || wantsVersion) {
+    if (wantsHelp && wantsVersion) return failure(json, "choose either --help or --version");
+    return { ok: true, command: { kind: wantsHelp ? "help" : "version", json } };
+  }
+
+  const [first, second, ...rest] = tokens.positionals;
+  if (first === undefined) return { ok: true, command: { kind: "help", json } };
+  if (first === "doctor") {
+    if (second !== undefined || rest.length !== 0 || tokens.options.size > (json ? 1 : 0)) {
+      return failure(json, "doctor accepts only --json");
+    }
+    return { ok: true, command: { kind: "doctor", json } };
+  }
+  if (first === "verify") {
+    if (second === undefined || rest.length !== 0 || tokens.options.size > (json ? 1 : 0)) {
+      return failure(json, "verify requires exactly one item directory and accepts only --json");
+    }
+    if (second.includes("\0") || second.length > 4_096) return failure(json, "invalid item directory");
+    return { ok: true, command: { kind: "verify", itemDirectory: resolve(second), json } };
+  }
+  if (first === "transcriber") {
+    if (second !== "setup" || rest.length !== 0) {
+      return failure(json, "transcriber requires the setup subcommand");
+    }
+    return transcriberSetupCommand(tokens);
+  }
+  if (captureModes.has(first as CaptureMode)) {
+    if (second === undefined || rest.length !== 0) return failure(json, `${first} requires exactly one URL`);
+    return captureCommand(tokens, first as CaptureMode, second);
+  }
+  if (rest.length !== 0 || second !== undefined) return failure(json, "default capture accepts exactly one URL");
+  return captureCommand(tokens, "archive", first);
+}

package/src/media/cli.ts

@@ -0,0 +1,287 @@
+import { homedir } from "node:os";
+import { MediaArchiveError, mediaUrl, type MediaArchiveOptions, type MediaArchiveResult } from "./archive";
+import { parseArgs, USAGE } from "./args";
+import { renderDoctorReport, runDoctor, type DoctorOptions, type DoctorReport } from "./doctor";
+import {
+  GHOSTGET_MEDIA_VERSION,
+  verifyMediaItem,
+  type MediaManifest,
+  type VerifyItemResult,
+} from "./manifest";
+import { redactDiagnostic, sanitizeTerminalText, urlDerivedRedactions } from "./process";
+import {
+  setupWhisperCppTranscriber,
+  WhisperCppTranscriberSetupError,
+  type ReadyTranscriber,
+  type SetupWhisperCppTranscriberOptions,
+} from "./transcriber-config";
+
+export interface CliIo {
+  readonly stdout: (value: string) => void;
+  readonly stderr: (value: string) => void;
+}
+
+export type MediaCliEnvironment = Readonly<Record<string, string | undefined>>;
+
+export interface MediaCliDependencies {
+  readonly mediaUrl: (options: MediaArchiveOptions) => Promise<MediaArchiveResult>;
+  readonly runDoctor: (options: DoctorOptions) => Promise<DoctorReport>;
+  readonly verifyMediaItem: (itemDirectory: string) => Promise<VerifyItemResult>;
+  readonly setupWhisperCppTranscriber: (
+    options: SetupWhisperCppTranscriberOptions,
+  ) => Promise<ReadyTranscriber>;
+}
+
+export interface RunCliOptions {
+  readonly io?: CliIo;
+  readonly environment?: MediaCliEnvironment;
+  readonly homeDirectory?: string;
+  readonly signal?: AbortSignal;
+  readonly dependencies?: MediaCliDependencies;
+}
+
+const processIo: CliIo = {
+  stdout: (value) => { void process.stdout.write(value); },
+  stderr: (value) => { void process.stderr.write(value); },
+};
+
+const defaultDependencies: MediaCliDependencies = {
+  mediaUrl: async (options) => await mediaUrl(options),
+  runDoctor: async (options) => await runDoctor(options),
+  verifyMediaItem: async (itemDirectory) => await verifyMediaItem(itemDirectory),
+  setupWhisperCppTranscriber: async (options) => await setupWhisperCppTranscriber(options),
+};
+
+const archiveExitCodes: Readonly<Record<MediaArchiveError["code"], number>> = {
+  CANCELLED: 130,
+  DEPENDENCY_MISSING: 3,
+  UNSUPPORTED_SOURCE: 4,
+  PROBE_FAILED: 4,
+  TRANSCRIPT_UNAVAILABLE: 5,
+  CAPTURE_FAILED: 6,
+  DERIVATION_FAILED: 7,
+  TRANSCRIPTION_FAILED: 7,
+  ARCHIVE_CONFLICT: 8,
+  ARCHIVE_INVALID: 8,
+  BUSY: 9,
+  IO_ERROR: 10,
+};
+
+function writeJson(io: CliIo, channel: "stdout" | "stderr", value: unknown): void {
+  const source = JSON.stringify(value).replace(/[\u007f-\u009f]/gu, (character) =>
+    `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`,
+  );
+  io[channel](`${source}\n`);
+}
+
+function safeDetails(
+  details: Readonly<Record<string, unknown>>,
+  homeDirectory: string,
+  secrets: readonly string[] = [],
+): Readonly<Record<string, unknown>> {
+  const redacted = redactDiagnostic(JSON.stringify(details), { homeDirectory, secrets });
+  try {
+    const value: unknown = JSON.parse(redacted);
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value as Readonly<Record<string, unknown>> : {};
+  } catch {
+    return {};
+  }
+}
+
+function captureSummary(result: MediaArchiveResult): Readonly<Record<string, unknown>> {
+  const revision = "revision" in result.manifest
+    ? {
+        sequence: result.manifest.revision.sequence,
+        subjectAssetKey: result.manifest.revision.subjectAssetKey,
+        previousAssetKey: result.manifest.revision.previousAssetKey ?? null,
+        contentSha256: result.manifest.revision.content.sha256,
+      }
+    : null;
+  return {
+    ok: true,
+    status: result.status,
+    itemDirectory: result.itemDirectory,
+    assetKey: result.manifest.assetKey,
+    title: result.manifest.source.title ?? null,
+    artifactCount: result.manifest.artifacts.length,
+    transcript: result.manifest.transcript,
+    revision,
+    warnings: result.warnings,
+  };
+}
+
+function humanCaptureSummary(result: MediaArchiveResult): string {
+  const titleCandidate = sanitizeTerminalText(
+    result.manifest.source.title ?? result.manifest.assetKey,
+  );
+  const title = titleCandidate.length === 0 ? result.manifest.assetKey : titleCandidate;
+  const action = result.status === "created" ? "Saved" : "Already archived";
+  const revision = "revision" in result.manifest
+    ? ` · revision ${String(result.manifest.revision.sequence)}`
+    : "";
+  const transcript = humanTranscriptSummary(result.manifest.transcript);
+  const warningLines = result.warnings
+    .map((warning) => sanitizeTerminalText(warning))
+    .filter((warning) => warning.length > 0)
+    .map((warning) => `warning: ${warning}\n`)
+    .join("");
+  return `${action} ${title}${revision}\n${sanitizeTerminalText(result.itemDirectory)}\n${String(result.manifest.artifacts.length)} artifacts · ${transcript}\n${warningLines}`;
+}
+
+function humanTranscriptSummary(transcript: MediaManifest["transcript"]): string {
+  if (transcript.status === "available") {
+    const language = sanitizeTerminalText(transcript.language) || "unknown-language";
+    return `${transcript.source} ${language} transcript`;
+  }
+  switch (transcript.reason) {
+    case "provider_has_no_captions":
+      return "no provider transcript";
+    case "not_requested":
+      return "transcript not requested";
+    case "transcriber_not_configured":
+      return "no transcript · local transcriber not configured";
+    case "audio_not_present":
+      return "no transcript · audio not present";
+    case "no_speech":
+      return "no speech detected";
+  }
+}
+
+function sanitizeHumanReport(value: string): string {
+  return value
+    .split("\n")
+    .map((line) => sanitizeTerminalText(line))
+    .join("\n");
+}
+
+function sourceLabel(url: string): string {
+  try { return new URL(url).hostname; } catch { return "source"; }
+}
+
+export async function runCli(argv: readonly string[], options: RunCliOptions = {}): Promise<number> {
+  const io = options.io ?? processIo;
+  const environment = options.environment ?? process.env;
+  const homeDirectory = options.homeDirectory ?? homedir();
+  const dependencies = options.dependencies ?? defaultDependencies;
+  const parsed = parseArgs(argv);
+  if (!parsed.ok) {
+    if (parsed.json) writeJson(io, "stderr", { ok: false, error: { code: "USAGE", message: parsed.message } });
+    else io.stderr(`ghostget media: ${parsed.message}\n\n${USAGE}\n`);
+    return 2;
+  }
+  const { command } = parsed;
+  if (command.kind === "help") {
+    if (command.json) writeJson(io, "stdout", { ok: true, usage: USAGE });
+    else io.stdout(`${USAGE}\n`);
+    return 0;
+  }
+  if (command.kind === "version") {
+    if (command.json) writeJson(io, "stdout", { ok: true, version: GHOSTGET_MEDIA_VERSION });
+    else io.stdout(`ghostget media ${GHOSTGET_MEDIA_VERSION}\n`);
+    return 0;
+  }
+  if (command.kind === "doctor") {
+    const report = await dependencies.runDoctor({ env: environment, homeDirectory });
+    if (command.json) writeJson(io, report.ok ? "stdout" : "stderr", { ok: report.ok, report });
+    else io[report.ok ? "stdout" : "stderr"](sanitizeHumanReport(renderDoctorReport(report)));
+    return report.ok ? 0 : 3;
+  }
+  if (command.kind === "verify") {
+    const result = await dependencies.verifyMediaItem(command.itemDirectory);
+    if (command.json) writeJson(io, result.ok ? "stdout" : "stderr", { ok: result.ok, verification: result });
+    else if (result.ok) io.stdout(`Verified ${sanitizeTerminalText(result.assetKey ?? command.itemDirectory)}: ${String(result.checkedArtifacts)} artifacts\n`);
+    else io.stderr(`ghostget media: verification failed\n${result.failures.map((failure) => `- ${redactDiagnostic(failure, { homeDirectory })}`).join("\n")}\n`);
+    return result.ok ? 0 : 8;
+  }
+  if (command.kind === "transcriber-setup") {
+    try {
+      const transcriber = await dependencies.setupWhisperCppTranscriber({
+        modelPath: command.modelPath,
+        ...(command.executablePath === undefined
+          ? {}
+          : { executablePath: command.executablePath }),
+        replace: command.replace,
+        env: environment,
+        homeDirectory,
+      });
+      const configured = {
+        adapter: transcriber.descriptor.adapter,
+        profile: transcriber.descriptor.profile,
+        executableSha256: transcriber.descriptor.executableSha256,
+        modelSha256: transcriber.descriptor.modelSha256,
+        modelBytes: transcriber.descriptor.modelBytes,
+        runtimeProfile: transcriber.descriptor.runtimeProfile,
+        runtimeSha256: transcriber.descriptor.runtimeSha256,
+        runtimeDependencyCount: transcriber.descriptor.runtimeDependencyCount,
+      };
+      if (command.json) writeJson(io, "stdout", { ok: true, transcriber: configured });
+      else {
+        io.stdout(
+          `Configured offline whisper.cpp transcription.\n${String(configured.modelBytes)} model bytes · ${String(configured.runtimeDependencyCount)} runtime ${configured.runtimeDependencyCount === 1 ? "dependency" : "dependencies"} · ${configured.profile}\n`,
+        );
+      }
+      return 0;
+    } catch (error) {
+      const code = error instanceof WhisperCppTranscriberSetupError
+        ? error.code
+        : "CONFIG_WRITE_FAILED";
+      const message = redactDiagnostic(
+        error instanceof Error ? error.message : "local transcriber setup failed",
+        { homeDirectory },
+      );
+      if (command.json) {
+        writeJson(io, "stderr", {
+          ok: false,
+          error: { code: `TRANSCRIBER_${code}`, message },
+        });
+      } else {
+        io.stderr(`ghostget media: TRANSCRIBER_${code}: ${message}\n`);
+      }
+      return 3;
+    }
+  }
+
+  try {
+    if (!command.json) io.stderr(`Archiving media from ${sourceLabel(command.url)}…\n`);
+    const result = await dependencies.mediaUrl({
+      url: command.url,
+      mode: command.mode,
+      language: command.language,
+      ...(options.signal === undefined ? {} : { signal: options.signal }),
+      ...(command.outputDirectory === undefined ? {} : { libraryDirectory: command.outputDirectory }),
+      ...(command.browser === undefined ? {} : { browser: command.browser }),
+      ...(command.authContext === undefined ? {} : { authContext: command.authContext }),
+      inheritYtDlpConfig: command.inheritYtDlpConfig,
+      refresh: command.refresh,
+      environment,
+      homeDirectory,
+    });
+    if (command.json) writeJson(io, "stdout", captureSummary(result));
+    else io.stdout(humanCaptureSummary(result));
+    return 0;
+  } catch (error) {
+    const secrets = [
+      command.url,
+      ...urlDerivedRedactions(command.url),
+      ...(command.browser === undefined ? [] : [command.browser]),
+      ...(command.authContext === undefined ? [] : [command.authContext]),
+    ];
+    if (error instanceof MediaArchiveError) {
+      const message = redactDiagnostic(error.message, { homeDirectory, secrets });
+      if (command.json) {
+        writeJson(io, "stderr", { ok: false, error: { code: error.code, message, details: safeDetails(error.details, homeDirectory, secrets) } });
+      } else {
+        io.stderr(`ghostget media: ${error.code}: ${message}\n`);
+        const staging = error.details["stagingDirectory"];
+        if (typeof staging === "string") {
+          io.stderr(`diagnostic staging: ${redactDiagnostic(staging, { homeDirectory, secrets })}\n`);
+        }
+      }
+      return archiveExitCodes[error.code];
+    }
+    const message = redactDiagnostic(error instanceof Error ? error.message : "unexpected failure", { homeDirectory, secrets });
+    if (command.json) writeJson(io, "stderr", { ok: false, error: { code: "INTERNAL", message } });
+    else io.stderr(`ghostget media: INTERNAL: ${message}\n`);
+    return 1;
+  }
+}