@editframe/assets 0.37.3-beta → 0.38.0

package/dist/md5.cjs

@@ -0,0 +1,64 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs);
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+let node_crypto = require("node:crypto");
+node_crypto = require_rolldown_runtime.__toESM(node_crypto);
+
+//#region src/md5.ts
+async function md5Directory(directory, spinner) {
+	const shouldEndSpinner = !spinner;
+	if (!spinner) {
+		const { default: ora } = await import("ora");
+		spinner = ora("⚡️ Calculating MD5").start();
+	}
+	spinner.suffixText = directory;
+	const files = await (0, node_fs_promises.readdir)(directory, { withFileTypes: true });
+	const hashes = await Promise.all(files.map(async (file) => {
+		const filePath = (0, node_path.join)(directory, file.name);
+		if (file.isDirectory()) return md5Directory(filePath, spinner);
+		spinner.suffixText = filePath;
+		return md5FilePath(filePath);
+	}));
+	const hash = node_crypto.default.createHash("md5");
+	for (const fileHash of hashes) hash.update(fileHash);
+	if (shouldEndSpinner) {
+		spinner.succeed("MD5 calculated");
+		spinner.suffixText = directory;
+	}
+	return addDashesToUUID(hash.digest("hex"));
+}
+async function md5FilePath(filePath) {
+	return md5ReadStream((0, node_fs.createReadStream)(filePath));
+}
+function md5ReadStream(readStream) {
+	return new Promise((resolve, reject) => {
+		const hash = node_crypto.default.createHash("md5");
+		readStream.on("data", (data) => {
+			hash.update(data);
+		});
+		readStream.on("error", reject);
+		readStream.on("end", () => {
+			resolve(addDashesToUUID(hash.digest("hex")));
+		});
+	});
+}
+function md5Buffer(buffer) {
+	const hash = node_crypto.default.createHash("md5");
+	hash.update(buffer);
+	return addDashesToUUID(hash.digest("hex"));
+}
+function addDashesToUUID(uuidWithoutDashes) {
+	if (uuidWithoutDashes.length !== 32) throw new Error("Invalid UUID without dashes. Expected 32 characters.");
+	return uuidWithoutDashes.slice(0, 8) + "-" + uuidWithoutDashes.slice(8, 12) + "-" + uuidWithoutDashes.slice(12, 16) + "-" + uuidWithoutDashes.slice(16, 20) + "-" + uuidWithoutDashes.slice(20, 32);
+}
+
+//#endregion
+exports.md5Buffer = md5Buffer;
+exports.md5Directory = md5Directory;
+exports.md5FilePath = md5FilePath;
+exports.md5ReadStream = md5ReadStream;
+//# sourceMappingURL=md5.cjs.map

package/dist/md5.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"md5.cjs","names":["crypto"],"sources":["../src/md5.ts"],"sourcesContent":["import { type ReadStream, createReadStream } from \"node:fs\";\nimport { readdir } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport crypto from \"node:crypto\";\nimport type { Ora } from \"ora\";\n\n// Recursively calculate the MD5 hash of all files in a directory\nexport async function md5Directory(directory: string, spinner?: Ora) {\n  const shouldEndSpinner = !spinner;\n  if (!spinner) {\n    const { default: ora } = await import(\"ora\");\n    spinner = ora(\"⚡️ Calculating MD5\").start();\n  }\n  spinner.suffixText = directory;\n  const files = await readdir(directory, { withFileTypes: true });\n  const hashes = await Promise.all(\n    files.map(async (file) => {\n      const filePath = join(directory, file.name);\n      if (file.isDirectory()) {\n        return md5Directory(filePath, spinner);\n      }\n      spinner.suffixText = filePath;\n      return md5FilePath(filePath);\n    }),\n  );\n\n  const hash = crypto.createHash(\"md5\");\n  for (const fileHash of hashes) {\n    hash.update(fileHash);\n  }\n\n  if (shouldEndSpinner) {\n    spinner.succeed(\"MD5 calculated\");\n    spinner.suffixText = directory;\n  }\n  return addDashesToUUID(hash.digest(\"hex\"));\n}\n\nexport async function md5FilePath(filePath: string) {\n  const readStream = createReadStream(filePath);\n  return md5ReadStream(readStream);\n}\n\nexport function md5ReadStream(readStream: ReadStream) {\n  return new Promise<string>((resolve, reject) => {\n    const hash = crypto.createHash(\"md5\");\n    readStream.on(\"data\", (data) => {\n      hash.update(data);\n    });\n    readStream.on(\"error\", reject);\n    readStream.on(\"end\", () => {\n      resolve(addDashesToUUID(hash.digest(\"hex\")));\n    });\n  });\n}\n\nexport function md5Buffer(buffer: Buffer) {\n  const hash = crypto.createHash(\"md5\");\n  hash.update(buffer);\n  return addDashesToUUID(hash.digest(\"hex\"));\n}\n\nfunction addDashesToUUID(uuidWithoutDashes: string) {\n  if (uuidWithoutDashes.length !== 32) {\n    throw new Error(\"Invalid UUID without dashes. Expected 32 characters.\");\n  }\n\n  return (\n    // biome-ignore lint/style/useTemplate: using a template makes a long line\n    uuidWithoutDashes.slice(0, 8) +\n    \"-\" +\n    uuidWithoutDashes.slice(8, 12) +\n    \"-\" +\n    uuidWithoutDashes.slice(12, 16) +\n    \"-\" +\n    uuidWithoutDashes.slice(16, 20) +\n    \"-\" +\n    uuidWithoutDashes.slice(20, 32)\n  );\n}\n"],"mappings":";;;;;;;;;;;AAOA,eAAsB,aAAa,WAAmB,SAAe;CACnE,MAAM,mBAAmB,CAAC;AAC1B,KAAI,CAAC,SAAS;EACZ,MAAM,EAAE,SAAS,QAAQ,MAAM,OAAO;AACtC,YAAU,IAAI,qBAAqB,CAAC,OAAO;;AAE7C,SAAQ,aAAa;CACrB,MAAM,QAAQ,oCAAc,WAAW,EAAE,eAAe,MAAM,CAAC;CAC/D,MAAM,SAAS,MAAM,QAAQ,IAC3B,MAAM,IAAI,OAAO,SAAS;EACxB,MAAM,+BAAgB,WAAW,KAAK,KAAK;AAC3C,MAAI,KAAK,aAAa,CACpB,QAAO,aAAa,UAAU,QAAQ;AAExC,UAAQ,aAAa;AACrB,SAAO,YAAY,SAAS;GAC5B,CACH;CAED,MAAM,OAAOA,oBAAO,WAAW,MAAM;AACrC,MAAK,MAAM,YAAY,OACrB,MAAK,OAAO,SAAS;AAGvB,KAAI,kBAAkB;AACpB,UAAQ,QAAQ,iBAAiB;AACjC,UAAQ,aAAa;;AAEvB,QAAO,gBAAgB,KAAK,OAAO,MAAM,CAAC;;AAG5C,eAAsB,YAAY,UAAkB;AAElD,QAAO,4CAD6B,SAAS,CACb;;AAGlC,SAAgB,cAAc,YAAwB;AACpD,QAAO,IAAI,SAAiB,SAAS,WAAW;EAC9C,MAAM,OAAOA,oBAAO,WAAW,MAAM;AACrC,aAAW,GAAG,SAAS,SAAS;AAC9B,QAAK,OAAO,KAAK;IACjB;AACF,aAAW,GAAG,SAAS,OAAO;AAC9B,aAAW,GAAG,aAAa;AACzB,WAAQ,gBAAgB,KAAK,OAAO,MAAM,CAAC,CAAC;IAC5C;GACF;;AAGJ,SAAgB,UAAU,QAAgB;CACxC,MAAM,OAAOA,oBAAO,WAAW,MAAM;AACrC,MAAK,OAAO,OAAO;AACnB,QAAO,gBAAgB,KAAK,OAAO,MAAM,CAAC;;AAG5C,SAAS,gBAAgB,mBAA2B;AAClD,KAAI,kBAAkB,WAAW,GAC/B,OAAM,IAAI,MAAM,uDAAuD;AAGzE,QAEE,kBAAkB,MAAM,GAAG,EAAE,GAC7B,MACA,kBAAkB,MAAM,GAAG,GAAG,GAC9B,MACA,kBAAkB,MAAM,IAAI,GAAG,GAC/B,MACA,kBAAkB,MAAM,IAAI,GAAG,GAC/B,MACA,kBAAkB,MAAM,IAAI,GAAG"}

package/dist/md5.d.cts

@@ -0,0 +1,11 @@
+import { ReadStream } from "node:fs";
+import { Ora } from "ora";
+
+//#region src/md5.d.ts
+declare function md5Directory(directory: string, spinner?: Ora): Promise<string>;
+declare function md5FilePath(filePath: string): Promise<string>;
+declare function md5ReadStream(readStream: ReadStream): Promise<string>;
+declare function md5Buffer(buffer: Buffer): string;
+//#endregion
+export { md5Buffer, md5Directory, md5FilePath, md5ReadStream };
+//# sourceMappingURL=md5.d.cts.map

package/dist/md5.js

