@zfadhli/tokrec 0.12.2 → 0.15.0

package/dist/app/recorder.mjs

@@ -0,0 +1,233 @@
+import { planTick } from "../core/plan.mjs";
+import { verdictOf } from "../core/verdict.mjs";
+import { createHttpClient } from "../io/http.mjs";
+import { createConverter } from "../io/media/convert.mjs";
+import { downloadStream } from "../io/media/download.mjs";
+import { createAudioNormalizer } from "../io/media/normalize.mjs";
+import { createTikTokClient } from "../io/tiktok/client.mjs";
+import { abortScope } from "./abort.mjs";
+import { resolveConfig } from "./config.mjs";
+import { createEventEmitter } from "./events.mjs";
+import { createRecordingJob } from "./job.mjs";
+import { createLogger } from "./logger.mjs";
+import { createPollingMonitor } from "./loop.mjs";
+//#region src/app/recorder.ts
+/**
+* Recorder orchestrator — wires the TikTok client, stream download, and
+* RecordingJob into a single RecorderController.
+*
+* Policy lives in `policy/tick.ts`; this file maps a TickPlan to effects and
+* owns the session state those effects mutate. Everything a tick needs is
+* constructed as a `const` in `start()` and passed in, so no call site has to
+* assert a non-null module-level `let` back into existence.
+*/
+/** Max wait for a stop-time remux before aborting it (matches the pre-#32 cap). */
+const POST_REMUX_GRACE_MS = 600 * 1e3;
+function createRecorder(config) {
+	const cfg = resolveConfig(config);
+	const logger = createLogger({
+		level: cfg.logLevel,
+		logFile: "tiktok-recorder.log",
+		console: cfg.logConsole
+	});
+	const emitter = createEventEmitter();
+	const status = {
+		state: "idle",
+		user: cfg.user
+	};
+	let running = null;
+	let postScope = null;
+	let currentJob = null;
+	let recordedSec = 0;
+	let consecutiveErrors = 0;
+	function setState(partial) {
+		const prev = status.state;
+		Object.assign(status, partial);
+		if (partial.state !== void 0 && partial.state !== prev) {
+			logger.info(`State: ${prev} → ${partial.state}`);
+			if (partial.state === "polling") status.lastPollTime = (/* @__PURE__ */ new Date()).toISOString();
+		}
+	}
+	async function tick(d) {
+		const { client, monitor, scope, post } = d;
+		if (scope.signal.aborted) return;
+		const user = cfg.user;
+		client.invalidateCache();
+		logger.info(`Checking @${user}...`);
+		const verdict = await client.getVerdict(user);
+		const facts = {
+			recording: currentJob !== null,
+			recordedSec,
+			oneShot: cfg.duration > 0,
+			consecutiveErrors
+		};
+		consecutiveErrors = verdict.reason === "error" || verdict.reason === "no-room-id" ? consecutiveErrors + 1 : 0;
+		emitter.emit("verdict", verdict);
+		const plan = planTick(verdict, facts);
+		switch (plan.kind) {
+			case "poll":
+				logger.info(`@${user} ${plan.note} (reason: ${verdict.reason}, source: ${lastSource(verdict)})`);
+				return;
+			case "hold":
+				if (plan.reason === "restricted") logger.warn(`@${user} is live but age-protected/restricted — stream unavailable (reason: restricted, status_code 4003110, room: ${plan.room.id})`);
+				else logger.warn(`@${user} is live but no stream URL found (reason: no-stream-url, room: ${plan.room.id})`);
+				return;
+			case "stop":
+				if (plan.why === "one-shot") {
+					logger.info("Duration limit reached — exiting");
+					monitor.stopAfterCurrentTick();
+				} else if (plan.why === "gave-up") {
+					logger.error(`@${user} gave up after ${consecutiveErrors} consecutive errors`);
+					monitor.stopAfterCurrentTick();
+				}
+				return;
+			case "record": {
+				const { room, stream } = plan;
+				logger.info(`@${user} is LIVE! (room: ${room.id}, reason: live)`);
+				setState({ state: "recording" });
+				emitter.emit("record", {
+					phase: "start",
+					user,
+					file: ""
+				});
+				const getNextUrl = async () => {
+					if (scope.signal.aborted) return null;
+					if (!await client.isRoomAlive(room.id)) {
+						logger.info(`@${user} is no longer live — stopping`);
+						return null;
+					}
+					client.invalidateCache();
+					return client.getLiveUrl(room.id);
+				};
+				const result = await downloadStream(stream.url, user, cfg.outputDir, cfg.duration, (info) => emitter.emit("progress", {
+					kind: "download",
+					...info
+				}), getNextUrl, scope.signal, logger, cfg.cookies);
+				emitter.emit("record", {
+					phase: "download",
+					...result
+				});
+				recordedSec += result.duration;
+				const job = createRecordingJob({
+					result,
+					cfg: { segmentMinutes: cfg.segmentMinutes },
+					logger,
+					converter: d.converter,
+					audioNormalizer: d.audioNormalizer,
+					signal: post.signal,
+					emitRecord: (event) => emitter.emit("record", event),
+					emitProgress: (event) => emitter.emit("progress", event),
+					emitFailure: (err) => emitter.emit("failure", err),
+					setState
+				});
+				currentJob = job;
+				try {
+					await job.finish();
+				} finally {
+					currentJob = null;
+				}
+				if (cfg.duration > 0) {
+					logger.info("Duration limit reached — exiting");
+					monitor.stopAfterCurrentTick();
+				} else if (!scope.signal.aborted) {
+					if (!await client.isRoomAlive(room.id)) {
+						logger.info(`@${user} is offline`);
+						emitter.emit("verdict", verdictOf({
+							room: {
+								...room,
+								live: false
+							},
+							evidence: verdict.evidence
+						}));
+					}
+				}
+				return;
+			}
+		}
+	}
+	async function start() {
+		if (status.state !== "idle") {
+			logger.warn(`start() ignored: already in state ${status.state}`);
+			return;
+		}
+		const scope = abortScope();
+		const post = abortScope();
+		postScope = post;
+		currentJob = null;
+		recordedSec = 0;
+		consecutiveErrors = 0;
+		logger.info(`Starting recorder for @${cfg.user}`);
+		const http = await createHttpClient(cfg);
+		const client = createTikTokClient(http, logger, cfg.debug, scope.signal);
+		const converter = createConverter(logger, post.signal);
+		const audioNormalizer = cfg.normalizeAudio ? createAudioNormalizer({
+			loudness: cfg.normalizeLoudness,
+			audioCodec: cfg.normalizeCodec,
+			audioBitrate: cfg.normalizeBitrate,
+			onProgress: (file, percent, phase) => emitter.emit("progress", {
+				kind: "normalize",
+				file,
+				percent,
+				phase
+			})
+		}, logger) : null;
+		let monitor;
+		monitor = createPollingMonitor({
+			intervalMinutes: cfg.interval,
+			signal: scope.signal,
+			logger,
+			onTick: () => tick({
+				client,
+				monitor,
+				scope,
+				post,
+				converter,
+				audioNormalizer
+			})
+		});
+		running = {
+			monitor,
+			http,
+			scope
+		};
+		setState({ state: "polling" });
+		await monitor.start();
+	}
+	async function stop() {
+		if (status.state === "stopped") {
+			logger.warn(`stop() ignored: already stopped`);
+			return;
+		}
+		logger.info("Stopping recorder...");
+		running?.scope.close("user");
+		const grace = setTimeout(() => postScope?.close("stop-timeout"), POST_REMUX_GRACE_MS);
+		try {
+			const job = currentJob;
+			if (job) {
+				logger.info("Waiting for active recording to finish...");
+				await job.finish();
+			}
+			if (running) await running.monitor.stop();
+		} finally {
+			clearTimeout(grace);
+		}
+		if (running) await running.http.close();
+		emitter.clear();
+		setState({ state: "stopped" });
+		logger.info("Recorder stopped");
+	}
+	return {
+		start,
+		stop,
+		getStatus: () => ({ ...status }),
+		on: emitter.on,
+		off: emitter.off
+	};
+}
+function lastSource(verdict) {
+	return [...verdict.evidence].reverse().find((e) => e.outcome === "hit" || e.outcome === "denied")?.source ?? "none";
+}
+//#endregion
+export { createRecorder };
+
+//# sourceMappingURL=recorder.mjs.map

