@zfadhli/tokrec 0.11.4 → 0.12.0

package/dist/recorder/convert.mjs

@@ -1,67 +0,0 @@
-import { TikTokError } from "../config.mjs";
-import { findFfmpegPath } from "../utils.mjs";
-import { spawn } from "node:child_process";
-import { unlinkSync } from "node:fs";
-//#region src/recorder/convert.ts
-/**
-* Converter — spawns FFmpeg to convert TS → MP4 (stream copy by default).
-* Deletes the original file on success.
-*/
-function createConverter(logger, signal) {
-	async function convert(input) {
-		const output = input.replace(/\.(flv|ts)$/i, ".mp4");
-		logger?.info(`Converting: ${input} → ${output}`);
-		const ffmpegPath = findFfmpegPath();
-		if (!ffmpegPath) throw new TikTokError("ffmpeg-not-found", "FFmpeg not found. Install it:\n  Linux:  apt install ffmpeg / brew install ffmpeg / pacman -S ffmpeg\n  macOS:  brew install ffmpeg\n  Windows: choco install ffmpeg");
-		await runFfmpeg(ffmpegPath, input, output, signal);
-		try {
-			unlinkSync(input);
-			logger?.info(`Deleted original: ${input}`);
-		} catch {
-			logger?.warn(`Could not delete original: ${input}`);
-		}
-		logger?.info(`Converted: ${output}`);
-		return output;
-	}
-	return { convert };
-}
-function runFfmpeg(ffmpegPath, input, output, signal) {
-	return new Promise((resolve, reject) => {
-		const proc = spawn(ffmpegPath, [
-			"-i",
-			input,
-			"-c",
-			"copy",
-			"-y",
-			output
-		], {
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			signal
-		});
-		let stderr = "";
-		proc.stderr?.on("data", (chunk) => {
-			stderr += chunk.toString();
-			if (stderr.length > 1e4) stderr = stderr.slice(-5e3);
-		});
-		proc.on("close", (code) => {
-			if (signal?.aborted) {
-				reject(new TikTokError("aborted", "Aborted by user"));
-				return;
-			}
-			if (code === 0) resolve();
-			else reject(new TikTokError("ffmpeg-error", `FFmpeg exited with code ${code}\n${stderr.slice(-500)}`));
-		});
-		proc.on("error", (err) => {
-			if (err instanceof Error && err.name === "AbortError") return;
-			reject(new TikTokError("ffmpeg-error", `Failed to spawn FFmpeg: ${err.message}`));
-		});
-	});
-}
-//#endregion
-export { createConverter };
-
-//# sourceMappingURL=convert.mjs.map

package/dist/recorder/convert.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"convert.mjs","names":[],"sources":["../../src/recorder/convert.ts"],"sourcesContent":["/**\n * Converter — spawns FFmpeg to convert TS → MP4 (stream copy by default).\n * Deletes the original file on success.\n */\n\nimport { spawn } from \"node:child_process\"\nimport { unlinkSync } from \"node:fs\"\nimport { TikTokError } from \"../config\"\nimport type { Logger } from \"../logger\"\nimport { findFfmpegPath } from \"../utils\"\n\nexport interface Converter {\n  /** Convert a TS file to MP4. Returns the output filepath. */\n  convert: (input: string) => Promise<string>\n}\n\nexport function createConverter(logger?: Logger, signal?: AbortSignal): Converter {\n  async function convert(input: string): Promise<string> {\n    const output = input.replace(/\\.(flv|ts)$/i, \".mp4\")\n\n    logger?.info(`Converting: ${input} → ${output}`)\n\n    const ffmpegPath = findFfmpegPath()\n    if (!ffmpegPath) {\n      throw new TikTokError(\n        \"ffmpeg-not-found\",\n        \"FFmpeg not found. Install it:\\n\" +\n          \"  Linux:  apt install ffmpeg / brew install ffmpeg / pacman -S ffmpeg\\n\" +\n          \"  macOS:  brew install ffmpeg\\n\" +\n          \"  Windows: choco install ffmpeg\",\n      )\n    }\n\n    await runFfmpeg(ffmpegPath, input, output, signal)\n\n    // Delete original TS\n    try {\n      unlinkSync(input)\n      logger?.info(`Deleted original: ${input}`)\n    } catch {\n      logger?.warn(`Could not delete original: ${input}`)\n    }\n\n    logger?.info(`Converted: ${output}`)\n    return output\n  }\n\n  return { convert }\n}\n\nfunction runFfmpeg(\n  ffmpegPath: string,\n  input: string,\n  output: string,\n  signal?: AbortSignal,\n): Promise<void> {\n  return new Promise((resolve, reject) => {\n    const args = [\n      \"-i\",\n      input,\n      \"-c\",\n      \"copy\", // stream copy — no re-encode, fast\n      \"-y\", // overwrite output\n      output,\n    ]\n\n    const proc = spawn(ffmpegPath, args, {\n      stdio: [\"ignore\", \"pipe\", \"pipe\"],\n      signal,\n    })\n\n    let stderr = \"\"\n\n    proc.stderr?.on(\"data\", (chunk: Buffer) => {\n      stderr += chunk.toString()\n      if (stderr.length > 10000) stderr = stderr.slice(-5000)\n    })\n\n    proc.on(\"close\", (code) => {\n      if (signal?.aborted) {\n        reject(new TikTokError(\"aborted\", \"Aborted by user\"))\n        return\n      }\n      if (code === 0) {\n        resolve()\n      } else {\n        reject(\n          new TikTokError(\"ffmpeg-error\", `FFmpeg exited with code ${code}\\n${stderr.slice(-500)}`),\n        )\n      }\n    })\n\n    proc.on(\"error\", (err) => {\n      if (err instanceof Error && err.name === \"AbortError\") return\n      reject(new TikTokError(\"ffmpeg-error\", `Failed to spawn FFmpeg: ${err.message}`))\n    })\n  })\n}\n"],"mappings":";;;;;;;;;AAgBA,SAAgB,gBAAgB,QAAiB,QAAiC;CAChF,eAAe,QAAQ,OAAgC;EACrD,MAAM,SAAS,MAAM,QAAQ,gBAAgB,MAAM;EAEnD,QAAQ,KAAK,eAAe,MAAM,KAAK,QAAQ;EAE/C,MAAM,aAAa,eAAe;EAClC,IAAI,CAAC,YACH,MAAM,IAAI,YACR,oBACA,sKAIF;EAGF,MAAM,UAAU,YAAY,OAAO,QAAQ,MAAM;EAGjD,IAAI;GACF,WAAW,KAAK;GAChB,QAAQ,KAAK,qBAAqB,OAAO;EAC3C,QAAQ;GACN,QAAQ,KAAK,8BAA8B,OAAO;EACpD;EAEA,QAAQ,KAAK,cAAc,QAAQ;EACnC,OAAO;CACT;CAEA,OAAO,EAAE,QAAQ;AACnB;AAEA,SAAS,UACP,YACA,OACA,QACA,QACe;CACf,OAAO,IAAI,SAAS,SAAS,WAAW;EAUtC,MAAM,OAAO,MAAM,YAAY;GAR7B;GACA;GACA;GACA;GACA;GACA;EAGgC,GAAG;GACnC,OAAO;IAAC;IAAU;IAAQ;GAAM;GAChC;EACF,CAAC;EAED,IAAI,SAAS;EAEb,KAAK,QAAQ,GAAG,SAAS,UAAkB;GACzC,UAAU,MAAM,SAAS;GACzB,IAAI,OAAO,SAAS,KAAO,SAAS,OAAO,MAAM,IAAK;EACxD,CAAC;EAED,KAAK,GAAG,UAAU,SAAS;GACzB,IAAI,QAAQ,SAAS;IACnB,OAAO,IAAI,YAAY,WAAW,iBAAiB,CAAC;IACpD;GACF;GACA,IAAI,SAAS,GACX,QAAQ;QAER,OACE,IAAI,YAAY,gBAAgB,2BAA2B,KAAK,IAAI,OAAO,MAAM,IAAI,GAAG,CAC1F;EAEJ,CAAC;EAED,KAAK,GAAG,UAAU,QAAQ;GACxB,IAAI,eAAe,SAAS,IAAI,SAAS,cAAc;GACvD,OAAO,IAAI,YAAY,gBAAgB,2BAA2B,IAAI,SAAS,CAAC;EAClF,CAAC;CACH,CAAC;AACH"}