@@ -2,12 +2,14 @@ import { createReadStream } from "node:fs";
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import crypto from "node:crypto";
-import ora from "ora";
 
 //#region src/md5.ts
 async function md5Directory(directory, spinner) {
 	const shouldEndSpinner = !spinner;
-	spinner ||= ora("⚡️ Calculating MD5").start();
+	if (!spinner) {
+		const { default: ora } = await import("ora");
+		spinner = ora("⚡️ Calculating MD5").start();
+	}
 	spinner.suffixText = directory;
 	const files = await readdir(directory, { withFileTypes: true });
 	const hashes = await Promise.all(files.map(async (file) => {

package/dist/md5.js.map

@@ -1 +1 @@
-{"version":3,"file":"md5.js","names":[],"sources":["../src/md5.ts"],"sourcesContent":["import { type ReadStream, createReadStream } from \"node:fs\";\nimport { readdir } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport crypto from \"node:crypto\";\nimport ora, { type Ora } from \"ora\";\n\n// Recursively calculate the MD5 hash of all files in a directory\nexport async function md5Directory(directory: string, spinner?: Ora) {\n  const shouldEndSpinner = !spinner;\n  spinner ||= ora(\"⚡️ Calculating MD5\").start();\n  spinner.suffixText = directory;\n  const files = await readdir(directory, { withFileTypes: true });\n  const hashes = await Promise.all(\n    files.map(async (file) => {\n      const filePath = join(directory, file.name);\n      if (file.isDirectory()) {\n        return md5Directory(filePath, spinner);\n      }\n      spinner.suffixText = filePath;\n      return md5FilePath(filePath);\n    }),\n  );\n\n  const hash = crypto.createHash(\"md5\");\n  for (const fileHash of hashes) {\n    hash.update(fileHash);\n  }\n\n  if (shouldEndSpinner) {\n    spinner.succeed(\"MD5 calculated\");\n    spinner.suffixText = directory;\n  }\n  return addDashesToUUID(hash.digest(\"hex\"));\n}\n\nexport async function md5FilePath(filePath: string) {\n  const readStream = createReadStream(filePath);\n  return md5ReadStream(readStream);\n}\n\nexport function md5ReadStream(readStream: ReadStream) {\n  return new Promise<string>((resolve, reject) => {\n    const hash = crypto.createHash(\"md5\");\n    readStream.on(\"data\", (data) => {\n      hash.update(data);\n    });\n    readStream.on(\"error\", reject);\n    readStream.on(\"end\", () => {\n      resolve(addDashesToUUID(hash.digest(\"hex\")));\n    });\n  });\n}\n\nexport function md5Buffer(buffer: Buffer) {\n  const hash = crypto.createHash(\"md5\");\n  hash.update(buffer);\n  return addDashesToUUID(hash.digest(\"hex\"));\n}\n\nfunction addDashesToUUID(uuidWithoutDashes: string) {\n  if (uuidWithoutDashes.length !== 32) {\n    throw new Error(\"Invalid UUID without dashes. Expected 32 characters.\");\n  }\n\n  return (\n    // biome-ignore lint/style/useTemplate: using a template makes a long line\n    uuidWithoutDashes.slice(0, 8) +\n    \"-\" +\n    uuidWithoutDashes.slice(8, 12) +\n    \"-\" +\n    uuidWithoutDashes.slice(12, 16) +\n    \"-\" +\n    uuidWithoutDashes.slice(16, 20) +\n    \"-\" +\n    uuidWithoutDashes.slice(20, 32)\n  );\n}\n"],"mappings":";;;;;;;AAOA,eAAsB,aAAa,WAAmB,SAAe;CACnE,MAAM,mBAAmB,CAAC;AAC1B,aAAY,IAAI,qBAAqB,CAAC,OAAO;AAC7C,SAAQ,aAAa;CACrB,MAAM,QAAQ,MAAM,QAAQ,WAAW,EAAE,eAAe,MAAM,CAAC;CAC/D,MAAM,SAAS,MAAM,QAAQ,IAC3B,MAAM,IAAI,OAAO,SAAS;EACxB,MAAM,WAAW,KAAK,WAAW,KAAK,KAAK;AAC3C,MAAI,KAAK,aAAa,CACpB,QAAO,aAAa,UAAU,QAAQ;AAExC,UAAQ,aAAa;AACrB,SAAO,YAAY,SAAS;GAC5B,CACH;CAED,MAAM,OAAO,OAAO,WAAW,MAAM;AACrC,MAAK,MAAM,YAAY,OACrB,MAAK,OAAO,SAAS;AAGvB,KAAI,kBAAkB;AACpB,UAAQ,QAAQ,iBAAiB;AACjC,UAAQ,aAAa;;AAEvB,QAAO,gBAAgB,KAAK,OAAO,MAAM,CAAC;;AAG5C,eAAsB,YAAY,UAAkB;AAElD,QAAO,cADY,iBAAiB,SAAS,CACb;;AAGlC,SAAgB,cAAc,YAAwB;AACpD,QAAO,IAAI,SAAiB,SAAS,WAAW;EAC9C,MAAM,OAAO,OAAO,WAAW,MAAM;AACrC,aAAW,GAAG,SAAS,SAAS;AAC9B,QAAK,OAAO,KAAK;IACjB;AACF,aAAW,GAAG,SAAS,OAAO;AAC9B,aAAW,GAAG,aAAa;AACzB,WAAQ,gBAAgB,KAAK,OAAO,MAAM,CAAC,CAAC;IAC5C;GACF;;AAGJ,SAAgB,UAAU,QAAgB;CACxC,MAAM,OAAO,OAAO,WAAW,MAAM;AACrC,MAAK,OAAO,OAAO;AACnB,QAAO,gBAAgB,KAAK,OAAO,MAAM,CAAC;;AAG5C,SAAS,gBAAgB,mBAA2B;AAClD,KAAI,kBAAkB,WAAW,GAC/B,OAAM,IAAI,MAAM,uDAAuD;AAGzE,QAEE,kBAAkB,MAAM,GAAG,EAAE,GAC7B,MACA,kBAAkB,MAAM,GAAG,GAAG,GAC9B,MACA,kBAAkB,MAAM,IAAI,GAAG,GAC/B,MACA,kBAAkB,MAAM,IAAI,GAAG,GAC/B,MACA,kBAAkB,MAAM,IAAI,GAAG"}
+{"version":3,"file":"md5.js","names":[],"sources":["../src/md5.ts"],"sourcesContent":["import { type ReadStream, createReadStream } from \"node:fs\";\nimport { readdir } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport crypto from \"node:crypto\";\nimport type { Ora } from \"ora\";\n\n// Recursively calculate the MD5 hash of all files in a directory\nexport async function md5Directory(directory: string, spinner?: Ora) {\n  const shouldEndSpinner = !spinner;\n  if (!spinner) {\n    const { default: ora } = await import(\"ora\");\n    spinner = ora(\"⚡️ Calculating MD5\").start();\n  }\n  spinner.suffixText = directory;\n  const files = await readdir(directory, { withFileTypes: true });\n  const hashes = await Promise.all(\n    files.map(async (file) => {\n      const filePath = join(directory, file.name);\n      if (file.isDirectory()) {\n        return md5Directory(filePath, spinner);\n      }\n      spinner.suffixText = filePath;\n      return md5FilePath(filePath);\n    }),\n  );\n\n  const hash = crypto.createHash(\"md5\");\n  for (const fileHash of hashes) {\n    hash.update(fileHash);\n  }\n\n  if (shouldEndSpinner) {\n    spinner.succeed(\"MD5 calculated\");\n    spinner.suffixText = directory;\n  }\n  return addDashesToUUID(hash.digest(\"hex\"));\n}\n\nexport async function md5FilePath(filePath: string) {\n  const readStream = createReadStream(filePath);\n  return md5ReadStream(readStream);\n}\n\nexport function md5ReadStream(readStream: ReadStream) {\n  return new Promise<string>((resolve, reject) => {\n    const hash = crypto.createHash(\"md5\");\n    readStream.on(\"data\", (data) => {\n      hash.update(data);\n    });\n    readStream.on(\"error\", reject);\n    readStream.on(\"end\", () => {\n      resolve(addDashesToUUID(hash.digest(\"hex\")));\n    });\n  });\n}\n\nexport function md5Buffer(buffer: Buffer) {\n  const hash = crypto.createHash(\"md5\");\n  hash.update(buffer);\n  return addDashesToUUID(hash.digest(\"hex\"));\n}\n\nfunction addDashesToUUID(uuidWithoutDashes: string) {\n  if (uuidWithoutDashes.length !== 32) {\n    throw new Error(\"Invalid UUID without dashes. Expected 32 characters.\");\n  }\n\n  return (\n    // biome-ignore lint/style/useTemplate: using a template makes a long line\n    uuidWithoutDashes.slice(0, 8) +\n    \"-\" +\n    uuidWithoutDashes.slice(8, 12) +\n    \"-\" +\n    uuidWithoutDashes.slice(12, 16) +\n    \"-\" +\n    uuidWithoutDashes.slice(16, 20) +\n    \"-\" +\n    uuidWithoutDashes.slice(20, 32)\n  );\n}\n"],"mappings":";;;;;;AAOA,eAAsB,aAAa,WAAmB,SAAe;CACnE,MAAM,mBAAmB,CAAC;AAC1B,KAAI,CAAC,SAAS;EACZ,MAAM,EAAE,SAAS,QAAQ,MAAM,OAAO;AACtC,YAAU,IAAI,qBAAqB,CAAC,OAAO;;AAE7C,SAAQ,aAAa;CACrB,MAAM,QAAQ,MAAM,QAAQ,WAAW,EAAE,eAAe,MAAM,CAAC;CAC/D,MAAM,SAAS,MAAM,QAAQ,IAC3B,MAAM,IAAI,OAAO,SAAS;EACxB,MAAM,WAAW,KAAK,WAAW,KAAK,KAAK;AAC3C,MAAI,KAAK,aAAa,CACpB,QAAO,aAAa,UAAU,QAAQ;AAExC,UAAQ,aAAa;AACrB,SAAO,YAAY,SAAS;GAC5B,CACH;CAED,MAAM,OAAO,OAAO,WAAW,MAAM;AACrC,MAAK,MAAM,YAAY,OACrB,MAAK,OAAO,SAAS;AAGvB,KAAI,kBAAkB;AACpB,UAAQ,QAAQ,iBAAiB;AACjC,UAAQ,aAAa;;AAEvB,QAAO,gBAAgB,KAAK,OAAO,MAAM,CAAC;;AAG5C,eAAsB,YAAY,UAAkB;AAElD,QAAO,cADY,iBAAiB,SAAS,CACb;;AAGlC,SAAgB,cAAc,YAAwB;AACpD,QAAO,IAAI,SAAiB,SAAS,WAAW;EAC9C,MAAM,OAAO,OAAO,WAAW,MAAM;AACrC,aAAW,GAAG,SAAS,SAAS;AAC9B,QAAK,OAAO,KAAK;IACjB;AACF,aAAW,GAAG,SAAS,OAAO;AAC9B,aAAW,GAAG,aAAa;AACzB,WAAQ,gBAAgB,KAAK,OAAO,MAAM,CAAC,CAAC;IAC5C;GACF;;AAGJ,SAAgB,UAAU,QAAgB;CACxC,MAAM,OAAO,OAAO,WAAW,MAAM;AACrC,MAAK,OAAO,OAAO;AACnB,QAAO,gBAAgB,KAAK,OAAO,MAAM,CAAC;;AAG5C,SAAS,gBAAgB,mBAA2B;AAClD,KAAI,kBAAkB,WAAW,GAC/B,OAAM,IAAI,MAAM,uDAAuD;AAGzE,QAEE,kBAAkB,MAAM,GAAG,EAAE,GAC7B,MACA,kBAAkB,MAAM,GAAG,GAAG,GAC9B,MACA,kBAAkB,MAAM,IAAI,GAAG,GAC/B,MACA,kBAAkB,MAAM,IAAI,GAAG,GAC/B,MACA,kBAAkB,MAAM,IAAI,GAAG"}

package/dist/tasks/cacheImage.cjs

@@ -0,0 +1,28 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_idempotentTask = require('../idempotentTask.cjs');
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+
+//#region src/tasks/cacheImage.ts
+const cacheImageTask = require_idempotentTask.idempotentTask({
+	label: "image",
+	filename: (absolutePath) => node_path.default.basename(absolutePath),
+	runner: async (absolutePath) => {
+		return (0, node_fs.createReadStream)(absolutePath);
+	}
+});
+const cacheImage = async (cacheRoot, absolutePath) => {
+	try {
+		return await cacheImageTask(cacheRoot, absolutePath);
+	} catch (error) {
+		console.error(error);
+		console.trace("Error caching image", error);
+		throw error;
+	}
+};
+
+//#endregion
+exports.cacheImage = cacheImage;
+//# sourceMappingURL=cacheImage.cjs.map

package/dist/tasks/cacheImage.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cacheImage.cjs","names":["idempotentTask","path"],"sources":["../../src/tasks/cacheImage.ts"],"sourcesContent":["import { idempotentTask } from \"../idempotentTask.js\";\nimport { createReadStream } from \"node:fs\";\n\nimport path from \"node:path\";\n\nconst cacheImageTask = idempotentTask({\n  label: \"image\",\n  filename: (absolutePath: string) => path.basename(absolutePath),\n  runner: async (absolutePath) => {\n    return createReadStream(absolutePath);\n  },\n});\n\nexport const cacheImage = async (cacheRoot: string, absolutePath: string) => {\n  try {\n    return await cacheImageTask(cacheRoot, absolutePath);\n  } catch (error) {\n    console.error(error);\n    console.trace(\"Error caching image\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;;AAKA,MAAM,iBAAiBA,sCAAe;CACpC,OAAO;CACP,WAAW,iBAAyBC,kBAAK,SAAS,aAAa;CAC/D,QAAQ,OAAO,iBAAiB;AAC9B,uCAAwB,aAAa;;CAExC,CAAC;AAEF,MAAa,aAAa,OAAO,WAAmB,iBAAyB;AAC3E,KAAI;AACF,SAAO,MAAM,eAAe,WAAW,aAAa;UAC7C,OAAO;AACd,UAAQ,MAAM,MAAM;AACpB,UAAQ,MAAM,uBAAuB,MAAM;AAC3C,QAAM"}

package/dist/tasks/cacheImage.d.cts

@@ -0,0 +1,7 @@
+import { TaskResult } from "../idempotentTask.cjs";
+
+//#region src/tasks/cacheImage.d.ts
+declare const cacheImage: (cacheRoot: string, absolutePath: string) => Promise<TaskResult>;
+//#endregion
+export { cacheImage };
+//# sourceMappingURL=cacheImage.d.cts.map

package/dist/tasks/findOrCreateCaptions.cjs

@@ -0,0 +1,58 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_idempotentTask = require('../idempotentTask.cjs');
+let node_child_process = require("node:child_process");
+node_child_process = require_rolldown_runtime.__toESM(node_child_process);
+let node_util = require("node:util");
+node_util = require_rolldown_runtime.__toESM(node_util);
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+
+//#region src/tasks/findOrCreateCaptions.ts
+const execPromise = (0, node_util.promisify)(node_child_process.exec);
+const log = (0, debug.default)("ef:generateCaptions");
+const convertWhisperToEditframeFormat = (whisperData) => {
+	return {
+		segments: whisperData.segments.map((segment) => ({
+			start: Math.round(segment.start * 1e3),
+			end: Math.round(segment.end * 1e3),
+			text: segment.text.trim()
+		})),
+		word_segments: whisperData.segments.flatMap((segment) => segment.words.map((word) => ({
+			text: word.text,
+			start: Math.round(word.start * 1e3),
+			end: Math.round(word.end * 1e3)
+		})))
+	};
+};
+const generateCaptionDataFromPath = async (absolutePath) => {
+	const command = `whisper_timestamped --language en --efficient --output_format json ${absolutePath}`;
+	log(`Running command: ${command}`);
+	const { stdout } = await execPromise(command);
+	try {
+		const captionData = convertWhisperToEditframeFormat(JSON.parse(stdout));
+		return JSON.stringify(captionData, null, 2);
+	} catch (error) {
+		log(`Error parsing whisper output: ${error}`);
+		throw new Error(`Failed to parse whisper_timestamped output: ${error}`);
+	}
+};
+const generateCaptionDataTask = require_idempotentTask.idempotentTask({
+	label: "captions",
+	filename: (absolutePath) => `${(0, node_path.basename)(absolutePath)}.captions.json`,
+	runner: generateCaptionDataFromPath
+});
+const findOrCreateCaptions = async (cacheRoot, absolutePath) => {
+	try {
+		return await generateCaptionDataTask(cacheRoot, absolutePath);
+	} catch (error) {
+		console.trace("Error finding or creating captions", error);
+		throw error;
+	}
+};
+
+//#endregion
+exports.findOrCreateCaptions = findOrCreateCaptions;
+exports.generateCaptionDataFromPath = generateCaptionDataFromPath;
+//# sourceMappingURL=findOrCreateCaptions.cjs.map

package/dist/tasks/findOrCreateCaptions.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"findOrCreateCaptions.cjs","names":["exec","idempotentTask"],"sources":["../../src/tasks/findOrCreateCaptions.ts"],"sourcesContent":["import { basename } from \"node:path\";\nimport { promisify } from \"node:util\";\nimport { exec } from \"node:child_process\";\n\nimport debug from \"debug\";\n\nimport { idempotentTask } from \"../idempotentTask.js\";\n\nconst execPromise = promisify(exec);\n\nconst log = debug(\"ef:generateCaptions\");\n\ninterface WhisperWord {\n  text: string;\n  start: number;\n  end: number;\n  confidence: number;\n}\n\ninterface WhisperSegment {\n  text: string;\n  start: number;\n  end: number;\n  words: WhisperWord[];\n}\n\ninterface WhisperOutput {\n  segments: WhisperSegment[];\n}\n\ninterface CaptionOutput {\n  segments: Array<{\n    start: number;\n    end: number;\n    text: string;\n  }>;\n  word_segments: Array<{\n    text: string;\n    start: number;\n    end: number;\n  }>;\n}\n\nconst convertWhisperToEditframeFormat = (\n  whisperData: WhisperOutput,\n): CaptionOutput => {\n  const segments = whisperData.segments.map((segment) => ({\n    start: Math.round(segment.start * 1000), // Convert to milliseconds\n    end: Math.round(segment.end * 1000),\n    text: segment.text.trim(),\n  }));\n\n  const word_segments = whisperData.segments.flatMap((segment) =>\n    segment.words.map((word) => ({\n      text: word.text,\n      start: Math.round(word.start * 1000), // Convert to milliseconds\n      end: Math.round(word.end * 1000),\n    })),\n  );\n\n  return { segments, word_segments };\n};\n\nexport const generateCaptionDataFromPath = async (absolutePath: string) => {\n  const command = `whisper_timestamped --language en --efficient --output_format json ${absolutePath}`;\n  log(`Running command: ${command}`);\n  const { stdout } = await execPromise(command);\n\n  try {\n    const whisperData = JSON.parse(stdout) as WhisperOutput;\n    const captionData = convertWhisperToEditframeFormat(whisperData);\n    return JSON.stringify(captionData, null, 2);\n  } catch (error) {\n    log(`Error parsing whisper output: ${error}`);\n    throw new Error(`Failed to parse whisper_timestamped output: ${error}`);\n  }\n};\n\nconst generateCaptionDataTask = idempotentTask({\n  label: \"captions\",\n  filename: (absolutePath) => `${basename(absolutePath)}.captions.json`,\n  runner: generateCaptionDataFromPath,\n});\n\nexport const findOrCreateCaptions = async (\n  cacheRoot: string,\n  absolutePath: string,\n) => {\n  try {\n    return await generateCaptionDataTask(cacheRoot, absolutePath);\n  } catch (error) {\n    console.trace(\"Error finding or creating captions\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;;;;;;AAQA,MAAM,uCAAwBA,wBAAK;AAEnC,MAAM,yBAAY,sBAAsB;AAiCxC,MAAM,mCACJ,gBACkB;AAelB,QAAO;EAAE,UAdQ,YAAY,SAAS,KAAK,aAAa;GACtD,OAAO,KAAK,MAAM,QAAQ,QAAQ,IAAK;GACvC,KAAK,KAAK,MAAM,QAAQ,MAAM,IAAK;GACnC,MAAM,QAAQ,KAAK,MAAM;GAC1B,EAAE;EAUgB,eARG,YAAY,SAAS,SAAS,YAClD,QAAQ,MAAM,KAAK,UAAU;GAC3B,MAAM,KAAK;GACX,OAAO,KAAK,MAAM,KAAK,QAAQ,IAAK;GACpC,KAAK,KAAK,MAAM,KAAK,MAAM,IAAK;GACjC,EAAE,CACJ;EAEiC;;AAGpC,MAAa,8BAA8B,OAAO,iBAAyB;CACzE,MAAM,UAAU,sEAAsE;AACtF,KAAI,oBAAoB,UAAU;CAClC,MAAM,EAAE,WAAW,MAAM,YAAY,QAAQ;AAE7C,KAAI;EAEF,MAAM,cAAc,gCADA,KAAK,MAAM,OAAO,CAC0B;AAChE,SAAO,KAAK,UAAU,aAAa,MAAM,EAAE;UACpC,OAAO;AACd,MAAI,iCAAiC,QAAQ;AAC7C,QAAM,IAAI,MAAM,+CAA+C,QAAQ;;;AAI3E,MAAM,0BAA0BC,sCAAe;CAC7C,OAAO;CACP,WAAW,iBAAiB,2BAAY,aAAa,CAAC;CACtD,QAAQ;CACT,CAAC;AAEF,MAAa,uBAAuB,OAClC,WACA,iBACG;AACH,KAAI;AACF,SAAO,MAAM,wBAAwB,WAAW,aAAa;UACtD,OAAO;AACd,UAAQ,MAAM,sCAAsC,MAAM;AAC1D,QAAM"}

package/dist/tasks/findOrCreateCaptions.d.cts

@@ -0,0 +1,8 @@
+import { TaskResult } from "../idempotentTask.cjs";
+
+//#region src/tasks/findOrCreateCaptions.d.ts
+declare const generateCaptionDataFromPath: (absolutePath: string) => Promise<string>;
+declare const findOrCreateCaptions: (cacheRoot: string, absolutePath: string) => Promise<TaskResult>;
+//#endregion
+export { findOrCreateCaptions, generateCaptionDataFromPath };
+//# sourceMappingURL=findOrCreateCaptions.d.cts.map

package/dist/tasks/findOrCreateCaptions.js.map

@@ -1 +1 @@
-{"version":3,"file":"findOrCreateCaptions.js","names":[],"sources":["../../src/tasks/findOrCreateCaptions.ts"],"sourcesContent":["import { basename } from \"node:path\";\nimport { promisify } from \"node:util\";\nimport { exec } from \"node:child_process\";\n\nimport debug from \"debug\";\n\nimport { idempotentTask } from \"../idempotentTask.js\";\n\nconst execPromise = promisify(exec);\n\nconst log = debug(\"ef:generateCaptions\");\n\ninterface WhisperWord {\n  text: string;\n  start: number;\n  end: number;\n  confidence: number;\n}\n\ninterface WhisperSegment {\n  text: string;\n  start: number;\n  end: number;\n  words: WhisperWord[];\n}\n\ninterface WhisperOutput {\n  segments: WhisperSegment[];\n}\n\ninterface CaptionOutput {\n  segments: Array<{\n    start: number;\n    end: number;\n    text: string;\n  }>;\n  word_segments: Array<{\n    text: string;\n    start: number;\n    end: number;\n  }>;\n}\n\nconst convertWhisperToEditframeFormat = (whisperData: WhisperOutput): CaptionOutput => {\n  const segments = whisperData.segments.map(segment => ({\n    start: Math.round(segment.start * 1000), // Convert to milliseconds\n    end: Math.round(segment.end * 1000),\n    text: segment.text.trim(),\n  }));\n\n  const word_segments = whisperData.segments.flatMap(segment =>\n    segment.words.map(word => ({\n      text: word.text,\n      start: Math.round(word.start * 1000), // Convert to milliseconds\n      end: Math.round(word.end * 1000),\n    }))\n  );\n\n  return { segments, word_segments };\n};\n\nexport const generateCaptionDataFromPath = async (absolutePath: string) => {\n  const command = `whisper_timestamped --language en --efficient --output_format json ${absolutePath}`;\n  log(`Running command: ${command}`);\n  const { stdout } = await execPromise(command);\n  \n  try {\n    const whisperData = JSON.parse(stdout) as WhisperOutput;\n    const captionData = convertWhisperToEditframeFormat(whisperData);\n    return JSON.stringify(captionData, null, 2);\n  } catch (error) {\n    log(`Error parsing whisper output: ${error}`);\n    throw new Error(`Failed to parse whisper_timestamped output: ${error}`);\n  }\n};\n\nconst generateCaptionDataTask = idempotentTask({\n  label: \"captions\",\n  filename: (absolutePath) => `${basename(absolutePath)}.captions.json`,\n  runner: generateCaptionDataFromPath,\n});\n\nexport const findOrCreateCaptions = async (\n  cacheRoot: string,\n  absolutePath: string,\n) => {\n  try {\n    return await generateCaptionDataTask(cacheRoot, absolutePath);\n  } catch (error) {\n    console.trace(\"Error finding or creating captions\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;AAQA,MAAM,cAAc,UAAU,KAAK;AAEnC,MAAM,MAAM,MAAM,sBAAsB;AAiCxC,MAAM,mCAAmC,gBAA8C;AAerF,QAAO;EAAE,UAdQ,YAAY,SAAS,KAAI,aAAY;GACpD,OAAO,KAAK,MAAM,QAAQ,QAAQ,IAAK;GACvC,KAAK,KAAK,MAAM,QAAQ,MAAM,IAAK;GACnC,MAAM,QAAQ,KAAK,MAAM;GAC1B,EAAE;EAUgB,eARG,YAAY,SAAS,SAAQ,YACjD,QAAQ,MAAM,KAAI,UAAS;GACzB,MAAM,KAAK;GACX,OAAO,KAAK,MAAM,KAAK,QAAQ,IAAK;GACpC,KAAK,KAAK,MAAM,KAAK,MAAM,IAAK;GACjC,EAAE,CACJ;EAEiC;;AAGpC,MAAa,8BAA8B,OAAO,iBAAyB;CACzE,MAAM,UAAU,sEAAsE;AACtF,KAAI,oBAAoB,UAAU;CAClC,MAAM,EAAE,WAAW,MAAM,YAAY,QAAQ;AAE7C,KAAI;EAEF,MAAM,cAAc,gCADA,KAAK,MAAM,OAAO,CAC0B;AAChE,SAAO,KAAK,UAAU,aAAa,MAAM,EAAE;UACpC,OAAO;AACd,MAAI,iCAAiC,QAAQ;AAC7C,QAAM,IAAI,MAAM,+CAA+C,QAAQ;;;AAI3E,MAAM,0BAA0B,eAAe;CAC7C,OAAO;CACP,WAAW,iBAAiB,GAAG,SAAS,aAAa,CAAC;CACtD,QAAQ;CACT,CAAC;AAEF,MAAa,uBAAuB,OAClC,WACA,iBACG;AACH,KAAI;AACF,SAAO,MAAM,wBAAwB,WAAW,aAAa;UACtD,OAAO;AACd,UAAQ,MAAM,sCAAsC,MAAM;AAC1D,QAAM"}
+{"version":3,"file":"findOrCreateCaptions.js","names":[],"sources":["../../src/tasks/findOrCreateCaptions.ts"],"sourcesContent":["import { basename } from \"node:path\";\nimport { promisify } from \"node:util\";\nimport { exec } from \"node:child_process\";\n\nimport debug from \"debug\";\n\nimport { idempotentTask } from \"../idempotentTask.js\";\n\nconst execPromise = promisify(exec);\n\nconst log = debug(\"ef:generateCaptions\");\n\ninterface WhisperWord {\n  text: string;\n  start: number;\n  end: number;\n  confidence: number;\n}\n\ninterface WhisperSegment {\n  text: string;\n  start: number;\n  end: number;\n  words: WhisperWord[];\n}\n\ninterface WhisperOutput {\n  segments: WhisperSegment[];\n}\n\ninterface CaptionOutput {\n  segments: Array<{\n    start: number;\n    end: number;\n    text: string;\n  }>;\n  word_segments: Array<{\n    text: string;\n    start: number;\n    end: number;\n  }>;\n}\n\nconst convertWhisperToEditframeFormat = (\n  whisperData: WhisperOutput,\n): CaptionOutput => {\n  const segments = whisperData.segments.map((segment) => ({\n    start: Math.round(segment.start * 1000), // Convert to milliseconds\n    end: Math.round(segment.end * 1000),\n    text: segment.text.trim(),\n  }));\n\n  const word_segments = whisperData.segments.flatMap((segment) =>\n    segment.words.map((word) => ({\n      text: word.text,\n      start: Math.round(word.start * 1000), // Convert to milliseconds\n      end: Math.round(word.end * 1000),\n    })),\n  );\n\n  return { segments, word_segments };\n};\n\nexport const generateCaptionDataFromPath = async (absolutePath: string) => {\n  const command = `whisper_timestamped --language en --efficient --output_format json ${absolutePath}`;\n  log(`Running command: ${command}`);\n  const { stdout } = await execPromise(command);\n\n  try {\n    const whisperData = JSON.parse(stdout) as WhisperOutput;\n    const captionData = convertWhisperToEditframeFormat(whisperData);\n    return JSON.stringify(captionData, null, 2);\n  } catch (error) {\n    log(`Error parsing whisper output: ${error}`);\n    throw new Error(`Failed to parse whisper_timestamped output: ${error}`);\n  }\n};\n\nconst generateCaptionDataTask = idempotentTask({\n  label: \"captions\",\n  filename: (absolutePath) => `${basename(absolutePath)}.captions.json`,\n  runner: generateCaptionDataFromPath,\n});\n\nexport const findOrCreateCaptions = async (\n  cacheRoot: string,\n  absolutePath: string,\n) => {\n  try {\n    return await generateCaptionDataTask(cacheRoot, absolutePath);\n  } catch (error) {\n    console.trace(\"Error finding or creating captions\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;AAQA,MAAM,cAAc,UAAU,KAAK;AAEnC,MAAM,MAAM,MAAM,sBAAsB;AAiCxC,MAAM,mCACJ,gBACkB;AAelB,QAAO;EAAE,UAdQ,YAAY,SAAS,KAAK,aAAa;GACtD,OAAO,KAAK,MAAM,QAAQ,QAAQ,IAAK;GACvC,KAAK,KAAK,MAAM,QAAQ,MAAM,IAAK;GACnC,MAAM,QAAQ,KAAK,MAAM;GAC1B,EAAE;EAUgB,eARG,YAAY,SAAS,SAAS,YAClD,QAAQ,MAAM,KAAK,UAAU;GAC3B,MAAM,KAAK;GACX,OAAO,KAAK,MAAM,KAAK,QAAQ,IAAK;GACpC,KAAK,KAAK,MAAM,KAAK,MAAM,IAAK;GACjC,EAAE,CACJ;EAEiC;;AAGpC,MAAa,8BAA8B,OAAO,iBAAyB;CACzE,MAAM,UAAU,sEAAsE;AACtF,KAAI,oBAAoB,UAAU;CAClC,MAAM,EAAE,WAAW,MAAM,YAAY,QAAQ;AAE7C,KAAI;EAEF,MAAM,cAAc,gCADA,KAAK,MAAM,OAAO,CAC0B;AAChE,SAAO,KAAK,UAAU,aAAa,MAAM,EAAE;UACpC,OAAO;AACd,MAAI,iCAAiC,QAAQ;AAC7C,QAAM,IAAI,MAAM,+CAA+C,QAAQ;;;AAI3E,MAAM,0BAA0B,eAAe;CAC7C,OAAO;CACP,WAAW,iBAAiB,GAAG,SAAS,aAAa,CAAC;CACtD,QAAQ;CACT,CAAC;AAEF,MAAa,uBAAuB,OAClC,WACA,iBACG;AACH,KAAI;AACF,SAAO,MAAM,wBAAwB,WAAW,aAAa;UACtD,OAAO;AACd,UAAQ,MAAM,sCAAsC,MAAM;AAC1D,QAAM"}

package/dist/tasks/generateScrubTrack.cjs

@@ -0,0 +1,107 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_Probe = require('../Probe.cjs');
+const require_generateFragmentIndex = require('../generateFragmentIndex.cjs');
+const require_idempotentTask = require('../idempotentTask.cjs');
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let node_stream = require("node:stream");
+node_stream = require_rolldown_runtime.__toESM(node_stream);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+
+//#region src/tasks/generateScrubTrack.ts
+const log = (0, debug.default)("ef:generateScrubTrack");
+const generateScrubTrackFromPath = async (absolutePath) => {
+	log(`Generating scrub track for ${absolutePath}`);
+	const probe = await require_Probe.Probe.probePath(absolutePath);
+	if (probe.videoStreams.length === 0) throw new Error("No video stream found for scrub track generation");
+	const scrubStream = probe.createScrubTrackReadstream();
+	let startTimeOffsetMs;
+	if (probe.format.start_time && Number(probe.format.start_time) !== 0) {
+		startTimeOffsetMs = Number(probe.format.start_time) * 1e3;
+		log(`Extracted format start_time offset: ${probe.format.start_time}s (${startTimeOffsetMs}ms)`);
+	} else {
+		const videoStream = probe.videoStreams[0];
+		if (videoStream && videoStream.start_time && Number(videoStream.start_time) !== 0) {
+			startTimeOffsetMs = Number(videoStream.start_time) * 1e3;
+			log(`Extracted video stream start_time offset: ${videoStream.start_time}s (${startTimeOffsetMs}ms)`);
+		}
+	}
+	const outputStream = new node_stream.PassThrough();
+	const indexStream = new node_stream.PassThrough();
+	scrubStream.pipe(outputStream, { end: false });
+	scrubStream.pipe(indexStream);
+	let sourceStreamEnded = false;
+	scrubStream.on("end", () => {
+		sourceStreamEnded = true;
+	});
+	scrubStream.on("error", (error) => {
+		outputStream.destroy(error);
+		indexStream.destroy(error);
+	});
+	const scrubTrackId = -1;
+	const fragmentIndexPromise = require_generateFragmentIndex.generateFragmentIndex(indexStream, startTimeOffsetMs, { 1: scrubTrackId });
+	fragmentIndexPromise.then(() => {
+		if (sourceStreamEnded) outputStream.end();
+		else scrubStream.once("end", () => {
+			outputStream.end();
+		});
+	}).catch((error) => {
+		outputStream.destroy(error);
+	});
+	return {
+		stream: outputStream,
+		fragmentIndex: fragmentIndexPromise
+	};
+};
+const generateScrubTrackTask = require_idempotentTask.idempotentTask({
+	label: "scrub-track",
+	filename: (absolutePath) => `${(0, node_path.basename)(absolutePath)}.scrub-track.mp4`,
+	runner: async (absolutePath) => {
+		const probe = await require_Probe.Probe.probePath(absolutePath);
+		if (probe.videoStreams.length === 0) throw new Error("No video stream found for scrub track generation");
+		const scrubStream = probe.createScrubTrackReadstream();
+		const finalStream = new node_stream.PassThrough();
+		let progressTimeout = null;
+		const resetProgressTimeout = () => {
+			if (progressTimeout) clearTimeout(progressTimeout);
+			progressTimeout = setTimeout(() => {
+				if (!finalStream.destroyed) {
+					console.warn(`Progress timeout triggered for scrub track - no activity for 30 seconds`);
+					finalStream.destroy(/* @__PURE__ */ new Error("Scrub track generation timeout"));
+				}
+			}, 3e4);
+		};
+		resetProgressTimeout();
+		scrubStream.on("data", () => {
+			resetProgressTimeout();
+		});
+		scrubStream.on("end", () => {
+			resetProgressTimeout();
+			finalStream.end();
+		});
+		scrubStream.on("error", (error) => {
+			if (progressTimeout) clearTimeout(progressTimeout);
+			finalStream.destroy(error);
+		});
+		scrubStream.pipe(finalStream, { end: false });
+		finalStream.on("end", () => {
+			if (progressTimeout) clearTimeout(progressTimeout);
+		});
+		return finalStream;
+	}
+});
+const generateScrubTrack = async (cacheRoot, absolutePath) => {
+	try {
+		return await generateScrubTrackTask(cacheRoot, absolutePath);
+	} catch (error) {
+		console.error(error);
+		console.trace("Error generating scrub track", error);
+		throw error;
+	}
+};
+
+//#endregion
+exports.generateScrubTrack = generateScrubTrack;
+exports.generateScrubTrackFromPath = generateScrubTrackFromPath;
+//# sourceMappingURL=generateScrubTrack.cjs.map

package/dist/tasks/generateScrubTrack.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateScrubTrack.cjs","names":["Probe","startTimeOffsetMs: number | undefined","PassThrough","generateFragmentIndex","idempotentTask","progressTimeout: NodeJS.Timeout | null"],"sources":["../../src/tasks/generateScrubTrack.ts"],"sourcesContent":["import { idempotentTask } from \"../idempotentTask.js\";\nimport debug from \"debug\";\nimport { basename } from \"node:path\";\nimport { PassThrough } from \"node:stream\";\nimport { Probe } from \"../Probe.js\";\nimport { generateFragmentIndex } from \"../generateFragmentIndex.js\";\n\nconst log = debug(\"ef:generateScrubTrack\");\n\nexport const generateScrubTrackFromPath = async (absolutePath: string) => {\n  log(`Generating scrub track for ${absolutePath}`);\n\n  const probe = await Probe.probePath(absolutePath);\n\n  // Check if video stream exists\n  if (probe.videoStreams.length === 0) {\n    throw new Error(\"No video stream found for scrub track generation\");\n  }\n\n  // Get the scrub track stream from FFmpeg (low-res transcoded video)\n  const scrubStream = probe.createScrubTrackReadstream();\n\n  // Extract timing offset from probe metadata (same logic as generateTrackFragmentIndex)\n  let startTimeOffsetMs: number | undefined;\n\n  // First check format-level start_time\n  if (probe.format.start_time && Number(probe.format.start_time) !== 0) {\n    startTimeOffsetMs = Number(probe.format.start_time) * 1000;\n    log(\n      `Extracted format start_time offset: ${probe.format.start_time}s (${startTimeOffsetMs}ms)`,\n    );\n  } else {\n    // Check for video stream start_time (more common)\n    const videoStream = probe.videoStreams[0];\n    if (\n      videoStream &&\n      videoStream.start_time &&\n      Number(videoStream.start_time) !== 0\n    ) {\n      startTimeOffsetMs = Number(videoStream.start_time) * 1000;\n      log(\n        `Extracted video stream start_time offset: ${videoStream.start_time}s (${startTimeOffsetMs}ms)`,\n      );\n    }\n  }\n\n  // Create a PassThrough to tee the stream\n  const outputStream = new PassThrough();\n  const indexStream = new PassThrough();\n\n  // Pipe data but DON'T end outputStream automatically - we'll control this\n  scrubStream.pipe(outputStream, { end: false });\n  scrubStream.pipe(indexStream);\n\n  // Track when the source stream ends (but don't end output yet)\n  let sourceStreamEnded = false;\n  scrubStream.on(\"end\", () => {\n    sourceStreamEnded = true;\n  });\n\n  scrubStream.on(\"error\", (error) => {\n    outputStream.destroy(error);\n    indexStream.destroy(error);\n  });\n\n  // Generate fragment index from the scrub track stream\n  // Use a special track ID to identify scrub track (e.g., -1 or \"scrub\")\n  // We'll use a negative track ID to distinguish from regular tracks\n  const scrubTrackId = -1;\n  const trackIdMapping = { 1: scrubTrackId }; // Single track 1 -> scrub track ID\n\n  const fragmentIndexPromise = generateFragmentIndex(\n    indexStream,\n    startTimeOffsetMs,\n    trackIdMapping,\n  );\n\n  // End outputStream only after BOTH source ends AND fragment index completes\n  fragmentIndexPromise\n    .then(() => {\n      if (sourceStreamEnded) {\n        outputStream.end();\n      } else {\n        // If fragment index completes first, wait for stream to end\n        scrubStream.once(\"end\", () => {\n          outputStream.end();\n        });\n      }\n    })\n    .catch((error) => {\n      outputStream.destroy(error);\n    });\n\n  // Return both the stream and the index\n  return {\n    stream: outputStream,\n    fragmentIndex: fragmentIndexPromise,\n  };\n};\n\nexport const generateScrubTrackTask = idempotentTask({\n  label: \"scrub-track\",\n  filename: (absolutePath: string) =>\n    `${basename(absolutePath)}.scrub-track.mp4`,\n  runner: async (absolutePath: string) => {\n    const probe = await Probe.probePath(absolutePath);\n\n    if (probe.videoStreams.length === 0) {\n      throw new Error(\"No video stream found for scrub track generation\");\n    }\n\n    // Get the scrub track stream from FFmpeg\n    const scrubStream = probe.createScrubTrackReadstream();\n\n    // Wrap in PassThrough with timeout handling to ensure stream completes\n    const finalStream = new PassThrough();\n\n    // Monitor progress and extend timeout based on actual work\n    let progressTimeout: NodeJS.Timeout | null = null;\n\n    const resetProgressTimeout = () => {\n      if (progressTimeout) {\n        clearTimeout(progressTimeout);\n      }\n\n      progressTimeout = setTimeout(() => {\n        if (!finalStream.destroyed) {\n          console.warn(\n            `Progress timeout triggered for scrub track - no activity for 30 seconds`,\n          );\n          finalStream.destroy(new Error(\"Scrub track generation timeout\"));\n        }\n      }, 30000); // 30 second sliding timeout (longer for transcoding)\n    };\n\n    // Start the initial timeout\n    resetProgressTimeout();\n\n    // Monitor data flow to detect active work\n    scrubStream.on(\"data\", () => {\n      resetProgressTimeout(); // Reset timeout when we see data\n    });\n\n    scrubStream.on(\"end\", () => {\n      resetProgressTimeout(); // Reset timeout when stream ends\n      finalStream.end();\n    });\n\n    scrubStream.on(\"error\", (error) => {\n      if (progressTimeout) {\n        clearTimeout(progressTimeout);\n      }\n      finalStream.destroy(error);\n    });\n\n    // Pipe data through\n    scrubStream.pipe(finalStream, { end: false });\n\n    // Clean up timeout when stream ends\n    finalStream.on(\"end\", () => {\n      if (progressTimeout) {\n        clearTimeout(progressTimeout);\n      }\n    });\n\n    return finalStream;\n  },\n});\n\nexport const generateScrubTrack = async (\n  cacheRoot: string,\n  absolutePath: string,\n) => {\n  try {\n    return await generateScrubTrackTask(cacheRoot, absolutePath);\n  } catch (error) {\n    console.error(error);\n    console.trace(\"Error generating scrub track\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;;;;;;AAOA,MAAM,yBAAY,wBAAwB;AAE1C,MAAa,6BAA6B,OAAO,iBAAyB;AACxE,KAAI,8BAA8B,eAAe;CAEjD,MAAM,QAAQ,MAAMA,oBAAM,UAAU,aAAa;AAGjD,KAAI,MAAM,aAAa,WAAW,EAChC,OAAM,IAAI,MAAM,mDAAmD;CAIrE,MAAM,cAAc,MAAM,4BAA4B;CAGtD,IAAIC;AAGJ,KAAI,MAAM,OAAO,cAAc,OAAO,MAAM,OAAO,WAAW,KAAK,GAAG;AACpE,sBAAoB,OAAO,MAAM,OAAO,WAAW,GAAG;AACtD,MACE,uCAAuC,MAAM,OAAO,WAAW,KAAK,kBAAkB,KACvF;QACI;EAEL,MAAM,cAAc,MAAM,aAAa;AACvC,MACE,eACA,YAAY,cACZ,OAAO,YAAY,WAAW,KAAK,GACnC;AACA,uBAAoB,OAAO,YAAY,WAAW,GAAG;AACrD,OACE,6CAA6C,YAAY,WAAW,KAAK,kBAAkB,KAC5F;;;CAKL,MAAM,eAAe,IAAIC,yBAAa;CACtC,MAAM,cAAc,IAAIA,yBAAa;AAGrC,aAAY,KAAK,cAAc,EAAE,KAAK,OAAO,CAAC;AAC9C,aAAY,KAAK,YAAY;CAG7B,IAAI,oBAAoB;AACxB,aAAY,GAAG,aAAa;AAC1B,sBAAoB;GACpB;AAEF,aAAY,GAAG,UAAU,UAAU;AACjC,eAAa,QAAQ,MAAM;AAC3B,cAAY,QAAQ,MAAM;GAC1B;CAKF,MAAM,eAAe;CAGrB,MAAM,uBAAuBC,oDAC3B,aACA,mBAJqB,EAAE,GAAG,cAAc,CAMzC;AAGD,sBACG,WAAW;AACV,MAAI,kBACF,cAAa,KAAK;MAGlB,aAAY,KAAK,aAAa;AAC5B,gBAAa,KAAK;IAClB;GAEJ,CACD,OAAO,UAAU;AAChB,eAAa,QAAQ,MAAM;GAC3B;AAGJ,QAAO;EACL,QAAQ;EACR,eAAe;EAChB;;AAGH,MAAa,yBAAyBC,sCAAe;CACnD,OAAO;CACP,WAAW,iBACT,2BAAY,aAAa,CAAC;CAC5B,QAAQ,OAAO,iBAAyB;EACtC,MAAM,QAAQ,MAAMJ,oBAAM,UAAU,aAAa;AAEjD,MAAI,MAAM,aAAa,WAAW,EAChC,OAAM,IAAI,MAAM,mDAAmD;EAIrE,MAAM,cAAc,MAAM,4BAA4B;EAGtD,MAAM,cAAc,IAAIE,yBAAa;EAGrC,IAAIG,kBAAyC;EAE7C,MAAM,6BAA6B;AACjC,OAAI,gBACF,cAAa,gBAAgB;AAG/B,qBAAkB,iBAAiB;AACjC,QAAI,CAAC,YAAY,WAAW;AAC1B,aAAQ,KACN,0EACD;AACD,iBAAY,wBAAQ,IAAI,MAAM,iCAAiC,CAAC;;MAEjE,IAAM;;AAIX,wBAAsB;AAGtB,cAAY,GAAG,cAAc;AAC3B,yBAAsB;IACtB;AAEF,cAAY,GAAG,aAAa;AAC1B,yBAAsB;AACtB,eAAY,KAAK;IACjB;AAEF,cAAY,GAAG,UAAU,UAAU;AACjC,OAAI,gBACF,cAAa,gBAAgB;AAE/B,eAAY,QAAQ,MAAM;IAC1B;AAGF,cAAY,KAAK,aAAa,EAAE,KAAK,OAAO,CAAC;AAG7C,cAAY,GAAG,aAAa;AAC1B,OAAI,gBACF,cAAa,gBAAgB;IAE/B;AAEF,SAAO;;CAEV,CAAC;AAEF,MAAa,qBAAqB,OAChC,WACA,iBACG;AACH,KAAI;AACF,SAAO,MAAM,uBAAuB,WAAW,aAAa;UACrD,OAAO;AACd,UAAQ,MAAM,MAAM;AACpB,UAAQ,MAAM,gCAAgC,MAAM;AACpD,QAAM"}

package/dist/tasks/generateScrubTrack.d.cts

@@ -0,0 +1,12 @@
+import { TrackFragmentIndex } from "../Probe.cjs";
+import { TaskResult } from "../idempotentTask.cjs";
+
+//#region src/tasks/generateScrubTrack.d.ts
+declare const generateScrubTrackFromPath: (absolutePath: string) => Promise<{
+  stream: any;
+  fragmentIndex: Promise<Record<number, TrackFragmentIndex>>;
+}>;
+declare const generateScrubTrack: (cacheRoot: string, absolutePath: string) => Promise<TaskResult>;
+//#endregion
+export { generateScrubTrack, generateScrubTrackFromPath };
+//# sourceMappingURL=generateScrubTrack.d.cts.map

package/dist/tasks/generateScrubTrack.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateScrubTrack.js","names":["startTimeOffsetMs: number | undefined","progressTimeout: NodeJS.Timeout | null"],"sources":["../../src/tasks/generateScrubTrack.ts"],"sourcesContent":["import { idempotentTask } from \"../idempotentTask.js\";\nimport debug from \"debug\";\nimport { basename } from \"node:path\";\nimport { PassThrough } from \"node:stream\";\nimport { Probe } from \"../Probe.js\";\nimport { generateFragmentIndex } from \"../generateFragmentIndex.js\";\n\nconst log = debug(\"ef:generateScrubTrack\");\n\nexport const generateScrubTrackFromPath = async (\n  absolutePath: string,\n) => {\n  log(`Generating scrub track for ${absolutePath}`);\n\n  const probe = await Probe.probePath(absolutePath);\n\n  // Check if video stream exists\n  if (probe.videoStreams.length === 0) {\n    throw new Error(\"No video stream found for scrub track generation\");\n  }\n\n  // Get the scrub track stream from FFmpeg (low-res transcoded video)\n  const scrubStream = probe.createScrubTrackReadstream();\n\n  // Extract timing offset from probe metadata (same logic as generateTrackFragmentIndex)\n  let startTimeOffsetMs: number | undefined;\n\n  // First check format-level start_time\n  if (probe.format.start_time && Number(probe.format.start_time) !== 0) {\n    startTimeOffsetMs = Number(probe.format.start_time) * 1000;\n    log(\n      `Extracted format start_time offset: ${probe.format.start_time}s (${startTimeOffsetMs}ms)`,\n    );\n  } else {\n    // Check for video stream start_time (more common)\n    const videoStream = probe.videoStreams[0];\n    if (\n      videoStream &&\n      videoStream.start_time &&\n      Number(videoStream.start_time) !== 0\n    ) {\n      startTimeOffsetMs = Number(videoStream.start_time) * 1000;\n      log(\n        `Extracted video stream start_time offset: ${videoStream.start_time}s (${startTimeOffsetMs}ms)`,\n      );\n    }\n  }\n\n  // Create a PassThrough to tee the stream\n  const outputStream = new PassThrough();\n  const indexStream = new PassThrough();\n\n  // Pipe data but DON'T end outputStream automatically - we'll control this\n  scrubStream.pipe(outputStream, { end: false });\n  scrubStream.pipe(indexStream);\n\n  // Track when the source stream ends (but don't end output yet)\n  let sourceStreamEnded = false;\n  scrubStream.on(\"end\", () => {\n    sourceStreamEnded = true;\n  });\n\n  scrubStream.on(\"error\", (error) => {\n    outputStream.destroy(error);\n    indexStream.destroy(error);\n  });\n\n  // Generate fragment index from the scrub track stream\n  // Use a special track ID to identify scrub track (e.g., -1 or \"scrub\")\n  // We'll use a negative track ID to distinguish from regular tracks\n  const scrubTrackId = -1;\n  const trackIdMapping = { 1: scrubTrackId }; // Single track 1 -> scrub track ID\n\n  const fragmentIndexPromise = generateFragmentIndex(\n    indexStream,\n    startTimeOffsetMs,\n    trackIdMapping,\n  );\n\n  // End outputStream only after BOTH source ends AND fragment index completes\n  fragmentIndexPromise\n    .then(() => {\n      if (sourceStreamEnded) {\n        outputStream.end();\n      } else {\n        // If fragment index completes first, wait for stream to end\n        scrubStream.once(\"end\", () => {\n          outputStream.end();\n        });\n      }\n    })\n    .catch((error) => {\n      outputStream.destroy(error);\n    });\n\n  // Return both the stream and the index\n  return {\n    stream: outputStream,\n    fragmentIndex: fragmentIndexPromise,\n  };\n};\n\nexport const generateScrubTrackTask = idempotentTask({\n  label: \"scrub-track\",\n  filename: (absolutePath: string) =>\n    `${basename(absolutePath)}.scrub-track.mp4`,\n  runner: async (absolutePath: string) => {\n    const probe = await Probe.probePath(absolutePath);\n    \n    if (probe.videoStreams.length === 0) {\n      throw new Error(\"No video stream found for scrub track generation\");\n    }\n\n    // Get the scrub track stream from FFmpeg\n    const scrubStream = probe.createScrubTrackReadstream();\n\n    // Wrap in PassThrough with timeout handling to ensure stream completes\n    const finalStream = new PassThrough();\n\n    // Monitor progress and extend timeout based on actual work\n    let progressTimeout: NodeJS.Timeout | null = null;\n\n    const resetProgressTimeout = () => {\n      if (progressTimeout) {\n        clearTimeout(progressTimeout);\n      }\n\n      progressTimeout = setTimeout(() => {\n        if (!finalStream.destroyed) {\n          console.warn(\n            `Progress timeout triggered for scrub track - no activity for 30 seconds`,\n          );\n          finalStream.destroy(new Error(\"Scrub track generation timeout\"));\n        }\n      }, 30000); // 30 second sliding timeout (longer for transcoding)\n    };\n\n    // Start the initial timeout\n    resetProgressTimeout();\n\n    // Monitor data flow to detect active work\n    scrubStream.on(\"data\", () => {\n      resetProgressTimeout(); // Reset timeout when we see data\n    });\n\n    scrubStream.on(\"end\", () => {\n      resetProgressTimeout(); // Reset timeout when stream ends\n      finalStream.end();\n    });\n\n    scrubStream.on(\"error\", (error) => {\n      if (progressTimeout) {\n        clearTimeout(progressTimeout);\n      }\n      finalStream.destroy(error);\n    });\n\n    // Pipe data through\n    scrubStream.pipe(finalStream, { end: false });\n\n    // Clean up timeout when stream ends\n    finalStream.on(\"end\", () => {\n      if (progressTimeout) {\n        clearTimeout(progressTimeout);\n      }\n    });\n\n    return finalStream;\n  },\n});\n\nexport const generateScrubTrack = async (\n  cacheRoot: string,\n  absolutePath: string,\n) => {\n  try {\n    return await generateScrubTrackTask(cacheRoot, absolutePath);\n  } catch (error) {\n    console.error(error);\n    console.trace(\"Error generating scrub track\", error);\n    throw error;\n  }\n};\n\n"],"mappings":";;;;;;;;AAOA,MAAM,MAAM,MAAM,wBAAwB;AAE1C,MAAa,6BAA6B,OACxC,iBACG;AACH,KAAI,8BAA8B,eAAe;CAEjD,MAAM,QAAQ,MAAM,MAAM,UAAU,aAAa;AAGjD,KAAI,MAAM,aAAa,WAAW,EAChC,OAAM,IAAI,MAAM,mDAAmD;CAIrE,MAAM,cAAc,MAAM,4BAA4B;CAGtD,IAAIA;AAGJ,KAAI,MAAM,OAAO,cAAc,OAAO,MAAM,OAAO,WAAW,KAAK,GAAG;AACpE,sBAAoB,OAAO,MAAM,OAAO,WAAW,GAAG;AACtD,MACE,uCAAuC,MAAM,OAAO,WAAW,KAAK,kBAAkB,KACvF;QACI;EAEL,MAAM,cAAc,MAAM,aAAa;AACvC,MACE,eACA,YAAY,cACZ,OAAO,YAAY,WAAW,KAAK,GACnC;AACA,uBAAoB,OAAO,YAAY,WAAW,GAAG;AACrD,OACE,6CAA6C,YAAY,WAAW,KAAK,kBAAkB,KAC5F;;;CAKL,MAAM,eAAe,IAAI,aAAa;CACtC,MAAM,cAAc,IAAI,aAAa;AAGrC,aAAY,KAAK,cAAc,EAAE,KAAK,OAAO,CAAC;AAC9C,aAAY,KAAK,YAAY;CAG7B,IAAI,oBAAoB;AACxB,aAAY,GAAG,aAAa;AAC1B,sBAAoB;GACpB;AAEF,aAAY,GAAG,UAAU,UAAU;AACjC,eAAa,QAAQ,MAAM;AAC3B,cAAY,QAAQ,MAAM;GAC1B;CAKF,MAAM,eAAe;CAGrB,MAAM,uBAAuB,sBAC3B,aACA,mBAJqB,EAAE,GAAG,cAAc,CAMzC;AAGD,sBACG,WAAW;AACV,MAAI,kBACF,cAAa,KAAK;MAGlB,aAAY,KAAK,aAAa;AAC5B,gBAAa,KAAK;IAClB;GAEJ,CACD,OAAO,UAAU;AAChB,eAAa,QAAQ,MAAM;GAC3B;AAGJ,QAAO;EACL,QAAQ;EACR,eAAe;EAChB;;AAGH,MAAa,yBAAyB,eAAe;CACnD,OAAO;CACP,WAAW,iBACT,GAAG,SAAS,aAAa,CAAC;CAC5B,QAAQ,OAAO,iBAAyB;EACtC,MAAM,QAAQ,MAAM,MAAM,UAAU,aAAa;AAEjD,MAAI,MAAM,aAAa,WAAW,EAChC,OAAM,IAAI,MAAM,mDAAmD;EAIrE,MAAM,cAAc,MAAM,4BAA4B;EAGtD,MAAM,cAAc,IAAI,aAAa;EAGrC,IAAIC,kBAAyC;EAE7C,MAAM,6BAA6B;AACjC,OAAI,gBACF,cAAa,gBAAgB;AAG/B,qBAAkB,iBAAiB;AACjC,QAAI,CAAC,YAAY,WAAW;AAC1B,aAAQ,KACN,0EACD;AACD,iBAAY,wBAAQ,IAAI,MAAM,iCAAiC,CAAC;;MAEjE,IAAM;;AAIX,wBAAsB;AAGtB,cAAY,GAAG,cAAc;AAC3B,yBAAsB;IACtB;AAEF,cAAY,GAAG,aAAa;AAC1B,yBAAsB;AACtB,eAAY,KAAK;IACjB;AAEF,cAAY,GAAG,UAAU,UAAU;AACjC,OAAI,gBACF,cAAa,gBAAgB;AAE/B,eAAY,QAAQ,MAAM;IAC1B;AAGF,cAAY,KAAK,aAAa,EAAE,KAAK,OAAO,CAAC;AAG7C,cAAY,GAAG,aAAa;AAC1B,OAAI,gBACF,cAAa,gBAAgB;IAE/B;AAEF,SAAO;;CAEV,CAAC;AAEF,MAAa,qBAAqB,OAChC,WACA,iBACG;AACH,KAAI;AACF,SAAO,MAAM,uBAAuB,WAAW,aAAa;UACrD,OAAO;AACd,UAAQ,MAAM,MAAM;AACpB,UAAQ,MAAM,gCAAgC,MAAM;AACpD,QAAM"}
+{"version":3,"file":"generateScrubTrack.js","names":["startTimeOffsetMs: number | undefined","progressTimeout: NodeJS.Timeout | null"],"sources":["../../src/tasks/generateScrubTrack.ts"],"sourcesContent":["import { idempotentTask } from \"../idempotentTask.js\";\nimport debug from \"debug\";\nimport { basename } from \"node:path\";\nimport { PassThrough } from \"node:stream\";\nimport { Probe } from \"../Probe.js\";\nimport { generateFragmentIndex } from \"../generateFragmentIndex.js\";\n\nconst log = debug(\"ef:generateScrubTrack\");\n\nexport const generateScrubTrackFromPath = async (absolutePath: string) => {\n  log(`Generating scrub track for ${absolutePath}`);\n\n  const probe = await Probe.probePath(absolutePath);\n\n  // Check if video stream exists\n  if (probe.videoStreams.length === 0) {\n    throw new Error(\"No video stream found for scrub track generation\");\n  }\n\n  // Get the scrub track stream from FFmpeg (low-res transcoded video)\n  const scrubStream = probe.createScrubTrackReadstream();\n\n  // Extract timing offset from probe metadata (same logic as generateTrackFragmentIndex)\n  let startTimeOffsetMs: number | undefined;\n\n  // First check format-level start_time\n  if (probe.format.start_time && Number(probe.format.start_time) !== 0) {\n    startTimeOffsetMs = Number(probe.format.start_time) * 1000;\n    log(\n      `Extracted format start_time offset: ${probe.format.start_time}s (${startTimeOffsetMs}ms)`,\n    );\n  } else {\n    // Check for video stream start_time (more common)\n    const videoStream = probe.videoStreams[0];\n    if (\n      videoStream &&\n      videoStream.start_time &&\n      Number(videoStream.start_time) !== 0\n    ) {\n      startTimeOffsetMs = Number(videoStream.start_time) * 1000;\n      log(\n        `Extracted video stream start_time offset: ${videoStream.start_time}s (${startTimeOffsetMs}ms)`,\n      );\n    }\n  }\n\n  // Create a PassThrough to tee the stream\n  const outputStream = new PassThrough();\n  const indexStream = new PassThrough();\n\n  // Pipe data but DON'T end outputStream automatically - we'll control this\n  scrubStream.pipe(outputStream, { end: false });\n  scrubStream.pipe(indexStream);\n\n  // Track when the source stream ends (but don't end output yet)\n  let sourceStreamEnded = false;\n  scrubStream.on(\"end\", () => {\n    sourceStreamEnded = true;\n  });\n\n  scrubStream.on(\"error\", (error) => {\n    outputStream.destroy(error);\n    indexStream.destroy(error);\n  });\n\n  // Generate fragment index from the scrub track stream\n  // Use a special track ID to identify scrub track (e.g., -1 or \"scrub\")\n  // We'll use a negative track ID to distinguish from regular tracks\n  const scrubTrackId = -1;\n  const trackIdMapping = { 1: scrubTrackId }; // Single track 1 -> scrub track ID\n\n  const fragmentIndexPromise = generateFragmentIndex(\n    indexStream,\n    startTimeOffsetMs,\n    trackIdMapping,\n  );\n\n  // End outputStream only after BOTH source ends AND fragment index completes\n  fragmentIndexPromise\n    .then(() => {\n      if (sourceStreamEnded) {\n        outputStream.end();\n      } else {\n        // If fragment index completes first, wait for stream to end\n        scrubStream.once(\"end\", () => {\n          outputStream.end();\n        });\n      }\n    })\n    .catch((error) => {\n      outputStream.destroy(error);\n    });\n\n  // Return both the stream and the index\n  return {\n    stream: outputStream,\n    fragmentIndex: fragmentIndexPromise,\n  };\n};\n\nexport const generateScrubTrackTask = idempotentTask({\n  label: \"scrub-track\",\n  filename: (absolutePath: string) =>\n    `${basename(absolutePath)}.scrub-track.mp4`,\n  runner: async (absolutePath: string) => {\n    const probe = await Probe.probePath(absolutePath);\n\n    if (probe.videoStreams.length === 0) {\n      throw new Error(\"No video stream found for scrub track generation\");\n    }\n\n    // Get the scrub track stream from FFmpeg\n    const scrubStream = probe.createScrubTrackReadstream();\n\n    // Wrap in PassThrough with timeout handling to ensure stream completes\n    const finalStream = new PassThrough();\n\n    // Monitor progress and extend timeout based on actual work\n    let progressTimeout: NodeJS.Timeout | null = null;\n\n    const resetProgressTimeout = () => {\n      if (progressTimeout) {\n        clearTimeout(progressTimeout);\n      }\n\n      progressTimeout = setTimeout(() => {\n        if (!finalStream.destroyed) {\n          console.warn(\n            `Progress timeout triggered for scrub track - no activity for 30 seconds`,\n          );\n          finalStream.destroy(new Error(\"Scrub track generation timeout\"));\n        }\n      }, 30000); // 30 second sliding timeout (longer for transcoding)\n    };\n\n    // Start the initial timeout\n    resetProgressTimeout();\n\n    // Monitor data flow to detect active work\n    scrubStream.on(\"data\", () => {\n      resetProgressTimeout(); // Reset timeout when we see data\n    });\n\n    scrubStream.on(\"end\", () => {\n      resetProgressTimeout(); // Reset timeout when stream ends\n      finalStream.end();\n    });\n\n    scrubStream.on(\"error\", (error) => {\n      if (progressTimeout) {\n        clearTimeout(progressTimeout);\n      }\n      finalStream.destroy(error);\n    });\n\n    // Pipe data through\n    scrubStream.pipe(finalStream, { end: false });\n\n    // Clean up timeout when stream ends\n    finalStream.on(\"end\", () => {\n      if (progressTimeout) {\n        clearTimeout(progressTimeout);\n      }\n    });\n\n    return finalStream;\n  },\n});\n\nexport const generateScrubTrack = async (\n  cacheRoot: string,\n  absolutePath: string,\n) => {\n  try {\n    return await generateScrubTrackTask(cacheRoot, absolutePath);\n  } catch (error) {\n    console.error(error);\n    console.trace(\"Error generating scrub track\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;;AAOA,MAAM,MAAM,MAAM,wBAAwB;AAE1C,MAAa,6BAA6B,OAAO,iBAAyB;AACxE,KAAI,8BAA8B,eAAe;CAEjD,MAAM,QAAQ,MAAM,MAAM,UAAU,aAAa;AAGjD,KAAI,MAAM,aAAa,WAAW,EAChC,OAAM,IAAI,MAAM,mDAAmD;CAIrE,MAAM,cAAc,MAAM,4BAA4B;CAGtD,IAAIA;AAGJ,KAAI,MAAM,OAAO,cAAc,OAAO,MAAM,OAAO,WAAW,KAAK,GAAG;AACpE,sBAAoB,OAAO,MAAM,OAAO,WAAW,GAAG;AACtD,MACE,uCAAuC,MAAM,OAAO,WAAW,KAAK,kBAAkB,KACvF;QACI;EAEL,MAAM,cAAc,MAAM,aAAa;AACvC,MACE,eACA,YAAY,cACZ,OAAO,YAAY,WAAW,KAAK,GACnC;AACA,uBAAoB,OAAO,YAAY,WAAW,GAAG;AACrD,OACE,6CAA6C,YAAY,WAAW,KAAK,kBAAkB,KAC5F;;;CAKL,MAAM,eAAe,IAAI,aAAa;CACtC,MAAM,cAAc,IAAI,aAAa;AAGrC,aAAY,KAAK,cAAc,EAAE,KAAK,OAAO,CAAC;AAC9C,aAAY,KAAK,YAAY;CAG7B,IAAI,oBAAoB;AACxB,aAAY,GAAG,aAAa;AAC1B,sBAAoB;GACpB;AAEF,aAAY,GAAG,UAAU,UAAU;AACjC,eAAa,QAAQ,MAAM;AAC3B,cAAY,QAAQ,MAAM;GAC1B;CAKF,MAAM,eAAe;CAGrB,MAAM,uBAAuB,sBAC3B,aACA,mBAJqB,EAAE,GAAG,cAAc,CAMzC;AAGD,sBACG,WAAW;AACV,MAAI,kBACF,cAAa,KAAK;MAGlB,aAAY,KAAK,aAAa;AAC5B,gBAAa,KAAK;IAClB;GAEJ,CACD,OAAO,UAAU;AAChB,eAAa,QAAQ,MAAM;GAC3B;AAGJ,QAAO;EACL,QAAQ;EACR,eAAe;EAChB;;AAGH,MAAa,yBAAyB,eAAe;CACnD,OAAO;CACP,WAAW,iBACT,GAAG,SAAS,aAAa,CAAC;CAC5B,QAAQ,OAAO,iBAAyB;EACtC,MAAM,QAAQ,MAAM,MAAM,UAAU,aAAa;AAEjD,MAAI,MAAM,aAAa,WAAW,EAChC,OAAM,IAAI,MAAM,mDAAmD;EAIrE,MAAM,cAAc,MAAM,4BAA4B;EAGtD,MAAM,cAAc,IAAI,aAAa;EAGrC,IAAIC,kBAAyC;EAE7C,MAAM,6BAA6B;AACjC,OAAI,gBACF,cAAa,gBAAgB;AAG/B,qBAAkB,iBAAiB;AACjC,QAAI,CAAC,YAAY,WAAW;AAC1B,aAAQ,KACN,0EACD;AACD,iBAAY,wBAAQ,IAAI,MAAM,iCAAiC,CAAC;;MAEjE,IAAM;;AAIX,wBAAsB;AAGtB,cAAY,GAAG,cAAc;AAC3B,yBAAsB;IACtB;AAEF,cAAY,GAAG,aAAa;AAC1B,yBAAsB;AACtB,eAAY,KAAK;IACjB;AAEF,cAAY,GAAG,UAAU,UAAU;AACjC,OAAI,gBACF,cAAa,gBAAgB;AAE/B,eAAY,QAAQ,MAAM;IAC1B;AAGF,cAAY,KAAK,aAAa,EAAE,KAAK,OAAO,CAAC;AAG7C,cAAY,GAAG,aAAa;AAC1B,OAAI,gBACF,cAAa,gBAAgB;IAE/B;AAEF,SAAO;;CAEV,CAAC;AAEF,MAAa,qBAAqB,OAChC,WACA,iBACG;AACH,KAAI;AACF,SAAO,MAAM,uBAAuB,WAAW,aAAa;UACrD,OAAO;AACd,UAAQ,MAAM,MAAM;AACpB,UAAQ,MAAM,gCAAgC,MAAM;AACpD,QAAM"}

package/dist/tasks/generateTrack.cjs

@@ -0,0 +1,34 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_idempotentTask = require('../idempotentTask.cjs');
+const require_generateSingleTrack = require('../generateSingleTrack.cjs');
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+
+//#region src/tasks/generateTrack.ts
+const generateTrackFromPath = async (absolutePath, trackId) => {
+	(0, debug.default)("ef:generateTrackFragment")(`Generating track ${trackId} for ${absolutePath}`);
+	return (await require_generateSingleTrack.generateSingleTrackFromPath(absolutePath, trackId)).stream;
+};
+const generateTrackTask = require_idempotentTask.idempotentTask({
+	label: "track",
+	filename: (absolutePath, trackId) => `${(0, node_path.basename)(absolutePath)}.track-${trackId}.mp4`,
+	runner: generateTrackFromPath
+});
+const generateTrack = async (cacheRoot, absolutePath, url) => {
+	try {
+		const trackId = new URL(`http://localhost${url}`).searchParams.get("trackId");
+		if (trackId === null) throw new Error("No trackId provided. It must be specified in the query string: ?trackId=1 (for video) or ?trackId=2 (for audio)");
+		return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));
+	} catch (error) {
+		console.error(error);
+		console.trace("Error generating track", error);
+		throw error;
+	}
+};
+
+//#endregion
+exports.generateTrack = generateTrack;
+exports.generateTrackFromPath = generateTrackFromPath;
+//# sourceMappingURL=generateTrack.cjs.map

package/dist/tasks/generateTrack.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateTrack.cjs","names":["generateSingleTrackFromPath","idempotentTask"],"sources":["../../src/tasks/generateTrack.ts"],"sourcesContent":["import { idempotentTask } from \"../idempotentTask.js\";\nimport debug from \"debug\";\nimport { basename } from \"node:path\";\nimport { generateSingleTrackFromPath } from \"../generateSingleTrack.js\";\n\nexport const generateTrackFromPath = async (\n  absolutePath: string,\n  trackId: number,\n) => {\n  const log = debug(\"ef:generateTrackFragment\");\n  log(`Generating track ${trackId} for ${absolutePath}`);\n\n  // Use the single-track implementation\n  const result = await generateSingleTrackFromPath(absolutePath, trackId);\n\n  // Return just the stream for compatibility with existing API\n  return result.stream;\n};\n\nexport const generateTrackTask = idempotentTask({\n  label: \"track\",\n  filename: (absolutePath: string, trackId: number) =>\n    `${basename(absolutePath)}.track-${trackId}.mp4`,\n  runner: generateTrackFromPath,\n});\n\nexport const generateTrack = async (\n  cacheRoot: string,\n  absolutePath: string,\n  url: string,\n) => {\n  try {\n    const trackId = new URL(`http://localhost${url}`).searchParams.get(\n      \"trackId\",\n    );\n    if (trackId === null) {\n      throw new Error(\n        \"No trackId provided. It must be specified in the query string: ?trackId=1 (for video) or ?trackId=2 (for audio)\",\n      );\n    }\n    return await generateTrackTask(cacheRoot, absolutePath, Number(trackId));\n  } catch (error) {\n    console.error(error);\n    console.trace(\"Error generating track\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;;;AAKA,MAAa,wBAAwB,OACnC,cACA,YACG;AAEH,oBADkB,2BAA2B,CACzC,oBAAoB,QAAQ,OAAO,eAAe;AAMtD,SAHe,MAAMA,wDAA4B,cAAc,QAAQ,EAGzD;;AAGhB,MAAa,oBAAoBC,sCAAe;CAC9C,OAAO;CACP,WAAW,cAAsB,YAC/B,2BAAY,aAAa,CAAC,SAAS,QAAQ;CAC7C,QAAQ;CACT,CAAC;AAEF,MAAa,gBAAgB,OAC3B,WACA,cACA,QACG;AACH,KAAI;EACF,MAAM,UAAU,IAAI,IAAI,mBAAmB,MAAM,CAAC,aAAa,IAC7D,UACD;AACD,MAAI,YAAY,KACd,OAAM,IAAI,MACR,kHACD;AAEH,SAAO,MAAM,kBAAkB,WAAW,cAAc,OAAO,QAAQ,CAAC;UACjE,OAAO;AACd,UAAQ,MAAM,MAAM;AACpB,UAAQ,MAAM,0BAA0B,MAAM;AAC9C,QAAM"}

