tmdb-kit 1.0.0 → 1.1.0

package/dist/cli.js

@@ -0,0 +1,3132 @@
+#!/usr/bin/env node
+// node_modules/citty/dist/_chunks/libs/scule.mjs
+var NUMBER_CHAR_RE = /\d/;
+var STR_SPLITTERS = [
+  "-",
+  "_",
+  "/",
+  "."
+];
+function isUppercase(char = "") {
+  if (NUMBER_CHAR_RE.test(char))
+    return;
+  return char !== char.toLowerCase();
+}
+function splitByCase(str, separators) {
+  const splitters = separators ?? STR_SPLITTERS;
+  const parts = [];
+  if (!str || typeof str !== "string")
+    return parts;
+  let buff = "";
+  let previousUpper;
+  let previousSplitter;
+  for (const char of str) {
+    const isSplitter = splitters.includes(char);
+    if (isSplitter === true) {
+      parts.push(buff);
+      buff = "";
+      previousUpper = undefined;
+      continue;
+    }
+    const isUpper = isUppercase(char);
+    if (previousSplitter === false) {
+      if (previousUpper === false && isUpper === true) {
+        parts.push(buff);
+        buff = char;
+        previousUpper = isUpper;
+        continue;
+      }
+      if (previousUpper === true && isUpper === false && buff.length > 1) {
+        const lastChar = buff.at(-1);
+        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
+        buff = lastChar + char;
+        previousUpper = isUpper;
+        continue;
+      }
+    }
+    buff += char;
+    previousUpper = isUpper;
+    previousSplitter = isSplitter;
+  }
+  parts.push(buff);
+  return parts;
+}
+function upperFirst(str) {
+  return str ? str[0].toUpperCase() + str.slice(1) : "";
+}
+function lowerFirst(str) {
+  return str ? str[0].toLowerCase() + str.slice(1) : "";
+}
+function pascalCase(str, opts) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join("") : "";
+}
+function camelCase(str, opts) {
+  return lowerFirst(pascalCase(str || "", opts));
+}
+function kebabCase(str, joiner) {
+  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
+}
+function snakeCase(str) {
+  return kebabCase(str || "", "_");
+}
+
+// node_modules/citty/dist/index.mjs
+import { parseArgs as parseArgs$1 } from "node:util";
+function toArray(val) {
+  if (Array.isArray(val))
+    return val;
+  return val === undefined ? [] : [val];
+}
+function formatLineColumns(lines, linePrefix = "") {
+  const maxLength = [];
+  for (const line of lines)
+    for (const [i, element] of line.entries())
+      maxLength[i] = Math.max(maxLength[i] || 0, element.length);
+  return lines.map((l) => l.map((c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLength[i])).join("  ")).join(`
+`);
+}
+function resolveValue(input) {
+  return typeof input === "function" ? input() : input;
+}
+var CLIError = class extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "CLIError";
+    this.code = code;
+  }
+};
+function parseRawArgs(args = [], opts = {}) {
+  const booleans = new Set(opts.boolean || []);
+  const strings = new Set(opts.string || []);
+  const aliasMap = opts.alias || {};
+  const defaults = opts.default || {};
+  const aliasToMain = /* @__PURE__ */ new Map;
+  const mainToAliases = /* @__PURE__ */ new Map;
+  for (const [key, value] of Object.entries(aliasMap)) {
+    const targets = value;
+    for (const target of targets) {
+      aliasToMain.set(key, target);
+      if (!mainToAliases.has(target))
+        mainToAliases.set(target, []);
+      mainToAliases.get(target).push(key);
+      aliasToMain.set(target, key);
+      if (!mainToAliases.has(key))
+        mainToAliases.set(key, []);
+      mainToAliases.get(key).push(target);
+    }
+  }
+  const options = {};
+  function getType(name) {
+    if (booleans.has(name))
+      return "boolean";
+    const aliases = mainToAliases.get(name) || [];
+    for (const alias of aliases)
+      if (booleans.has(alias))
+        return "boolean";
+    return "string";
+  }
+  function isStringType(name) {
+    if (strings.has(name))
+      return true;
+    const aliases = mainToAliases.get(name) || [];
+    for (const alias of aliases)
+      if (strings.has(alias))
+        return true;
+    return false;
+  }
+  const allOptions = new Set([
+    ...booleans,
+    ...strings,
+    ...Object.keys(aliasMap),
+    ...Object.values(aliasMap).flat(),
+    ...Object.keys(defaults)
+  ]);
+  for (const name of allOptions)
+    if (!options[name])
+      options[name] = {
+        type: getType(name),
+        default: defaults[name]
+      };
+  for (const [alias, main] of aliasToMain.entries())
+    if (alias.length === 1 && options[main] && !options[main].short)
+      options[main].short = alias;
+  const processedArgs = [];
+  const negatedFlags = {};
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      processedArgs.push(...args.slice(i));
+      break;
+    }
+    if (arg.startsWith("--no-")) {
+      const flagName = arg.slice(5);
+      negatedFlags[flagName] = true;
+      continue;
+    }
+    processedArgs.push(arg);
+  }
+  let parsed;
+  try {
+    parsed = parseArgs$1({
+      args: processedArgs,
+      options: Object.keys(options).length > 0 ? options : undefined,
+      allowPositionals: true,
+      strict: false
+    });
+  } catch {
+    parsed = {
+      values: {},
+      positionals: processedArgs
+    };
+  }
+  const out = { _: [] };
+  out._ = parsed.positionals;
+  for (const [key, value] of Object.entries(parsed.values)) {
+    let coerced = value;
+    if (getType(key) === "boolean" && typeof value === "string")
+      coerced = value !== "false";
+    else if (isStringType(key) && typeof value === "boolean")
+      coerced = "";
+    out[key] = coerced;
+  }
+  for (const [name] of Object.entries(negatedFlags)) {
+    out[name] = false;
+    const mainName = aliasToMain.get(name);
+    if (mainName)
+      out[mainName] = false;
+    const aliases = mainToAliases.get(name);
+    if (aliases)
+      for (const alias of aliases)
+        out[alias] = false;
+  }
+  for (const [alias, main] of aliasToMain.entries()) {
+    if (out[alias] !== undefined && out[main] === undefined)
+      out[main] = out[alias];
+    if (out[main] !== undefined && out[alias] === undefined)
+      out[alias] = out[main];
+    if (out[alias] !== out[main] && defaults[main] === out[main])
+      out[main] = out[alias];
+  }
+  return out;
+}
+var noColor = /* @__PURE__ */ (() => {
+  const env = globalThis.process?.env ?? {};
+  return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
+})();
+var _c = (c, r = 39) => (t) => noColor ? t : `\x1B[${c}m${t}\x1B[${r}m`;
+var bold = /* @__PURE__ */ _c(1, 22);
+var cyan = /* @__PURE__ */ _c(36);
+var gray = /* @__PURE__ */ _c(90);
+var underline = /* @__PURE__ */ _c(4, 24);
+function parseArgs(rawArgs, argsDef) {
+  const parseOptions = {
+    boolean: [],
+    string: [],
+    alias: {},
+    default: {}
+  };
+  const args = resolveArgs(argsDef);
+  for (const arg of args) {
+    if (arg.type === "positional")
+      continue;
+    if (arg.type === "string" || arg.type === "enum")
+      parseOptions.string.push(arg.name);
+    else if (arg.type === "boolean")
+      parseOptions.boolean.push(arg.name);
+    if (arg.default !== undefined)
+      parseOptions.default[arg.name] = arg.default;
+    if (arg.alias)
+      parseOptions.alias[arg.name] = arg.alias;
+    const camelName = camelCase(arg.name);
+    const kebabName = kebabCase(arg.name);
+    if (camelName !== arg.name || kebabName !== arg.name) {
+      const existingAliases = toArray(parseOptions.alias[arg.name] || []);
+      if (camelName !== arg.name && !existingAliases.includes(camelName))
+        existingAliases.push(camelName);
+      if (kebabName !== arg.name && !existingAliases.includes(kebabName))
+        existingAliases.push(kebabName);
+      if (existingAliases.length > 0)
+        parseOptions.alias[arg.name] = existingAliases;
+    }
+  }
+  const parsed = parseRawArgs(rawArgs, parseOptions);
+  const [...positionalArguments] = parsed._;
+  const parsedArgsProxy = new Proxy(parsed, { get(target, prop) {
+    return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
+  } });
+  for (const [, arg] of args.entries())
+    if (arg.type === "positional") {
+      const nextPositionalArgument = positionalArguments.shift();
+      if (nextPositionalArgument !== undefined)
+        parsedArgsProxy[arg.name] = nextPositionalArgument;
+      else if (arg.default === undefined && arg.required !== false)
+        throw new CLIError(`Missing required positional argument: ${arg.name.toUpperCase()}`, "EARG");
+      else
+        parsedArgsProxy[arg.name] = arg.default;
+    } else if (arg.type === "enum") {
+      const argument = parsedArgsProxy[arg.name];
+      const options = arg.options || [];
+      if (argument !== undefined && options.length > 0 && !options.includes(argument))
+        throw new CLIError(`Invalid value for argument: ${cyan(`--${arg.name}`)} (${cyan(argument)}). Expected one of: ${options.map((o) => cyan(o)).join(", ")}.`, "EARG");
+    } else if (arg.required && parsedArgsProxy[arg.name] === undefined)
+      throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
+  return parsedArgsProxy;
+}
+function resolveArgs(argsDef) {
+  const args = [];
+  for (const [name, argDef] of Object.entries(argsDef || {}))
+    args.push({
+      ...argDef,
+      name,
+      alias: toArray(argDef.alias)
+    });
+  return args;
+}
+async function resolvePlugins(plugins) {
+  return Promise.all(plugins.map((p) => resolveValue(p)));
+}
+function defineCommand(def) {
+  return def;
+}
+async function runCommand(cmd, opts) {
+  const cmdArgs = await resolveValue(cmd.args || {});
+  const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+  const context = {
+    rawArgs: opts.rawArgs,
+    args: parsedArgs,
+    data: opts.data,
+    cmd
+  };
+  const plugins = await resolvePlugins(cmd.plugins ?? []);
+  let result;
+  let runError;
+  try {
+    for (const plugin of plugins)
+      await plugin.setup?.(context);
+    if (typeof cmd.setup === "function")
+      await cmd.setup(context);
+    const subCommands = await resolveValue(cmd.subCommands);
+    if (subCommands && Object.keys(subCommands).length > 0) {
+      const subCommandArgIndex = findSubCommandIndex(opts.rawArgs, cmdArgs);
+      const explicitName = opts.rawArgs[subCommandArgIndex];
+      if (explicitName) {
+        const subCommand = await _findSubCommand(subCommands, explicitName);
+        if (!subCommand)
+          throw new CLIError(`Unknown command ${cyan(explicitName)}`, "E_UNKNOWN_COMMAND");
+        await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+      } else {
+        const defaultSubCommand = await resolveValue(cmd.default);
+        if (defaultSubCommand) {
+          if (cmd.run)
+            throw new CLIError(`Cannot specify both 'run' and 'default' on the same command.`, "E_DEFAULT_CONFLICT");
+          const subCommand = await _findSubCommand(subCommands, defaultSubCommand);
+          if (!subCommand)
+            throw new CLIError(`Default sub command ${cyan(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
+          await runCommand(subCommand, { rawArgs: opts.rawArgs });
+        } else if (!cmd.run)
+          throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+      }
+    }
+    if (typeof cmd.run === "function")
+      result = await cmd.run(context);
+  } catch (error) {
+    runError = error;
+  }
+  const cleanupErrors = [];
+  if (typeof cmd.cleanup === "function")
+    try {
+      await cmd.cleanup(context);
+    } catch (error) {
+      cleanupErrors.push(error);
+    }
+  for (const plugin of [...plugins].reverse())
+    try {
+      await plugin.cleanup?.(context);
+    } catch (error) {
+      cleanupErrors.push(error);
+    }
+  if (runError)
+    throw runError;
+  if (cleanupErrors.length === 1)
+    throw cleanupErrors[0];
+  if (cleanupErrors.length > 1)
+    throw new Error("Multiple cleanup errors", { cause: cleanupErrors });
+  return { result };
+}
+async function resolveSubCommand(cmd, rawArgs, parent) {
+  const subCommands = await resolveValue(cmd.subCommands);
+  if (subCommands && Object.keys(subCommands).length > 0) {
+    const subCommandArgIndex = findSubCommandIndex(rawArgs, await resolveValue(cmd.args || {}));
+    const subCommandName = rawArgs[subCommandArgIndex];
+    const subCommand = await _findSubCommand(subCommands, subCommandName);
+    if (subCommand)
+      return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
+  }
+  return [cmd, parent];
+}
+async function _findSubCommand(subCommands, name) {
+  if (name in subCommands)
+    return resolveValue(subCommands[name]);
+  for (const sub of Object.values(subCommands)) {
+    const resolved = await resolveValue(sub);
+    const meta = await resolveValue(resolved?.meta);
+    if (meta?.alias) {
+      if (toArray(meta.alias).includes(name))
+        return resolved;
+    }
+  }
+}
+function findSubCommandIndex(rawArgs, argsDef) {
+  for (let i = 0;i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg === "--")
+      return -1;
+    if (arg.startsWith("-")) {
+      if (!arg.includes("=") && _isValueFlag(arg, argsDef))
+        i++;
+      continue;
+    }
+    return i;
+  }
+  return -1;
+}
+function _isValueFlag(flag, argsDef) {
+  const name = flag.replace(/^-{1,2}/, "");
+  const normalized = camelCase(name);
+  for (const [key, def] of Object.entries(argsDef)) {
+    if (def.type !== "string" && def.type !== "enum")
+      continue;
+    if (normalized === camelCase(key))
+      return true;
+    if ((Array.isArray(def.alias) ? def.alias : def.alias ? [def.alias] : []).includes(name))
+      return true;
+  }
+  return false;
+}
+async function showUsage(cmd, parent) {
+  try {
+    console.log(await renderUsage(cmd, parent) + `
+`);
+  } catch (error) {
+    console.error(error);
+  }
+}
+var negativePrefixRe = /^no[-A-Z]/;
+async function renderUsage(cmd, parent) {
+  const cmdMeta = await resolveValue(cmd.meta || {});
+  const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
+  const parentMeta = await resolveValue(parent?.meta || {});
+  const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ""}` + (cmdMeta.name || process.argv[1]);
+  const argLines = [];
+  const posLines = [];
+  const commandsLines = [];
+  const usageLine = [];
+  for (const arg of cmdArgs)
+    if (arg.type === "positional") {
+      const name = arg.name.toUpperCase();
+      const isRequired = arg.required !== false && arg.default === undefined;
+      posLines.push([cyan(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
+      usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
+    } else {
+      const isRequired = arg.required === true && arg.default === undefined;
+      const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + renderValueHint(arg);
+      argLines.push([cyan(argStr), renderDescription(arg, isRequired)]);
+      if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
+        const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
+        argLines.push([cyan(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
+      }
+      if (isRequired)
+        usageLine.push(`--${arg.name}` + renderValueHint(arg));
+    }
+  if (cmd.subCommands) {
+    const commandNames = [];
+    const subCommands = await resolveValue(cmd.subCommands);
+    for (const [name, sub] of Object.entries(subCommands)) {
+      const meta = await resolveValue((await resolveValue(sub))?.meta);
+      if (meta?.hidden)
+        continue;
+      const aliases = toArray(meta?.alias);
+      const label = [name, ...aliases].join(", ");
+      commandsLines.push([cyan(label), meta?.description || ""]);
+      commandNames.push(name, ...aliases);
+    }
+    usageLine.push(commandNames.join("|"));
+  }
+  const usageLines = [];
+  const version = cmdMeta.version || parentMeta.version;
+  usageLines.push(gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
+  const hasOptions = argLines.length > 0 || posLines.length > 0;
+  usageLines.push(`${underline(bold("USAGE"))} ${cyan(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
+  if (posLines.length > 0) {
+    usageLines.push(underline(bold("ARGUMENTS")), "");
+    usageLines.push(formatLineColumns(posLines, "  "));
+    usageLines.push("");
+  }
+  if (argLines.length > 0) {
+    usageLines.push(underline(bold("OPTIONS")), "");
+    usageLines.push(formatLineColumns(argLines, "  "));
+    usageLines.push("");
+  }
+  if (commandsLines.length > 0) {
+    usageLines.push(underline(bold("COMMANDS")), "");
+    usageLines.push(formatLineColumns(commandsLines, "  "));
+    usageLines.push("", `Use ${cyan(`${commandName} <command> --help`)} for more information about a command.`);
+  }
+  return usageLines.filter((l) => typeof l === "string").join(`
+`);
+}
+function renderValueHint(arg) {
+  const valueHint = arg.valueHint ? `=<${arg.valueHint}>` : "";
+  const fallbackValueHint = valueHint || `=<${snakeCase(arg.name)}>`;
+  if (!arg.type || arg.type === "positional" || arg.type === "boolean")
+    return valueHint;
+  if (arg.type === "enum" && arg.options?.length)
+    return `=<${arg.options.join("|")}>`;
+  return fallbackValueHint;
+}
+function renderDescription(arg, required) {
+  const requiredHint = required ? gray("(Required)") : "";
+  const defaultHint = arg.default === undefined ? "" : gray(`(Default: ${arg.default})`);
+  return [
+    arg.description,
+    requiredHint,
+    defaultHint
+  ].filter(Boolean).join(" ");
+}
+async function runMain(cmd, opts = {}) {
+  const rawArgs = opts.rawArgs || process.argv.slice(2);
+  const showUsage$1 = opts.showUsage || showUsage;
+  try {
+    const builtinFlags = await _resolveBuiltinFlags(cmd);
+    if (builtinFlags.help.length > 0 && rawArgs.some((arg) => builtinFlags.help.includes(arg))) {
+      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+      process.exit(0);
+    } else if (rawArgs.length === 1 && builtinFlags.version.includes(rawArgs[0])) {
+      const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
+      if (!meta?.version)
+        throw new CLIError("No version specified", "E_NO_VERSION");
+      console.log(meta.version);
+    } else
+      await runCommand(cmd, { rawArgs });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+      console.error(error.message);
+    } else
+      console.error(error, `
+`);
+    process.exit(1);
+  }
+}
+async function _resolveBuiltinFlags(cmd) {
+  const argsDef = await resolveValue(cmd.args || {});
+  const userNames = /* @__PURE__ */ new Set;
+  const userAliases = /* @__PURE__ */ new Set;
+  for (const [name, def] of Object.entries(argsDef)) {
+    userNames.add(name);
+    for (const alias of toArray(def.alias))
+      userAliases.add(alias);
+  }
+  return {
+    help: _getBuiltinFlags("help", "h", userNames, userAliases),
+    version: _getBuiltinFlags("version", "v", userNames, userAliases)
+  };
+}
+function _getBuiltinFlags(long, short, userNames, userAliases) {
+  if (userNames.has(long) || userAliases.has(long))
+    return [];
+  if (userNames.has(short) || userAliases.has(short))
+    return [`--${long}`];
+  return [`--${long}`, `-${short}`];
+}
+// package.json
+var package_default = {
+  name: "tmdb-kit",
+  type: "module",
+  version: "1.1.0",
+  description: "A tiny, typed, zero-runtime-dependency TMDB SDK and CLI for Node.js, Bun, Deno, and edge runtimes.",
+  author: "isaced",
+  license: "MIT",
+  homepage: "https://github.com/isaced/tmdb-kit#readme",
+  keywords: [
+    "tmdb",
+    "themoviedb",
+    "sdk",
+    "typescript",
+    "node",
+    "bun",
+    "cli",
+    "deno",
+    "edge",
+    "esm",
+    "cjs"
+  ],
+  repository: {
+    type: "git",
+    url: "git+https://github.com/isaced/tmdb-kit.git"
+  },
+  bugs: {
+    url: "https://github.com/isaced/tmdb-kit/issues"
+  },
+  sideEffects: false,
+  engines: {
+    node: ">=18"
+  },
+  packageManager: "bun@1.4.4",
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/index.d.ts",
+        default: "./dist/index.js"
+      },
+      require: {
+        types: "./dist/index.d.cts",
+        default: "./dist/index.cjs"
+      },
+      default: "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  main: "./dist/index.cjs",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  bin: {
+    tmdb: "./dist/cli.js",
+    "tmdb-kit": "./dist/cli.js"
+  },
+  files: [
+    "dist",
+    "README.md"
+  ],
+  publishConfig: {
+    access: "public",
+    provenance: true
+  },
+  scripts: {
+    build: "bun run scripts/build.ts",
+    "build:cli": "bun run scripts/build.ts --cli",
+    cli: "bun run build:cli && bun ./dist/cli.js",
+    dev: "bun build ./src/index.ts --outdir ./dist --entry-naming '[name].js' --format esm --target browser --sourcemap=linked --watch",
+    test: "bun test --isolate tests/unit tests/resources tests/cli",
+    "test:resources": "bun test --isolate tests/resources",
+    "test:unit": "bun test --isolate tests/unit",
+    "test:watch": "bun test --isolate --watch tests/unit tests/resources tests/cli",
+    "test:coverage": "bun test --isolate --coverage tests/unit tests/resources tests/cli",
+    "test:integration": "bun test --isolate tests/integration",
+    typecheck: "bun check",
+    format: "bun fmt",
+    "format:check": "bun fmt --check",
+    ci: "bun run format:check && bun run typecheck && bun run test:coverage && bun run build",
+    release: "bumpp",
+    prepublishOnly: "bun run ci"
+  },
+  devDependencies: {
+    "@types/bun": "^1.4.4",
+    "@types/node": "^25.6.2",
+    bumpp: "^11.1.0",
+    citty: "^0.2.2",
+    typescript: "^6.0.3"
+  }
+};
+
+// src/cli/commands/auth.ts
+import { existsSync as existsSync2 } from "node:fs";
+
+// src/errors.ts
+class TMDBError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TMDBError";
+  }
+}
+
+class TMDBRequestError extends TMDBError {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TMDBRequestError";
+  }
+}
+
+class TMDBResponseError extends TMDBError {
+  body;
+  headers;
+  requestId;
+  status;
+  statusCode;
+  statusMessage;
+  statusText;
+  url;
+  constructor(message, options) {
+    super(message);
+    this.name = "TMDBResponseError";
+    this.body = options.body;
+    this.headers = options.headers;
+    this.requestId = options.headers.get("x-request-id");
+    this.status = options.status;
+    this.statusText = options.statusText;
+    this.url = options.url;
+    const body = isErrorResponseBody(options.body) ? options.body : undefined;
+    this.statusCode = body?.status_code;
+    this.statusMessage = body?.status_message;
+  }
+  get isRateLimit() {
+    return this.status === 429;
+  }
+  get isNotFound() {
+    return this.status === 404;
+  }
+  get isUnauthorized() {
+    return this.status === 401;
+  }
+  get isForbidden() {
+    return this.status === 403;
+  }
+  get isServerError() {
+    return this.status >= 500 && this.status < 600;
+  }
+}
+
+class TMDBRateLimitError extends TMDBResponseError {
+  retryAfter;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "TMDBRateLimitError";
+    this.retryAfter = options.retryAfter;
+  }
+}
+function createResponseError(options) {
+  const body = isErrorResponseBody(options.body) ? options.body : undefined;
+  const message = body?.status_message ?? `${options.status} ${options.statusText}`.trim();
+  if (options.status === 429) {
+    return new TMDBRateLimitError(message, {
+      ...options,
+      retryAfter: parseRetryAfter(options.headers.get("retry-after"))
+    });
+  }
+  return new TMDBResponseError(message, options);
+}
+function parseRetryAfter(value) {
+  if (value === null || value === undefined) {
+    return 1;
+  }
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return 1;
+  }
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return seconds;
+  }
+  const date = Date.parse(trimmed);
+  if (Number.isFinite(date)) {
+    const deltaMs = date - Date.now();
+    return Math.max(1, Math.ceil(deltaMs / 1000));
+  }
+  return 1;
+}
+function isErrorResponseBody(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/query.ts
+var DEFAULT_API_BASE_URL = "https://api.themoviedb.org/3";
+var DEFAULT_IMAGE_BASE_URL = "https://image.tmdb.org/t/p";
+function appendQuery(url, query) {
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      url.searchParams.set(key, value.map(String).join(","));
+      continue;
+    }
+    url.searchParams.set(key, String(value));
+  }
+}
+function withLanguage(defaults, query) {
+  const language = typeof query.language === "string" ? query.language : defaults.language;
+  return {
+    ...query,
+    language
+  };
+}
+function withListDefaults(defaults, query) {
+  const region = typeof query.region === "string" ? query.region : defaults.region;
+  return {
+    ...withLanguage(defaults, query),
+    region
+  };
+}
+function toCommaList(value) {
+  if (value === undefined) {
+    return;
+  }
+  return typeof value === "string" ? value : value.join(",");
+}
+function toId(value, name) {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new TMDBRequestError(`${name} must be a positive integer`);
+  }
+  return String(value);
+}
+function toSearchQuery(value) {
+  const query = value.trim();
+  if (query.length === 0) {
+    throw new TMDBRequestError("search query must not be empty");
+  }
+  return query;
+}
+function toTimeWindow(value) {
+  if (value !== "day" && value !== "week") {
+    throw new TMDBRequestError('timeWindow must be either "day" or "week"');
+  }
+  return value;
+}
+function buildImageUrl(path, size = "original", options = {}) {
+  if (path === undefined || path === null || path.trim() === "") {
+    return null;
+  }
+  const baseUrl = normalizeBaseUrl(options.baseUrl ?? DEFAULT_IMAGE_BASE_URL);
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  const url = `${baseUrl}/${size}${normalizedPath}`;
+  return options.transform ? options.transform(url) : url;
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+
+// src/http.ts
+class TMDBHttpClient {
+  defaults;
+  imageTransform;
+  #apiKey;
+  #accessToken;
+  #baseUrl;
+  #fetch;
+  #headers;
+  constructor(options) {
+    const accessToken = normalizeSecret("accessToken" in options ? options.accessToken : undefined);
+    const apiKey = normalizeSecret("apiKey" in options ? options.apiKey : undefined);
+    if (Boolean(accessToken) === Boolean(apiKey)) {
+      throw new TMDBRequestError("Provide exactly one of accessToken or apiKey");
+    }
+    this.#accessToken = accessToken;
+    this.#apiKey = apiKey;
+    this.#baseUrl = normalizeBaseUrl(options.baseUrl ?? DEFAULT_API_BASE_URL);
+    this.#fetch = options.fetch;
+    this.#headers = options.headers;
+    this.defaults = {
+      imageBaseUrl: normalizeBaseUrl(options.imageBaseUrl ?? DEFAULT_IMAGE_BASE_URL),
+      language: options.defaultLanguage,
+      region: options.defaultRegion
+    };
+    this.imageTransform = options.images?.transform;
+  }
+  async get(path, options = {}) {
+    const url = this.#createUrl(path, options.query ?? {});
+    const headers = this.#createHeaders(options.headers);
+    const fetchImpl = this.#resolveFetch();
+    let response;
+    try {
+      response = await fetchImpl(url, {
+        headers,
+        method: "GET",
+        signal: options.signal
+      });
+    } catch (error) {
+      throw new TMDBRequestError(`TMDB request failed: ${String(error)}`, { cause: error });
+    }
+    const body = await readJson(response);
+    if (!response.ok) {
+      throw createResponseError({
+        body,
+        headers: response.headers,
+        status: response.status,
+        statusText: response.statusText,
+        url
+      });
+    }
+    return body;
+  }
+  #resolveFetch() {
+    if (this.#fetch !== undefined) {
+      return this.#fetch;
+    }
+    const globalFetch = globalThis.fetch;
+    if (typeof globalFetch !== "function") {
+      throw new TMDBRequestError("No fetch implementation found. Pass options.fetch in this runtime.");
+    }
+    return globalFetch.bind(globalThis);
+  }
+  #createHeaders(headersInit) {
+    const headers = new Headers(this.#headers);
+    const requestHeaders = new Headers(headersInit);
+    headers.set("Accept", "application/json");
+    for (const [key, value] of requestHeaders) {
+      headers.set(key, value);
+    }
+    if (this.#accessToken !== undefined) {
+      headers.set("Authorization", `Bearer ${this.#accessToken}`);
+    }
+    return headers;
+  }
+  #createUrl(path, query) {
+    const relativePath = path.replace(/^\/+/, "");
+    const url = new URL(relativePath, `${this.#baseUrl}/`);
+    appendQuery(url, {
+      ...query,
+      api_key: this.#apiKey
+    });
+    return url.toString();
+  }
+}
+async function readJson(response) {
+  const text = await response.text();
+  if (text.length === 0) {
+    return;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function normalizeSecret(value) {
+  const secret = value?.trim();
+  return secret === "" ? undefined : secret;
+}
+
+// src/resources/configuration.ts
+class ConfigurationResource {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  details() {
+    return this.#transport.get("/configuration");
+  }
+  countries() {
+    return this.#transport.get("/configuration/countries");
+  }
+  jobs() {
+    return this.#transport.get("/configuration/jobs");
+  }
+  languages() {
+    return this.#transport.get("/configuration/languages");
+  }
+  primaryTranslations() {
+    return this.#transport.get("/configuration/primary_translations");
+  }
+  timezones() {
+    return this.#transport.get("/configuration/timezones");
+  }
+}
+
+// src/resources/genres.ts
+class GenresResource {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  movies(options = {}) {
+    return this.#transport.get("/genre/movie/list", {
+      query: withLanguage(this.#transport.defaults, {
+        language: options.language
+      })
+    });
+  }
+  tv(options = {}) {
+    return this.#transport.get("/genre/tv/list", {
+      query: withLanguage(this.#transport.defaults, {
+        language: options.language
+      })
+    });
+  }
+}
+
+// src/resources/images.ts
+class ImagesHelper {
+  #transport;
+  #transform;
+  constructor(transport, transform) {
+    this.#transport = transport;
+    this.#transform = transform;
+  }
+  url(path, size = "original", options = {}) {
+    return buildImageUrl(path, size, {
+      baseUrl: this.#transport.defaults.imageBaseUrl,
+      transform: options.transform ?? this.#transform
+    });
+  }
+}
+
+// src/resources/movies.ts
+class MoviesResource {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  popular(options = {}) {
+    return this.#transport.get("/movie/popular", {
+      query: movieListQuery(this.#transport, options)
+    });
+  }
+  topRated(options = {}) {
+    return this.#transport.get("/movie/top_rated", {
+      query: movieListQuery(this.#transport, options)
+    });
+  }
+  nowPlaying(options = {}) {
+    return this.#transport.get("/movie/now_playing", {
+      query: movieListQuery(this.#transport, options)
+    });
+  }
+  upcoming(options = {}) {
+    return this.#transport.get("/movie/upcoming", {
+      query: movieListQuery(this.#transport, options)
+    });
+  }
+  details(movieId, options = {}) {
+    return this.#transport.get(`/movie/${toId(movieId, "movieId")}`, {
+      query: withLanguage(this.#transport.defaults, {
+        append_to_response: toCommaList(options.appendToResponse),
+        language: options.language
+      })
+    });
+  }
+  credits(movieId, options = {}) {
+    return this.#transport.get(`/movie/${toId(movieId, "movieId")}/credits`, {
+      query: withLanguage(this.#transport.defaults, {
+        language: options.language
+      })
+    });
+  }
+  images(movieId, options = {}) {
+    return this.#transport.get(`/movie/${toId(movieId, "movieId")}/images`, {
+      query: withLanguage(this.#transport.defaults, {
+        include_image_language: toCommaList(options.includeImageLanguage),
+        language: options.language
+      })
+    });
+  }
+  recommendations(movieId, options = {}) {
+    return this.#transport.get(`/movie/${toId(movieId, "movieId")}/recommendations`, {
+      query: movieListQuery(this.#transport, options)
+    });
+  }
+  similar(movieId, options = {}) {
+    return this.#transport.get(`/movie/${toId(movieId, "movieId")}/similar`, {
+      query: movieListQuery(this.#transport, options)
+    });
+  }
+  videos(movieId, options = {}) {
+    return this.#transport.get(`/movie/${toId(movieId, "movieId")}/videos`, {
+      query: withLanguage(this.#transport.defaults, {
+        language: options.language
+      })
+    });
+  }
+}
+function movieListQuery(transport, options) {
+  return withListDefaults(transport.defaults, {
+    language: options.language,
+    page: options.page,
+    region: options.region
+  });
+}
+
+// src/resources/people.ts
+class PeopleResource {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  popular(options = {}) {
+    return this.#transport.get("/person/popular", {
+      query: peopleListQuery(this.#transport, options)
+    });
+  }
+  details(personId, options = {}) {
+    return this.#transport.get(`/person/${toId(personId, "personId")}`, {
+      query: withLanguage(this.#transport.defaults, {
+        language: options.language
+      })
+    });
+  }
+  combinedCredits(personId, options = {}) {
+    return this.#transport.get(`/person/${toId(personId, "personId")}/combined_credits`, {
+      query: withLanguage(this.#transport.defaults, {
+        language: options.language
+      })
+    });
+  }
+}
+function peopleListQuery(transport, options) {
+  return withLanguage(transport.defaults, {
+    language: options.language,
+    page: options.page
+  });
+}
+
+// src/resources/search.ts
+class SearchResource {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  movies(query, options = {}) {
+    return this.#transport.get("/search/movie", {
+      query: movieSearchQuery(this.#transport, query, options)
+    });
+  }
+  tv(query, options = {}) {
+    return this.#transport.get("/search/tv", {
+      query: tvSearchQuery(this.#transport, query, options)
+    });
+  }
+  people(query, options = {}) {
+    return this.#transport.get("/search/person", {
+      query: commonSearchQuery(this.#transport, query, options)
+    });
+  }
+  async multi(query, options = {}) {
+    const response = await this.#transport.get("/search/multi", {
+      query: commonSearchQuery(this.#transport, query, options)
+    });
+    const excluded = options.exclude;
+    if (excluded === undefined || excluded.length === 0) {
+      return response;
+    }
+    const excludedSet = new Set(excluded);
+    return {
+      ...response,
+      results: response.results.filter((result) => !excludedSet.has(result.media_type))
+    };
+  }
+}
+function movieSearchQuery(transport, query, options) {
+  return withListDefaults(transport.defaults, {
+    include_adult: options.includeAdult,
+    language: options.language,
+    page: options.page,
+    primary_release_year: options.primaryReleaseYear,
+    query: toSearchQuery(query),
+    region: options.region,
+    year: options.year
+  });
+}
+function tvSearchQuery(transport, query, options) {
+  return withLanguage(transport.defaults, {
+    first_air_date_year: options.firstAirDateYear,
+    include_adult: options.includeAdult,
+    language: options.language,
+    page: options.page,
+    query: toSearchQuery(query),
+    year: options.year
+  });
+}
+function commonSearchQuery(transport, query, options) {
+  return withLanguage(transport.defaults, {
+    include_adult: options.includeAdult,
+    language: options.language,
+    page: options.page,
+    query: toSearchQuery(query)
+  });
+}
+
+// src/resources/trending.ts
+class TrendingResource {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  all(timeWindow = "day", options = {}) {
+    return this.#transport.get(`/trending/all/${toTimeWindow(timeWindow)}`, {
+      query: withLanguage(this.#transport.defaults, {
+        language: options.language,
+        page: options.page
+      })
+    });
+  }
+  movies(timeWindow = "day", options = {}) {
+    return this.#transport.get(`/trending/movie/${toTimeWindow(timeWindow)}`, {
+      query: withLanguage(this.#transport.defaults, {
+        language: options.language,
+        page: options.page
+      })
+    });
+  }
+  tv(timeWindow = "day", options = {}) {
+    return this.#transport.get(`/trending/tv/${toTimeWindow(timeWindow)}`, {
+      query: withLanguage(this.#transport.defaults, {
+        language: options.language,
+        page: options.page
+      })
+    });
+  }
+  people(timeWindow = "day", options = {}) {
+    return this.#transport.get(`/trending/person/${toTimeWindow(timeWindow)}`, {
+      query: withLanguage(this.#transport.defaults, {
+        language: options.language,
+        page: options.page
+      })
+    });
+  }
+}
+
+// src/resources/tv.ts
+class TVResource {
+  #transport;
+  constructor(transport) {
+    this.#transport = transport;
+  }
+  popular(options = {}) {
+    return this.#transport.get("/tv/popular", {
+      query: tvListQuery(this.#transport, options)
+    });
+  }
+  topRated(options = {}) {
+    return this.#transport.get("/tv/top_rated", {
+      query: tvListQuery(this.#transport, options)
+    });
+  }
+  airingToday(options = {}) {
+    return this.#transport.get("/tv/airing_today", {
+      query: tvListQuery(this.#transport, options)
+    });
+  }
+  onTheAir(options = {}) {
+    return this.#transport.get("/tv/on_the_air", {
+      query: tvListQuery(this.#transport, options)
+    });
+  }
+  details(seriesId, options = {}) {
+    return this.#transport.get(`/tv/${toId(seriesId, "seriesId")}`, {
+      query: withLanguage(this.#transport.defaults, {
+        append_to_response: toCommaList(options.appendToResponse),
+        language: options.language
+      })
+    });
+  }
+  credits(seriesId, options = {}) {
+    return this.#transport.get(`/tv/${toId(seriesId, "seriesId")}/credits`, {
+      query: withLanguage(this.#transport.defaults, {
+        language: options.language
+      })
+    });
+  }
+  images(seriesId, options = {}) {
+    return this.#transport.get(`/tv/${toId(seriesId, "seriesId")}/images`, {
+      query: withLanguage(this.#transport.defaults, {
+        include_image_language: toCommaList(options.includeImageLanguage),
+        language: options.language
+      })
+    });
+  }
+  recommendations(seriesId, options = {}) {
+    return this.#transport.get(`/tv/${toId(seriesId, "seriesId")}/recommendations`, {
+      query: tvListQuery(this.#transport, options)
+    });
+  }
+  similar(seriesId, options = {}) {
+    return this.#transport.get(`/tv/${toId(seriesId, "seriesId")}/similar`, {
+      query: tvListQuery(this.#transport, options)
+    });
+  }
+  videos(seriesId, options = {}) {
+    return this.#transport.get(`/tv/${toId(seriesId, "seriesId")}/videos`, {
+      query: withLanguage(this.#transport.defaults, {
+        language: options.language
+      })
+    });
+  }
+  seasonDetails(seriesId, seasonNumber, options = {}) {
+    return this.#transport.get(`/tv/${toId(seriesId, "seriesId")}/season/${toId(seasonNumber, "seasonNumber")}`, {
+      query: withLanguage(this.#transport.defaults, {
+        append_to_response: toCommaList(options.appendToResponse),
+        language: options.language
+      })
+    });
+  }
+}
+function tvListQuery(transport, options) {
+  return withLanguage(transport.defaults, {
+    language: options.language,
+    page: options.page
+  });
+}
+
+// src/client.ts
+class TMDBClient {
+  configuration;
+  genres;
+  images;
+  movies;
+  people;
+  search;
+  trending;
+  tv;
+  #transport;
+  constructor(options) {
+    const { transport, images, ...httpOptions } = options;
+    const fallbackTransform = images?.transform;
+    const builtInClient = transport === undefined ? new TMDBHttpClient({ ...httpOptions, images }) : undefined;
+    this.#transport = builtInClient ?? transport;
+    this.configuration = new ConfigurationResource(this.#transport);
+    this.genres = new GenresResource(this.#transport);
+    this.images = new ImagesHelper(this.#transport, builtInClient ? builtInClient.imageTransform : fallbackTransform);
+    this.movies = new MoviesResource(this.#transport);
+    this.people = new PeopleResource(this.#transport);
+    this.search = new SearchResource(this.#transport);
+    this.trending = new TrendingResource(this.#transport);
+    this.tv = new TVResource(this.#transport);
+  }
+  request(path, options) {
+    return this.#transport.get(path, options);
+  }
+}
+function createTMDB(options) {
+  return new TMDBClient(options);
+}
+// src/cli/config.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+// src/cli/errors.ts
+class CliError extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+}
+function exitCodeFor(error) {
+  if (error instanceof CliError) {
+    return error.exitCode;
+  }
+  if (error instanceof TMDBRateLimitError) {
+    return 5;
+  }
+  if (error instanceof TMDBResponseError) {
+    if (error.status === 401 || error.status === 403)
+      return 3;
+    if (error.status === 404)
+      return 4;
+    if (error.status === 429)
+      return 5;
+  }
+  return 1;
+}
+function errorMessage(error) {
+  if (error instanceof CliError) {
+    return error.message;
+  }
+  if (error instanceof TMDBRateLimitError) {
+    return `TMDB rate limit exceeded. Retry after ${error.retryAfter} seconds.`;
+  }
+  if (error instanceof TMDBResponseError) {
+    if (error.status === 401 || error.status === 403) {
+      return [
+        `TMDB rejected the credentials (HTTP ${error.status}): ${error.message}`,
+        "Run `tmdb auth login` to replace the token, or check `tmdb config show`."
+      ].join(`
+`);
+    }
+    return `TMDB request failed (${error.status}): ${error.message}`;
+  }
+  if (error instanceof TMDBRequestError) {
+    return error.message;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+async function runSafely(task) {
+  try {
+    await task();
+  } catch (error) {
+    process.stderr.write(`${errorMessage(error)}
+`);
+    process.exitCode = exitCodeFor(error);
+  }
+}
+
+// src/cli/config.ts
+var CONFIG_DIR = "tmdb-kit";
+function getConfigPath() {
+  if (process.platform === "win32") {
+    return join(process.env.APPDATA ?? homedir(), CONFIG_DIR, "config.json");
+  }
+  const configHome = process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+  return join(configHome, CONFIG_DIR, "config.json");
+}
+function readConfig() {
+  const path = getConfigPath();
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch (error) {
+    if (isNotFound(error)) {
+      return {};
+    }
+    throw new CliError(`Failed to read config file at ${path}: ${messageOf(error)}`, 3);
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("expected a JSON object");
+    }
+    const record = parsed;
+    return {
+      accessToken: readStringField(record, "accessToken"),
+      apiKey: readStringField(record, "apiKey"),
+      language: readStringField(record, "language"),
+      region: readStringField(record, "region")
+    };
+  } catch (error) {
+    throw new CliError(`Invalid config file at ${path}: ${messageOf(error)}`, 3);
+  }
+}
+function setConfigValue(field, value) {
+  writeConfig({ ...readConfig(), [field]: value });
+}
+function unsetConfigValue(field) {
+  const config = readConfig();
+  delete config[field];
+  writeConfig(config);
+}
+function writeConfig(config) {
+  const path = getConfigPath();
+  const directory = dirname(path);
+  const tempPath = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    mkdirSync(directory, { recursive: true, mode: 448 });
+    if (process.platform !== "win32") {
+      chmodSync(directory, 448);
+    }
+    writeFileSync(tempPath, `${JSON.stringify(config, null, 2)}
+`, {
+      mode: 384
+    });
+    if (process.platform !== "win32") {
+      chmodSync(tempPath, 384);
+    }
+    renameSync(tempPath, path);
+    if (process.platform !== "win32") {
+      chmodSync(path, 384);
+    }
+  } catch (error) {
+    if (existsSync(tempPath)) {
+      unlinkSync(tempPath);
+    }
+    throw new CliError(`Failed to write config file at ${path}: ${messageOf(error)}`, 3);
+  }
+}
+function readStringField(record, key) {
+  const value = record[key];
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${key} must be a string`);
+  }
+  return value;
+}
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/cli/credential-format.ts
+var ACCESS_TOKEN_PATTERN = /^eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+var API_KEY_PATTERN = /^[a-fA-F0-9]{32}$/;
+function detectCredential(input) {
+  const value = input.trim().replace(/^Bearer\s+/i, "");
+  if (API_KEY_PATTERN.test(value)) {
+    return { kind: "apiKey", value };
+  }
+  if (ACCESS_TOKEN_PATTERN.test(value)) {
+    return { kind: "accessToken", value };
+  }
+  return;
+}
+function unrecognizedCredentialMessage() {
+  return [
+    "Unrecognized TMDB credential format.",
+    "",
+    "Expected one of:",
+    "  - API Read Access Token (JWT, three dot-separated segments)",
+    "  - API Key (32 hexadecimal characters)",
+    "",
+    "Create credentials:",
+    "  https://www.themoviedb.org/settings/api"
+  ].join(`
+`);
+}
+
+// src/cli/redact.ts
+var PLACEHOLDER_CREDENTIALS = new Set(["YOUR_TMDB_ACCESS_TOKEN", "YOUR_TMDB_API_KEY"]);
+function isPlaceholderCredential(value) {
+  return value !== undefined && PLACEHOLDER_CREDENTIALS.has(value.trim());
+}
+function maskSecret(value) {
+  if (!value) {
+    return null;
+  }
+  return value.length <= 4 ? "••••" : `••••${value.slice(-4)}`;
+}
+function describeSecret(value) {
+  if (!value) {
+    return null;
+  }
+  return isPlaceholderCredential(value) ? "(placeholder)" : maskSecret(value);
+}
+
+// src/cli/credentials.ts
+function resolveCredentials() {
+  const config = readConfig();
+  const envAccessToken = usableCredential(process.env.TMDB_ACCESS_TOKEN);
+  const envApiKey = usableCredential(process.env.TMDB_API_KEY);
+  const configAccessToken = usableCredential(config.accessToken);
+  const configApiKey = usableCredential(config.apiKey);
+  if (envAccessToken) {
+    return {
+      accessToken: envAccessToken,
+      config,
+      configField: null,
+      envVar: "TMDB_ACCESS_TOKEN",
+      source: "environment"
+    };
+  }
+  if (envApiKey) {
+    return {
+      apiKey: envApiKey,
+      config,
+      configField: null,
+      envVar: "TMDB_API_KEY",
+      source: "environment"
+    };
+  }
+  if (configAccessToken) {
+    return {
+      accessToken: configAccessToken,
+      config,
+      configField: "accessToken",
+      envVar: null,
+      source: "config"
+    };
+  }
+  if (configApiKey) {
+    return {
+      apiKey: configApiKey,
+      config,
+      configField: "apiKey",
+      envVar: null,
+      source: "config"
+    };
+  }
+  return {
+    config,
+    configField: null,
+    envVar: null,
+    source: "none"
+  };
+}
+function usableCredential(value) {
+  const trimmed = value?.trim();
+  if (!trimmed || isPlaceholderCredential(trimmed)) {
+    return;
+  }
+  return trimmed;
+}
+function missingCredentialsMessage() {
+  return [
+    "No TMDB credentials found.",
+    "",
+    "Recommended:",
+    "  tmdb auth login",
+    "",
+    "Or use an environment variable:",
+    "  export TMDB_ACCESS_TOKEN=...",
+    "  export TMDB_API_KEY=...  (legacy v3 API key)",
+    "",
+    "Or edit the config file:",
+    `  ${getConfigPath()}`,
+    "",
+    "  {",
+    '    "accessToken": "YOUR_TMDB_ACCESS_TOKEN",',
+    '    "language": "en-US",',
+    '    "region": "US"',
+    "  }",
+    "",
+    "Create a token:",
+    "  https://www.themoviedb.org/settings/api",
+    "",
+    "Use the API Read Access Token, not the legacy API Key."
+  ].join(`
+`);
+}
+
+// src/cli/format.ts
+function printJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+function printSearchResults(response, type) {
+  const lines = [
+    `Page ${response.page}/${response.total_pages} · ${response.total_results} results`
+  ];
+  if (response.results.length === 0) {
+    lines.push("No results.");
+  } else {
+    response.results.forEach((result, index) => {
+      lines.push(formatSearchResult(result, index, type));
+    });
+  }
+  writeLines(lines);
+}
+function printMovie(movie, tmdb) {
+  const year = movie.release_date ? ` (${movie.release_date.slice(0, 4)})` : "";
+  const lines = [`${movie.title}${year}`];
+  if (movie.original_title !== movie.title) {
+    lines.push(`Original title: ${movie.original_title}`);
+  }
+  if (movie.tagline) {
+    lines.push(movie.tagline);
+  }
+  const facts = [
+    movie.status,
+    movie.runtime ? `${movie.runtime} min` : undefined,
+    `★ ${movie.vote_average.toFixed(1)}/10 (${movie.vote_count} votes)`
+  ].filter(Boolean);
+  lines.push(facts.join(" · "));
+  if (movie.genres.length > 0) {
+    lines.push(`Genres: ${movie.genres.map((genre) => genre.name).join(", ")}`);
+  }
+  lines.push(`TMDB: https://www.themoviedb.org/movie/${movie.id}`);
+  const poster = tmdb.images.url(movie.poster_path, "w500");
+  if (poster) {
+    lines.push(`Poster: ${poster}`);
+  }
+  const backdrop = tmdb.images.url(movie.backdrop_path, "w780");
+  if (backdrop) {
+    lines.push(`Backdrop: ${backdrop}`);
+  }
+  if (movie.homepage) {
+    lines.push(`Homepage: ${movie.homepage}`);
+  }
+  if (movie.overview) {
+    lines.push("", movie.overview);
+  }
+  writeLines(lines);
+}
+function printTV(tv, tmdb) {
+  const year = tv.first_air_date ? ` (${tv.first_air_date.slice(0, 4)})` : "";
+  const lines = [`${tv.name}${year}`];
+  if (tv.original_name !== tv.name) {
+    lines.push(`Original name: ${tv.original_name}`);
+  }
+  if (tv.tagline) {
+    lines.push(tv.tagline);
+  }
+  const facts = [
+    tv.status,
+    `${tv.number_of_seasons} seasons`,
+    `${tv.number_of_episodes} episodes`,
+    `★ ${tv.vote_average.toFixed(1)}/10 (${tv.vote_count} votes)`
+  ].filter(Boolean);
+  lines.push(facts.join(" · "));
+  if (tv.genres.length > 0) {
+    lines.push(`Genres: ${tv.genres.map((genre) => genre.name).join(", ")}`);
+  }
+  if (tv.networks.length > 0) {
+    lines.push(`Networks: ${tv.networks.map((network) => network.name).join(", ")}`);
+  }
+  if (tv.created_by.length > 0) {
+    lines.push(`Created by: ${tv.created_by.map((person) => person.name).join(", ")}`);
+  }
+  lines.push(`TMDB: https://www.themoviedb.org/tv/${tv.id}`);
+  const poster = tmdb.images.url(tv.poster_path, "w500");
+  if (poster) {
+    lines.push(`Poster: ${poster}`);
+  }
+  const backdrop = tmdb.images.url(tv.backdrop_path, "w780");
+  if (backdrop) {
+    lines.push(`Backdrop: ${backdrop}`);
+  }
+  if (tv.homepage) {
+    lines.push(`Homepage: ${tv.homepage}`);
+  }
+  if (tv.overview) {
+    lines.push("", tv.overview);
+  }
+  if (tv.seasons.length > 0) {
+    lines.push("", "Seasons:");
+    for (const season of tv.seasons) {
+      const airDate = season.air_date ? ` (${season.air_date.slice(0, 4)})` : "";
+      lines.push(`  ${season.season_number}. ${season.name}${airDate} · ${season.episode_count} episodes`);
+    }
+  }
+  writeLines(lines);
+}
+function printCredits(credits, limit = 10) {
+  const lines = [];
+  if (credits.cast.length > 0) {
+    lines.push("Cast:");
+    for (const member of credits.cast.slice(0, limit)) {
+      const character = member.character ? ` as ${member.character}` : "";
+      lines.push(`  ${member.name}${character}  #${member.id}`);
+    }
+  }
+  if (credits.crew.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push("Crew:");
+    for (const member of credits.crew.slice(0, limit)) {
+      lines.push(`  ${member.name} — ${member.job} (${member.department})  #${member.id}`);
+    }
+  }
+  if (lines.length === 0) {
+    lines.push("No credits.");
+  }
+  writeLines(lines);
+}
+function printImages(images, tmdb) {
+  const lines = [];
+  appendImageSection(lines, "Posters", images.posters, "w500", tmdb);
+  appendImageSection(lines, "Backdrops", images.backdrops, "w780", tmdb);
+  appendImageSection(lines, "Logos", images.logos ?? [], "w300", tmdb);
+  if (lines.length === 0) {
+    lines.push("No images.");
+  }
+  writeLines(lines);
+}
+function printVideos(videos) {
+  if (videos.results.length === 0) {
+    writeLines(["No videos."]);
+    return;
+  }
+  const lines = videos.results.map((video) => {
+    const url = video.site.toLowerCase() === "youtube" ? `https://www.youtube.com/watch?v=${video.key}` : video.key;
+    return `${video.type}: ${video.name}  ${url}`;
+  });
+  writeLines(lines);
+}
+function printSeason(season, tmdb) {
+  const year = season.air_date ? ` (${season.air_date.slice(0, 4)})` : "";
+  const lines = [
+    `${season.name}${year}`,
+    `Episodes: ${season.episodes.length} · ★ ${season.vote_average.toFixed(1)}/10`
+  ];
+  if (season.overview) {
+    lines.push("", season.overview);
+  }
+  const poster = tmdb.images.url(season.poster_path, "w500");
+  if (poster) {
+    lines.push(`Poster: ${poster}`);
+  }
+  if (season.episodes.length > 0) {
+    lines.push("", "Episodes:");
+    for (const episode of season.episodes) {
+      const airDate = episode.air_date ? ` ${episode.air_date}` : "";
+      const runtime = episode.runtime ? ` · ${episode.runtime} min` : "";
+      lines.push(`  E${String(episode.episode_number).padStart(2, "0")}  ${episode.name}${airDate}${runtime}  ★ ${episode.vote_average.toFixed(1)}  #${episode.id}`);
+    }
+  }
+  writeLines(lines);
+}
+function printPerson(person, tmdb) {
+  const lines = [person.name];
+  const facts = [
+    person.known_for_department,
+    person.birthday ? `Born: ${person.birthday}` : undefined,
+    person.deathday ? `Died: ${person.deathday}` : undefined
+  ].filter(Boolean);
+  if (facts.length > 0) {
+    lines.push(facts.join(" · "));
+  }
+  if (person.place_of_birth) {
+    lines.push(`From: ${person.place_of_birth}`);
+  }
+  lines.push(`TMDB: https://www.themoviedb.org/person/${person.id}`);
+  const profile = tmdb.images.url(person.profile_path, "h632");
+  if (profile) {
+    lines.push(`Profile: ${profile}`);
+  }
+  if (person.homepage) {
+    lines.push(`Homepage: ${person.homepage}`);
+  }
+  if (person.imdb_id) {
+    lines.push(`IMDb: https://www.imdb.com/name/${person.imdb_id}`);
+  }
+  if (person.biography) {
+    lines.push("", person.biography);
+  }
+  writeLines(lines);
+}
+function printPersonCredits(credits, limit = 10) {
+  const lines = [];
+  const cast = [...credits.cast].sort(byCreditDate);
+  const crew = [...credits.crew].sort(byCreditDate);
+  if (cast.length > 0) {
+    lines.push("Cast:");
+    for (const item of cast.slice(0, limit)) {
+      lines.push(formatCombinedCast(item));
+    }
+  }
+  if (crew.length > 0) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push("Crew:");
+    for (const item of crew.slice(0, limit)) {
+      lines.push(formatCombinedCrew(item));
+    }
+  }
+  if (lines.length === 0) {
+    lines.push("No credits.");
+  }
+  writeLines(lines);
+}
+function printGenres(response) {
+  if (response.genres.length === 0) {
+    writeLines(["No genres."]);
+    return;
+  }
+  writeLines(response.genres.map((genre) => `${genre.id}  ${genre.name}`));
+}
+function appendImageSection(lines, title, images, size, tmdb) {
+  if (images.length === 0) {
+    return;
+  }
+  if (lines.length > 0) {
+    lines.push("");
+  }
+  lines.push(`${title}:`);
+  for (const image of images) {
+    const url = tmdb.images.url(image.file_path, size);
+    if (url) {
+      lines.push(`  ${url}  (${image.width}x${image.height})`);
+    }
+  }
+}
+function formatCombinedCast(item) {
+  const character = item.character ? ` as ${item.character}` : "";
+  const episodes = item.media_type === "tv" && item.episode_count ? ` · ${item.episode_count} eps` : "";
+  return `  ${creditYear(item)}  ${creditTitle(item)}${character}${episodes}  (${item.media_type}, ${item.id})`;
+}
+function formatCombinedCrew(item) {
+  return `  ${creditYear(item)}  ${creditTitle(item)} — ${item.job} (${item.department})  (${item.media_type}, ${item.id})`;
+}
+function byCreditDate(a, b) {
+  return creditDate(b).localeCompare(creditDate(a));
+}
+function creditDate(item) {
+  return "release_date" in item ? item.release_date : item.first_air_date;
+}
+function creditTitle(item) {
+  return "title" in item ? item.title : item.name;
+}
+function creditYear(item) {
+  const date = creditDate(item);
+  return date ? date.slice(0, 4) : "----";
+}
+function writeLines(lines) {
+  process.stdout.write(`${lines.join(`
+`)}
+`);
+}
+function formatSearchResult(result, index, fallbackType) {
+  const title = "title" in result ? result.title : result.name;
+  const date = "release_date" in result ? result.release_date : ("first_air_date" in result) ? result.first_air_date : "";
+  const year = date ? ` (${date.slice(0, 4)})` : "";
+  const mediaType = "media_type" in result && result.media_type ? result.media_type : fallbackType;
+  const score = "vote_average" in result && result.vote_average > 0 ? `  ★ ${result.vote_average.toFixed(1)}` : "";
+  return `${String(index + 1).padStart(2)}. ${title}${year}${score}  ${mediaType}  ${result.id}`;
+}
+
+// src/cli/options.ts
+var jsonArg = {
+  json: {
+    type: "boolean",
+    description: "Print the raw TMDB JSON response"
+  }
+};
+var commonArgs = {
+  ...jsonArg,
+  lang: {
+    type: "string",
+    description: "TMDB language code (default: en-US)"
+  }
+};
+var SEARCH_TYPES = ["all", "movie", "tv", "person"];
+function parseSearchType(value) {
+  if (!SEARCH_TYPES.includes(value)) {
+    throw new CliError(`Invalid --type "${value}". Expected one of: ${SEARCH_TYPES.join(", ")}.`, 2);
+  }
+  return value;
+}
+function parsePage(value) {
+  if (value === undefined || value === "") {
+    return 1;
+  }
+  const page = Number(value);
+  if (!Number.isInteger(page) || page < 1) {
+    throw new CliError("Invalid --page value: expected a positive integer.", 2);
+  }
+  return page;
+}
+function parseId(value, label) {
+  const id = Number(value);
+  if (!Number.isInteger(id) || id <= 0) {
+    throw new CliError(`Invalid ${label}: expected a positive integer.`, 2);
+  }
+  return id;
+}
+function parseSeasonNumber(value) {
+  const season = Number(value);
+  if (!Number.isInteger(season) || season < 0) {
+    throw new CliError("Invalid season number: expected a non-negative integer.", 2);
+  }
+  return season;
+}
+function parseLimit(value, fallback = 10) {
+  if (value === undefined || value === "") {
+    return fallback;
+  }
+  const limit = Number(value);
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new CliError("Invalid --limit value: expected a positive integer.", 2);
+  }
+  return limit;
+}
+function parseCommaList(value) {
+  if (value === undefined) {
+    return;
+  }
+  const values = value.split(",").map((item) => item.trim()).filter(Boolean);
+  return values.length > 0 ? values : undefined;
+}
+var TRENDING_WINDOWS = ["day", "week"];
+function parseWindow(value) {
+  if (!TRENDING_WINDOWS.includes(value)) {
+    throw new CliError(`Invalid --window "${value}". Expected one of: ${TRENDING_WINDOWS.join(", ")}.`, 2);
+  }
+  return value;
+}
+var GENRE_TYPES = ["movie", "tv"];
+function parseGenreType(value) {
+  if (!GENRE_TYPES.includes(value)) {
+    throw new CliError(`Invalid --type "${value}". Expected one of: ${GENRE_TYPES.join(", ")}.`, 2);
+  }
+  return value;
+}
+var MOVIE_LIST_CATEGORIES = ["popular", "top-rated", "now-playing", "upcoming"];
+function parseMovieListCategory(value) {
+  if (!MOVIE_LIST_CATEGORIES.includes(value)) {
+    throw new CliError(`Invalid movie list category "${value}". Expected one of: ${MOVIE_LIST_CATEGORIES.join(", ")}.`, 2);
+  }
+  return value;
+}
+var TV_LIST_CATEGORIES = ["popular", "top-rated", "airing-today", "on-the-air"];
+function parseTVListCategory(value) {
+  if (!TV_LIST_CATEGORIES.includes(value)) {
+    throw new CliError(`Invalid TV list category "${value}". Expected one of: ${TV_LIST_CATEGORIES.join(", ")}.`, 2);
+  }
+  return value;
+}
+
+// src/cli/prompt.ts
+import { createInterface } from "node:readline/promises";
+async function readSecret(prompt) {
+  if (!process.stdin.isTTY) {
+    return readStdinSecret();
+  }
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  const target = rl;
+  const writeToOutput = target._writeToOutput;
+  target._writeToOutput = () => {};
+  try {
+    const answer = await rl.question(prompt);
+    process.stdout.write(`
+`);
+    return answer.trim();
+  } finally {
+    target._writeToOutput = writeToOutput;
+    rl.close();
+  }
+}
+async function confirm(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function readStdinSecret() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8").trim();
+}
+
+// src/cli/commands/auth.ts
+var authCommand = defineCommand({
+  meta: {
+    name: "auth",
+    description: "Manage TMDB API credentials"
+  },
+  subCommands: {
+    login: defineCommand({
+      meta: {
+        name: "login",
+        description: "Validate and save TMDB API credentials"
+      },
+      args: {
+        "token-stdin": {
+          type: "boolean",
+          description: "Read the credential from stdin instead of prompting"
+        },
+        force: {
+          type: "boolean",
+          description: "Replace existing credentials without confirmation"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const existing = resolveCredentials();
+          if (!args.force && existing.source !== "none") {
+            if (!process.stdin.isTTY) {
+              throw new CliError(existingCredentialsMessage(existing), 2);
+            }
+            process.stdout.write(`${describeExistingCredentials(existing)}
+`);
+            const question = existing.source === "environment" ? "Save a config token anyway? [y/N] " : "Replace existing credentials? [y/N] ";
+            if (!await confirm(question)) {
+              process.stdout.write(`Kept existing credentials.
+`);
+              return;
+            }
+          }
+          const input = args["token-stdin"] ? await readStdinSecret() : await promptForCredential();
+          if (!input) {
+            throw new CliError("Credential must not be empty.", 2);
+          }
+          const credential = detectCredential(input);
+          if (!credential) {
+            throw new CliError(unrecognizedCredentialMessage(), 2);
+          }
+          const config = readConfig();
+          const common = {
+            baseUrl: process.env.TMDB_BASE_URL,
+            defaultLanguage: config.language ?? "en-US"
+          };
+          const client = credential.kind === "accessToken" ? createTMDB({ accessToken: credential.value, ...common }) : createTMDB({ apiKey: credential.value, ...common });
+          try {
+            await client.movies.details(550);
+          } catch (error) {
+            if (error instanceof TMDBResponseError && (error.status === 401 || error.status === 403)) {
+              throw new CliError([
+                "Credential validation failed: TMDB rejected the credential.",
+                "Make sure you copied the API Read Access Token or API Key correctly.",
+                "Existing config was not changed."
+              ].join(`
+`), 3);
+            }
+            throw new CliError(`Credential validation failed; existing config was not changed.
+${errorMessage(error)}`, exitCodeFor(error));
+          }
+          delete config.accessToken;
+          delete config.apiKey;
+          config[credential.kind] = credential.value;
+          writeConfig(config);
+          process.stdout.write(`Credential validated.
+Saved ${credential.kind} to ${getConfigPath()}
+`);
+          if (credential.kind === "apiKey") {
+            process.stdout.write(`Note: API Key is the legacy v3 method. The API Read Access Token is recommended.
+`);
+          }
+          const effective = resolveCredentials();
+          if (effective.source === "environment") {
+            process.stdout.write(`Note: ${effective.envVar} is set and takes precedence over the config file.
+`);
+          }
+        });
+      }
+    }),
+    status: defineCommand({
+      meta: {
+        name: "status",
+        description: "Show credential source, token mask, and config path"
+      },
+      args: { ...jsonArg },
+      async run({ args }) {
+        await runSafely(async () => {
+          const credentials = resolveCredentials();
+          const path = getConfigPath();
+          const configExists = existsSync2(path);
+          const view = {
+            source: credentials.source,
+            environmentVariable: credentials.envVar,
+            configField: credentials.configField,
+            token: maskSecret(credentials.accessToken ?? credentials.apiKey),
+            configPath: path,
+            configExists,
+            language: credentials.config.language ?? null,
+            region: credentials.config.region ?? null
+          };
+          if (args.json) {
+            printJson(view);
+            return;
+          }
+          const lines = [
+            `Credential source: ${describeSource(credentials)}`,
+            `Token: ${view.token ?? "(not set)"}`,
+            `Config: ${path}${configExists ? "" : " (missing)"}`,
+            `Language: ${view.language ?? "(not set)"}`,
+            `Region: ${view.region ?? "(not set)"}`
+          ];
+          const hasConfigCredentials = Boolean(credentials.config.accessToken && !isPlaceholderCredential(credentials.config.accessToken) || credentials.config.apiKey && !isPlaceholderCredential(credentials.config.apiKey));
+          if (credentials.source === "environment" && hasConfigCredentials) {
+            lines.push("Note: config credentials are shadowed by environment variables.");
+          }
+          if (credentials.source === "none") {
+            lines.push("", "Run `tmdb auth login` to set up credentials.");
+          }
+          process.stdout.write(`${lines.join(`
+`)}
+`);
+        });
+      }
+    }),
+    logout: defineCommand({
+      meta: {
+        name: "logout",
+        description: "Remove saved API credentials from the config file"
+      },
+      async run() {
+        await runSafely(async () => {
+          const config = readConfig();
+          const hadCredentials = Boolean(config.accessToken || config.apiKey);
+          if (hadCredentials) {
+            delete config.accessToken;
+            delete config.apiKey;
+            writeConfig(config);
+            process.stdout.write(`Removed API credentials from ${getConfigPath()}
+`);
+          } else {
+            process.stdout.write(`No saved API credentials found.
+`);
+          }
+          if (resolveCredentials().source === "environment") {
+            process.stdout.write(`Environment credentials are still set and will continue to be used.
+`);
+          }
+        });
+      }
+    })
+  }
+});
+async function promptForCredential() {
+  if (!process.stdin.isTTY) {
+    throw new CliError([
+      "No interactive terminal available.",
+      "Pipe the credential with --token-stdin:",
+      `  printf '%s' "$TMDB_ACCESS_TOKEN" | tmdb auth login --token-stdin`,
+      "Or set TMDB_ACCESS_TOKEN / TMDB_API_KEY directly."
+    ].join(`
+`), 2);
+  }
+  process.stdout.write([
+    "Create credentials at https://www.themoviedb.org/settings/api",
+    "API Read Access Token (recommended) or API Key are accepted.",
+    ""
+  ].join(`
+`));
+  return readSecret("TMDB credential: ");
+}
+function describeSource(credentials) {
+  if (credentials.source === "environment") {
+    return `environment (${credentials.envVar})`;
+  }
+  if (credentials.source === "config") {
+    return `config (${credentials.configField})`;
+  }
+  return "none";
+}
+function describeExistingCredentials(credentials) {
+  const secret = maskSecret(credentials.accessToken ?? credentials.apiKey) ?? "(unknown)";
+  if (credentials.source === "environment") {
+    return [
+      `Credentials are currently provided by ${credentials.envVar} (${secret}).`,
+      "A config token will not take effect while that environment variable is set."
+    ].join(`
+`);
+  }
+  return `Existing credentials: config (${credentials.configField}, ${secret}).`;
+}
+function existingCredentialsMessage(credentials) {
+  const secret = maskSecret(credentials.accessToken ?? credentials.apiKey) ?? "(unknown)";
+  const label = credentials.source === "environment" ? `environment (${credentials.envVar})` : `config (${credentials.configField})`;
+  return [
+    `Existing credentials found: ${label} (${secret}).`,
+    credentials.source === "environment" ? "Re-run with --force to save a config token anyway." : "Re-run with --force to replace them."
+  ].join(`
+`);
+}
+
+// src/cli/client.ts
+function createClient(options = {}) {
+  const credentials = resolveCredentials();
+  const common = {
+    baseUrl: process.env.TMDB_BASE_URL,
+    defaultLanguage: options.language ?? credentials.config.language ?? "en-US",
+    defaultRegion: credentials.config.region
+  };
+  if (credentials.accessToken) {
+    return createTMDB({ accessToken: credentials.accessToken, ...common });
+  }
+  if (credentials.apiKey) {
+    return createTMDB({ apiKey: credentials.apiKey, ...common });
+  }
+  throw new CliError(missingCredentialsMessage(), 3);
+}
+
+// src/cli/commands/config.ts
+var CONFIG_KEY_ALIASES = {
+  token: "accessToken",
+  accessToken: "accessToken",
+  "api-key": "apiKey",
+  apiKey: "apiKey",
+  language: "language",
+  region: "region"
+};
+var configCommand = defineCommand({
+  meta: {
+    name: "config",
+    description: "Manage TMDB CLI configuration"
+  },
+  subCommands: {
+    show: defineCommand({
+      meta: {
+        name: "show",
+        description: "Show the resolved config with secrets masked"
+      },
+      args: { ...jsonArg },
+      async run({ args }) {
+        await runSafely(async () => {
+          const config = readConfig();
+          const path = getConfigPath();
+          const view = {
+            path,
+            accessToken: describeSecret(config.accessToken),
+            apiKey: describeSecret(config.apiKey),
+            language: config.language ?? null,
+            region: config.region ?? null
+          };
+          if (args.json) {
+            printJson(view);
+            return;
+          }
+          process.stdout.write([
+            `Path: ${path}`,
+            `accessToken: ${view.accessToken ?? "(not set)"}`,
+            `apiKey: ${view.apiKey ?? "(not set)"}`,
+            `language: ${view.language ?? "(not set)"}`,
+            `region: ${view.region ?? "(not set)"}`
+          ].join(`
+`) + `
+`);
+        });
+      }
+    }),
+    path: defineCommand({
+      meta: {
+        name: "path",
+        description: "Print the config file path"
+      },
+      run() {
+        process.stdout.write(`${getConfigPath()}
+`);
+      }
+    }),
+    test: defineCommand({
+      meta: {
+        name: "test",
+        description: "Verify credentials with an authenticated TMDB request"
+      },
+      args: { ...jsonArg },
+      async run({ args }) {
+        await runSafely(async () => {
+          const client = createClient();
+          await client.movies.details(550);
+          if (args.json) {
+            printJson({ ok: true });
+            return;
+          }
+          process.stdout.write(`TMDB connection OK
+Credentials are valid.
+`);
+        });
+      }
+    }),
+    set: defineCommand({
+      meta: {
+        name: "set",
+        description: "Set a config value (token and api-key are read securely)"
+      },
+      args: {
+        key: {
+          type: "positional",
+          description: "token, api-key, language, or region",
+          required: true
+        },
+        value: {
+          type: "positional",
+          description: "Value for language or region",
+          required: false
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const field = parseConfigKey(args.key);
+          const path = getConfigPath();
+          if (field === "accessToken" || field === "apiKey") {
+            if (args.value !== undefined) {
+              throw new CliError("Do not pass secrets as command arguments. Run the command without a value to enter it securely.", 2);
+            }
+            const label = field === "accessToken" ? "TMDB access token" : "TMDB API key";
+            const secret = await readSecret(`${label}: `);
+            if (!secret) {
+              throw new CliError("Secret must not be empty.", 2);
+            }
+            setConfigValue(field, secret);
+            process.stdout.write(`Saved ${field} to ${path}
+`);
+            return;
+          }
+          const value = args.value?.trim();
+          if (!value) {
+            throw new CliError(`A value is required for ${args.key}.`, 2);
+          }
+          setConfigValue(field, field === "region" ? value.toUpperCase() : value);
+          process.stdout.write(`Saved ${field} to ${path}
+`);
+        });
+      }
+    }),
+    unset: defineCommand({
+      meta: {
+        name: "unset",
+        description: "Remove a config value"
+      },
+      args: {
+        key: {
+          type: "positional",
+          description: "token, api-key, language, or region",
+          required: true
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const field = parseConfigKey(args.key);
+          unsetConfigValue(field);
+          process.stdout.write(`Removed ${field} from ${getConfigPath()}
+`);
+        });
+      }
+    })
+  }
+});
+function parseConfigKey(value) {
+  if (!(value in CONFIG_KEY_ALIASES)) {
+    throw new CliError(`Unknown config key "${value}". Expected one of: ${Object.keys(CONFIG_KEY_ALIASES).join(", ")}.`, 2);
+  }
+  return CONFIG_KEY_ALIASES[value];
+}
+
+// src/cli/commands/genres.ts
+var genresCommand = defineCommand({
+  meta: {
+    name: "genres",
+    description: "List movie or TV genres"
+  },
+  args: {
+    ...commonArgs,
+    type: {
+      type: "positional",
+      description: "Genre list type: movie or tv",
+      default: "movie"
+    }
+  },
+  async run({ args }) {
+    await runSafely(async () => {
+      const type = parseGenreType(args.type);
+      const client = createClient({ language: args.lang });
+      const response = type === "tv" ? await client.genres.tv() : await client.genres.movies();
+      if (args.json) {
+        printJson(response);
+      } else {
+        printGenres(response);
+      }
+    });
+  }
+});
+
+// src/cli/commands/movie.ts
+var movieCommand = defineCommand({
+  meta: {
+    name: "movie",
+    description: "Movie commands"
+  },
+  subCommands: {
+    list: defineCommand({
+      meta: {
+        name: "list",
+        description: "List popular, top-rated, now-playing, or upcoming movies"
+      },
+      args: {
+        ...commonArgs,
+        category: {
+          type: "positional",
+          description: "popular, top-rated, now-playing, or upcoming",
+          default: "popular"
+        },
+        page: {
+          type: "string",
+          description: "Page number"
+        },
+        region: {
+          type: "string",
+          description: "ISO 3166-1 region code"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const category = parseMovieListCategory(args.category);
+          const options = { page: parsePage(args.page), region: args.region };
+          const client = createClient({ language: args.lang });
+          const response = category === "top-rated" ? await client.movies.topRated(options) : category === "now-playing" ? await client.movies.nowPlaying(options) : category === "upcoming" ? await client.movies.upcoming(options) : await client.movies.popular(options);
+          if (args.json) {
+            printJson(response);
+          } else {
+            printSearchResults(response, "movie");
+          }
+        });
+      }
+    }),
+    get: defineCommand({
+      meta: {
+        name: "get",
+        description: "Get movie details by TMDB ID"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB movie ID",
+          required: true
+        },
+        append: {
+          type: "string",
+          description: "Comma-separated append_to_response values"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "movie ID");
+          const client = createClient({ language: args.lang });
+          const appendToResponse = parseCommaList(args.append);
+          const movie = await client.movies.details(id, { appendToResponse });
+          if (args.json) {
+            printJson(movie);
+          } else {
+            printMovie(movie, client);
+          }
+        });
+      }
+    }),
+    credits: defineCommand({
+      meta: {
+        name: "credits",
+        description: "Show movie cast and crew"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB movie ID",
+          required: true
+        },
+        limit: {
+          type: "string",
+          description: "Maximum cast/crew rows (default: 10)"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "movie ID");
+          const limit = parseLimit(args.limit);
+          const client = createClient({ language: args.lang });
+          const credits = await client.movies.credits(id);
+          if (args.json) {
+            printJson(credits);
+          } else {
+            printCredits(credits, limit);
+          }
+        });
+      }
+    }),
+    images: defineCommand({
+      meta: {
+        name: "images",
+        description: "Show movie image URLs"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB movie ID",
+          required: true
+        },
+        "image-language": {
+          type: "string",
+          description: "Comma-separated image language codes"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "movie ID");
+          const includeImageLanguage = parseCommaList(args["image-language"]);
+          const client = createClient({ language: args.lang });
+          const images = await client.movies.images(id, { includeImageLanguage });
+          if (args.json) {
+            printJson(images);
+          } else {
+            printImages(images, client);
+          }
+        });
+      }
+    }),
+    videos: defineCommand({
+      meta: {
+        name: "videos",
+        description: "Show movie videos and trailers"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB movie ID",
+          required: true
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "movie ID");
+          const client = createClient({ language: args.lang });
+          const videos = await client.movies.videos(id);
+          if (args.json) {
+            printJson(videos);
+          } else {
+            printVideos(videos);
+          }
+        });
+      }
+    }),
+    similar: defineCommand({
+      meta: {
+        name: "similar",
+        description: "List movies similar to a movie"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB movie ID",
+          required: true
+        },
+        page: {
+          type: "string",
+          description: "Page number"
+        },
+        region: {
+          type: "string",
+          description: "ISO 3166-1 region code"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "movie ID");
+          const options = { page: parsePage(args.page), region: args.region };
+          const client = createClient({ language: args.lang });
+          const response = await client.movies.similar(id, options);
+          if (args.json) {
+            printJson(response);
+          } else {
+            printSearchResults(response, "movie");
+          }
+        });
+      }
+    }),
+    recommendations: defineCommand({
+      meta: {
+        name: "recommendations",
+        description: "List recommended movies for a movie"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB movie ID",
+          required: true
+        },
+        page: {
+          type: "string",
+          description: "Page number"
+        },
+        region: {
+          type: "string",
+          description: "ISO 3166-1 region code"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "movie ID");
+          const options = { page: parsePage(args.page), region: args.region };
+          const client = createClient({ language: args.lang });
+          const response = await client.movies.recommendations(id, options);
+          if (args.json) {
+            printJson(response);
+          } else {
+            printSearchResults(response, "movie");
+          }
+        });
+      }
+    })
+  }
+});
+
+// src/cli/commands/person.ts
+var personCommand = defineCommand({
+  meta: {
+    name: "person",
+    description: "Person commands"
+  },
+  subCommands: {
+    get: defineCommand({
+      meta: {
+        name: "get",
+        description: "Get person details by TMDB ID"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB person ID",
+          required: true
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "person ID");
+          const client = createClient({ language: args.lang });
+          const person = await client.people.details(id);
+          if (args.json) {
+            printJson(person);
+          } else {
+            printPerson(person, client);
+          }
+        });
+      }
+    }),
+    credits: defineCommand({
+      meta: {
+        name: "credits",
+        description: "Show a person combined cast and crew credits"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB person ID",
+          required: true
+        },
+        limit: {
+          type: "string",
+          description: "Maximum rows per section (default: 10)"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "person ID");
+          const limit = parseLimit(args.limit);
+          const client = createClient({ language: args.lang });
+          const credits = await client.people.combinedCredits(id);
+          if (args.json) {
+            printJson(credits);
+          } else {
+            printPersonCredits(credits, limit);
+          }
+        });
+      }
+    })
+  }
+});
+
+// src/cli/commands/search.ts
+var searchCommand = defineCommand({
+  meta: {
+    name: "search",
+    description: "Search movies, TV shows, and people"
+  },
+  args: {
+    ...commonArgs,
+    query: {
+      type: "positional",
+      description: "Search query",
+      required: true
+    },
+    type: {
+      type: "enum",
+      description: "Media type to search",
+      options: [...SEARCH_TYPES],
+      default: "all"
+    },
+    page: {
+      type: "string",
+      description: "Page number"
+    },
+    year: {
+      type: "string",
+      description: "Release year for movies, first-air year for TV"
+    }
+  },
+  async run({ args }) {
+    await runSafely(async () => {
+      const query = args.query.trim();
+      if (!query) {
+        throw new CliError("Search query must not be empty.", 2);
+      }
+      const type = parseSearchType(args.type);
+      const page = parsePage(args.page);
+      const year = args.year?.trim() || undefined;
+      if (year && type !== "movie" && type !== "tv") {
+        throw new CliError("--year is only supported with --type movie or tv.", 2);
+      }
+      const client = createClient({ language: args.lang });
+      const options = { page };
+      const response = type === "movie" ? await client.search.movies(query, { ...options, year }) : type === "tv" ? await client.search.tv(query, { ...options, firstAirDateYear: year }) : type === "person" ? await client.search.people(query, options) : await client.search.multi(query, options);
+      if (args.json) {
+        printJson(response);
+      } else {
+        printSearchResults(response, type);
+      }
+    });
+  }
+});
+
+// src/cli/commands/trending.ts
+var trendingCommand = defineCommand({
+  meta: {
+    name: "trending",
+    description: "Show trending movies, TV shows, people, or all media"
+  },
+  args: {
+    ...commonArgs,
+    type: {
+      type: "positional",
+      description: "Media type: all, movie, tv, or person",
+      default: "all"
+    },
+    window: {
+      type: "enum",
+      description: "Trending window",
+      options: [...TRENDING_WINDOWS],
+      default: "week"
+    },
+    page: {
+      type: "string",
+      description: "Page number"
+    }
+  },
+  async run({ args }) {
+    await runSafely(async () => {
+      const type = parseSearchType(args.type);
+      const window = parseWindow(args.window);
+      const page = parsePage(args.page);
+      const client = createClient({ language: args.lang });
+      const response = type === "movie" ? await client.trending.movies(window, { page }) : type === "tv" ? await client.trending.tv(window, { page }) : type === "person" ? await client.trending.people(window, { page }) : await client.trending.all(window, { page });
+      if (args.json) {
+        printJson(response);
+      } else {
+        printSearchResults(response, type);
+      }
+    });
+  }
+});
+
+// src/cli/commands/tv.ts
+var tvCommand = defineCommand({
+  meta: {
+    name: "tv",
+    description: "TV show commands"
+  },
+  subCommands: {
+    list: defineCommand({
+      meta: {
+        name: "list",
+        description: "List popular, top-rated, airing-today, or on-the-air shows"
+      },
+      args: {
+        ...commonArgs,
+        category: {
+          type: "positional",
+          description: "popular, top-rated, airing-today, or on-the-air",
+          default: "popular"
+        },
+        page: {
+          type: "string",
+          description: "Page number"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const category = parseTVListCategory(args.category);
+          const options = { page: parsePage(args.page) };
+          const client = createClient({ language: args.lang });
+          const response = category === "top-rated" ? await client.tv.topRated(options) : category === "airing-today" ? await client.tv.airingToday(options) : category === "on-the-air" ? await client.tv.onTheAir(options) : await client.tv.popular(options);
+          if (args.json) {
+            printJson(response);
+          } else {
+            printSearchResults(response, "tv");
+          }
+        });
+      }
+    }),
+    get: defineCommand({
+      meta: {
+        name: "get",
+        description: "Get TV show details by TMDB ID"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB TV show ID",
+          required: true
+        },
+        append: {
+          type: "string",
+          description: "Comma-separated append_to_response values"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "TV show ID");
+          const client = createClient({ language: args.lang });
+          const appendToResponse = parseCommaList(args.append);
+          const tv = await client.tv.details(id, { appendToResponse });
+          if (args.json) {
+            printJson(tv);
+          } else {
+            printTV(tv, client);
+          }
+        });
+      }
+    }),
+    credits: defineCommand({
+      meta: {
+        name: "credits",
+        description: "Show TV show cast and crew"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB TV show ID",
+          required: true
+        },
+        limit: {
+          type: "string",
+          description: "Maximum cast/crew rows (default: 10)"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "TV show ID");
+          const limit = parseLimit(args.limit);
+          const client = createClient({ language: args.lang });
+          const credits = await client.tv.credits(id);
+          if (args.json) {
+            printJson(credits);
+          } else {
+            printCredits(credits, limit);
+          }
+        });
+      }
+    }),
+    images: defineCommand({
+      meta: {
+        name: "images",
+        description: "Show TV show image URLs"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB TV show ID",
+          required: true
+        },
+        "image-language": {
+          type: "string",
+          description: "Comma-separated image language codes"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "TV show ID");
+          const includeImageLanguage = parseCommaList(args["image-language"]);
+          const client = createClient({ language: args.lang });
+          const images = await client.tv.images(id, { includeImageLanguage });
+          if (args.json) {
+            printJson(images);
+          } else {
+            printImages(images, client);
+          }
+        });
+      }
+    }),
+    videos: defineCommand({
+      meta: {
+        name: "videos",
+        description: "Show TV show videos and trailers"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB TV show ID",
+          required: true
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "TV show ID");
+          const client = createClient({ language: args.lang });
+          const videos = await client.tv.videos(id);
+          if (args.json) {
+            printJson(videos);
+          } else {
+            printVideos(videos);
+          }
+        });
+      }
+    }),
+    similar: defineCommand({
+      meta: {
+        name: "similar",
+        description: "List TV shows similar to a show"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB TV show ID",
+          required: true
+        },
+        page: {
+          type: "string",
+          description: "Page number"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "TV show ID");
+          const options = { page: parsePage(args.page) };
+          const client = createClient({ language: args.lang });
+          const response = await client.tv.similar(id, options);
+          if (args.json) {
+            printJson(response);
+          } else {
+            printSearchResults(response, "tv");
+          }
+        });
+      }
+    }),
+    recommendations: defineCommand({
+      meta: {
+        name: "recommendations",
+        description: "List recommended TV shows for a show"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB TV show ID",
+          required: true
+        },
+        page: {
+          type: "string",
+          description: "Page number"
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "TV show ID");
+          const options = { page: parsePage(args.page) };
+          const client = createClient({ language: args.lang });
+          const response = await client.tv.recommendations(id, options);
+          if (args.json) {
+            printJson(response);
+          } else {
+            printSearchResults(response, "tv");
+          }
+        });
+      }
+    }),
+    season: defineCommand({
+      meta: {
+        name: "season",
+        description: "Show a TV season and its episodes"
+      },
+      args: {
+        ...commonArgs,
+        id: {
+          type: "positional",
+          description: "TMDB TV show ID",
+          required: true
+        },
+        season: {
+          type: "positional",
+          description: "Season number (0 for specials)",
+          required: true
+        }
+      },
+      async run({ args }) {
+        await runSafely(async () => {
+          const id = parseId(args.id, "TV show ID");
+          const seasonNumber = parseSeasonNumber(args.season);
+          const client = createClient({ language: args.lang });
+          const season = await client.tv.seasonDetails(id, seasonNumber);
+          if (args.json) {
+            printJson(season);
+          } else {
+            printSeason(season, client);
+          }
+        });
+      }
+    })
+  }
+});
+
+// src/cli/command.ts
+var CLI_VERSION = package_default.version;
+var mainCommand = defineCommand({
+  meta: {
+    name: "tmdb",
+    version: CLI_VERSION,
+    description: "A read-only TMDB command-line client"
+  },
+  subCommands: {
+    search: searchCommand,
+    movie: movieCommand,
+    tv: tvCommand,
+    person: personCommand,
+    trending: trendingCommand,
+    genres: genresCommand,
+    auth: authCommand,
+    config: configCommand
+  }
+});
+
+// src/cli/help.ts
+var AUTHENTICATION_HELP = [
+  "AUTHENTICATION",
+  "",
+  "  tmdb auth login        Set up a TMDB API Read Access Token",
+  "  tmdb auth status       Show credential source and config path",
+  "  tmdb auth logout       Remove saved API credentials",
+  "  tmdb config show       Show config path and masked values",
+  "  tmdb config path       Print the config file path",
+  "",
+  "  TMDB_ACCESS_TOKEN      Environment variable (takes precedence)",
+  "  TMDB_API_KEY           Legacy v3 API key (takes precedence)"
+].join(`
+`);
+
+// src/cli/main.ts
+await runMain(mainCommand, { showUsage: showFullUsage });
+async function showFullUsage(cmd, parent) {
+  const path = await findPath(mainCommand, cmd);
+  if (!parent || !path || path.length === 0) {
+    const usage = await renderUsage(cmd);
+    const authentication = cmd === mainCommand ? `
+
+${AUTHENTICATION_HELP}` : "";
+    process.stdout.write(`${usage}${authentication}
+`);
+    return;
+  }
+  const parentName = ["tmdb", ...path.slice(0, -1)].join(" ");
+  const usageParent = defineCommand({
+    meta: { name: parentName, version: CLI_VERSION }
+  });
+  process.stdout.write(`${await renderUsage(cmd, usageParent)}
+`);
+}
+async function findPath(root, target, path = []) {
+  if (root === target) {
+    return path;
+  }
+  const subCommands = await resolveValue2(root.subCommands);
+  if (!subCommands) {
+    return;
+  }
+  for (const [name, subCommand] of Object.entries(subCommands)) {
+    const resolved = await resolveValue2(subCommand);
+    if (!resolved) {
+      continue;
+    }
+    const found = await findPath(resolved, target, [...path, name]);
+    if (found) {
+      return found;
+    }
+  }
+  return;
+}
+async function resolveValue2(value) {
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value === "function") {
+    return await value();
+  }
+  return await value;
+}