package/dist/recorder/download.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"download.mjs","names":[],"sources":["../../src/recorder/download.ts"],"sourcesContent":["/**\n * Live stream downloader — downloads a live stream via FFmpeg stdout pipe.\n *\n * Outputs MPEG-TS (.ts) format, which is crash-safe and append-friendly.\n * FFmpeg handles HTTP reconnection via -reconnect flags. When TikTok's\n * short-lived stream URL expires, FFmpeg exits and the outer loop fetches\n * a fresh URL via getNextUrl.\n *\n * Both FLV and HLS streams are handled by the same download function —\n * the only difference is an optional label in the log messages.\n */\n\nimport { createWriteStream, statSync } from \"node:fs\"\nimport { join } from \"node:path\"\nimport { TikTokError } from \"../config\"\nimport type { Logger } from \"../logger\"\nimport { bytesToHuman, findFfmpegPath, formatDuration, formatFilename } from \"../utils\"\nimport { pipeFfmpegSegment } from \"./ffmpeg-utils\"\nimport type { DownloadResult, ProgressInfo } from \"./stream\"\n\nexport async function downloadStream(\n  liveUrl: string,\n  user: string,\n  outputDir: string,\n  maxDuration: number,\n  onProgress: ((info: ProgressInfo) => void) | undefined,\n  getNextUrl: (() => Promise<string | null>) | undefined,\n  signal: AbortSignal,\n  logger?: Logger,\n  label?: string,\n): Promise<DownloadResult> {\n  const filename = formatFilename(user, \"ts\")\n  const filepath = join(outputDir, filename)\n  const prefix = label ? ` (${label})` : \"\"\n  logger?.info(`Recording${prefix}: ${filename}`)\n\n  const startTime = Date.now()\n\n  /** File size read directly from disk — authoritative, avoids in-memory counter drift. */\n  let fileSize = 0\n  let lastProgressTime = 0\n\n  const ffmpegPath = findFfmpegPath()\n  if (!ffmpegPath) {\n    throw new TikTokError(\n      \"ffmpeg-not-found\",\n      \"FFmpeg not found — required for stream download. Install it:\\n\" +\n        \"  Linux:  apt install ffmpeg\\n  macOS:  brew install ffmpeg\",\n    )\n  }\n\n  function elapsed(): number {\n    return (Date.now() - startTime) / 1000\n  }\n\n  const writer = createWriteStream(filepath)\n\n  try {\n    while (!signal.aborted) {\n      const remaining = maxDuration > 0 ? Math.max(1, maxDuration - elapsed()) : undefined\n      await pipeFfmpegSegment(ffmpegPath, liveUrl, writer, signal, remaining)\n\n      // Read actual file size from disk — always authoritative\n      try {\n        fileSize = statSync(filepath).size\n      } catch {\n        // File may not be accessible; leave fileSize at last known value\n      }\n\n      // Report progress after each segment\n      const now = Date.now()\n      const e = elapsed()\n      if (onProgress && now - lastProgressTime >= 1000) {\n        lastProgressTime = now\n        const speed = e > 0 ? fileSize / e : 0\n        onProgress({ bytes: fileSize, elapsed: e, speed })\n      }\n\n      if (signal.aborted) break\n      if (maxDuration > 0 && e >= maxDuration) {\n        logger?.info(`Duration limit reached (${maxDuration}s)`)\n        break\n      }\n      if (!getNextUrl) break\n\n      const nextUrl = await getNextUrl()\n      if (!nextUrl) {\n        logger?.info(\"No new stream URL — recording finished\")\n        break\n      }\n      liveUrl = nextUrl\n    }\n  } catch (err) {\n    logger?.error(`Recording error: ${err instanceof Error ? err.message : String(err)}`)\n  } finally {\n    await new Promise<void>((resolve) => writer.end(resolve))\n  }\n\n  const duration = elapsed()\n  // Final authoritative size after flush\n  try {\n    fileSize = statSync(filepath).size\n  } catch {\n    // keep last known value\n  }\n  if (onProgress) {\n    onProgress({\n      bytes: fileSize,\n      elapsed: duration,\n      speed: duration > 0 ? fileSize / duration : 0,\n    })\n  }\n  logger?.info(\n    `Recording finished: ${filename} (${formatDuration(duration)}, ${bytesToHuman(fileSize)})`,\n  )\n\n  return { file: filepath, duration, size: fileSize }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAoBA,eAAsB,eACpB,SACA,MACA,WACA,aACA,YACA,YACA,QACA,QACA,OACyB;CACzB,MAAM,WAAW,eAAe,MAAM,IAAI;CAC1C,MAAM,WAAW,KAAK,WAAW,QAAQ;CACzC,MAAM,SAAS,QAAQ,KAAK,MAAM,KAAK;CACvC,QAAQ,KAAK,YAAY,OAAO,IAAI,UAAU;CAE9C,MAAM,YAAY,KAAK,IAAI;;CAG3B,IAAI,WAAW;CACf,IAAI,mBAAmB;CAEvB,MAAM,aAAa,eAAe;CAClC,IAAI,CAAC,YACH,MAAM,IAAI,YACR,oBACA,2HAEF;CAGF,SAAS,UAAkB;EACzB,QAAQ,KAAK,IAAI,IAAI,aAAa;CACpC;CAEA,MAAM,SAAS,kBAAkB,QAAQ;CAEzC,IAAI;EACF,OAAO,CAAC,OAAO,SAAS;GACtB,MAAM,YAAY,cAAc,IAAI,KAAK,IAAI,GAAG,cAAc,QAAQ,CAAC,IAAI,KAAA;GAC3E,MAAM,kBAAkB,YAAY,SAAS,QAAQ,QAAQ,SAAS;GAGtE,IAAI;IACF,WAAW,SAAS,QAAQ,CAAC,CAAC;GAChC,QAAQ,CAER;GAGA,MAAM,MAAM,KAAK,IAAI;GACrB,MAAM,IAAI,QAAQ;GAClB,IAAI,cAAc,MAAM,oBAAoB,KAAM;IAChD,mBAAmB;IACnB,MAAM,QAAQ,IAAI,IAAI,WAAW,IAAI;IACrC,WAAW;KAAE,OAAO;KAAU,SAAS;KAAG;IAAM,CAAC;GACnD;GAEA,IAAI,OAAO,SAAS;GACpB,IAAI,cAAc,KAAK,KAAK,aAAa;IACvC,QAAQ,KAAK,2BAA2B,YAAY,GAAG;IACvD;GACF;GACA,IAAI,CAAC,YAAY;GAEjB,MAAM,UAAU,MAAM,WAAW;GACjC,IAAI,CAAC,SAAS;IACZ,QAAQ,KAAK,wCAAwC;IACrD;GACF;GACA,UAAU;EACZ;CACF,SAAS,KAAK;EACZ,QAAQ,MAAM,oBAAoB,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,GAAG;CACtF,UAAU;EACR,MAAM,IAAI,SAAe,YAAY,OAAO,IAAI,OAAO,CAAC;CAC1D;CAEA,MAAM,WAAW,QAAQ;CAEzB,IAAI;EACF,WAAW,SAAS,QAAQ,CAAC,CAAC;CAChC,QAAQ,CAER;CACA,IAAI,YACF,WAAW;EACT,OAAO;EACP,SAAS;EACT,OAAO,WAAW,IAAI,WAAW,WAAW;CAC9C,CAAC;CAEH,QAAQ,KACN,uBAAuB,SAAS,IAAI,eAAe,QAAQ,EAAE,IAAI,aAAa,QAAQ,EAAE,EAC1F;CAEA,OAAO;EAAE,MAAM;EAAU;EAAU,MAAM;CAAS;AACpD"}

package/dist/recorder/ffmpeg-utils.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ffmpeg-utils.mjs","names":[],"sources":["../../src/recorder/ffmpeg-utils.ts"],"sourcesContent":["/**\n * Shared FFmpeg utilities — stream-download pipe primitive and constants.\n */\n\nimport { spawn } from \"node:child_process\"\nimport type { WriteStream } from \"node:fs\"\nimport { TikTokError } from \"../config\"\n\n/** Kill FFmpeg if no output is received within this window after spawn. */\nexport const FFMPEG_STARTUP_TIMEOUT = 30_000\n\n/** Standard FFmpeg reconnect + mpegts pipe arguments. */\nconst FFMPEG_BASE_ARGS = [\n  \"-reconnect\",\n  \"1\",\n  \"-reconnect_at_eof\",\n  \"1\",\n  \"-reconnect_streamed\",\n  \"1\",\n  \"-reconnect_delay_max\",\n  \"5\",\n  \"-c\",\n  \"copy\",\n  \"-f\",\n  \"mpegts\",\n  \"pipe:1\",\n]\n\n/**\n * Spawn an FFmpeg process to download from `url` and pipe its stdout to\n * `writer` with backpressure handling.\n *\n * Features:\n * - Transparent HTTP reconnection via FFmpeg `-reconnect` flags\n * - `FFMPEG_STARTUP_TIMEOUT` (30s) startup guard with SIGTERM → SIGKILL\n *   escalation to prevent orphaned processes\n * - Bounded stderr capture (10k chars) for error diagnostics\n * - Automatic cleanup when `signal` fires (uses spawn `signal` option)\n * - AbortError is swallowed — the promise resolves instead of rejecting,\n *   allowing the caller to check `signal.aborted` and react accordingly\n *\n * The caller is responsible for tracking file size via `statSync` — this\n * function deliberately avoids maintaining its own byte counter to prevent\n * divergence between the in-memory count and actual disk writes.\n */\nexport async function pipeFfmpegSegment(\n  ffmpegPath: string,\n  url: string,\n  writer: WriteStream,\n  signal: AbortSignal,\n  maxDuration?: number,\n): Promise<void> {\n  const durationArgs = maxDuration ? [\"-t\", String(maxDuration)] : []\n  const proc = spawn(ffmpegPath, [\"-i\", url, ...durationArgs, ...FFMPEG_BASE_ARGS], {\n    stdio: [\"ignore\", \"pipe\", \"pipe\"],\n    signal,\n  })\n\n  let stderr = \"\"\n  let firstDataTimer: ReturnType<typeof setTimeout> | null = null\n\n  const clearStartupTimer = () => {\n    if (firstDataTimer) {\n      clearTimeout(firstDataTimer)\n      firstDataTimer = null\n    }\n  }\n\n  proc.stderr?.on(\"data\", (chunk: Buffer) => {\n    clearStartupTimer()\n    stderr += chunk.toString()\n    if (stderr.length > 10000) stderr = stderr.slice(-5000)\n  })\n\n  proc.stdout.on(\"data\", (chunk: Buffer) => {\n    clearStartupTimer()\n    const canContinue = writer.write(chunk)\n    if (!canContinue) {\n      proc.stdout.pause()\n      writer.once(\"drain\", () => proc.stdout.resume())\n    }\n  })\n\n  await new Promise<void>((resolve, reject) => {\n    firstDataTimer = setTimeout(() => {\n      if (!proc.killed) {\n        proc.kill(\"SIGTERM\")\n        setTimeout(() => {\n          if (!proc.killed) proc.kill(\"SIGKILL\")\n        }, 2000)\n      }\n      reject(\n        new TikTokError(\n          \"ffmpeg-error\",\n          `FFmpeg startup timed out after ${FFMPEG_STARTUP_TIMEOUT / 1000}s\\n${stderr.slice(-500)}`,\n        ),\n      )\n    }, FFMPEG_STARTUP_TIMEOUT)\n\n    proc.on(\"close\", (code) => {\n      clearStartupTimer()\n      if (signal.aborted) {\n        resolve()\n        return\n      }\n      if (code === 0 || code === null) {\n        resolve()\n        return\n      }\n      reject(\n        new TikTokError(\"ffmpeg-error\", `FFmpeg exited with code ${code}\\n${stderr.slice(-500)}`),\n      )\n    })\n\n    proc.on(\"error\", (err) => {\n      clearStartupTimer()\n      if (err instanceof Error && err.name === \"AbortError\") return\n      reject(err)\n    })\n  })\n}\n"],"mappings":";;;;;;;AASA,MAAa,yBAAyB;;AAGtC,MAAM,mBAAmB;CACvB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;;;;;AAmBA,eAAsB,kBACpB,YACA,KACA,QACA,QACA,aACe;CAEf,MAAM,OAAO,MAAM,YAAY;EAAC;EAAM;EAAK,GADtB,cAAc,CAAC,MAAM,OAAO,WAAW,CAAC,IAAI,CAAC;EACN,GAAG;CAAgB,GAAG;EAChF,OAAO;GAAC;GAAU;GAAQ;EAAM;EAChC;CACF,CAAC;CAED,IAAI,SAAS;CACb,IAAI,iBAAuD;CAE3D,MAAM,0BAA0B;EAC9B,IAAI,gBAAgB;GAClB,aAAa,cAAc;GAC3B,iBAAiB;EACnB;CACF;CAEA,KAAK,QAAQ,GAAG,SAAS,UAAkB;EACzC,kBAAkB;EAClB,UAAU,MAAM,SAAS;EACzB,IAAI,OAAO,SAAS,KAAO,SAAS,OAAO,MAAM,IAAK;CACxD,CAAC;CAED,KAAK,OAAO,GAAG,SAAS,UAAkB;EACxC,kBAAkB;EAElB,IAAI,CADgB,OAAO,MAAM,KAClB,GAAG;GAChB,KAAK,OAAO,MAAM;GAClB,OAAO,KAAK,eAAe,KAAK,OAAO,OAAO,CAAC;EACjD;CACF,CAAC;CAED,MAAM,IAAI,SAAe,SAAS,WAAW;EAC3C,iBAAiB,iBAAiB;GAChC,IAAI,CAAC,KAAK,QAAQ;IAChB,KAAK,KAAK,SAAS;IACnB,iBAAiB;KACf,IAAI,CAAC,KAAK,QAAQ,KAAK,KAAK,SAAS;IACvC,GAAG,GAAI;GACT;GACA,OACE,IAAI,YACF,gBACA,kCAAkC,yBAAyB,IAAK,KAAK,OAAO,MAAM,IAAI,GACxF,CACF;EACF,GAAG,sBAAsB;EAEzB,KAAK,GAAG,UAAU,SAAS;GACzB,kBAAkB;GAClB,IAAI,OAAO,SAAS;IAClB,QAAQ;IACR;GACF;GACA,IAAI,SAAS,KAAK,SAAS,MAAM;IAC/B,QAAQ;IACR;GACF;GACA,OACE,IAAI,YAAY,gBAAgB,2BAA2B,KAAK,IAAI,OAAO,MAAM,IAAI,GAAG,CAC1F;EACF,CAAC;EAED,KAAK,GAAG,UAAU,QAAQ;GACxB,kBAAkB;GAClB,IAAI,eAAe,SAAS,IAAI,SAAS,cAAc;GACvD,OAAO,GAAG;EACZ,CAAC;CACH,CAAC;AACH"}