package/dist/app/recorder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recorder.mjs","names":[],"sources":["../../src/app/recorder.ts"],"sourcesContent":["/**\n * Recorder orchestrator — wires the TikTok client, stream download, and\n * RecordingJob into a single RecorderController.\n *\n * Policy lives in `policy/tick.ts`; this file maps a TickPlan to effects and\n * owns the session state those effects mutate. Everything a tick needs is\n * constructed as a `const` in `start()` and passed in, so no call site has to\n * assert a non-null module-level `let` back into existence.\n */\n\nimport { planTick, type TickFacts } from \"../core/plan\"\nimport { verdictOf } from \"../core/verdict\"\nimport { createHttpClient, type HttpClient } from \"../io/http\"\nimport { type Converter, createConverter } from \"../io/media/convert\"\nimport { downloadStream } from \"../io/media/download\"\nimport { type AudioNormalizer, createAudioNormalizer } from \"../io/media/normalize\"\nimport { createTikTokClient, type TikTokClient } from \"../io/tiktok/client\"\nimport { type AbortScope, abortScope } from \"./abort\"\nimport type { RecorderConfig, RecorderController, RecorderStatus } from \"./config\"\nimport { resolveConfig } from \"./config\"\nimport { createEventEmitter } from \"./events\"\nimport { createRecordingJob, type RecordingJob } from \"./job\"\nimport { createLogger } from \"./logger\"\nimport { createPollingMonitor, type PollingMonitor } from \"./loop\"\n\n/** Max wait for a stop-time remux before aborting it (matches the pre-#32 cap). */\nconst POST_REMUX_GRACE_MS = 10 * 60 * 1000\n\n/** Everything one poll tick needs, built by `start()` before the tick can run. */\ninterface TickDeps {\n  client: TikTokClient\n  monitor: PollingMonitor\n  scope: AbortScope\n  post: AbortScope\n  converter: Converter\n  audioNormalizer: AudioNormalizer | null\n}\n\n/** What `stop()` has to join and release. */\ninterface Running {\n  monitor: PollingMonitor\n  http: HttpClient\n  scope: AbortScope\n}\n\nexport function createRecorder(config: RecorderConfig): RecorderController {\n  const cfg = resolveConfig(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\n  // Session state — written by ticks and by the job lifecycle, read by getStatus().\n  const status: RecorderStatus = { state: \"idle\", user: cfg.user }\n  let running: Running | null = null\n  let postScope: AbortScope | null = null\n  let currentJob: RecordingJob | null = null\n  let recordedSec = 0\n  let consecutiveErrors = 0\n\n  function setState(partial: Partial<RecorderStatus>): void {\n    const prev = status.state\n    Object.assign(status, partial)\n    if (partial.state !== undefined && partial.state !== prev) {\n      logger.info(`State: ${prev} → ${partial.state}`)\n      if (partial.state === \"polling\") status.lastPollTime = new Date().toISOString()\n    }\n  }\n\n  async function tick(d: TickDeps): Promise<void> {\n    const { client, monitor, scope, post } = d\n    if (scope.signal.aborted) return\n    const user = cfg.user\n\n    client.invalidateCache()\n    logger.info(`Checking @${user}...`)\n\n    const verdict = await client.getVerdict(user)\n    const facts: TickFacts = {\n      recording: currentJob !== null,\n      recordedSec,\n      oneShot: cfg.duration > 0,\n      consecutiveErrors,\n    }\n    consecutiveErrors =\n      verdict.reason === \"error\" || verdict.reason === \"no-room-id\" ? consecutiveErrors + 1 : 0\n\n    emitter.emit(\"verdict\", verdict)\n    const plan = planTick(verdict, facts)\n\n    switch (plan.kind) {\n      case \"poll\": {\n        logger.info(\n          `@${user} ${plan.note} (reason: ${verdict.reason}, source: ${lastSource(verdict)})`,\n        )\n        return\n      }\n      case \"hold\": {\n        if (plan.reason === \"restricted\") {\n          logger.warn(\n            `@${user} is live but age-protected/restricted — stream unavailable (reason: restricted, status_code 4003110, room: ${plan.room.id})`,\n          )\n        } else {\n          logger.warn(\n            `@${user} is live but no stream URL found (reason: no-stream-url, room: ${plan.room.id})`,\n          )\n        }\n        return\n      }\n      case \"stop\": {\n        if (plan.why === \"one-shot\") {\n          logger.info(\"Duration limit reached — exiting\")\n          monitor.stopAfterCurrentTick()\n        } else if (plan.why === \"gave-up\") {\n          logger.error(`@${user} gave up after ${consecutiveErrors} consecutive errors`)\n          monitor.stopAfterCurrentTick()\n        }\n        return\n      }\n      case \"record\": {\n        const { room, stream } = plan\n        logger.info(`@${user} is LIVE! (room: ${room.id}, reason: live)`)\n        setState({ state: \"recording\" })\n        emitter.emit(\"record\", { phase: \"start\", user, file: \"\" })\n\n        const getNextUrl = async (): Promise<string | null> => {\n          if (scope.signal.aborted) return 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 client.isRoomAlive(room.id)\n          if (!alive) {\n            logger.info(`@${user} is no longer live — stopping`)\n            return null\n          }\n          client.invalidateCache()\n          return client.getLiveUrl(room.id)\n        }\n\n        const result = await downloadStream(\n          stream.url,\n          user,\n          cfg.outputDir,\n          cfg.duration,\n          (info) => emitter.emit(\"progress\", { kind: \"download\", ...info }),\n          getNextUrl,\n          scope.signal,\n          logger,\n          cfg.cookies,\n        )\n\n        emitter.emit(\"record\", { phase: \"download\", ...result })\n        recordedSec += result.duration\n\n        const job = createRecordingJob({\n          result,\n          cfg: { segmentMinutes: cfg.segmentMinutes },\n          logger,\n          converter: d.converter,\n          audioNormalizer: d.audioNormalizer,\n          signal: post.signal,\n          emitRecord: (event) => emitter.emit(\"record\", event),\n          emitProgress: (event) => emitter.emit(\"progress\", event),\n          emitFailure: (err) => emitter.emit(\"failure\", err),\n          setState,\n        })\n        currentJob = job\n        try {\n          await job.finish()\n        } finally {\n          currentJob = null\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          monitor.stopAfterCurrentTick()\n        } else if (!scope.signal.aborted) {\n          // Recording ended because the stream went offline (not user-initiated\n          // stop). Immediately re-check via the lightweight endpoint.\n          const alive = await client.isRoomAlive(room.id)\n          if (!alive) {\n            logger.info(`@${user} is offline`)\n            emitter.emit(\n              \"verdict\",\n              verdictOf({ room: { ...room, live: false }, evidence: verdict.evidence }),\n            )\n          }\n        }\n        return\n      }\n    }\n  }\n\n  async function start(): Promise<void> {\n    if (status.state !== \"idle\") {\n      logger.warn(`start() ignored: already in state ${status.state}`)\n      return\n    }\n    const scope = abortScope()\n    // Post-processing outlives a user stop: Ctrl+C aborts the download, but the\n    // partial .ts is still remuxed to .mp4 before the process exits.\n    const post = abortScope()\n    postScope = post\n    currentJob = null\n    recordedSec = 0\n    consecutiveErrors = 0\n\n    logger.info(`Starting recorder for @${cfg.user}`)\n    const http = await createHttpClient(cfg)\n    const client = createTikTokClient(http, logger, cfg.debug, scope.signal)\n    const converter = createConverter(logger, post.signal)\n    const audioNormalizer = cfg.normalizeAudio\n      ? createAudioNormalizer(\n          {\n            loudness: cfg.normalizeLoudness,\n            audioCodec: cfg.normalizeCodec,\n            audioBitrate: cfg.normalizeBitrate,\n            onProgress: (file, percent, phase) =>\n              emitter.emit(\"progress\", {\n                kind: \"normalize\",\n                file,\n                percent,\n                phase: phase as \"analyzing\" | \"normalizing\",\n              }),\n          },\n          logger,\n        )\n      : null\n\n    // Self-reference inside `onTick` is safe: the monitor calls it from\n    // `start()`, never during construction.\n    let monitor: PollingMonitor\n    monitor = createPollingMonitor({\n      intervalMinutes: cfg.interval,\n      signal: scope.signal,\n      logger,\n      onTick: () => tick({ client, monitor, scope, post, converter, audioNormalizer }),\n    })\n    running = { monitor, http, scope }\n\n    setState({ state: \"polling\" })\n    await monitor.start()\n  }\n\n  async function stop(): Promise<void> {\n    if (status.state === \"stopped\") {\n      logger.warn(`stop() ignored: already stopped`)\n      return\n    }\n    logger.info(\"Stopping recorder...\")\n    running?.scope.close(\"user\")\n\n    const grace = setTimeout(() => postScope?.close(\"stop-timeout\"), POST_REMUX_GRACE_MS)\n    try {\n      const job = currentJob\n      if (job) {\n        logger.info(\"Waiting for active recording to finish...\")\n        await job.finish()\n      }\n\n      if (running) await running.monitor.stop()\n    } finally {\n      clearTimeout(grace)\n    }\n    if (running) await running.http.close()\n    emitter.clear()\n    setState({ state: \"stopped\" })\n    logger.info(\"Recorder stopped\")\n  }\n\n  return {\n    start,\n    stop,\n    getStatus: () => ({ ...status }),\n    on: emitter.on,\n    off: emitter.off,\n  }\n}\n\nfunction lastSource(verdict: ReturnType<typeof verdictOf>): string {\n  return (\n    [...verdict.evidence].reverse().find((e) => e.outcome === \"hit\" || e.outcome === \"denied\")\n      ?.source ?? \"none\"\n  )\n}\n"],"mappings":"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"}