package/dist/tasks/generateTrack.d.cts

@@ -0,0 +1,8 @@
+import { TaskResult } from "../idempotentTask.cjs";
+
+//#region src/tasks/generateTrack.d.ts
+declare const generateTrackFromPath: (absolutePath: string, trackId: number) => Promise<any>;
+declare const generateTrack: (cacheRoot: string, absolutePath: string, url: string) => Promise<TaskResult>;
+//#endregion
+export { generateTrack, generateTrackFromPath };
+//# sourceMappingURL=generateTrack.d.cts.map

package/dist/tasks/generateTrackFragmentIndex.cjs

@@ -0,0 +1,69 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_Probe = require('../Probe.cjs');
+const require_generateFragmentIndex = require('../generateFragmentIndex.cjs');
+const require_idempotentTask = require('../idempotentTask.cjs');
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let node_path = require("node:path");
+node_path = require_rolldown_runtime.__toESM(node_path);
+
+//#region src/tasks/generateTrackFragmentIndex.ts
+const generateTrackFragmentIndexFromPath = async (absolutePath) => {
+	const log = (0, debug.default)("ef:generateTrackFragment");
+	const probe = await require_Probe.Probe.probePath(absolutePath);
+	let startTimeOffsetMs;
+	if (probe.format.start_time && Number(probe.format.start_time) !== 0) {
+		startTimeOffsetMs = Number(probe.format.start_time) * 1e3;
+		log(`Extracted format start_time offset: ${probe.format.start_time}s (${startTimeOffsetMs}ms)`);
+	} else {
+		const videoStream = probe.streams.find((stream) => stream.codec_type === "video");
+		if (videoStream && videoStream.start_time && Number(videoStream.start_time) !== 0) {
+			startTimeOffsetMs = Number(videoStream.start_time) * 1e3;
+			log(`Extracted video stream start_time offset: ${videoStream.start_time}s (${startTimeOffsetMs}ms)`);
+		} else log("No format/stream timing offset found - will detect from composition time");
+	}
+	log(`Generating track fragment index for ${absolutePath} using single-track approach`);
+	const trackFragmentIndexes = {};
+	for (let streamIndex = 0; streamIndex < probe.streams.length; streamIndex++) {
+		const stream = probe.streams[streamIndex];
+		if (stream.codec_type !== "audio" && stream.codec_type !== "video") continue;
+		const trackId = streamIndex + 1;
+		log(`Processing track ${trackId} (${stream.codec_type})`);
+		const singleTrackIndexes = await require_generateFragmentIndex.generateFragmentIndex(probe.createTrackReadstream(streamIndex), startTimeOffsetMs, { 0: trackId });
+		Object.assign(trackFragmentIndexes, singleTrackIndexes);
+	}
+	if (probe.videoStreams.length > 0) try {
+		log("Generating scrub track fragment index");
+		const scrubStream = probe.createScrubTrackReadstream();
+		const scrubTrackId = -1;
+		const scrubFragmentIndex = await require_generateFragmentIndex.generateFragmentIndex(scrubStream, startTimeOffsetMs, { 0: scrubTrackId });
+		if (scrubFragmentIndex[scrubTrackId]) {
+			trackFragmentIndexes[scrubTrackId] = scrubFragmentIndex[scrubTrackId];
+			log("Scrub track fragment index generated successfully");
+		}
+	} catch (error) {
+		log(`Failed to generate scrub track fragment index: ${error}`);
+	}
+	return trackFragmentIndexes;
+};
+const generateTrackFragmentIndexTask = require_idempotentTask.idempotentTask({
+	label: "trackFragmentIndex",
+	filename: (absolutePath) => `${(0, node_path.basename)(absolutePath)}.tracks.json`,
+	runner: async (absolutePath) => {
+		const index = await generateTrackFragmentIndexFromPath(absolutePath);
+		return JSON.stringify(index, null, 2);
+	}
+});
+const generateTrackFragmentIndex = async (cacheRoot, absolutePath) => {
+	try {
+		return await generateTrackFragmentIndexTask(cacheRoot, absolutePath);
+	} catch (error) {
+		console.trace("Error generating track fragment index", error);
+		throw error;
+	}
+};
+
+//#endregion
+exports.generateTrackFragmentIndex = generateTrackFragmentIndex;
+exports.generateTrackFragmentIndexFromPath = generateTrackFragmentIndexFromPath;
+//# sourceMappingURL=generateTrackFragmentIndex.cjs.map