package/dist/recorder/index.d.mts

@@ -1,7 +0,0 @@
-import { RecorderConfig, RecorderController } from "../config.mjs";
-
-//#region src/recorder/index.d.ts
-declare function createRecorder(config: RecorderConfig): RecorderController;
-//#endregion
-export { createRecorder };
-//# sourceMappingURL=index.d.mts.map

package/dist/recorder/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/recorder/index.ts"],"mappings":";;;iBAqBgB,cAAA,CAAe,MAAA,EAAQ,cAAA,GAAiB,kBAAA"}

package/dist/recorder/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/recorder/index.ts"],"sourcesContent":["/**\n * Recorder orchestrator — wires together the API, monitor, stream downloader,\n * and converter into a single RecorderController.\n */\n\nimport { spawn } from \"node:child_process\"\nimport { createHttpClient } from \"../api/client\"\nimport { createTikTokApi, type TikTokApi } from \"../api/tiktok\"\nimport type { RecorderConfig, RecorderController } from \"../config\"\nimport { normalizeConfig, TikTokError } from \"../config\"\nimport { createLogger } from \"../logger\"\nimport { createPollingMonitor, type PollingMonitor } from \"../monitor\"\nimport { findFfmpegPath, sleep } from \"../utils\"\nimport { type Converter, createConverter } from \"./convert\"\nimport { type AudioNormalizer, createAudioNormalizer } from \"./normalize\"\nimport { processRecording } from \"./post-processing\"\nimport { createEventEmitter } from \"./recorder-events\"\nimport { createRecorderState } from \"./recorder-state\"\nimport type { DownloadResult } from \"./stream\"\nimport { createStreamDownloader, type StreamDownloader } from \"./stream\"\n\nexport function createRecorder(config: RecorderConfig): RecorderController {\n  const cfg = normalizeConfig(config)\n  const logger = createLogger({\n    level: cfg.logLevel,\n    logFile: \"tiktok-recorder.log\",\n    console: cfg.logConsole,\n  })\n\n  const emitter = createEventEmitter()\n  const stateManager = createRecorderState({ state: \"idle\" as const, user: cfg.user }, logger)\n\n  // State variables\n  let httpClient: Awaited<ReturnType<typeof createHttpClient>> | null = null\n  let api: TikTokApi | null = null\n  let monitor: PollingMonitor | null = null\n  let downloader: StreamDownloader | null = null\n  let converter: Converter | null = null\n  let audioNormalizer: AudioNormalizer | null = null\n  let stopRequested = false\n  let stopAbortController = new AbortController()\n  let pendingRemuxes: Promise<unknown>[] = []\n\n  function runFfmpeg(args: string[], signal?: AbortSignal): Promise<void> {\n    return new Promise((resolve, reject) => {\n      const ffmpegPath = findFfmpegPath()\n      if (!ffmpegPath) {\n        reject(\n          new TikTokError(\n            \"ffmpeg-not-found\",\n            \"FFmpeg not found. Install it:\\n  Linux: apt install ffmpeg\\n  macOS: brew install ffmpeg\",\n          ),\n        )\n        return\n      }\n      const proc = spawn(ffmpegPath, args, {\n        stdio: [\"ignore\", \"pipe\", \"pipe\"],\n        signal,\n      })\n\n      let stderr = \"\"\n      proc.stderr?.on(\"data\", (chunk: Buffer) => {\n        stderr += chunk.toString()\n        if (stderr.length > 10000) stderr = stderr.slice(-5000)\n      })\n\n      proc.on(\"close\", (code) => {\n        if (signal?.aborted) {\n          reject(new TikTokError(\"unknown\", \"Aborted by user\"))\n          return\n        }\n        if (code === 0) {\n          resolve()\n        } else {\n          reject(\n            new TikTokError(\"unknown\", `FFmpeg exited with code ${code}\\n${stderr.slice(-500)}`),\n          )\n        }\n      })\n\n      proc.on(\"error\", (err) => {\n        if (err instanceof Error && err.name === \"AbortError\") return\n        reject(new TikTokError(\"unknown\", `Failed to spawn FFmpeg: ${err.message}`))\n      })\n    })\n  }\n\n  async function start(): Promise<void> {\n    if (stateManager.getStatus().state !== \"idle\") {\n      logger.warn(`start() ignored: already in state ${stateManager.getStatus().state}`)\n      return\n    }\n    stopRequested = false\n    pendingRemuxes = []\n    stopAbortController = new AbortController()\n\n    logger.info(`Starting recorder for @${cfg.user}`)\n    httpClient = await createHttpClient(cfg)\n    api = createTikTokApi(httpClient, logger, cfg.debug)\n    downloader = createStreamDownloader(logger)\n    converter = createConverter(logger, stopAbortController.signal)\n    audioNormalizer = cfg.normalizeAudio\n      ? createAudioNormalizer(\n          {\n            loudness: cfg.normalizeLoudness,\n            audioCodec: cfg.normalizeCodec,\n            audioBitrate: cfg.normalizeBitrate,\n            onStart: (file) => emitter.emit(\"normalize:start\", { file }),\n            onProgress: (file, percent, phase) =>\n              emitter.emit(\"normalize:progress\", {\n                file,\n                percent,\n                phase: phase as \"analyzing\" | \"normalizing\",\n              }),\n            onComplete: (result) =>\n              emitter.emit(\"normalize:end\", { input: result.input, output: result.output }),\n            onError: (file, err) =>\n              emitter.emit(\"normalize:error\", { input: file, error: err.message }),\n          },\n          logger,\n        )\n      : null\n\n    monitor = createPollingMonitor({\n      intervalMinutes: cfg.interval,\n      logger,\n      onTick: async () => {\n        if (stopRequested) return\n\n        // All dependencies are initialized by start() before onTick runs\n        const tikTokApi = api as TikTokApi\n        const streamDownloader = downloader as StreamDownloader\n        const pollingMonitor = monitor as PollingMonitor\n\n        const user = cfg.user\n        tikTokApi.invalidateCache()\n\n        emitter.emit(\"checking\", { user })\n        logger.info(`Checking @${user}...`)\n\n        const roomId = await tikTokApi.getRoomId(user)\n        if (!roomId) {\n          logger.info(`@${user} is offline`)\n          emitter.emit(\"tick\", { user, isLive: false })\n          return\n        }\n\n        const liveUrl = await tikTokApi.getLiveUrl(roomId)\n        if (!liveUrl) {\n          logger.warn(`@${user} is live but no stream URL found`)\n          emitter.emit(\"tick\", { user, isLive: false, roomId })\n          return\n        }\n\n        logger.info(`@${user} is LIVE! (room: ${roomId})`)\n        emitter.emit(\"tick\", { user, isLive: true, roomId })\n\n        stateManager.setState({ state: \"recording\" })\n        emitter.emit(\"recording:start\", { user, file: \"\" })\n\n        const getNextUrl = async (): Promise<string | null> => {\n          // Use the lightweight check_alive endpoint first — avoids a full\n          // page re-scan + room/info call when the stream is still active.\n          const alive = await tikTokApi.isRoomAlive(roomId)\n          if (!alive) {\n            logger.info(`@${user} is no longer live — stopping`)\n            return null\n          }\n          // Still alive — invalidate cache and get a fresh stream URL.\n          tikTokApi.invalidateCache()\n          return tikTokApi.getLiveUrl(roomId)\n        }\n\n        const result = await streamDownloader.download(\n          liveUrl,\n          user,\n          cfg.outputDir,\n          cfg.duration,\n          (info) => emitter.emit(\"download:progress\", info),\n          getNextUrl,\n        )\n\n        emitter.emit(\"download:end\", {\n          file: result.file,\n          duration: result.duration,\n          size: result.size,\n        })\n\n        await processRecording(result as DownloadResult, cfg, {\n          runFfmpeg,\n          converter: converter as Converter,\n          audioNormalizer,\n          stopAbortController,\n          pendingRemuxes,\n          emit: (emitter.emit as (event: string, ...args: unknown[]) => void).bind(emitter),\n          setState: stateManager.setState,\n          stopRequested: () => stopRequested,\n          logger,\n        })\n\n        // One-shot mode: if a duration was set, stop after this recording\n        if (cfg.duration > 0) {\n          logger.info(\"Duration limit reached — exiting\")\n          pollingMonitor.stopAfterCurrentTick()\n        } else if (!stopRequested && roomId) {\n          // Recording ended because the stream went offline (not user-initiated stop).\n          // Immediately re-check via lightweight check_alive endpoint instead of\n          // waiting for the next poll interval.\n          const alive = await tikTokApi.isRoomAlive(roomId)\n          if (!alive) {\n            logger.info(`@${user} is offline`)\n            emitter.emit(\"tick\", { user, isLive: false })\n          }\n        }\n      },\n    })\n\n    stateManager.setState({ state: \"polling\" })\n    await monitor.start()\n  }\n\n  async function stop(): Promise<void> {\n    if (stateManager.getStatus().state === \"stopped\") {\n      logger.warn(`stop() ignored: already stopped`)\n      return\n    }\n    stopRequested = true\n    logger.info(\"Stopping recorder...\")\n\n    if (pendingRemuxes.length > 0) {\n      logger.info(`Waiting for ${pendingRemuxes.length} pending conversion(s) (max 60s)...`)\n      const abortTimeout = new AbortController()\n      await Promise.race([\n        Promise.allSettled(pendingRemuxes).finally(() => abortTimeout.abort()),\n        sleep(60_000, abortTimeout.signal),\n      ])\n      pendingRemuxes = []\n    }\n\n    if (downloader) downloader.abort()\n    if (monitor) await monitor.stop()\n    stopAbortController.abort()\n    if (httpClient) await httpClient.close()\n    emitter.clear()\n    stateManager.setState({ state: \"stopped\" })\n    logger.info(\"Recorder stopped\")\n  }\n\n  return {\n    start,\n    stop,\n    getStatus: stateManager.getStatus,\n    on: emitter.on,\n    off: emitter.off,\n  }\n}\n"],"mappings":"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"}