package/dist/core/errors.d.mts

@@ -0,0 +1,16 @@
+//#region src/core/errors.d.ts
+/**
+* The single error type the library throws, plus its code union.
+*
+* Pure band: `io/` constructs it (`ffmpeg-error`, `aborted`) and `app/`
+* constructs it (`config-error`), so it belongs below both.
+*/
+type TikTokErrorCode = "config-error" | "ffmpeg-not-found" | "ffmpeg-error" | "aborted" | "unknown";
+declare class TikTokError extends Error {
+  readonly code: TikTokErrorCode;
+  override readonly cause?: unknown;
+  constructor(code: TikTokErrorCode, message: string, cause?: unknown);
+}
+//#endregion
+export { TikTokError, TikTokErrorCode };
+//# sourceMappingURL=errors.d.mts.map

package/dist/core/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../../src/core/errors.ts"],"mappings":";;AAOA;;;;AAAY;KAAA,eAAA;AAAA,cAOC,WAAA,SAAoB,KAAA;EAAA,SAE7B,IAAA,EAAsB,eAAA;EAAA,kBAEtB,KAAA;EAHF,WAAA,CACE,IAAA,EAAsB,eAAA,EACtB,OAAA,UACA,KAAA;AAAA"}

package/dist/core/errors.mjs