package/dist/tasks/generateTrackFragmentIndex.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateTrackFragmentIndex.cjs","names":["Probe","startTimeOffsetMs: number | undefined","trackFragmentIndexes: Record<number, TrackFragmentIndex>","generateFragmentIndex","idempotentTask"],"sources":["../../src/tasks/generateTrackFragmentIndex.ts"],"sourcesContent":["import { idempotentTask } from \"../idempotentTask.js\";\nimport debug from \"debug\";\nimport { basename } from \"node:path\";\nimport { Probe } from \"../Probe.js\";\nimport { generateFragmentIndex } from \"../generateFragmentIndex.js\";\nimport type { TrackFragmentIndex } from \"../Probe.js\";\n\nexport const generateTrackFragmentIndexFromPath = async (\n  absolutePath: string,\n) => {\n  const log = debug(\"ef:generateTrackFragment\");\n  const probe = await Probe.probePath(absolutePath);\n\n  // Extract timing offset from probe metadata (same logic as processISOBMFF.ts)\n  let startTimeOffsetMs: number | undefined;\n\n  // First check format-level start_time\n  if (probe.format.start_time && Number(probe.format.start_time) !== 0) {\n    startTimeOffsetMs = Number(probe.format.start_time) * 1000;\n    log(\n      `Extracted format start_time offset: ${probe.format.start_time}s (${startTimeOffsetMs}ms)`,\n    );\n  } else {\n    // Check for video stream start_time (more common)\n    const videoStream = probe.streams.find(\n      (stream) => stream.codec_type === \"video\",\n    );\n    if (\n      videoStream &&\n      videoStream.start_time &&\n      Number(videoStream.start_time) !== 0\n    ) {\n      startTimeOffsetMs = Number(videoStream.start_time) * 1000;\n      log(\n        `Extracted video stream start_time offset: ${videoStream.start_time}s (${startTimeOffsetMs}ms)`,\n      );\n    } else {\n      log(\n        \"No format/stream timing offset found - will detect from composition time\",\n      );\n    }\n  }\n\n  log(\n    `Generating track fragment index for ${absolutePath} using single-track approach`,\n  );\n\n  // FIXED: Generate fragment indexes from individual single-track files\n  // This ensures byte offsets match the actual single-track files that clients will request\n  const trackFragmentIndexes: Record<number, TrackFragmentIndex> = {};\n\n  // Process each audio/video stream as a separate track\n  for (let streamIndex = 0; streamIndex < probe.streams.length; streamIndex++) {\n    const stream = probe.streams[streamIndex]!;\n\n    // Only process audio and video streams\n    if (stream.codec_type !== \"audio\" && stream.codec_type !== \"video\") {\n      continue;\n    }\n\n    const trackId = streamIndex + 1; // Convert to 1-based track ID\n    log(`Processing track ${trackId} (${stream.codec_type})`);\n\n    // Generate single-track file and its fragment index\n    const trackStream = probe.createTrackReadstream(streamIndex);\n    const trackIdMapping = { 0: trackId }; // Map single-track stream index 0 to original track ID\n\n    const singleTrackIndexes = await generateFragmentIndex(\n      trackStream,\n      startTimeOffsetMs,\n      trackIdMapping,\n    );\n\n    // Merge the single-track index into the combined result\n    Object.assign(trackFragmentIndexes, singleTrackIndexes);\n  }\n\n  // Generate scrub track fragment index if video stream exists\n  if (probe.videoStreams.length > 0) {\n    try {\n      log(\"Generating scrub track fragment index\");\n      // Generate scrub track stream and fragment index directly (don't generate full file)\n      const scrubStream = probe.createScrubTrackReadstream();\n      const scrubTrackId = -1;\n      const trackIdMapping = { 0: scrubTrackId }; // Map single-track stream index 0 to scrub track ID -1\n\n      const scrubFragmentIndex = await generateFragmentIndex(\n        scrubStream,\n        startTimeOffsetMs,\n        trackIdMapping,\n      );\n\n      if (scrubFragmentIndex[scrubTrackId]) {\n        trackFragmentIndexes[scrubTrackId] = scrubFragmentIndex[scrubTrackId]!;\n        log(\"Scrub track fragment index generated successfully\");\n      }\n    } catch (error) {\n      log(`Failed to generate scrub track fragment index: ${error}`);\n      // Don't fail the entire operation if scrub track generation fails\n    }\n  }\n\n  return trackFragmentIndexes;\n};\n\nconst generateTrackFragmentIndexTask = idempotentTask({\n  label: \"trackFragmentIndex\",\n  filename: (absolutePath) => `${basename(absolutePath)}.tracks.json`,\n  runner: async (absolutePath: string) => {\n    const index = await generateTrackFragmentIndexFromPath(absolutePath);\n    return JSON.stringify(index, null, 2);\n  },\n});\n\nexport const generateTrackFragmentIndex = async (\n  cacheRoot: string,\n  absolutePath: string,\n) => {\n  try {\n    return await generateTrackFragmentIndexTask(cacheRoot, absolutePath);\n  } catch (error) {\n    console.trace(\"Error generating track fragment index\", error);\n    throw error;\n  }\n};\n"],"mappings":";;;;;;;;;;AAOA,MAAa,qCAAqC,OAChD,iBACG;CACH,MAAM,yBAAY,2BAA2B;CAC7C,MAAM,QAAQ,MAAMA,oBAAM,UAAU,aAAa;CAGjD,IAAIC;AAGJ,KAAI,MAAM,OAAO,cAAc,OAAO,MAAM,OAAO,WAAW,KAAK,GAAG;AACpE,sBAAoB,OAAO,MAAM,OAAO,WAAW,GAAG;AACtD,MACE,uCAAuC,MAAM,OAAO,WAAW,KAAK,kBAAkB,KACvF;QACI;EAEL,MAAM,cAAc,MAAM,QAAQ,MAC/B,WAAW,OAAO,eAAe,QACnC;AACD,MACE,eACA,YAAY,cACZ,OAAO,YAAY,WAAW,KAAK,GACnC;AACA,uBAAoB,OAAO,YAAY,WAAW,GAAG;AACrD,OACE,6CAA6C,YAAY,WAAW,KAAK,kBAAkB,KAC5F;QAED,KACE,2EACD;;AAIL,KACE,uCAAuC,aAAa,8BACrD;CAID,MAAMC,uBAA2D,EAAE;AAGnE,MAAK,IAAI,cAAc,GAAG,cAAc,MAAM,QAAQ,QAAQ,eAAe;EAC3E,MAAM,SAAS,MAAM,QAAQ;AAG7B,MAAI,OAAO,eAAe,WAAW,OAAO,eAAe,QACzD;EAGF,MAAM,UAAU,cAAc;AAC9B,MAAI,oBAAoB,QAAQ,IAAI,OAAO,WAAW,GAAG;EAMzD,MAAM,qBAAqB,MAAMC,oDAHb,MAAM,sBAAsB,YAAY,EAK1D,mBAJqB,EAAE,GAAG,SAAS,CAMpC;AAGD,SAAO,OAAO,sBAAsB,mBAAmB;;AAIzD,KAAI,MAAM,aAAa,SAAS,EAC9B,KAAI;AACF,MAAI,wCAAwC;EAE5C,MAAM,cAAc,MAAM,4BAA4B;EACtD,MAAM,eAAe;EAGrB,MAAM,qBAAqB,MAAMA,oDAC/B,aACA,mBAJqB,EAAE,GAAG,cAAc,CAMzC;AAED,MAAI,mBAAmB,eAAe;AACpC,wBAAqB,gBAAgB,mBAAmB;AACxD,OAAI,oDAAoD;;UAEnD,OAAO;AACd,MAAI,kDAAkD,QAAQ;;AAKlE,QAAO;;AAGT,MAAM,iCAAiCC,sCAAe;CACpD,OAAO;CACP,WAAW,iBAAiB,2BAAY,aAAa,CAAC;CACtD,QAAQ,OAAO,iBAAyB;EACtC,MAAM,QAAQ,MAAM,mCAAmC,aAAa;AACpE,SAAO,KAAK,UAAU,OAAO,MAAM,EAAE;;CAExC,CAAC;AAEF,MAAa,6BAA6B,OACxC,WACA,iBACG;AACH,KAAI;AACF,SAAO,MAAM,+BAA+B,WAAW,aAAa;UAC7D,OAAO;AACd,UAAQ,MAAM,yCAAyC,MAAM;AAC7D,QAAM"}