package/dist/recorder/normalize.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"normalize.mjs","names":[],"sources":["../../src/recorder/normalize.ts"],"sourcesContent":["/**\n * Audio normalizer — wraps peaknorm's EBU R128 loudness normalization.\n * Runs after conversion/segmenting to normalize the final MP4 audio.\n */\n\nimport type { NormalizeOptions, NormalizeResult } from \"peaknorm\"\nimport { normalizeFile } from \"peaknorm\"\nimport type { Logger } from \"../logger\"\n\nexport interface AudioNormalizer {\n  /** Normalize a single audio/video file. Returns the normalize result. */\n  normalize(file: string): Promise<NormalizeResult>\n}\n\nexport interface AudioNormalizerOptions {\n  /** Target loudness in LUFS (default: -14). */\n  loudness: number\n  /** Audio codec for output (default: peaknorm's default, \"libopus\"). */\n  audioCodec?: string\n  /** Audio bitrate for output (default: peaknorm's default, \"96k\"). */\n  audioBitrate?: string\n  /** Called when a file starts normalization. */\n  onStart?: (file: string) => void\n  /** Called with progress updates (percent 0-100, phase \"analyzing\"|\"normalizing\"). */\n  onProgress?: (file: string, percent: number, phase: string) => void\n  /** Called when a file completes normalization successfully. */\n  onComplete?: (result: NormalizeResult) => void\n  /** Called when a file errors during normalization. */\n  onError?: (file: string, error: Error) => void\n}\n\nexport function createAudioNormalizer(\n  opts: AudioNormalizerOptions,\n  logger?: Logger,\n): AudioNormalizer {\n  return {\n    async normalize(file: string): Promise<NormalizeResult> {\n      logger?.info(`Normalizing audio: ${file}`)\n      opts.onStart?.(file)\n\n      try {\n        const normalizeOpts: NormalizeOptions = {\n          loudness: opts.loudness,\n          backup: false,\n          onFileProgress: (f, percent, phase) => {\n            opts.onProgress?.(f, percent, phase)\n          },\n        }\n        if (opts.audioCodec !== undefined) normalizeOpts.audioCodec = opts.audioCodec\n        if (opts.audioBitrate !== undefined) normalizeOpts.audioBitrate = opts.audioBitrate\n        const result = await normalizeFile(file, normalizeOpts)\n\n        logger?.info(`Audio normalized: ${result.output}`)\n        opts.onComplete?.(result)\n        return result\n      } catch (err) {\n        const error = err instanceof Error ? err : new Error(String(err))\n        logger?.error(`Audio normalization failed: ${error.message}`)\n        opts.onError?.(file, error)\n        throw error\n      }\n    },\n  }\n}\n"],"mappings":";;AA+BA,SAAgB,sBACd,MACA,QACiB;CACjB,OAAO,EACL,MAAM,UAAU,MAAwC;EACtD,QAAQ,KAAK,sBAAsB,MAAM;EACzC,KAAK,UAAU,IAAI;EAEnB,IAAI;GACF,MAAM,gBAAkC;IACtC,UAAU,KAAK;IACf,QAAQ;IACR,iBAAiB,GAAG,SAAS,UAAU;KACrC,KAAK,aAAa,GAAG,SAAS,KAAK;IACrC;GACF;GACA,IAAI,KAAK,eAAe,KAAA,GAAW,cAAc,aAAa,KAAK;GACnE,IAAI,KAAK,iBAAiB,KAAA,GAAW,cAAc,eAAe,KAAK;GACvE,MAAM,SAAS,MAAM,cAAc,MAAM,aAAa;GAEtD,QAAQ,KAAK,qBAAqB,OAAO,QAAQ;GACjD,KAAK,aAAa,MAAM;GACxB,OAAO;EACT,SAAS,KAAK;GACZ,MAAM,QAAQ,eAAe,QAAQ,MAAM,IAAI,MAAM,OAAO,GAAG,CAAC;GAChE,QAAQ,MAAM,+BAA+B,MAAM,SAAS;GAC5D,KAAK,UAAU,MAAM,KAAK;GAC1B,MAAM;EACR;CACF,EACF;AACF"}