@@ -0,0 +1,15 @@
+//#region src/core/errors.ts
+var TikTokError = class extends Error {
+	code;
+	cause;
+	constructor(code, message, cause) {
+		super(message);
+		this.code = code;
+		this.cause = cause;
+		this.name = "TikTokError";
+	}
+};
+//#endregion
+export { TikTokError };
+
+//# sourceMappingURL=errors.mjs.map

package/dist/core/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../../src/core/errors.ts"],"sourcesContent":["/**\n * The single error type the library throws, plus its code union.\n *\n * Pure band: `io/` constructs it (`ffmpeg-error`, `aborted`) and `app/`\n * constructs it (`config-error`), so it belongs below both.\n */\n\nexport type TikTokErrorCode =\n  | \"config-error\"\n  | \"ffmpeg-not-found\"\n  | \"ffmpeg-error\"\n  | \"aborted\"\n  | \"unknown\"\n\nexport class TikTokError extends Error {\n  constructor(\n    public readonly code: TikTokErrorCode,\n    message: string,\n    public override readonly cause?: unknown,\n  ) {\n    super(message)\n    this.name = \"TikTokError\"\n  }\n}\n"],"mappings":";AAcA,IAAa,cAAb,cAAiC,MAAM;CAEnB;CAES;CAH3B,YACE,MACA,SACA,OACA;EACA,MAAM,OAAO;EAJG,KAAA,OAAA;EAES,KAAA,QAAA;EAGzB,KAAK,OAAO;CACd;AACF"}