package/dist/tasks/generateTrackFragmentIndex.d.cts

@@ -0,0 +1,9 @@
+import { TrackFragmentIndex } from "../Probe.cjs";
+import { TaskResult } from "../idempotentTask.cjs";
+
+//#region src/tasks/generateTrackFragmentIndex.d.ts
+declare const generateTrackFragmentIndexFromPath: (absolutePath: string) => Promise<Record<number, TrackFragmentIndex>>;
+declare const generateTrackFragmentIndex: (cacheRoot: string, absolutePath: string) => Promise<TaskResult>;
+//#endregion
+export { generateTrackFragmentIndex, generateTrackFragmentIndexFromPath };
+//# sourceMappingURL=generateTrackFragmentIndex.d.cts.map

package/dist/truncateDecimal.cjs

@@ -0,0 +1,10 @@
+
+//#region src/truncateDecimal.ts
+function truncateDecimal(num, decimals) {
+	const factor = 10 ** decimals;
+	return Math.trunc(num * factor) / factor;
+}
+
+//#endregion
+exports.truncateDecimal = truncateDecimal;
+//# sourceMappingURL=truncateDecimal.cjs.map

package/dist/truncateDecimal.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"truncateDecimal.cjs","names":[],"sources":["../src/truncateDecimal.ts"],"sourcesContent":["// Helper to calculate AAC frame-aligned segment durations for audio\nexport function truncateDecimal(num: number, decimals: number) {\n  const factor = 10 ** decimals;\n  return Math.trunc(num * factor) / factor;\n}\n"],"mappings":";;AACA,SAAgB,gBAAgB,KAAa,UAAkB;CAC7D,MAAM,SAAS,MAAM;AACrB,QAAO,KAAK,MAAM,MAAM,OAAO,GAAG"}