package/dist/recorder/post-processing.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"post-processing.mjs","names":[],"sources":["../../src/recorder/post-processing.ts"],"sourcesContent":["/**\n * Post-recording processing — segmenting, conversion, and audio normalization.\n *\n * After a stream download completes, this module handles:\n * - Splitting the downloaded file into timed MP4 segments\n * - Converting TS to MP4 (fallback or direct)\n * - Audio normalization via EBU R128\n * - File management (deleting originals, setting timestamps)\n * - Event emissions for each step\n */\n\nimport { readdirSync, statSync, unlinkSync, utimesSync } from \"node:fs\"\nimport { join, parse } from \"node:path\"\nimport type { RecorderConfig } from \"../config\"\nimport { TikTokError } from \"../config\"\nimport type { Logger } from \"../logger\"\nimport type { Converter } from \"./convert\"\nimport type { AudioNormalizer } from \"./normalize\"\nimport type { DownloadResult } from \"./stream\"\n\nexport interface ProcessingDeps {\n  runFfmpeg: (args: string[], signal?: AbortSignal) => Promise<void>\n  converter: Converter\n  audioNormalizer: AudioNormalizer | null\n  stopAbortController: AbortController\n  pendingRemuxes: Promise<unknown>[]\n  emit: (event: string, ...args: unknown[]) => void\n  setState: (partial: Record<string, unknown>) => void\n  stopRequested: () => boolean\n  logger: Logger\n}\n\nexport async function processRecording(\n  result: DownloadResult,\n  cfg: RecorderConfig,\n  deps: ProcessingDeps,\n): Promise<void> {\n  try {\n    if (statSync(result.file).size === 0) return\n  } catch {\n    return // file doesn't exist or can't be accessed\n  }\n\n  deps.setState({ state: \"converting\" })\n\n  if (cfg.segmentMinutes && cfg.segmentMinutes >= 1) {\n    await processSegmenting(result, cfg, deps)\n  } else {\n    await processConversion(result, cfg, deps)\n  }\n\n  deps.setState({ state: \"polling\" })\n}\n\n// ─── Segmenting path ──────────────────────────────────────────────\n\nasync function processSegmenting(\n  result: DownloadResult,\n  cfg: RecorderConfig,\n  deps: ProcessingDeps,\n): Promise<void> {\n  const parsed = parse(result.file)\n  const segmentTime = Math.max(1, (cfg.segmentMinutes ?? 20) * 60)\n  const outputPattern = join(parsed.dir, `${parsed.name}_part%d.mp4`)\n\n  deps.logger.info(\n    `Segmenting: ${parsed.base} → ${parsed.name}_partN.mp4 (${cfg.segmentMinutes ?? 20} min each)`,\n  )\n  deps.emit(\"segmenting:start\", { input: result.file, outputPattern })\n\n  try {\n    const segmentPromise = deps.runFfmpeg(\n      [\n        \"-i\",\n        result.file,\n        \"-c\",\n        \"copy\",\n        \"-f\",\n        \"segment\",\n        \"-segment_time\",\n        String(segmentTime),\n        \"-reset_timestamps\",\n        \"1\",\n        \"-segment_start_number\",\n        \"1\",\n        outputPattern,\n      ],\n      deps.stopAbortController.signal,\n    )\n    deps.pendingRemuxes.push(segmentPromise)\n    await segmentPromise\n\n    // Capture file timestamp before deletion\n    const fileMtimeMs = statSync(result.file).mtimeMs\n    const recStartMs = fileMtimeMs - (result.duration ?? 0) * 1000\n\n    // Delete the original TS\n    try {\n      unlinkSync(result.file)\n      deps.logger.info(`Deleted original: ${parsed.base}`)\n    } catch {\n      deps.logger.warn(`Could not delete original: ${parsed.base}`)\n    }\n\n    // Find generated segment files\n    const allFiles = readdirSync(parsed.dir)\n    const prefix = `${parsed.name}_part`\n    const segmentFiles = allFiles\n      .filter((f) => f.startsWith(prefix) && f.endsWith(\".mp4\"))\n      .sort((a, b) => {\n        const na = Number.parseInt(a.match(/_part(\\d+)\\.mp4$/)?.[1] ?? \"0\", 10)\n        const nb = Number.parseInt(b.match(/_part(\\d+)\\.mp4$/)?.[1] ?? \"0\", 10)\n        return na - nb\n      })\n\n    const segmentDurationSec = segmentTime\n    const totalDuration = result.duration\n\n    // Emit events for each segment\n    for (let i = 0; i < segmentFiles.length; i++) {\n      const filePath = join(parsed.dir, segmentFiles[i] as string)\n      const stats = statSync(filePath)\n      const isLast = i === segmentFiles.length - 1\n      const estDuration = isLast\n        ? Math.max(0, totalDuration - segmentDurationSec * (segmentFiles.length - 1))\n        : segmentDurationSec\n\n      deps.emit(\"recording:end\", { file: filePath, duration: estDuration, size: stats.size })\n      deps.emit(\"converted\", { input: result.file, output: filePath })\n    }\n\n    // Set file modification times so segments sort chronologically\n    for (let i = 0; i < segmentFiles.length; i++) {\n      const fp = join(parsed.dir, segmentFiles[i] as string)\n      const segStart = recStartMs + i * segmentDurationSec * 1000\n      utimesSync(fp, new Date(segStart), new Date(segStart))\n    }\n\n    deps.emit(\"segmenting:end\", { segments: segmentFiles.length })\n\n    // Normalize audio for each segment if enabled\n    if (deps.audioNormalizer) {\n      const normalizer = deps.audioNormalizer\n      const normalizePromises = segmentFiles.map(async (segFile) => {\n        const segPath = join(parsed.dir, segFile)\n        try {\n          await normalizer.normalize(segPath)\n        } catch {\n          // Error already emitted via onError callback\n        }\n      })\n      deps.pendingRemuxes.push(...normalizePromises)\n      await Promise.allSettled(normalizePromises)\n    }\n\n    deps.setState({\n      currentFile:\n        segmentFiles.length > 0 ? join(parsed.dir, segmentFiles.at(-1) as string) : result.file,\n      sessionDuration: result.duration,\n    })\n  } catch (err) {\n    if (deps.stopRequested()) return\n    const msg = err instanceof Error ? err.message : String(err)\n    deps.logger.error(`Segmenting failed: ${msg}`)\n    deps.setState({ lastError: `Segmenting failed: ${msg}` })\n    // Fallback: try simple conversion of the whole TS\n    await runFallbackConversion(result, deps)\n  }\n}\n\n// ─── Shared converter helper ────────────────────────────────────\n\n/**\n * Convert a downloaded file to MP4 and optionally normalize audio.\n * Shared by the direct conversion and fallback paths.\n *\n * @param emitRecordingEnd  When true, also emit a `recording:end` event\n *   (used by the direct conversion path; the segmenting path emits its\n *   own `recording:end` events per segment).\n */\nasync function convertFile(\n  result: DownloadResult,\n  deps: ProcessingDeps,\n  emitRecordingEnd?: boolean,\n): Promise<void> {\n  deps.emit(\"converting:start\", { input: result.file })\n  try {\n    const convertPromise = deps.converter.convert(result.file)\n    deps.pendingRemuxes.push(convertPromise)\n    const mp4File = await convertPromise\n\n    if (deps.audioNormalizer) {\n      const normalizePromise = deps.audioNormalizer.normalize(mp4File).catch(() => {})\n      deps.pendingRemuxes.push(normalizePromise)\n      await normalizePromise\n    }\n\n    if (emitRecordingEnd) {\n      deps.emit(\"recording:end\", { file: mp4File, duration: result.duration, size: result.size })\n    }\n    deps.emit(\"converted\", { input: result.file, output: mp4File })\n  } catch (convErr) {\n    const tkErr =\n      convErr instanceof TikTokError ? convErr : new TikTokError(\"unknown\", String(convErr))\n    deps.logger.error(`Conversion failed: ${tkErr.message}`)\n    deps.setState({ lastError: `Conversion failed: ${tkErr.message}` })\n    deps.emit(\"error\", tkErr)\n  }\n}\n\n// ─── Conversion path (no segmenting) ─────────────────────────────\n\nasync function processConversion(\n  result: DownloadResult,\n  _cfg: RecorderConfig,\n  deps: ProcessingDeps,\n): Promise<void> {\n  return convertFile(result, deps, true)\n}\n\n// ─── Fallback conversion (when segmenting fails) ─────────────────\n\nasync function runFallbackConversion(result: DownloadResult, deps: ProcessingDeps): Promise<void> {\n  return convertFile(result, deps)\n}\n"],"mappings":";;;;;;;;;;;;;;AAgCA,eAAsB,iBACpB,QACA,KACA,MACe;CACf,IAAI;EACF,IAAI,SAAS,OAAO,IAAI,CAAC,CAAC,SAAS,GAAG;CACxC,QAAQ;EACN;CACF;CAEA,KAAK,SAAS,EAAE,OAAO,aAAa,CAAC;CAErC,IAAI,IAAI,kBAAkB,IAAI,kBAAkB,GAC9C,MAAM,kBAAkB,QAAQ,KAAK,IAAI;MAEzC,MAAM,kBAAkB,QAAQ,KAAK,IAAI;CAG3C,KAAK,SAAS,EAAE,OAAO,UAAU,CAAC;AACpC;AAIA,eAAe,kBACb,QACA,KACA,MACe;CACf,MAAM,SAAS,MAAM,OAAO,IAAI;CAChC,MAAM,cAAc,KAAK,IAAI,IAAI,IAAI,kBAAkB,MAAM,EAAE;CAC/D,MAAM,gBAAgB,KAAK,OAAO,KAAK,GAAG,OAAO,KAAK,YAAY;CAElE,KAAK,OAAO,KACV,eAAe,OAAO,KAAK,KAAK,OAAO,KAAK,cAAc,IAAI,kBAAkB,GAAG,WACrF;CACA,KAAK,KAAK,oBAAoB;EAAE,OAAO,OAAO;EAAM;CAAc,CAAC;CAEnE,IAAI;EACF,MAAM,iBAAiB,KAAK,UAC1B;GACE;GACA,OAAO;GACP;GACA;GACA;GACA;GACA;GACA,OAAO,WAAW;GAClB;GACA;GACA;GACA;GACA;EACF,GACA,KAAK,oBAAoB,MAC3B;EACA,KAAK,eAAe,KAAK,cAAc;EACvC,MAAM;EAIN,MAAM,aADc,SAAS,OAAO,IAAI,CAAC,CAAC,WACR,OAAO,YAAY,KAAK;EAG1D,IAAI;GACF,WAAW,OAAO,IAAI;GACtB,KAAK,OAAO,KAAK,qBAAqB,OAAO,MAAM;EACrD,QAAQ;GACN,KAAK,OAAO,KAAK,8BAA8B,OAAO,MAAM;EAC9D;EAGA,MAAM,WAAW,YAAY,OAAO,GAAG;EACvC,MAAM,SAAS,GAAG,OAAO,KAAK;EAC9B,MAAM,eAAe,SAClB,QAAQ,MAAM,EAAE,WAAW,MAAM,KAAK,EAAE,SAAS,MAAM,CAAC,CAAC,CACzD,MAAM,GAAG,MAAM;GAGd,OAFW,OAAO,SAAS,EAAE,MAAM,kBAAkB,CAAC,GAAG,MAAM,KAAK,EAE5D,IADG,OAAO,SAAS,EAAE,MAAM,kBAAkB,CAAC,GAAG,MAAM,KAAK,EACvD;EACf,CAAC;EAEH,MAAM,qBAAqB;EAC3B,MAAM,gBAAgB,OAAO;EAG7B,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;GAC5C,MAAM,WAAW,KAAK,OAAO,KAAK,aAAa,EAAY;GAC3D,MAAM,QAAQ,SAAS,QAAQ;GAE/B,MAAM,cADS,MAAM,aAAa,SAAS,IAEvC,KAAK,IAAI,GAAG,gBAAgB,sBAAsB,aAAa,SAAS,EAAE,IAC1E;GAEJ,KAAK,KAAK,iBAAiB;IAAE,MAAM;IAAU,UAAU;IAAa,MAAM,MAAM;GAAK,CAAC;GACtF,KAAK,KAAK,aAAa;IAAE,OAAO,OAAO;IAAM,QAAQ;GAAS,CAAC;EACjE;EAGA,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;GAC5C,MAAM,KAAK,KAAK,OAAO,KAAK,aAAa,EAAY;GACrD,MAAM,WAAW,aAAa,IAAI,qBAAqB;GACvD,WAAW,IAAI,IAAI,KAAK,QAAQ,GAAG,IAAI,KAAK,QAAQ,CAAC;EACvD;EAEA,KAAK,KAAK,kBAAkB,EAAE,UAAU,aAAa,OAAO,CAAC;EAG7D,IAAI,KAAK,iBAAiB;GACxB,MAAM,aAAa,KAAK;GACxB,MAAM,oBAAoB,aAAa,IAAI,OAAO,YAAY;IAC5D,MAAM,UAAU,KAAK,OAAO,KAAK,OAAO;IACxC,IAAI;KACF,MAAM,WAAW,UAAU,OAAO;IACpC,QAAQ,CAER;GACF,CAAC;GACD,KAAK,eAAe,KAAK,GAAG,iBAAiB;GAC7C,MAAM,QAAQ,WAAW,iBAAiB;EAC5C;EAEA,KAAK,SAAS;GACZ,aACE,aAAa,SAAS,IAAI,KAAK,OAAO,KAAK,aAAa,GAAG,EAAE,CAAW,IAAI,OAAO;GACrF,iBAAiB,OAAO;EAC1B,CAAC;CACH,SAAS,KAAK;EACZ,IAAI,KAAK,cAAc,GAAG;EAC1B,MAAM,MAAM,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;EAC3D,KAAK,OAAO,MAAM,sBAAsB,KAAK;EAC7C,KAAK,SAAS,EAAE,WAAW,sBAAsB,MAAM,CAAC;EAExD,MAAM,sBAAsB,QAAQ,IAAI;CAC1C;AACF;;;;;;;;;AAYA,eAAe,YACb,QACA,MACA,kBACe;CACf,KAAK,KAAK,oBAAoB,EAAE,OAAO,OAAO,KAAK,CAAC;CACpD,IAAI;EACF,MAAM,iBAAiB,KAAK,UAAU,QAAQ,OAAO,IAAI;EACzD,KAAK,eAAe,KAAK,cAAc;EACvC,MAAM,UAAU,MAAM;EAEtB,IAAI,KAAK,iBAAiB;GACxB,MAAM,mBAAmB,KAAK,gBAAgB,UAAU,OAAO,CAAC,CAAC,YAAY,CAAC,CAAC;GAC/E,KAAK,eAAe,KAAK,gBAAgB;GACzC,MAAM;EACR;EAEA,IAAI,kBACF,KAAK,KAAK,iBAAiB;GAAE,MAAM;GAAS,UAAU,OAAO;GAAU,MAAM,OAAO;EAAK,CAAC;EAE5F,KAAK,KAAK,aAAa;GAAE,OAAO,OAAO;GAAM,QAAQ;EAAQ,CAAC;CAChE,SAAS,SAAS;EAChB,MAAM,QACJ,mBAAmB,cAAc,UAAU,IAAI,YAAY,WAAW,OAAO,OAAO,CAAC;EACvF,KAAK,OAAO,MAAM,sBAAsB,MAAM,SAAS;EACvD,KAAK,SAAS,EAAE,WAAW,sBAAsB,MAAM,UAAU,CAAC;EAClE,KAAK,KAAK,SAAS,KAAK;CAC1B;AACF;AAIA,eAAe,kBACb,QACA,MACA,MACe;CACf,OAAO,YAAY,QAAQ,MAAM,IAAI;AACvC;AAIA,eAAe,sBAAsB,QAAwB,MAAqC;CAChG,OAAO,YAAY,QAAQ,IAAI;AACjC"}