package/dist/core/format.d.mts

@@ -0,0 +1,12 @@
+//#region src/core/format.d.ts
+/** Format bytes to human-readable size */
+declare function bytesToHuman(bytes: number): string;
+/** Strip leading @ from a username */
+declare function sanitizeUser(user: string): string;
+/** Format a millisecond elapsed time as a relative human-readable string. */
+declare function relativeTime(ms: number): string;
+/** Format seconds into a compact human-readable duration (e.g. "1m 5s", "30s"). */
+declare function formatDuration(seconds: number): string;
+//#endregion
+export { bytesToHuman, formatDuration, relativeTime, sanitizeUser };
+//# sourceMappingURL=format.d.mts.map

package/dist/core/format.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.mts","names":[],"sources":["../../src/core/format.ts"],"mappings":";;iBAiBgB,YAAA,CAAa,KAAA;;iBAQb,YAAA,CAAa,IAAA;AAK7B;AAAA,iBAAgB,YAAA,CAAa,EAAA;;iBAcb,cAAA,CAAe,OAAA"}

package/dist/{lib/utils.mjs → core/format.mjs}

@@ -1,7 +1,8 @@
-import { mkdirSync, statSync } from "node:fs";
-//#region src/lib/utils.ts
+//#region src/core/format.ts
 /**
-* Utility helpers — pure functions, no side effects.
+* Pure formatting helpers — no I/O, no imports. Output filenames, byte counts,
+* and human durations, shared by `io/` (download logging and output names) and
+* the public API.
 */
 /** Format a filename like username=2025.06.09_14-30-00_1.flv */
 function formatFilename(user, ext = "flv", part) {
@@ -9,30 +10,6 @@ function formatFilename(user, ext = "flv", part) {
 	const pad = (n) => String(n).padStart(2, "0");
 	return `${user}=${`${now.getFullYear()}${pad(now.getMonth() + 1)}${pad(now.getDate())}`}_${`${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`}${part !== void 0 ? `_part${part}` : ""}.${ext}`;
 }
-/** Ensure a directory exists (recursive) */
-function ensureDir(dir) {
-	mkdirSync(dir, { recursive: true });
-}
-/**
-* Sleep for `ms` milliseconds.
-*
-* When an `AbortSignal` is provided and fires before the timer elapses,
-* the promise resolves immediately and the underlying timeout is cleared.
-* This prevents orphaned timers in Promise.race patterns.
-*/
-function sleep(ms, signal) {
-	return new Promise((resolve) => {
-		if (signal?.aborted) {
-			resolve();
-			return;
-		}
-		const timer = setTimeout(resolve, ms);
-		if (signal) signal.addEventListener("abort", () => {
-			clearTimeout(timer);
-			resolve();
-		}, { once: true });
-	});
-}
 /** Format bytes to human-readable size */
 function bytesToHuman(bytes) {
 	if (bytes === 0) return "0 B";
@@ -68,19 +45,7 @@ function formatDuration(seconds) {
 	if (m > 0) return `${m}m ${s}s`;
 	return `${s}s`;
 }
-/** Find FFmpeg binary via Bun.which() or PATH search. */
-function findFfmpegPath() {
-	const bunWhich = globalThis.Bun?.which;
-	if (typeof bunWhich === "function") return bunWhich("ffmpeg") ?? null;
-	const paths = process.env.PATH?.split(":") ?? [];
-	for (const dir of paths) try {
-		const full = `${dir}/ffmpeg`;
-		statSync(full);
-		return full;
-	} catch {}
-	return null;
-}
 //#endregion
-export { bytesToHuman, ensureDir, findFfmpegPath, formatDuration, formatFilename, relativeTime, sanitizeUser, sleep };
+export { bytesToHuman, formatDuration, formatFilename, relativeTime, sanitizeUser };
 
-//# sourceMappingURL=utils.mjs.map
+//# sourceMappingURL=format.mjs.map

package/dist/core/format.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.mjs","names":[],"sources":["../../src/core/format.ts"],"sourcesContent":["/**\n * Pure formatting helpers — no I/O, no imports. Output filenames, byte counts,\n * and human durations, shared by `io/` (download logging and output names) and\n * the public API.\n */\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/** 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"],"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,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"}

package/dist/core/plan.mjs

@@ -0,0 +1,52 @@
+//#region src/core/plan.ts
+function planTick(v, f) {
+	switch (v.reason) {
+		case "live":
+			if (f.recording) return {
+				kind: "poll",
+				note: "already recording"
+			};
+			if (!v.room || !v.stream) return {
+				kind: "poll",
+				note: "live without refs"
+			};
+			return {
+				kind: "record",
+				room: v.room,
+				stream: v.stream
+			};
+		case "no-stream-url":
+		case "restricted":
+			if (!v.room) return {
+				kind: "poll",
+				note: "missing room"
+			};
+			return {
+				kind: "hold",
+				reason: v.reason,
+				room: v.room
+			};
+		case "offline": return f.oneShot && f.recordedSec > 0 ? {
+			kind: "stop",
+			why: "one-shot"
+		} : {
+			kind: "poll",
+			note: "offline"
+		};
+		case "no-room-id": return f.consecutiveErrors >= 10 ? {
+			kind: "stop",
+			why: "gave-up"
+		} : {
+			kind: "poll",
+			note: "no room"
+		};
+		case "error": return {
+			kind: "poll",
+			note: v.failure?.message ?? "error"
+		};
+	}
+}
+//#endregion
+export { planTick };
+
+//# sourceMappingURL=plan.mjs.map

package/dist/core/plan.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.mjs","names":[],"sources":["../../src/core/plan.ts"],"sourcesContent":["/**\n * Tick policy — pure mapping from a `Verdict` plus facts to an action.\n *\n * No I/O, no clock, no promises. `session/` executes the returned plan.\n */\n\nimport type { RoomRef, StreamRef, Verdict } from \"./verdict\"\n\nexport interface TickFacts {\n  readonly recording: boolean\n  readonly recordedSec: number\n  readonly oneShot: boolean\n  readonly consecutiveErrors: number\n}\n\nexport type TickPlan =\n  | { kind: \"poll\"; note: string }\n  | { kind: \"hold\"; reason: \"restricted\" | \"no-stream-url\"; room: RoomRef }\n  | { kind: \"record\"; room: RoomRef; stream: StreamRef }\n  | { kind: \"stop\"; why: \"one-shot\" | \"gave-up\" }\n\nexport function planTick(v: Verdict, f: TickFacts): TickPlan {\n  // No user-stop arm: `stop()` aborts the scope, which ends the poll loop before\n  // the next tick. A user stop is a signal, never a verdict.\n  switch (v.reason) {\n    case \"live\":\n      if (f.recording) return { kind: \"poll\", note: \"already recording\" }\n      if (!v.room || !v.stream) return { kind: \"poll\", note: \"live without refs\" }\n      return { kind: \"record\", room: v.room, stream: v.stream }\n\n    case \"no-stream-url\":\n    case \"restricted\":\n      if (!v.room) return { kind: \"poll\", note: \"missing room\" }\n      return { kind: \"hold\", reason: v.reason, room: v.room }\n\n    case \"offline\":\n      return f.oneShot && f.recordedSec > 0\n        ? { kind: \"stop\", why: \"one-shot\" }\n        : { kind: \"poll\", note: \"offline\" }\n\n    case \"no-room-id\":\n      return f.consecutiveErrors >= 10\n        ? { kind: \"stop\", why: \"gave-up\" }\n        : { kind: \"poll\", note: \"no room\" }\n\n    case \"error\":\n      return { kind: \"poll\", note: v.failure?.message ?? \"error\" }\n  }\n}\n"],"mappings":";AAqBA,SAAgB,SAAS,GAAY,GAAwB;CAG3D,QAAQ,EAAE,QAAV;EACE,KAAK;GACH,IAAI,EAAE,WAAW,OAAO;IAAE,MAAM;IAAQ,MAAM;GAAoB;GAClE,IAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAQ,OAAO;IAAE,MAAM;IAAQ,MAAM;GAAoB;GAC3E,OAAO;IAAE,MAAM;IAAU,MAAM,EAAE;IAAM,QAAQ,EAAE;GAAO;EAE1D,KAAK;EACL,KAAK;GACH,IAAI,CAAC,EAAE,MAAM,OAAO;IAAE,MAAM;IAAQ,MAAM;GAAe;GACzD,OAAO;IAAE,MAAM;IAAQ,QAAQ,EAAE;IAAQ,MAAM,EAAE;GAAK;EAExD,KAAK,WACH,OAAO,EAAE,WAAW,EAAE,cAAc,IAChC;GAAE,MAAM;GAAQ,KAAK;EAAW,IAChC;GAAE,MAAM;GAAQ,MAAM;EAAU;EAEtC,KAAK,cACH,OAAO,EAAE,qBAAqB,KAC1B;GAAE,MAAM;GAAQ,KAAK;EAAU,IAC/B;GAAE,MAAM;GAAQ,MAAM;EAAU;EAEtC,KAAK,SACH,OAAO;GAAE,MAAM;GAAQ,MAAM,EAAE,SAAS,WAAW;EAAQ;CAC/D;AACF"}

package/dist/core/verdict.d.mts

@@ -0,0 +1,44 @@
+//#region src/core/verdict.d.ts
+/**
+* Verdict — the per-tick liveness result and its machine-readable reason.
+*
+* Pure domain type: no I/O, no imports outside `domain/`. `reason` is derived
+* by `verdictOf`, never passed by callers; discovery reports facts, one total
+* function decides what they mean.
+*/
+/**
+* Machine-readable reason for a LIVE status verdict.
+* "live" = stream URL resolved; "offline" = room not live;
+* "restricted" = live but age-protected/gated (stream refused);
+* "no-stream-url" = live but no URL and no gate evidence;
+* "no-room-id" = no discovery path produced a room ID;
+* "error" = network/parse failure across paths.
+*/
+type LiveReason = "live" | "offline" | "restricted" | "no-stream-url" | "no-room-id" | "error";
+interface RoomRef {
+  readonly id: string;
+  readonly title: string | null;
+  readonly live: boolean;
+}
+interface StreamRef {
+  readonly url: string;
+}
+/** Where a fact came from. Legacy `LiveInfo.source` values stay valid. */
+type SourceId = "page" | "sigi" | "room-info" | "api-live" | "profile" | "none";
+type EvidenceOutcome = "hit" | "miss" | "denied" | "error";
+interface Evidence {
+  readonly source: SourceId;
+  readonly outcome: EvidenceOutcome;
+}
+interface Verdict {
+  readonly reason: LiveReason;
+  readonly room: RoomRef | null;
+  readonly stream: StreamRef | null;
+  readonly evidence: readonly Evidence[];
+  readonly failure: Error | null;
+}
+/** Whether a reason means the room itself is live (holding or recording). */
+declare function isLiveReason(reason: LiveReason): boolean;
+//#endregion
+export { Evidence, EvidenceOutcome, LiveReason, RoomRef, SourceId, StreamRef, Verdict, isLiveReason };
+//# sourceMappingURL=verdict.d.mts.map

package/dist/core/verdict.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verdict.d.mts","names":[],"sources":["../../src/core/verdict.ts"],"mappings":";;AAgBA;;;;AAAY;AAQZ;;;;;;;;AAGW;KAXC,UAAA;AAAA,UAQK,OAAA;EAAA,SACN,EAAA;EAAA,SACA,KAAA;EAAA,SACA,IAAA;AAAA;AAAA,UAGM,SAAA;EAAA,SACN,GAAA;AAAA;AAIC;AAAA,KAAA,QAAA;AAAA,KAEA,eAAA;AAAA,UAEK,QAAA;EAAA,SACN,MAAA,EAAQ,QAAA;EAAA,SACR,OAAA,EAAS,eAAA;AAAA;AAAA,UAGH,OAAA;EAAA,SACN,MAAA,EAAQ,UAAA;EAAA,SACR,IAAA,EAAM,OAAA;EAAA,SACN,MAAA,EAAQ,SAAA;EAAA,SACR,QAAA,WAAmB,QAAA;EAAA,SACnB,OAAA,EAAS,KAAA;AAAA;;iBAIJ,YAAA,CAAa,MAAQ,EAAA,UAAA"}

package/dist/core/verdict.mjs

@@ -0,0 +1,47 @@
+//#region src/core/verdict.ts
+/** Whether a reason means the room itself is live (holding or recording). */
+function isLiveReason(reason) {
+	return reason === "live" || reason === "restricted" || reason === "no-stream-url";
+}
+/**
+* The single constructor for `Verdict`. Six branches cover every reason;
+* precedence is failure → no room → offline → denied → live → no URL.
+*/
+function verdictOf(x) {
+	const room = x.room ?? null;
+	const stream = x.stream ?? null;
+	const base = {
+		room,
+		stream,
+		evidence: x.evidence ?? [],
+		failure: x.failure ?? null
+	};
+	if (x.failure) return {
+		...base,
+		reason: "error"
+	};
+	if (!room) return {
+		...base,
+		reason: "no-room-id"
+	};
+	if (!room.live) return {
+		...base,
+		reason: "offline"
+	};
+	if (x.denied) return {
+		...base,
+		reason: "restricted"
+	};
+	if (stream) return {
+		...base,
+		reason: "live"
+	};
+	return {
+		...base,
+		reason: "no-stream-url"
+	};
+}
+//#endregion
+export { isLiveReason, verdictOf };
+
+//# sourceMappingURL=verdict.mjs.map

package/dist/core/verdict.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"verdict.mjs","names":[],"sources":["../../src/core/verdict.ts"],"sourcesContent":["/**\n * Verdict — the per-tick liveness result and its machine-readable reason.\n *\n * Pure domain type: no I/O, no imports outside `domain/`. `reason` is derived\n * by `verdictOf`, never passed by callers; discovery reports facts, one total\n * function decides what they mean.\n */\n\n/**\n * Machine-readable reason for a LIVE status verdict.\n * \"live\" = stream URL resolved; \"offline\" = room not live;\n * \"restricted\" = live but age-protected/gated (stream refused);\n * \"no-stream-url\" = live but no URL and no gate evidence;\n * \"no-room-id\" = no discovery path produced a room ID;\n * \"error\" = network/parse failure across paths.\n */\nexport type LiveReason =\n  | \"live\"\n  | \"offline\"\n  | \"restricted\"\n  | \"no-stream-url\"\n  | \"no-room-id\"\n  | \"error\"\n\nexport interface RoomRef {\n  readonly id: string\n  readonly title: string | null\n  readonly live: boolean\n}\n\nexport interface StreamRef {\n  readonly url: string\n}\n\n/** Where a fact came from. Legacy `LiveInfo.source` values stay valid. */\nexport type SourceId = \"page\" | \"sigi\" | \"room-info\" | \"api-live\" | \"profile\" | \"none\"\n\nexport type EvidenceOutcome = \"hit\" | \"miss\" | \"denied\" | \"error\"\n\nexport interface Evidence {\n  readonly source: SourceId\n  readonly outcome: EvidenceOutcome\n}\n\nexport interface Verdict {\n  readonly reason: LiveReason\n  readonly room: RoomRef | null\n  readonly stream: StreamRef | null\n  readonly evidence: readonly Evidence[]\n  readonly failure: Error | null\n}\n\n/** Whether a reason means the room itself is live (holding or recording). */\nexport function isLiveReason(reason: LiveReason): boolean {\n  return reason === \"live\" || reason === \"restricted\" || reason === \"no-stream-url\"\n}\n\n/**\n * The single constructor for `Verdict`. Six branches cover every reason;\n * precedence is failure → no room → offline → denied → live → no URL.\n */\nexport function verdictOf(x: {\n  room?: RoomRef | null\n  stream?: StreamRef | null\n  denied?: boolean\n  failure?: Error | null\n  evidence?: readonly Evidence[]\n}): Verdict {\n  const room = x.room ?? null\n  const stream = x.stream ?? null\n  const base = { room, stream, evidence: x.evidence ?? [], failure: x.failure ?? null }\n\n  if (x.failure) return { ...base, reason: \"error\" }\n  if (!room) return { ...base, reason: \"no-room-id\" }\n  if (!room.live) return { ...base, reason: \"offline\" }\n  if (x.denied) return { ...base, reason: \"restricted\" }\n  if (stream) return { ...base, reason: \"live\" }\n  return { ...base, reason: \"no-stream-url\" }\n}\n"],"mappings":";;AAqDA,SAAgB,aAAa,QAA6B;CACxD,OAAO,WAAW,UAAU,WAAW,gBAAgB,WAAW;AACpE;;;;;AAMA,SAAgB,UAAU,GAMd;CACV,MAAM,OAAO,EAAE,QAAQ;CACvB,MAAM,SAAS,EAAE,UAAU;CAC3B,MAAM,OAAO;EAAE;EAAM;EAAQ,UAAU,EAAE,YAAY,CAAC;EAAG,SAAS,EAAE,WAAW;CAAK;CAEpF,IAAI,EAAE,SAAS,OAAO;EAAE,GAAG;EAAM,QAAQ;CAAQ;CACjD,IAAI,CAAC,MAAM,OAAO;EAAE,GAAG;EAAM,QAAQ;CAAa;CAClD,IAAI,CAAC,KAAK,MAAM,OAAO;EAAE,GAAG;EAAM,QAAQ;CAAU;CACpD,IAAI,EAAE,QAAQ,OAAO;EAAE,GAAG;EAAM,QAAQ;CAAa;CACrD,IAAI,QAAQ,OAAO;EAAE,GAAG;EAAM,QAAQ;CAAO;CAC7C,OAAO;EAAE,GAAG;EAAM,QAAQ;CAAgB;AAC5C"}