package/dist/recorder/recorder-events.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"recorder-events.mjs","names":[],"sources":["../../src/recorder/recorder-events.ts"],"sourcesContent":["/**\n * Typed event emitter for recorder lifecycle events.\n */\n\nimport type { RecorderEvent, RecorderEventHandler } from \"../config\"\n\nexport interface RecorderEventEmitter {\n  on<E extends RecorderEvent>(event: E, handler: RecorderEventHandler[E]): void\n  off<E extends RecorderEvent>(event: E, handler: RecorderEventHandler[E]): void\n  emit<E extends RecorderEvent>(event: E, ...args: Parameters<RecorderEventHandler[E]>): void\n  clear(): void\n}\n\nexport function createEventEmitter(): RecorderEventEmitter {\n  const handlers = new Map<string, Array<(...args: unknown[]) => void>>()\n\n  function on<E extends RecorderEvent>(event: E, handler: RecorderEventHandler[E]): void {\n    const list = handlers.get(event) ?? []\n    list.push(handler as (...args: unknown[]) => void)\n    handlers.set(event, list)\n  }\n\n  function off<E extends RecorderEvent>(event: E, handler: RecorderEventHandler[E]): void {\n    const list = handlers.get(event)\n    if (!list) return\n    const idx = list.indexOf(handler as (...args: unknown[]) => void)\n    if (idx !== -1) list.splice(idx, 1)\n  }\n\n  function emit<E extends RecorderEvent>(\n    event: E,\n    ...args: Parameters<RecorderEventHandler[E]>\n  ): void {\n    const list = handlers.get(event)\n    if (list) {\n      for (const h of list) {\n        try {\n          h(...args)\n        } catch {\n          // Never let an event handler crash the recorder\n        }\n      }\n    }\n  }\n\n  function clear(): void {\n    handlers.clear()\n  }\n\n  return { on, off, emit, clear }\n}\n"],"mappings":";AAaA,SAAgB,qBAA2C;CACzD,MAAM,2BAAW,IAAI,IAAiD;CAEtE,SAAS,GAA4B,OAAU,SAAwC;EACrF,MAAM,OAAO,SAAS,IAAI,KAAK,KAAK,CAAC;EACrC,KAAK,KAAK,OAAuC;EACjD,SAAS,IAAI,OAAO,IAAI;CAC1B;CAEA,SAAS,IAA6B,OAAU,SAAwC;EACtF,MAAM,OAAO,SAAS,IAAI,KAAK;EAC/B,IAAI,CAAC,MAAM;EACX,MAAM,MAAM,KAAK,QAAQ,OAAuC;EAChE,IAAI,QAAQ,IAAI,KAAK,OAAO,KAAK,CAAC;CACpC;CAEA,SAAS,KACP,OACA,GAAG,MACG;EACN,MAAM,OAAO,SAAS,IAAI,KAAK;EAC/B,IAAI,MACF,KAAK,MAAM,KAAK,MACd,IAAI;GACF,EAAE,GAAG,IAAI;EACX,QAAQ,CAER;CAGN;CAEA,SAAS,QAAc;EACrB,SAAS,MAAM;CACjB;CAEA,OAAO;EAAE;EAAI;EAAK;EAAM;CAAM;AAChC"}

package/dist/recorder/recorder-state.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"recorder-state.mjs","names":[],"sources":["../../src/recorder/recorder-state.ts"],"sourcesContent":["/**\n * State machine for the recorder lifecycle.\n */\n\nimport type { RecorderStatus } from \"../config\"\nimport type { Logger } from \"../logger\"\n\n// Valid state transitions: [from] → [to, to, ...]\nconst TRANSITIONS: Record<string, string[]> = {\n  idle: [\"polling\"],\n  polling: [\"recording\", \"stopped\"],\n  recording: [\"converting\", \"stopped\"],\n  converting: [\"polling\", \"stopped\"],\n  stopped: [],\n}\n\nexport interface RecorderStateManager {\n  setState(partial: Partial<RecorderStatus>): void\n  getStatus(): RecorderStatus\n}\n\nexport function createRecorderState(initial: RecorderStatus, logger: Logger): RecorderStateManager {\n  let state: RecorderStatus = { ...initial }\n\n  function setState(partial: Partial<RecorderStatus>): void {\n    const prevState = state.state\n    const newState = partial.state\n\n    // Validate state transitions\n    if (newState && newState !== prevState) {\n      const allowed = TRANSITIONS[prevState]\n      if (!allowed?.includes(newState)) {\n        logger.error(`Invalid state transition: ${prevState} → ${newState} (ignored)`)\n        return\n      }\n      logger.info(`State: ${prevState} → ${newState}`)\n    }\n\n    state = { ...state, ...partial }\n\n    // Auto-track timestamps on state entry\n    if (newState === \"polling\" && newState !== prevState) {\n      state.lastPollTime = new Date().toISOString()\n    }\n  }\n\n  function getStatus(): RecorderStatus {\n    return { ...state }\n  }\n\n  return { setState, getStatus }\n}\n"],"mappings":";AAQA,MAAM,cAAwC;CAC5C,MAAM,CAAC,SAAS;CAChB,SAAS,CAAC,aAAa,SAAS;CAChC,WAAW,CAAC,cAAc,SAAS;CACnC,YAAY,CAAC,WAAW,SAAS;CACjC,SAAS,CAAC;AACZ;AAOA,SAAgB,oBAAoB,SAAyB,QAAsC;CACjG,IAAI,QAAwB,EAAE,GAAG,QAAQ;CAEzC,SAAS,SAAS,SAAwC;EACxD,MAAM,YAAY,MAAM;EACxB,MAAM,WAAW,QAAQ;EAGzB,IAAI,YAAY,aAAa,WAAW;GAEtC,IAAI,CADY,YAAY,UAChB,EAAE,SAAS,QAAQ,GAAG;IAChC,OAAO,MAAM,6BAA6B,UAAU,KAAK,SAAS,WAAW;IAC7E;GACF;GACA,OAAO,KAAK,UAAU,UAAU,KAAK,UAAU;EACjD;EAEA,QAAQ;GAAE,GAAG;GAAO,GAAG;EAAQ;EAG/B,IAAI,aAAa,aAAa,aAAa,WACzC,MAAM,gCAAe,IAAI,KAAK,EAAA,CAAE,YAAY;CAEhD;CAEA,SAAS,YAA4B;EACnC,OAAO,EAAE,GAAG,MAAM;CACpB;CAEA,OAAO;EAAE;EAAU;CAAU;AAC/B"}

package/dist/recorder/stream.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"stream.mjs","names":[],"sources":["../../src/recorder/stream.ts"],"sourcesContent":["/**\n * Stream downloader — downloads a live stream to disk using FFmpeg.\n *\n * Both FLV and HLS streams are downloaded via FFmpeg subprocess with\n * transparent reconnection for transient network drops. Routes to the\n * appropriate downloader based on URL format.\n */\n\nimport type { Logger } from \"../logger\"\nimport { ensureDir } from \"../utils\"\nimport { downloadStream } from \"./download\"\n\nexport interface ProgressInfo {\n  bytes: number\n  elapsed: number\n  speed: number\n}\n\nexport interface DownloadResult {\n  file: string\n  duration: number\n  size: number\n}\n\nexport interface StreamDownloader {\n  /** Download a live stream. Resolves when the stream ends or is aborted. */\n  download: (\n    liveUrl: string,\n    user: string,\n    outputDir: string,\n    maxDuration?: number,\n    onProgress?: (info: ProgressInfo) => void,\n    /** Called when a stream segment ends and we attempt to fetch a fresh URL. */\n    getNextUrl?: () => Promise<string | null>,\n  ) => Promise<DownloadResult>\n  /** Abort an active download */\n  abort: () => void\n}\n\nexport function createStreamDownloader(logger?: Logger): StreamDownloader {\n  let abortController = new AbortController()\n\n  function abort(): void {\n    abortController.abort()\n  }\n\n  function isHlsUrl(url: string): boolean {\n    return url.includes(\".m3u8\")\n  }\n\n  async function download(\n    liveUrl: string,\n    user: string,\n    outputDir: string,\n    maxDuration = 0,\n    onProgress?: (info: ProgressInfo) => void,\n    getNextUrl?: () => Promise<string | null>,\n  ): Promise<DownloadResult> {\n    abortController = new AbortController()\n    ensureDir(outputDir)\n\n    return downloadStream(\n      liveUrl,\n      user,\n      outputDir,\n      maxDuration,\n      onProgress,\n      getNextUrl,\n      abortController.signal,\n      logger,\n      isHlsUrl(liveUrl) ? \"HLS\" : undefined,\n    )\n  }\n\n  return { download, abort }\n}\n"],"mappings":";;;AAuCA,SAAgB,uBAAuB,QAAmC;CACxE,IAAI,kBAAkB,IAAI,gBAAgB;CAE1C,SAAS,QAAc;EACrB,gBAAgB,MAAM;CACxB;CAEA,SAAS,SAAS,KAAsB;EACtC,OAAO,IAAI,SAAS,OAAO;CAC7B;CAEA,eAAe,SACb,SACA,MACA,WACA,cAAc,GACd,YACA,YACyB;EACzB,kBAAkB,IAAI,gBAAgB;EACtC,UAAU,SAAS;EAEnB,OAAO,eACL,SACA,MACA,WACA,aACA,YACA,YACA,gBAAgB,QAChB,QACA,SAAS,OAAO,IAAI,QAAQ,KAAA,CAC9B;CACF;CAEA,OAAO;EAAE;EAAU;CAAM;AAC3B"}