package/dist/index.d.mts

@@ -1,3 +1,6 @@
-import { AppErrorKind, RecorderConfig, RecorderController, RecorderEvent, RecorderEventHandler, RecorderStatus, TikTokError } from "./lib/config.mjs";
-import { createRecorder } from "./core/recorder/index.mjs";
-export { type AppErrorKind, type RecorderConfig, type RecorderController, type RecorderEvent, type RecorderEventHandler, type RecorderStatus, type TikTokError, createRecorder };
+import { TikTokError, TikTokErrorCode } from "./core/errors.mjs";
+import { Evidence, EvidenceOutcome, LiveReason, RoomRef, SourceId, StreamRef, Verdict, isLiveReason } from "./core/verdict.mjs";
+import { LogLevel, Phase, ProgressEvent, RecordEvent, RecordedFile, RecorderConfig, RecorderController, RecorderEvent, RecorderEventHandler, RecorderStatus } from "./app/config.mjs";
+import { createRecorder } from "./app/recorder.mjs";
+import { bytesToHuman, formatDuration, relativeTime, sanitizeUser } from "./core/format.mjs";
+export { type Evidence, type EvidenceOutcome, type LiveReason, type LogLevel, type Phase, type ProgressEvent, type RecordEvent, type RecordedFile, type RecorderConfig, type RecorderController, type RecorderEvent, type RecorderEventHandler, type RecorderStatus, type RoomRef, type SourceId, type StreamRef, TikTokError, type TikTokErrorCode, type Verdict, bytesToHuman, createRecorder, formatDuration, isLiveReason, relativeTime, sanitizeUser };

package/dist/index.mjs

@@ -1,2 +1,5 @@
-import { createRecorder } from "./core/recorder/index.mjs";
-export { createRecorder };
+import { isLiveReason } from "./core/verdict.mjs";
+import { TikTokError } from "./core/errors.mjs";
+import { bytesToHuman, formatDuration, relativeTime, sanitizeUser } from "./core/format.mjs";
+import { createRecorder } from "./app/recorder.mjs";
+export { TikTokError, bytesToHuman, createRecorder, formatDuration, isLiveReason, relativeTime, sanitizeUser };