package/dist/ui.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ui.mjs","names":[],"sources":["../src/ui.ts"],"sourcesContent":["/**\n * Terminal Display Manager — beautiful console output using koko-cli's\n * spinner, icons, and color utilities.\n *\n * This module owns the terminal and should be the only thing writing to\n * stdout/stderr (the file logger handles persistent logs).\n */\n\nimport type { SpinnerInstance } from \"@zfadhli/koko-cli\"\nimport { color, createSpinner } from \"@zfadhli/koko-cli\"\nimport { formatDuration } from \"./utils\"\n\n// ─── Tag helpers ──────────────────────────────────────────\nconst tag = {\n  ok: color.bold(color.green(\"[OK] \")),\n  done: color.bold(color.green(\"[DONE] \")),\n  live: color.bold(color.green(\"[LIVE] \")),\n  info: color.bold(color.blue(\"[INFO] \")),\n  off: color.bold(color.blue(\"[OFF] \")),\n  warn: color.bold(color.yellow(\"[WARN] \")),\n  err: color.bold(color.red(\"[ERR] \")),\n}\n\nexport interface Display {\n  /** Called once when polling begins. */\n  pollingStarted(intervalMinutes: number): void\n  /** Spinner while checking if a user is live. */\n  checkingUser(user: string): void\n  /** User is offline (no active display). */\n  userOffline(user: string): void\n  /** User is still offline — updates the previous offline line with a timestamp. */\n  userOfflineRepeat(user: string, lastCheck: string): void\n  /** User is live! Clears the checking spinner. */\n  userLive(user: string, roomId: string): void\n\n  /** Recording starts: spinner without filename (known only post-download). */\n  startRecording(): void\n  /** Recording finished successfully. Shows filename from the result. */\n  finishRecording(filename: string, duration: number, size: string): void\n  /** Recording encountered a non-fatal error. */\n  recordingError(message: string): void\n\n  /** FFmpeg segmenting starts. */\n  startSegmenting(): void\n  /** FFmpeg segmenting done. */\n  segmentsCreated(count: number): void\n\n  /** FFmpeg simple conversion starts (fallback path). */\n  startConverting(): void\n  /** Simple conversion done. */\n  conversionDone(output: string): void\n\n  /** Audio normalization starts (EBU R128 via peaknorm). */\n  normalizeStart(): void\n  /** Audio normalization progress update. */\n  normalizeProgress(percent: number, phase: string): void\n  /** Audio normalization completed successfully. */\n  normalizeComplete(): void\n  /** Audio normalization failed. */\n  normalizeError(message: string): void\n\n  /** Show version banner at startup. */\n  showVersion(name: string, version: string): void\n\n  /** General-purpose status helpers. */\n  showError(message: string): void\n  showInfo(message: string): void\n  showWarning(message: string): void\n\n  /** Stop all active spinners and clean up the terminal. */\n  stop(): void\n}\n\nexport function createDisplay(): Display {\n  let activeSpinner: SpinnerInstance | null = null\n  let offlineLineShown = false\n\n  // Recording timer state\n  let recordingStartTime: number | null = null\n  let recordingTimer: ReturnType<typeof setInterval> | null = null\n\n  /** Stop the currently active spinner (if any) without printing anything. */\n  function clearSpinner(): void {\n    if (recordingTimer) {\n      clearInterval(recordingTimer)\n      recordingTimer = null\n    }\n    if (activeSpinner?.isSpinning) {\n      activeSpinner.stop()\n    }\n    activeSpinner = null\n  }\n\n  /** Stop the current spinner and print a one-liner with the given tag prefix. */\n  function finalize(prefix: string, text: string): void {\n    clearSpinner()\n    process.stdout.write(`${prefix}${text}\\n`)\n  }\n\n  return {\n    pollingStarted(intervalMinutes: number): void {\n      finalize(\n        tag.info,\n        `${color.dim(\"Polling started (every \")}${color.bold(color.yellow(String(intervalMinutes)))}${color.dim(\" min)\")}`,\n      )\n    },\n\n    checkingUser(user: string): void {\n      clearSpinner()\n      activeSpinner = createSpinner(color.cyan(`Checking @${user}...`))\n      activeSpinner.start()\n    },\n\n    userOffline(user: string): void {\n      finalize(tag.off, `${color.bold(color.yellow(`@${user}`))}${color.dim(\" is offline\")}`)\n      offlineLineShown = true\n    },\n\n    userOfflineRepeat(user: string, lastCheck: string): void {\n      clearSpinner()\n      const text = `${tag.off}${color.bold(color.yellow(`@${user}`))}${color.dim(\" is offline\")} ${color.dim(`[last online: ${color.bold(color.yellow(lastCheck))}]`)}`\n      if (offlineLineShown) {\n        // Move cursor up one line and overwrite the previous offline message\n        process.stdout.write(`\\x1b[1A\\r${text}\\x1b[K\\n`)\n      } else {\n        process.stdout.write(`${text}\\n`)\n        offlineLineShown = true\n      }\n    },\n\n    userLive(user: string, roomId: string): void {\n      clearSpinner()\n      offlineLineShown = false\n      process.stdout.write(\n        `${tag.live}${color.bold(color.green(`@${user}`))} ${color.dim(`(room: ${color.bold(color.yellow(roomId))})`)}\\n`,\n      )\n    },\n\n    startRecording(): void {\n      clearSpinner()\n      recordingStartTime = Date.now()\n      activeSpinner = createSpinner(\n        `${color.cyan(\"Recording...\")} ${color.dim(`[${color.bold(color.yellow(\"0s\"))}]`)}`,\n      )\n      activeSpinner.start()\n\n      recordingTimer = setInterval(() => {\n        if (!activeSpinner?.isSpinning || !recordingStartTime) return\n        const elapsed = (Date.now() - recordingStartTime) / 1000\n        activeSpinner.text = `${color.cyan(\"Recording...\")} ${color.dim(`[${color.bold(color.yellow(formatDuration(elapsed)))}]`)}`\n      }, 1000)\n    },\n\n    finishRecording(filename: string, duration: number, size: string): void {\n      finalize(\n        tag.done,\n        `${color.cyan(filename)}${color.dim(\" — \")}${color.bold(color.yellow(size))}${color.dim(` in ${color.bold(color.yellow(formatDuration(duration)))}`)}`,\n      )\n    },\n\n    recordingError(message: string): void {\n      finalize(tag.err, color.red(`Recording failed: ${message}`))\n    },\n\n    startSegmenting(): void {\n      clearSpinner()\n      activeSpinner = createSpinner(color.cyan(\"Segmenting...\"))\n      activeSpinner.start()\n    },\n\n    segmentsCreated(count: number): void {\n      finalize(\n        tag.ok,\n        `${color.dim(\"Created \")}${color.bold(color.yellow(String(count)))}${color.dim(` MP4 segment${count !== 1 ? \"s\" : \"\"}`)}`,\n      )\n    },\n\n    startConverting(): void {\n      clearSpinner()\n      activeSpinner = createSpinner(color.cyan(\"Converting to MP4...\"))\n      activeSpinner.start()\n    },\n\n    conversionDone(output: string): void {\n      finalize(tag.done, `${color.cyan(output)}`)\n    },\n\n    normalizeStart(): void {\n      clearSpinner()\n      activeSpinner = createSpinner(color.cyan(\"Normalizing audio...\"))\n      activeSpinner.start()\n    },\n\n    normalizeProgress(percent: number, phase: string): void {\n      if (!activeSpinner?.isSpinning) return\n      const label = phase === \"analyzing\" ? \"Analyzing\" : \"Normalizing\"\n      activeSpinner.text = ` ${label}... ${color.bold(color.yellow(`${percent}%`))}`\n    },\n\n    normalizeComplete(): void {\n      finalize(tag.ok, color.green(\"Audio normalized\"))\n    },\n\n    normalizeError(message: string): void {\n      finalize(tag.err, color.red(`Normalization failed: ${message}`))\n    },\n\n    showVersion(name: string, version: string): void {\n      clearSpinner()\n      offlineLineShown = false\n      process.stdout.write(`${color.dim(`${name} ${version}`)}\\n`)\n    },\n\n    showError(message: string): void {\n      clearSpinner()\n      offlineLineShown = false\n      process.stdout.write(`${tag.err}${color.red(message)}\\n`)\n    },\n\n    showInfo(message: string): void {\n      clearSpinner()\n      offlineLineShown = false\n      process.stdout.write(`${tag.info}${color.dim(message)}\\n`)\n    },\n\n    showWarning(message: string): void {\n      clearSpinner()\n      offlineLineShown = false\n      process.stdout.write(`${tag.warn}${color.yellow(message)}\\n`)\n    },\n\n    stop(): void {\n      clearSpinner()\n      offlineLineShown = false\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/utils.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.mjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["/**\n * Utility helpers — pure functions, no side effects.\n */\n\nimport { mkdirSync, statSync } from \"node:fs\"\n\n/** Format a filename like username=2025.06.09_14-30-00_1.flv */\nexport function formatFilename(user: string, ext = \"flv\", part?: number): string {\n  const now = new Date()\n  const pad = (n: number) => String(n).padStart(2, \"0\")\n  const date = `${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`\n  const time = `${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`\n  const partSuffix = part !== undefined ? `_part${part}` : \"\"\n  return `${user}=${date}_${time}${partSuffix}.${ext}`\n}\n\n/** Ensure a directory exists (recursive) */\nexport function ensureDir(dir: string): void {\n  mkdirSync(dir, { recursive: true })\n}\n\n/**\n * Sleep for `ms` milliseconds.\n *\n * When an `AbortSignal` is provided and fires before the timer elapses,\n * the promise resolves immediately and the underlying timeout is cleared.\n * This prevents orphaned timers in Promise.race patterns.\n */\nexport function sleep(ms: number, signal?: AbortSignal): Promise<void> {\n  return new Promise((resolve) => {\n    if (signal?.aborted) {\n      resolve()\n      return\n    }\n    const timer = setTimeout(resolve, ms)\n    if (signal) {\n      signal.addEventListener(\n        \"abort\",\n        () => {\n          clearTimeout(timer)\n          resolve()\n        },\n        { once: true },\n      )\n    }\n  })\n}\n\n/** Format bytes to human-readable size */\nexport function bytesToHuman(bytes: number): string {\n  if (bytes === 0) return \"0 B\"\n  const units = [\"B\", \"KB\", \"MB\", \"GB\"]\n  const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1)\n  return `${(bytes / 1024 ** i).toFixed(1)} ${units[i]}`\n}\n\n/** Strip leading @ from a username */\nexport function sanitizeUser(user: string): string {\n  return user.replace(/^@+/, \"\").trim()\n}\n\n/** Format a millisecond elapsed time as a relative human-readable string. */\nexport function relativeTime(ms: number): string {\n  const sec = Math.floor(ms / 1000)\n  if (sec < 5) return \"just now\"\n  if (sec < 60) return `${sec}s ago`\n  const min = Math.floor(sec / 60)\n  if (min < 60) return `${min}m ago`\n  const hours = Math.floor(min / 60)\n  const mins = min % 60\n  if (hours < 24) return mins > 0 ? `${hours}h ${mins}m ago` : `${hours}h ago`\n  const days = Math.floor(hours / 24)\n  return `${days}d ago`\n}\n\n/** Format seconds into a compact human-readable duration (e.g. \"1m 5s\", \"30s\"). */\nexport function formatDuration(seconds: number): string {\n  const m = Math.floor(seconds / 60)\n  const s = Math.floor(seconds % 60)\n  if (m > 0) return `${m}m ${s}s`\n  return `${s}s`\n}\n\n/** Find FFmpeg binary via Bun.which() or PATH search. */\nexport function findFfmpegPath(): string | null {\n  const bunWhich = (globalThis as { Bun?: { which?: (cmd: string) => string | null } }).Bun?.which\n  if (typeof bunWhich === \"function\") {\n    return (bunWhich(\"ffmpeg\") as string) ?? null\n  }\n  const paths = process.env.PATH?.split(\":\") ?? []\n  for (const dir of paths) {\n    try {\n      const full = `${dir}/ffmpeg`\n      statSync(full)\n      return full\n    } catch {\n      // not found in this directory\n    }\n  }\n  return null\n}\n"],"mappings":";;;;;;AAOA,SAAgB,eAAe,MAAc,MAAM,OAAO,MAAuB;CAC/E,MAAM,sBAAM,IAAI,KAAK;CACrB,MAAM,OAAO,MAAc,OAAO,CAAC,CAAC,CAAC,SAAS,GAAG,GAAG;CAIpD,OAAO,GAAG,KAAK,GAAG,GAHF,IAAI,YAAY,IAAI,IAAI,IAAI,SAAS,IAAI,CAAC,IAAI,IAAI,IAAI,QAAQ,CAAC,IAGxD,GAAG,GAFV,IAAI,IAAI,SAAS,CAAC,IAAI,IAAI,IAAI,WAAW,CAAC,IAAI,IAAI,IAAI,WAAW,CAAC,MAC/D,SAAS,KAAA,IAAY,QAAQ,SAAS,GACb,GAAG;AACjD;;AAGA,SAAgB,UAAU,KAAmB;CAC3C,UAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AACpC;;;;;;;;AASA,SAAgB,MAAM,IAAY,QAAqC;CACrE,OAAO,IAAI,SAAS,YAAY;EAC9B,IAAI,QAAQ,SAAS;GACnB,QAAQ;GACR;EACF;EACA,MAAM,QAAQ,WAAW,SAAS,EAAE;EACpC,IAAI,QACF,OAAO,iBACL,eACM;GACJ,aAAa,KAAK;GAClB,QAAQ;EACV,GACA,EAAE,MAAM,KAAK,CACf;CAEJ,CAAC;AACH;;AAGA,SAAgB,aAAa,OAAuB;CAClD,IAAI,UAAU,GAAG,OAAO;CACxB,MAAM,QAAQ;EAAC;EAAK;EAAM;EAAM;CAAI;CACpC,MAAM,IAAI,KAAK,IAAI,KAAK,MAAM,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,IAAI,CAAC,GAAG,MAAM,SAAS,CAAC;CACjF,OAAO,IAAI,QAAQ,QAAQ,EAAA,CAAG,QAAQ,CAAC,EAAE,GAAG,MAAM;AACpD;;AAGA,SAAgB,aAAa,MAAsB;CACjD,OAAO,KAAK,QAAQ,OAAO,EAAE,CAAC,CAAC,KAAK;AACtC;;AAGA,SAAgB,aAAa,IAAoB;CAC/C,MAAM,MAAM,KAAK,MAAM,KAAK,GAAI;CAChC,IAAI,MAAM,GAAG,OAAO;CACpB,IAAI,MAAM,IAAI,OAAO,GAAG,IAAI;CAC5B,MAAM,MAAM,KAAK,MAAM,MAAM,EAAE;CAC/B,IAAI,MAAM,IAAI,OAAO,GAAG,IAAI;CAC5B,MAAM,QAAQ,KAAK,MAAM,MAAM,EAAE;CACjC,MAAM,OAAO,MAAM;CACnB,IAAI,QAAQ,IAAI,OAAO,OAAO,IAAI,GAAG,MAAM,IAAI,KAAK,SAAS,GAAG,MAAM;CAEtE,OAAO,GADM,KAAK,MAAM,QAAQ,EACnB,EAAE;AACjB;;AAGA,SAAgB,eAAe,SAAyB;CACtD,MAAM,IAAI,KAAK,MAAM,UAAU,EAAE;CACjC,MAAM,IAAI,KAAK,MAAM,UAAU,EAAE;CACjC,IAAI,IAAI,GAAG,OAAO,GAAG,EAAE,IAAI,EAAE;CAC7B,OAAO,GAAG,EAAE;AACd;;AAGA,SAAgB,iBAAgC;CAC9C,MAAM,WAAY,WAAoE,KAAK;CAC3F,IAAI,OAAO,aAAa,YACtB,OAAQ,SAAS,QAAQ,KAAgB;CAE3C,MAAM,QAAQ,QAAQ,IAAI,MAAM,MAAM,GAAG,KAAK,CAAC;CAC/C,KAAK,MAAM,OAAO,OAChB,IAAI;EACF,MAAM,OAAO,GAAG,IAAI;EACpB,SAAS,IAAI;EACb,OAAO;CACT,QAAQ,CAER;CAEF,OAAO;AACT"}