@editframe/assets 0.40.0 → 0.40.1-beta.0

package/dist/idempotentTask.cjs

@@ -1,5 +1,6 @@
 const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
 const require_md5 = require('./md5.cjs');
+const require_package = require('./package.cjs');
 let node_fs = require("node:fs");
 node_fs = require_rolldown_runtime.__toESM(node_fs);
 let debug = require("debug");
@@ -12,6 +13,30 @@ let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path);
 
 //#region src/idempotentTask.ts
+const CACHE_VERSION = require_package.version;
+const rootValidationPromises = /* @__PURE__ */ new Map();
+async function ensureCacheVersion(cacheDirRoot) {
+	const existing = rootValidationPromises.get(cacheDirRoot);
+	if (existing) return existing;
+	const promise = (async () => {
+		const versionFile = (0, node_path.join)(cacheDirRoot, ".version");
+		let storedVersion = null;
+		try {
+			storedVersion = (await (0, node_fs_promises.readFile)(versionFile, "utf-8")).trim();
+		} catch {}
+		if (storedVersion === CACHE_VERSION) return;
+		(0, debug.default)("ef:idempotentTask")(`Cache version mismatch (stored: ${storedVersion ?? "none"}, current: ${CACHE_VERSION}) — busting computed caches in ${cacheDirRoot}`);
+		const entries = await (0, node_fs_promises.readdir)(cacheDirRoot, { withFileTypes: true }).catch(() => []);
+		await Promise.all(entries.filter((e) => e.isDirectory()).map((e) => (0, node_fs_promises.rm)((0, node_path.join)(cacheDirRoot, e.name), {
+			recursive: true,
+			force: true
+		}).catch(() => {})));
+		await (0, node_fs_promises.mkdir)(cacheDirRoot, { recursive: true });
+		await (0, node_fs_promises.writeFile)(versionFile, CACHE_VERSION);
+	})();
+	rootValidationPromises.set(cacheDirRoot, promise);
+	return promise;
+}
 const idempotentTask = ({ label, filename, runner }) => {
 	const tasks = {};
 	const downloadTasks = {};
@@ -27,8 +52,9 @@ const idempotentTask = ({ label, filename, runner }) => {
 		const log = (0, debug.default)(`ef:${label}`);
 		const cacheDirRoot = node_path.default.join(rootDir, ".cache");
 		await (0, node_fs_promises.mkdir)(cacheDirRoot, { recursive: true });
+		await ensureCacheVersion(cacheDirRoot);
 		log(`Running ef:${label} task for ${absolutePath} in ${rootDir}`);
-		if (absolutePath.includes("http")) {
+		if (absolutePath.startsWith("http://") || absolutePath.startsWith("https://")) {
 			const safePath = absolutePath.replace(/[^a-zA-Z0-9]/g, "_");
 			const downloadCachePath = node_path.default.join(rootDir, ".cache", `${safePath}.file`);
 			if ((0, node_fs.existsSync)(downloadCachePath) && await isValidCacheFile(downloadCachePath, true)) {
@@ -53,8 +79,7 @@ const idempotentTask = ({ label, filename, runner }) => {
 								writeStream.on("error", reject);
 								writeStream.on("finish", () => resolve());
 							});
-							const { rename } = await import("node:fs/promises");
-							await rename(tempPath, downloadCachePath);
+							await (0, node_fs_promises.rename)(tempPath, downloadCachePath);
 							log(`Download completed for ${absolutePath}`);
 							return downloadCachePath;
 						} catch (error) {
@@ -125,8 +150,7 @@ const idempotentTask = ({ label, filename, runner }) => {
 						writeStream.on("error", reject);
 						writeStream.on("finish", () => resolve());
 					});
-					const { rename } = await import("node:fs/promises");
-					await rename(tempPath, resolvedCachePath);
+					await (0, node_fs_promises.rename)(tempPath, resolvedCachePath);
 				} else {
 					log(`Writing to ${resolvedCachePath}`);
 					await (0, node_fs_promises.writeFile)(resolvedCachePath, result);

package/dist/idempotentTask.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"idempotentTask.cjs","names":["tasks: Record<string, Promise<TaskResult>>","downloadTasks: Record<string, Promise<string>>","path","Readable","cachePath: string | null","md5: string | null","md5FilePath"],"sources":["../src/idempotentTask.ts"],"sourcesContent":["import { createWriteStream, existsSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { md5FilePath } from \"./md5.js\";\nimport debug from \"debug\";\nimport { mkdir, writeFile, stat, readdir } from \"node:fs/promises\";\nimport { Readable } from \"node:stream\";\n\ninterface TaskOptions<T extends unknown[]> {\n  label: string;\n  filename: (absolutePath: string, ...args: T) => string;\n  runner: (absolutePath: string, ...args: T) => Promise<string | Readable>;\n}\n\nexport interface TaskResult {\n  md5Sum: string;\n  cachePath: string;\n}\n\nexport const idempotentTask = <T extends unknown[]>({\n  label,\n  filename,\n  runner,\n}: TaskOptions<T>) => {\n  const tasks: Record<string, Promise<TaskResult>> = {};\n  const downloadTasks: Record<string, Promise<string>> = {};\n\n  // Helper function to validate cache file completeness\n  const isValidCacheFile = async (\n    filePath: string,\n    allowEmpty = false,\n  ): Promise<boolean> => {\n    try {\n      const stats = await stat(filePath);\n      // File must exist and either have content or be explicitly allowed to be empty\n      return allowEmpty || stats.size > 0;\n    } catch {\n      return false;\n    }\n  };\n\n  return async (\n    rootDir: string,\n    absolutePath: string,\n    ...args: T\n  ): Promise<TaskResult> => {\n    const log = debug(`ef:${label}`);\n    const cacheDirRoot = path.join(rootDir, \".cache\");\n    await mkdir(cacheDirRoot, { recursive: true });\n\n    log(`Running ef:${label} task for ${absolutePath} in ${rootDir}`);\n\n    // Handle HTTP downloads with proper race condition protection\n    if (absolutePath.includes(\"http\")) {\n      const safePath = absolutePath.replace(/[^a-zA-Z0-9]/g, \"_\");\n      const downloadCachePath = path.join(\n        rootDir,\n        \".cache\",\n        `${safePath}.file`,\n      );\n\n      // Check if already downloaded and valid (allow empty downloads)\n      if (\n        existsSync(downloadCachePath) &&\n        (await isValidCacheFile(downloadCachePath, true))\n      ) {\n        log(`Already cached ${absolutePath}`);\n        absolutePath = downloadCachePath;\n      } else {\n        // Use download task deduplication to prevent concurrent downloads\n        const downloadKey = absolutePath;\n        if (!downloadTasks[downloadKey]) {\n          log(`Starting download for ${absolutePath}`);\n          downloadTasks[downloadKey] = (async () => {\n            try {\n              const response = await fetch(absolutePath);\n              if (!response.ok) {\n                throw new Error(\n                  `Failed to fetch file from URL ${absolutePath}: ${response.status} ${response.statusText}`,\n                );\n              }\n\n              const stream = response.body;\n              if (!stream) {\n                throw new Error(`No response body for URL ${absolutePath}`);\n              }\n\n              // Use temporary file to prevent reading incomplete downloads\n              const tempPath = `${downloadCachePath}.tmp`;\n              const writeStream = createWriteStream(tempPath);\n\n              // @ts-ignore node web stream support in typescript is incorrect about this.\n              const readable = Readable.fromWeb(stream);\n              readable.pipe(writeStream);\n\n              await new Promise<void>((resolve, reject) => {\n                readable.on(\"error\", reject);\n                writeStream.on(\"error\", reject);\n                writeStream.on(\"finish\", () => resolve());\n              });\n\n              // Atomically move completed file to final location\n              const { rename } = await import(\"node:fs/promises\");\n              await rename(tempPath, downloadCachePath);\n\n              log(`Download completed for ${absolutePath}`);\n              return downloadCachePath;\n            } catch (error) {\n              log(`Download failed for ${absolutePath}: ${error}`);\n              // Clean up task reference on failure\n              delete downloadTasks[downloadKey];\n              throw error;\n            }\n          })();\n        }\n\n        absolutePath = await downloadTasks[downloadKey];\n        // Clean up completed task\n        delete downloadTasks[downloadKey];\n      }\n    }\n\n    // Deduplicate concurrent callers by input parameters before any async work.\n    // Using a synchronous key prevents the TOCTOU race where two concurrent\n    // callers both pass the tasks[] check before either registers a task.\n    const inputKey = JSON.stringify([absolutePath, ...args]);\n    if (tasks[inputKey]) {\n      log(`Returning existing ef:${label} task for ${absolutePath}`);\n      return await tasks[inputKey];\n    }\n\n    const fullTask = (async (): Promise<TaskResult> => {\n      try {\n        // Try to find existing cache by scanning cache directories.\n        // This avoids expensive MD5 computation when cache already exists.\n        const expectedFilename = filename(absolutePath, ...args);\n        let cachePath: string | null = null;\n        let md5: string | null = null;\n\n        const scanStartTime = Date.now();\n        try {\n          const cacheDirs = await readdir(cacheDirRoot, {\n            withFileTypes: true,\n          });\n          log(\n            `Scanning ${cacheDirs.length} cache directories for ${expectedFilename}`,\n          );\n          for (const dir of cacheDirs) {\n            if (dir.isDirectory()) {\n              const candidatePath = path.join(\n                cacheDirRoot,\n                dir.name,\n                expectedFilename,\n              );\n              if (\n                existsSync(candidatePath) &&\n                (await isValidCacheFile(candidatePath))\n              ) {\n                cachePath = candidatePath;\n                md5 = dir.name; // Directory name is the MD5\n                const scanElapsed = Date.now() - scanStartTime;\n                log(\n                  `Found existing cache in ${scanElapsed}ms: ${candidatePath} (skipped MD5)`,\n                );\n                break;\n              }\n            }\n          }\n          if (!cachePath) {\n            const scanElapsed = Date.now() - scanStartTime;\n            log(\n              `Cache scan completed in ${scanElapsed}ms, no cache found - will compute MD5`,\n            );\n          }\n        } catch (error) {\n          const scanElapsed = Date.now() - scanStartTime;\n          log(\n            `Cache scan failed after ${scanElapsed}ms, will compute MD5: ${error}`,\n          );\n        }\n\n        const resolvedMd5 =\n          md5 ??\n          (await (async () => {\n            const md5StartTime = Date.now();\n            log(`Computing MD5 for ${absolutePath}...`);\n            const computed = await md5FilePath(absolutePath);\n            const md5Elapsed = Date.now() - md5StartTime;\n            log(`MD5 computed in ${md5Elapsed}ms: ${computed}`);\n            return computed;\n          })());\n\n        const cacheDir = path.join(cacheDirRoot, resolvedMd5);\n        log(`Cache dir: ${cacheDir}`);\n        await mkdir(cacheDir, { recursive: true });\n\n        const resolvedCachePath =\n          cachePath ?? path.join(cacheDir, expectedFilename);\n\n        // Check if cache exists and is valid (not zero-byte)\n        if (\n          existsSync(resolvedCachePath) &&\n          (await isValidCacheFile(resolvedCachePath))\n        ) {\n          log(`Returning cached ef:${label} task for ${resolvedCachePath}`);\n          return { cachePath: resolvedCachePath, md5Sum: resolvedMd5 };\n        }\n\n        log(`Running ef:${label} runner for ${resolvedCachePath}`);\n        const result = await runner(absolutePath, ...args);\n\n        if (result instanceof Readable) {\n          log(`Piping task for ${resolvedCachePath} to cache`);\n          const tempPath = `${resolvedCachePath}.tmp`;\n          const writeStream = createWriteStream(tempPath);\n          result.pipe(writeStream);\n\n          await new Promise<void>((resolve, reject) => {\n            result.on(\"error\", reject);\n            writeStream.on(\"error\", reject);\n            writeStream.on(\"finish\", () => resolve());\n          });\n\n          const { rename } = await import(\"node:fs/promises\");\n          await rename(tempPath, resolvedCachePath);\n        } else {\n          log(`Writing to ${resolvedCachePath}`);\n          await writeFile(resolvedCachePath, result);\n        }\n\n        return {\n          md5Sum: resolvedMd5,\n          cachePath: resolvedCachePath,\n        };\n      } finally {\n        delete tasks[inputKey];\n      }\n    })();\n\n    tasks[inputKey] = fullTask;\n    return await fullTask;\n  };\n};\n"],"mappings":"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"}
+{"version":3,"file":"idempotentTask.cjs","names":["storedVersion: string | null","tasks: Record<string, Promise<TaskResult>>","downloadTasks: Record<string, Promise<string>>","path","Readable","cachePath: string | null","md5: string | null","md5FilePath"],"sources":["../src/idempotentTask.ts"],"sourcesContent":["import { createWriteStream, existsSync } from \"node:fs\";\nimport path, { join } from \"node:path\";\nimport { md5FilePath } from \"./md5.js\";\nimport debug from \"debug\";\nimport { mkdir, writeFile, stat, rename, readdir, readFile, rm } from \"node:fs/promises\";\nimport { Readable } from \"node:stream\";\nimport packageJson from \"../package.json\" with { type: \"json\" };\n\nconst CACHE_VERSION = packageJson.version;\n\n// Per-root validation promises — serializes the version check within a process\n// and memoizes it so subsequent calls in the same process are free.\nconst rootValidationPromises = new Map<string, Promise<void>>();\n\nasync function ensureCacheVersion(cacheDirRoot: string): Promise<void> {\n  const existing = rootValidationPromises.get(cacheDirRoot);\n  if (existing) return existing;\n\n  const promise = (async () => {\n    const versionFile = join(cacheDirRoot, \".version\");\n    let storedVersion: string | null = null;\n    try {\n      storedVersion = (await readFile(versionFile, \"utf-8\")).trim();\n    } catch {}\n\n    if (storedVersion === CACHE_VERSION) return;\n\n    const log = debug(\"ef:idempotentTask\");\n    log(\n      `Cache version mismatch (stored: ${storedVersion ?? \"none\"}, current: ${CACHE_VERSION}) — busting computed caches in ${cacheDirRoot}`,\n    );\n\n    // Delete computed output directories; preserve downloaded .file entries\n    const entries = await readdir(cacheDirRoot, { withFileTypes: true }).catch(\n      () => [],\n    );\n    await Promise.all(\n      entries\n        .filter((e) => e.isDirectory())\n        .map((e) =>\n          rm(join(cacheDirRoot, e.name), {\n            recursive: true,\n            force: true,\n          }).catch(() => {}),\n        ),\n    );\n\n    await mkdir(cacheDirRoot, { recursive: true });\n    await writeFile(versionFile, CACHE_VERSION);\n  })();\n\n  rootValidationPromises.set(cacheDirRoot, promise);\n  return promise;\n}\n\nconst MAX_CONCURRENT_RUNNERS = 4;\nlet activeRunners = 0;\nconst runnerQueue: Array<() => void> = [];\n\nfunction acquireRunnerSlot(): Promise<void> {\n  if (activeRunners < MAX_CONCURRENT_RUNNERS) {\n    activeRunners++;\n    return Promise.resolve();\n  }\n  return new Promise((resolve) => {\n    runnerQueue.push(() => {\n      activeRunners++;\n      resolve();\n    });\n  });\n}\n\nfunction releaseRunnerSlot(): void {\n  activeRunners--;\n  const next = runnerQueue.shift();\n  if (next) next();\n}\n\ninterface TaskOptions<T extends unknown[]> {\n  label: string;\n  filename: (absolutePath: string, ...args: T) => string;\n  runner: (absolutePath: string, ...args: T) => Promise<string | Readable>;\n}\n\nexport interface TaskResult {\n  md5Sum: string;\n  cachePath: string;\n}\n\nexport const idempotentTask = <T extends unknown[]>({\n  label,\n  filename,\n  runner,\n}: TaskOptions<T>) => {\n  const tasks: Record<string, Promise<TaskResult>> = {};\n  const downloadTasks: Record<string, Promise<string>> = {};\n\n  // Helper function to validate cache file completeness\n  const isValidCacheFile = async (\n    filePath: string,\n    allowEmpty = false,\n  ): Promise<boolean> => {\n    try {\n      const stats = await stat(filePath);\n      // File must exist and either have content or be explicitly allowed to be empty\n      return allowEmpty || stats.size > 0;\n    } catch {\n      return false;\n    }\n  };\n\n  return async (\n    rootDir: string,\n    absolutePath: string,\n    ...args: T\n  ): Promise<TaskResult> => {\n    const log = debug(`ef:${label}`);\n    const cacheDirRoot = path.join(rootDir, \".cache\");\n    await mkdir(cacheDirRoot, { recursive: true });\n    await ensureCacheVersion(cacheDirRoot);\n\n    log(`Running ef:${label} task for ${absolutePath} in ${rootDir}`);\n\n    // Handle HTTP downloads with proper race condition protection\n    if (absolutePath.startsWith(\"http://\") || absolutePath.startsWith(\"https://\")) {\n      const safePath = absolutePath.replace(/[^a-zA-Z0-9]/g, \"_\");\n      const downloadCachePath = path.join(\n        rootDir,\n        \".cache\",\n        `${safePath}.file`,\n      );\n\n      // Check if already downloaded and valid (allow empty downloads)\n      if (\n        existsSync(downloadCachePath) &&\n        (await isValidCacheFile(downloadCachePath, true))\n      ) {\n        log(`Already cached ${absolutePath}`);\n        absolutePath = downloadCachePath;\n      } else {\n        // Use download task deduplication to prevent concurrent downloads\n        const downloadKey = absolutePath;\n        if (!downloadTasks[downloadKey]) {\n          log(`Starting download for ${absolutePath}`);\n          downloadTasks[downloadKey] = (async () => {\n            try {\n              const response = await fetch(absolutePath);\n              if (!response.ok) {\n                throw new Error(\n                  `Failed to fetch file from URL ${absolutePath}: ${response.status} ${response.statusText}`,\n                );\n              }\n\n              const stream = response.body;\n              if (!stream) {\n                throw new Error(`No response body for URL ${absolutePath}`);\n              }\n\n              // Use temporary file to prevent reading incomplete downloads\n              const tempPath = `${downloadCachePath}.tmp`;\n              const writeStream = createWriteStream(tempPath);\n\n              // @ts-ignore node web stream support in typescript is incorrect about this.\n              const readable = Readable.fromWeb(stream);\n              readable.pipe(writeStream);\n\n              await new Promise<void>((resolve, reject) => {\n                readable.on(\"error\", reject);\n                writeStream.on(\"error\", reject);\n                writeStream.on(\"finish\", () => resolve());\n              });\n\n              // Atomically move completed file to final location\n              await rename(tempPath, downloadCachePath);\n\n              log(`Download completed for ${absolutePath}`);\n              return downloadCachePath;\n            } catch (error) {\n              log(`Download failed for ${absolutePath}: ${error}`);\n              // Clean up task reference on failure\n              delete downloadTasks[downloadKey];\n              throw error;\n            }\n          })();\n        }\n\n        absolutePath = await downloadTasks[downloadKey];\n        // Clean up completed task\n        delete downloadTasks[downloadKey];\n      }\n    }\n\n    // Deduplicate concurrent callers by input parameters before any async work.\n    // Using a synchronous key prevents the TOCTOU race where two concurrent\n    // callers both pass the tasks[] check before either registers a task.\n    const inputKey = JSON.stringify([absolutePath, ...args]);\n    if (tasks[inputKey]) {\n      log(`Returning existing ef:${label} task for ${absolutePath}`);\n      return await tasks[inputKey];\n    }\n\n    const fullTask = (async (): Promise<TaskResult> => {\n      try {\n        // Try to find existing cache by scanning cache directories.\n        // This avoids expensive MD5 computation when cache already exists.\n        const expectedFilename = filename(absolutePath, ...args);\n        let cachePath: string | null = null;\n        let md5: string | null = null;\n\n        const scanStartTime = Date.now();\n        try {\n          const cacheDirs = await readdir(cacheDirRoot, {\n            withFileTypes: true,\n          });\n          log(\n            `Scanning ${cacheDirs.length} cache directories for ${expectedFilename}`,\n          );\n          for (const dir of cacheDirs) {\n            if (dir.isDirectory()) {\n              const candidatePath = path.join(\n                cacheDirRoot,\n                dir.name,\n                expectedFilename,\n              );\n              if (\n                existsSync(candidatePath) &&\n                (await isValidCacheFile(candidatePath))\n              ) {\n                cachePath = candidatePath;\n                md5 = dir.name; // Directory name is the MD5\n                const scanElapsed = Date.now() - scanStartTime;\n                log(\n                  `Found existing cache in ${scanElapsed}ms: ${candidatePath} (skipped MD5)`,\n                );\n                break;\n              }\n            }\n          }\n          if (!cachePath) {\n            const scanElapsed = Date.now() - scanStartTime;\n            log(\n              `Cache scan completed in ${scanElapsed}ms, no cache found - will compute MD5`,\n            );\n          }\n        } catch (error) {\n          const scanElapsed = Date.now() - scanStartTime;\n          log(\n            `Cache scan failed after ${scanElapsed}ms, will compute MD5: ${error}`,\n          );\n        }\n\n        const resolvedMd5 =\n          md5 ??\n          (await (async () => {\n            const md5StartTime = Date.now();\n            log(`Computing MD5 for ${absolutePath}...`);\n            const computed = await md5FilePath(absolutePath);\n            const md5Elapsed = Date.now() - md5StartTime;\n            log(`MD5 computed in ${md5Elapsed}ms: ${computed}`);\n            return computed;\n          })());\n\n        const cacheDir = path.join(cacheDirRoot, resolvedMd5);\n        log(`Cache dir: ${cacheDir}`);\n        await mkdir(cacheDir, { recursive: true });\n\n        const resolvedCachePath =\n          cachePath ?? path.join(cacheDir, expectedFilename);\n\n        // Check if cache exists and is valid (not zero-byte)\n        if (\n          existsSync(resolvedCachePath) &&\n          (await isValidCacheFile(resolvedCachePath))\n        ) {\n          log(`Returning cached ef:${label} task for ${resolvedCachePath}`);\n          return { cachePath: resolvedCachePath, md5Sum: resolvedMd5 };\n        }\n\n        log(`Running ef:${label} runner for ${resolvedCachePath}`);\n        const result = await runner(absolutePath, ...args);\n\n        if (result instanceof Readable) {\n          log(`Piping task for ${resolvedCachePath} to cache`);\n          const tempPath = `${resolvedCachePath}.tmp`;\n          const writeStream = createWriteStream(tempPath);\n          result.pipe(writeStream);\n\n          await new Promise<void>((resolve, reject) => {\n            result.on(\"error\", reject);\n            writeStream.on(\"error\", reject);\n            writeStream.on(\"finish\", () => resolve());\n          });\n\n          await rename(tempPath, resolvedCachePath);\n        } else {\n          log(`Writing to ${resolvedCachePath}`);\n          await writeFile(resolvedCachePath, result);\n        }\n\n        return {\n          md5Sum: resolvedMd5,\n          cachePath: resolvedCachePath,\n        };\n      } finally {\n        delete tasks[inputKey];\n      }\n    })();\n\n    tasks[inputKey] = fullTask;\n    return await fullTask;\n  };\n};\n"],"mappings":"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"}

package/dist/idempotentTask.js

@@ -1,11 +1,36 @@
 import { md5FilePath } from "./md5.js";
+import { version } from "./package.js";
 import { createWriteStream, existsSync } from "node:fs";
 import debug from "debug";
 import { Readable } from "node:stream";
-import { mkdir, readdir, stat, writeFile } from "node:fs/promises";
-import path from "node:path";
+import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import path, { join } from "node:path";
 
 //#region src/idempotentTask.ts
+const CACHE_VERSION = version;
+const rootValidationPromises = /* @__PURE__ */ new Map();
+async function ensureCacheVersion(cacheDirRoot) {
+	const existing = rootValidationPromises.get(cacheDirRoot);
+	if (existing) return existing;
+	const promise = (async () => {
+		const versionFile = join(cacheDirRoot, ".version");
+		let storedVersion = null;
+		try {
+			storedVersion = (await readFile(versionFile, "utf-8")).trim();
+		} catch {}
+		if (storedVersion === CACHE_VERSION) return;
+		debug("ef:idempotentTask")(`Cache version mismatch (stored: ${storedVersion ?? "none"}, current: ${CACHE_VERSION}) — busting computed caches in ${cacheDirRoot}`);
+		const entries = await readdir(cacheDirRoot, { withFileTypes: true }).catch(() => []);
+		await Promise.all(entries.filter((e) => e.isDirectory()).map((e) => rm(join(cacheDirRoot, e.name), {
+			recursive: true,
+			force: true
+		}).catch(() => {})));
+		await mkdir(cacheDirRoot, { recursive: true });
+		await writeFile(versionFile, CACHE_VERSION);
+	})();
+	rootValidationPromises.set(cacheDirRoot, promise);
+	return promise;
+}
 const idempotentTask = ({ label, filename, runner }) => {
 	const tasks = {};
 	const downloadTasks = {};
@@ -21,8 +46,9 @@ const idempotentTask = ({ label, filename, runner }) => {
 		const log = debug(`ef:${label}`);
 		const cacheDirRoot = path.join(rootDir, ".cache");
 		await mkdir(cacheDirRoot, { recursive: true });
+		await ensureCacheVersion(cacheDirRoot);
 		log(`Running ef:${label} task for ${absolutePath} in ${rootDir}`);
-		if (absolutePath.includes("http")) {
+		if (absolutePath.startsWith("http://") || absolutePath.startsWith("https://")) {
 			const safePath = absolutePath.replace(/[^a-zA-Z0-9]/g, "_");
 			const downloadCachePath = path.join(rootDir, ".cache", `${safePath}.file`);
 			if (existsSync(downloadCachePath) && await isValidCacheFile(downloadCachePath, true)) {
@@ -47,7 +73,6 @@ const idempotentTask = ({ label, filename, runner }) => {
 								writeStream.on("error", reject);
 								writeStream.on("finish", () => resolve());
 							});
-							const { rename } = await import("node:fs/promises");
 							await rename(tempPath, downloadCachePath);
 							log(`Download completed for ${absolutePath}`);
 							return downloadCachePath;
@@ -119,7 +144,6 @@ const idempotentTask = ({ label, filename, runner }) => {
 						writeStream.on("error", reject);
 						writeStream.on("finish", () => resolve());
 					});
-					const { rename } = await import("node:fs/promises");
 					await rename(tempPath, resolvedCachePath);
 				} else {
 					log(`Writing to ${resolvedCachePath}`);

package/dist/idempotentTask.js.map

@@ -1 +1 @@
-{"version":3,"file":"idempotentTask.js","names":["tasks: Record<string, Promise<TaskResult>>","downloadTasks: Record<string, Promise<string>>","cachePath: string | null","md5: string | null"],"sources":["../src/idempotentTask.ts"],"sourcesContent":["import { createWriteStream, existsSync } from \"node:fs\";\nimport path from \"node:path\";\nimport { md5FilePath } from \"./md5.js\";\nimport debug from \"debug\";\nimport { mkdir, writeFile, stat, readdir } from \"node:fs/promises\";\nimport { Readable } from \"node:stream\";\n\ninterface TaskOptions<T extends unknown[]> {\n  label: string;\n  filename: (absolutePath: string, ...args: T) => string;\n  runner: (absolutePath: string, ...args: T) => Promise<string | Readable>;\n}\n\nexport interface TaskResult {\n  md5Sum: string;\n  cachePath: string;\n}\n\nexport const idempotentTask = <T extends unknown[]>({\n  label,\n  filename,\n  runner,\n}: TaskOptions<T>) => {\n  const tasks: Record<string, Promise<TaskResult>> = {};\n  const downloadTasks: Record<string, Promise<string>> = {};\n\n  // Helper function to validate cache file completeness\n  const isValidCacheFile = async (\n    filePath: string,\n    allowEmpty = false,\n  ): Promise<boolean> => {\n    try {\n      const stats = await stat(filePath);\n      // File must exist and either have content or be explicitly allowed to be empty\n      return allowEmpty || stats.size > 0;\n    } catch {\n      return false;\n    }\n  };\n\n  return async (\n    rootDir: string,\n    absolutePath: string,\n    ...args: T\n  ): Promise<TaskResult> => {\n    const log = debug(`ef:${label}`);\n    const cacheDirRoot = path.join(rootDir, \".cache\");\n    await mkdir(cacheDirRoot, { recursive: true });\n\n    log(`Running ef:${label} task for ${absolutePath} in ${rootDir}`);\n\n    // Handle HTTP downloads with proper race condition protection\n    if (absolutePath.includes(\"http\")) {\n      const safePath = absolutePath.replace(/[^a-zA-Z0-9]/g, \"_\");\n      const downloadCachePath = path.join(\n        rootDir,\n        \".cache\",\n        `${safePath}.file`,\n      );\n\n      // Check if already downloaded and valid (allow empty downloads)\n      if (\n        existsSync(downloadCachePath) &&\n        (await isValidCacheFile(downloadCachePath, true))\n      ) {\n        log(`Already cached ${absolutePath}`);\n        absolutePath = downloadCachePath;\n      } else {\n        // Use download task deduplication to prevent concurrent downloads\n        const downloadKey = absolutePath;\n        if (!downloadTasks[downloadKey]) {\n          log(`Starting download for ${absolutePath}`);\n          downloadTasks[downloadKey] = (async () => {\n            try {\n              const response = await fetch(absolutePath);\n              if (!response.ok) {\n                throw new Error(\n                  `Failed to fetch file from URL ${absolutePath}: ${response.status} ${response.statusText}`,\n                );\n              }\n\n              const stream = response.body;\n              if (!stream) {\n                throw new Error(`No response body for URL ${absolutePath}`);\n              }\n\n              // Use temporary file to prevent reading incomplete downloads\n              const tempPath = `${downloadCachePath}.tmp`;\n              const writeStream = createWriteStream(tempPath);\n\n              // @ts-ignore node web stream support in typescript is incorrect about this.\n              const readable = Readable.fromWeb(stream);\n              readable.pipe(writeStream);\n\n              await new Promise<void>((resolve, reject) => {\n                readable.on(\"error\", reject);\n                writeStream.on(\"error\", reject);\n                writeStream.on(\"finish\", () => resolve());\n              });\n\n              // Atomically move completed file to final location\n              const { rename } = await import(\"node:fs/promises\");\n              await rename(tempPath, downloadCachePath);\n\n              log(`Download completed for ${absolutePath}`);\n              return downloadCachePath;\n            } catch (error) {\n              log(`Download failed for ${absolutePath}: ${error}`);\n              // Clean up task reference on failure\n              delete downloadTasks[downloadKey];\n              throw error;\n            }\n          })();\n        }\n\n        absolutePath = await downloadTasks[downloadKey];\n        // Clean up completed task\n        delete downloadTasks[downloadKey];\n      }\n    }\n\n    // Deduplicate concurrent callers by input parameters before any async work.\n    // Using a synchronous key prevents the TOCTOU race where two concurrent\n    // callers both pass the tasks[] check before either registers a task.\n    const inputKey = JSON.stringify([absolutePath, ...args]);\n    if (tasks[inputKey]) {\n      log(`Returning existing ef:${label} task for ${absolutePath}`);\n      return await tasks[inputKey];\n    }\n\n    const fullTask = (async (): Promise<TaskResult> => {\n      try {\n        // Try to find existing cache by scanning cache directories.\n        // This avoids expensive MD5 computation when cache already exists.\n        const expectedFilename = filename(absolutePath, ...args);\n        let cachePath: string | null = null;\n        let md5: string | null = null;\n\n        const scanStartTime = Date.now();\n        try {\n          const cacheDirs = await readdir(cacheDirRoot, {\n            withFileTypes: true,\n          });\n          log(\n            `Scanning ${cacheDirs.length} cache directories for ${expectedFilename}`,\n          );\n          for (const dir of cacheDirs) {\n            if (dir.isDirectory()) {\n              const candidatePath = path.join(\n                cacheDirRoot,\n                dir.name,\n                expectedFilename,\n              );\n              if (\n                existsSync(candidatePath) &&\n                (await isValidCacheFile(candidatePath))\n              ) {\n                cachePath = candidatePath;\n                md5 = dir.name; // Directory name is the MD5\n                const scanElapsed = Date.now() - scanStartTime;\n                log(\n                  `Found existing cache in ${scanElapsed}ms: ${candidatePath} (skipped MD5)`,\n                );\n                break;\n              }\n            }\n          }\n          if (!cachePath) {\n            const scanElapsed = Date.now() - scanStartTime;\n            log(\n              `Cache scan completed in ${scanElapsed}ms, no cache found - will compute MD5`,\n            );\n          }\n        } catch (error) {\n          const scanElapsed = Date.now() - scanStartTime;\n          log(\n            `Cache scan failed after ${scanElapsed}ms, will compute MD5: ${error}`,\n          );\n        }\n\n        const resolvedMd5 =\n          md5 ??\n          (await (async () => {\n            const md5StartTime = Date.now();\n            log(`Computing MD5 for ${absolutePath}...`);\n            const computed = await md5FilePath(absolutePath);\n            const md5Elapsed = Date.now() - md5StartTime;\n            log(`MD5 computed in ${md5Elapsed}ms: ${computed}`);\n            return computed;\n          })());\n\n        const cacheDir = path.join(cacheDirRoot, resolvedMd5);\n        log(`Cache dir: ${cacheDir}`);\n        await mkdir(cacheDir, { recursive: true });\n\n        const resolvedCachePath =\n          cachePath ?? path.join(cacheDir, expectedFilename);\n\n        // Check if cache exists and is valid (not zero-byte)\n        if (\n          existsSync(resolvedCachePath) &&\n          (await isValidCacheFile(resolvedCachePath))\n        ) {\n          log(`Returning cached ef:${label} task for ${resolvedCachePath}`);\n          return { cachePath: resolvedCachePath, md5Sum: resolvedMd5 };\n        }\n\n        log(`Running ef:${label} runner for ${resolvedCachePath}`);\n        const result = await runner(absolutePath, ...args);\n\n        if (result instanceof Readable) {\n          log(`Piping task for ${resolvedCachePath} to cache`);\n          const tempPath = `${resolvedCachePath}.tmp`;\n          const writeStream = createWriteStream(tempPath);\n          result.pipe(writeStream);\n\n          await new Promise<void>((resolve, reject) => {\n            result.on(\"error\", reject);\n            writeStream.on(\"error\", reject);\n            writeStream.on(\"finish\", () => resolve());\n          });\n\n          const { rename } = await import(\"node:fs/promises\");\n          await rename(tempPath, resolvedCachePath);\n        } else {\n          log(`Writing to ${resolvedCachePath}`);\n          await writeFile(resolvedCachePath, result);\n        }\n\n        return {\n          md5Sum: resolvedMd5,\n          cachePath: resolvedCachePath,\n        };\n      } finally {\n        delete tasks[inputKey];\n      }\n    })();\n\n    tasks[inputKey] = fullTask;\n    return await fullTask;\n  };\n};\n"],"mappings":"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"}
+{"version":3,"file":"idempotentTask.js","names":["packageJson.version","storedVersion: string | null","tasks: Record<string, Promise<TaskResult>>","downloadTasks: Record<string, Promise<string>>","cachePath: string | null","md5: string | null"],"sources":["../src/idempotentTask.ts"],"sourcesContent":["import { createWriteStream, existsSync } from \"node:fs\";\nimport path, { join } from \"node:path\";\nimport { md5FilePath } from \"./md5.js\";\nimport debug from \"debug\";\nimport { mkdir, writeFile, stat, rename, readdir, readFile, rm } from \"node:fs/promises\";\nimport { Readable } from \"node:stream\";\nimport packageJson from \"../package.json\" with { type: \"json\" };\n\nconst CACHE_VERSION = packageJson.version;\n\n// Per-root validation promises — serializes the version check within a process\n// and memoizes it so subsequent calls in the same process are free.\nconst rootValidationPromises = new Map<string, Promise<void>>();\n\nasync function ensureCacheVersion(cacheDirRoot: string): Promise<void> {\n  const existing = rootValidationPromises.get(cacheDirRoot);\n  if (existing) return existing;\n\n  const promise = (async () => {\n    const versionFile = join(cacheDirRoot, \".version\");\n    let storedVersion: string | null = null;\n    try {\n      storedVersion = (await readFile(versionFile, \"utf-8\")).trim();\n    } catch {}\n\n    if (storedVersion === CACHE_VERSION) return;\n\n    const log = debug(\"ef:idempotentTask\");\n    log(\n      `Cache version mismatch (stored: ${storedVersion ?? \"none\"}, current: ${CACHE_VERSION}) — busting computed caches in ${cacheDirRoot}`,\n    );\n\n    // Delete computed output directories; preserve downloaded .file entries\n    const entries = await readdir(cacheDirRoot, { withFileTypes: true }).catch(\n      () => [],\n    );\n    await Promise.all(\n      entries\n        .filter((e) => e.isDirectory())\n        .map((e) =>\n          rm(join(cacheDirRoot, e.name), {\n            recursive: true,\n            force: true,\n          }).catch(() => {}),\n        ),\n    );\n\n    await mkdir(cacheDirRoot, { recursive: true });\n    await writeFile(versionFile, CACHE_VERSION);\n  })();\n\n  rootValidationPromises.set(cacheDirRoot, promise);\n  return promise;\n}\n\nconst MAX_CONCURRENT_RUNNERS = 4;\nlet activeRunners = 0;\nconst runnerQueue: Array<() => void> = [];\n\nfunction acquireRunnerSlot(): Promise<void> {\n  if (activeRunners < MAX_CONCURRENT_RUNNERS) {\n    activeRunners++;\n    return Promise.resolve();\n  }\n  return new Promise((resolve) => {\n    runnerQueue.push(() => {\n      activeRunners++;\n      resolve();\n    });\n  });\n}\n\nfunction releaseRunnerSlot(): void {\n  activeRunners--;\n  const next = runnerQueue.shift();\n  if (next) next();\n}\n\ninterface TaskOptions<T extends unknown[]> {\n  label: string;\n  filename: (absolutePath: string, ...args: T) => string;\n  runner: (absolutePath: string, ...args: T) => Promise<string | Readable>;\n}\n\nexport interface TaskResult {\n  md5Sum: string;\n  cachePath: string;\n}\n\nexport const idempotentTask = <T extends unknown[]>({\n  label,\n  filename,\n  runner,\n}: TaskOptions<T>) => {\n  const tasks: Record<string, Promise<TaskResult>> = {};\n  const downloadTasks: Record<string, Promise<string>> = {};\n\n  // Helper function to validate cache file completeness\n  const isValidCacheFile = async (\n    filePath: string,\n    allowEmpty = false,\n  ): Promise<boolean> => {\n    try {\n      const stats = await stat(filePath);\n      // File must exist and either have content or be explicitly allowed to be empty\n      return allowEmpty || stats.size > 0;\n    } catch {\n      return false;\n    }\n  };\n\n  return async (\n    rootDir: string,\n    absolutePath: string,\n    ...args: T\n  ): Promise<TaskResult> => {\n    const log = debug(`ef:${label}`);\n    const cacheDirRoot = path.join(rootDir, \".cache\");\n    await mkdir(cacheDirRoot, { recursive: true });\n    await ensureCacheVersion(cacheDirRoot);\n\n    log(`Running ef:${label} task for ${absolutePath} in ${rootDir}`);\n\n    // Handle HTTP downloads with proper race condition protection\n    if (absolutePath.startsWith(\"http://\") || absolutePath.startsWith(\"https://\")) {\n      const safePath = absolutePath.replace(/[^a-zA-Z0-9]/g, \"_\");\n      const downloadCachePath = path.join(\n        rootDir,\n        \".cache\",\n        `${safePath}.file`,\n      );\n\n      // Check if already downloaded and valid (allow empty downloads)\n      if (\n        existsSync(downloadCachePath) &&\n        (await isValidCacheFile(downloadCachePath, true))\n      ) {\n        log(`Already cached ${absolutePath}`);\n        absolutePath = downloadCachePath;\n      } else {\n        // Use download task deduplication to prevent concurrent downloads\n        const downloadKey = absolutePath;\n        if (!downloadTasks[downloadKey]) {\n          log(`Starting download for ${absolutePath}`);\n          downloadTasks[downloadKey] = (async () => {\n            try {\n              const response = await fetch(absolutePath);\n              if (!response.ok) {\n                throw new Error(\n                  `Failed to fetch file from URL ${absolutePath}: ${response.status} ${response.statusText}`,\n                );\n              }\n\n              const stream = response.body;\n              if (!stream) {\n                throw new Error(`No response body for URL ${absolutePath}`);\n              }\n\n              // Use temporary file to prevent reading incomplete downloads\n              const tempPath = `${downloadCachePath}.tmp`;\n              const writeStream = createWriteStream(tempPath);\n\n              // @ts-ignore node web stream support in typescript is incorrect about this.\n              const readable = Readable.fromWeb(stream);\n              readable.pipe(writeStream);\n\n              await new Promise<void>((resolve, reject) => {\n                readable.on(\"error\", reject);\n                writeStream.on(\"error\", reject);\n                writeStream.on(\"finish\", () => resolve());\n              });\n\n              // Atomically move completed file to final location\n              await rename(tempPath, downloadCachePath);\n\n              log(`Download completed for ${absolutePath}`);\n              return downloadCachePath;\n            } catch (error) {\n              log(`Download failed for ${absolutePath}: ${error}`);\n              // Clean up task reference on failure\n              delete downloadTasks[downloadKey];\n              throw error;\n            }\n          })();\n        }\n\n        absolutePath = await downloadTasks[downloadKey];\n        // Clean up completed task\n        delete downloadTasks[downloadKey];\n      }\n    }\n\n    // Deduplicate concurrent callers by input parameters before any async work.\n    // Using a synchronous key prevents the TOCTOU race where two concurrent\n    // callers both pass the tasks[] check before either registers a task.\n    const inputKey = JSON.stringify([absolutePath, ...args]);\n    if (tasks[inputKey]) {\n      log(`Returning existing ef:${label} task for ${absolutePath}`);\n      return await tasks[inputKey];\n    }\n\n    const fullTask = (async (): Promise<TaskResult> => {\n      try {\n        // Try to find existing cache by scanning cache directories.\n        // This avoids expensive MD5 computation when cache already exists.\n        const expectedFilename = filename(absolutePath, ...args);\n        let cachePath: string | null = null;\n        let md5: string | null = null;\n\n        const scanStartTime = Date.now();\n        try {\n          const cacheDirs = await readdir(cacheDirRoot, {\n            withFileTypes: true,\n          });\n          log(\n            `Scanning ${cacheDirs.length} cache directories for ${expectedFilename}`,\n          );\n          for (const dir of cacheDirs) {\n            if (dir.isDirectory()) {\n              const candidatePath = path.join(\n                cacheDirRoot,\n                dir.name,\n                expectedFilename,\n              );\n              if (\n                existsSync(candidatePath) &&\n                (await isValidCacheFile(candidatePath))\n              ) {\n                cachePath = candidatePath;\n                md5 = dir.name; // Directory name is the MD5\n                const scanElapsed = Date.now() - scanStartTime;\n                log(\n                  `Found existing cache in ${scanElapsed}ms: ${candidatePath} (skipped MD5)`,\n                );\n                break;\n              }\n            }\n          }\n          if (!cachePath) {\n            const scanElapsed = Date.now() - scanStartTime;\n            log(\n              `Cache scan completed in ${scanElapsed}ms, no cache found - will compute MD5`,\n            );\n          }\n        } catch (error) {\n          const scanElapsed = Date.now() - scanStartTime;\n          log(\n            `Cache scan failed after ${scanElapsed}ms, will compute MD5: ${error}`,\n          );\n        }\n\n        const resolvedMd5 =\n          md5 ??\n          (await (async () => {\n            const md5StartTime = Date.now();\n            log(`Computing MD5 for ${absolutePath}...`);\n            const computed = await md5FilePath(absolutePath);\n            const md5Elapsed = Date.now() - md5StartTime;\n            log(`MD5 computed in ${md5Elapsed}ms: ${computed}`);\n            return computed;\n          })());\n\n        const cacheDir = path.join(cacheDirRoot, resolvedMd5);\n        log(`Cache dir: ${cacheDir}`);\n        await mkdir(cacheDir, { recursive: true });\n\n        const resolvedCachePath =\n          cachePath ?? path.join(cacheDir, expectedFilename);\n\n        // Check if cache exists and is valid (not zero-byte)\n        if (\n          existsSync(resolvedCachePath) &&\n          (await isValidCacheFile(resolvedCachePath))\n        ) {\n          log(`Returning cached ef:${label} task for ${resolvedCachePath}`);\n          return { cachePath: resolvedCachePath, md5Sum: resolvedMd5 };\n        }\n\n        log(`Running ef:${label} runner for ${resolvedCachePath}`);\n        const result = await runner(absolutePath, ...args);\n\n        if (result instanceof Readable) {\n          log(`Piping task for ${resolvedCachePath} to cache`);\n          const tempPath = `${resolvedCachePath}.tmp`;\n          const writeStream = createWriteStream(tempPath);\n          result.pipe(writeStream);\n\n          await new Promise<void>((resolve, reject) => {\n            result.on(\"error\", reject);\n            writeStream.on(\"error\", reject);\n            writeStream.on(\"finish\", () => resolve());\n          });\n\n          await rename(tempPath, resolvedCachePath);\n        } else {\n          log(`Writing to ${resolvedCachePath}`);\n          await writeFile(resolvedCachePath, result);\n        }\n\n        return {\n          md5Sum: resolvedMd5,\n          cachePath: resolvedCachePath,\n        };\n      } finally {\n        delete tasks[inputKey];\n      }\n    })();\n\n    tasks[inputKey] = fullTask;\n    return await fullTask;\n  };\n};\n"],"mappings":"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"}

package/dist/package.cjs

@@ -0,0 +1,12 @@
+
+//#region package.json
+var version = "0.40.1-beta.0";
+
+//#endregion
+Object.defineProperty(exports, 'version', {
+  enumerable: true,
+  get: function () {
+    return version;
+  }
+});
+//# sourceMappingURL=package.cjs.map

package/dist/package.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.cjs","names":[],"sources":["../package.json"],"sourcesContent":["{\n  \"name\": \"@editframe/assets\",\n  \"version\": \"0.40.1-beta.0\",\n  \"description\": \"\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/editframe/elements.git\",\n    \"directory\": \"packages/assets\"\n  },\n  \"type\": \"module\",\n  \"scripts\": {\n    \"typecheck\": \"tsc --noEmit\",\n    \"build\": \"tsdown\",\n    \"build:watch\": \"tsdown --watch\",\n    \"typedoc\": \"(typedoc --json ./types.json --plugin typedoc-plugin-zod --excludeExternals ./src || true) && ([ -f ./types.json ] && jq -c . ./types.json > ./types.tmp.json && mv ./types.tmp.json ./types.json || true)\"\n  },\n  \"author\": \"\",\n  \"license\": \"UNLICENSED\",\n  \"dependencies\": {\n    \"debug\": \"^4.3.5\",\n    \"ora\": \"^8.0.1\",\n    \"zod\": \"^3.23.8\"\n  },\n  \"devDependencies\": {\n    \"@types/dom-webcodecs\": \"^0.1.11\",\n    \"@types/node\": \"^22.0.0\",\n    \"typescript\": \"^5.9.3\"\n  },\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.cts\",\n  \"exports\": {\n    \".\": {\n      \"import\": {\n        \"types\": \"./dist/index.d.ts\",\n        \"default\": \"./dist/index.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/index.d.cts\",\n        \"default\": \"./dist/index.cjs\"\n      }\n    },\n    \"./package.json\": \"./package.json\",\n    \"./types.json\": \"./types.json\"\n  },\n  \"publishConfig\": {\n    \"exports\": {\n      \".\": {\n        \"import\": {\n          \"types\": \"./dist/index.d.ts\",\n          \"default\": \"./dist/index.js\"\n        },\n        \"require\": {\n          \"types\": \"./dist/index.d.cts\",\n          \"default\": \"./dist/index.cjs\"\n        }\n      },\n      \"./package.json\": \"./package.json\",\n      \"./types.json\": \"./types.json\"\n    }\n  }\n}\n"],"mappings":";;cAEa"}

package/dist/package.js

@@ -0,0 +1,6 @@
+//#region package.json
+var version = "0.40.1-beta.0";
+
+//#endregion
+export { version };
+//# sourceMappingURL=package.js.map

package/dist/package.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.js","names":[],"sources":["../package.json"],"sourcesContent":["{\n  \"name\": \"@editframe/assets\",\n  \"version\": \"0.40.1-beta.0\",\n  \"description\": \"\",\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/editframe/elements.git\",\n    \"directory\": \"packages/assets\"\n  },\n  \"type\": \"module\",\n  \"scripts\": {\n    \"typecheck\": \"tsc --noEmit\",\n    \"build\": \"tsdown\",\n    \"build:watch\": \"tsdown --watch\",\n    \"typedoc\": \"(typedoc --json ./types.json --plugin typedoc-plugin-zod --excludeExternals ./src || true) && ([ -f ./types.json ] && jq -c . ./types.json > ./types.tmp.json && mv ./types.tmp.json ./types.json || true)\"\n  },\n  \"author\": \"\",\n  \"license\": \"UNLICENSED\",\n  \"dependencies\": {\n    \"debug\": \"^4.3.5\",\n    \"ora\": \"^8.0.1\",\n    \"zod\": \"^3.23.8\"\n  },\n  \"devDependencies\": {\n    \"@types/dom-webcodecs\": \"^0.1.11\",\n    \"@types/node\": \"^22.0.0\",\n    \"typescript\": \"^5.9.3\"\n  },\n  \"main\": \"./dist/index.cjs\",\n  \"module\": \"./dist/index.js\",\n  \"types\": \"./dist/index.d.cts\",\n  \"exports\": {\n    \".\": {\n      \"import\": {\n        \"types\": \"./dist/index.d.ts\",\n        \"default\": \"./dist/index.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/index.d.cts\",\n        \"default\": \"./dist/index.cjs\"\n      }\n    },\n    \"./package.json\": \"./package.json\",\n    \"./types.json\": \"./types.json\"\n  },\n  \"publishConfig\": {\n    \"exports\": {\n      \".\": {\n        \"import\": {\n          \"types\": \"./dist/index.d.ts\",\n          \"default\": \"./dist/index.js\"\n        },\n        \"require\": {\n          \"types\": \"./dist/index.d.cts\",\n          \"default\": \"./dist/index.cjs\"\n        }\n      },\n      \"./package.json\": \"./package.json\",\n      \"./types.json\": \"./types.json\"\n    }\n  }\n}\n"],"mappings":";cAEa"}

package/dist/tasks/findOrCreateCaptions.cjs

@@ -2,15 +2,15 @@ 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);
+let node_util = require("node:util");
+node_util = require_rolldown_runtime.__toESM(node_util);
 
 //#region src/tasks/findOrCreateCaptions.ts
-const execPromise = (0, node_util.promisify)(node_child_process.exec);
+const execFilePromise = (0, node_util.promisify)(node_child_process.execFile);
 const log = (0, debug.default)("ef:generateCaptions");
 const convertWhisperToEditframeFormat = (whisperData) => {
 	return {
@@ -27,9 +27,16 @@ const convertWhisperToEditframeFormat = (whisperData) => {
 	};
 };
 const generateCaptionDataFromPath = async (absolutePath) => {
-	const command = `whisper_timestamped --language en --efficient --output_format json ${absolutePath}`;
-	log(`Running command: ${command}`);
-	const { stdout } = await execPromise(command);
+	const args = [
+		"--language",
+		"en",
+		"--efficient",
+		"--output_format",
+		"json",
+		absolutePath
+	];
+	log("Running whisper_timestamped", args);
+	const { stdout } = await execFilePromise("whisper_timestamped", args);
 	try {
 		const captionData = convertWhisperToEditframeFormat(JSON.parse(stdout));
 		return JSON.stringify(captionData, null, 2);

package/dist/tasks/findOrCreateCaptions.cjs.map

@@ -1 +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"}
+{"version":3,"file":"findOrCreateCaptions.cjs","names":["execFile","idempotentTask"],"sources":["../../src/tasks/findOrCreateCaptions.ts"],"sourcesContent":["import { basename } from \"node:path\";\nimport { promisify } from \"node:util\";\nimport { execFile } from \"node:child_process\";\n\nimport debug from \"debug\";\n\nimport { idempotentTask } from \"../idempotentTask.js\";\n\nconst execFilePromise = promisify(execFile);\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 args = [\"--language\", \"en\", \"--efficient\", \"--output_format\", \"json\", absolutePath];\n  log(\"Running whisper_timestamped\", args);\n  const { stdout } = await execFilePromise(\"whisper_timestamped\", args);\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,2CAA4BA,4BAAS;AAE3C,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,OAAO;EAAC;EAAc;EAAM;EAAe;EAAmB;EAAQ;EAAa;AACzF,KAAI,+BAA+B,KAAK;CACxC,MAAM,EAAE,WAAW,MAAM,gBAAgB,uBAAuB,KAAK;AAErE,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.js

@@ -1,11 +1,11 @@
 import { idempotentTask } from "../idempotentTask.js";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
+import { execFile } from "node:child_process";
 import debug from "debug";
 import { basename } from "node:path";
+import { promisify } from "node:util";
 
 //#region src/tasks/findOrCreateCaptions.ts
-const execPromise = promisify(exec);
+const execFilePromise = promisify(execFile);
 const log = debug("ef:generateCaptions");
 const convertWhisperToEditframeFormat = (whisperData) => {
 	return {
@@ -22,9 +22,16 @@ const convertWhisperToEditframeFormat = (whisperData) => {
 	};
 };
 const generateCaptionDataFromPath = async (absolutePath) => {
-	const command = `whisper_timestamped --language en --efficient --output_format json ${absolutePath}`;
-	log(`Running command: ${command}`);
-	const { stdout } = await execPromise(command);
+	const args = [
+		"--language",
+		"en",
+		"--efficient",
+		"--output_format",
+		"json",
+		absolutePath
+	];
+	log("Running whisper_timestamped", args);
+	const { stdout } = await execFilePromise("whisper_timestamped", args);
 	try {
 		const captionData = convertWhisperToEditframeFormat(JSON.parse(stdout));
 		return JSON.stringify(captionData, null, 2);

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 = (\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"}
+{"version":3,"file":"findOrCreateCaptions.js","names":[],"sources":["../../src/tasks/findOrCreateCaptions.ts"],"sourcesContent":["import { basename } from \"node:path\";\nimport { promisify } from \"node:util\";\nimport { execFile } from \"node:child_process\";\n\nimport debug from \"debug\";\n\nimport { idempotentTask } from \"../idempotentTask.js\";\n\nconst execFilePromise = promisify(execFile);\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 args = [\"--language\", \"en\", \"--efficient\", \"--output_format\", \"json\", absolutePath];\n  log(\"Running whisper_timestamped\", args);\n  const { stdout } = await execFilePromise(\"whisper_timestamped\", args);\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,kBAAkB,UAAU,SAAS;AAE3C,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,OAAO;EAAC;EAAc;EAAM;EAAe;EAAmB;EAAQ;EAAa;AACzF,KAAI,+BAA+B,KAAK;CACxC,MAAM,EAAE,WAAW,MAAM,gBAAgB,uBAAuB,KAAK;AAErE,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

@@ -16,17 +16,7 @@ const generateScrubTrackFromPath = 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();
-	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 startTimeOffsetMs = probe.startTimeOffsetMs;
 	const outputStream = new node_stream.PassThrough();
 	const indexStream = new node_stream.PassThrough();
 	scrubStream.pipe(outputStream, { end: false });

package/dist/tasks/generateScrubTrack.cjs.map

@@ -1 +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"}
+{"version":3,"file":"generateScrubTrack.cjs","names":["Probe","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  const startTimeOffsetMs = probe.startTimeOffsetMs;\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;CAEtD,MAAM,oBAAoB,MAAM;CAGhC,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,MAAMH,oBAAM,UAAU,aAAa;AAEjD,MAAI,MAAM,aAAa,WAAW,EAChC,OAAM,IAAI,MAAM,mDAAmD;EAIrE,MAAM,cAAc,MAAM,4BAA4B;EAGtD,MAAM,cAAc,IAAIC,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.js

@@ -12,17 +12,7 @@ const generateScrubTrackFromPath = async (absolutePath) => {
 	const probe = await 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 startTimeOffsetMs = probe.startTimeOffsetMs;
 	const outputStream = new PassThrough();
 	const indexStream = new PassThrough();
 	scrubStream.pipe(outputStream, { end: false });

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 (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"}
+{"version":3,"file":"generateScrubTrack.js","names":["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  const startTimeOffsetMs = probe.startTimeOffsetMs;\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;CAEtD,MAAM,oBAAoB,MAAM;CAGhC,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,IAAIA,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/generateTrackFragmentIndex.cjs

@@ -11,39 +11,33 @@ node_path = require_rolldown_runtime.__toESM(node_path);
 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");
-	}
+	const startTimeOffsetMs = probe.startTimeOffsetMs;
+	if (startTimeOffsetMs !== void 0) log(`Extracted start_time offset: ${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 trackTasks = probe.streams.map((stream, streamIndex) => {
+		if (stream.codec_type !== "audio" && stream.codec_type !== "video") return null;
 		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];
+		return require_generateFragmentIndex.generateFragmentIndex(probe.createTrackReadstream(streamIndex), startTimeOffsetMs, { 0: trackId });
+	}).filter((task) => task !== null);
+	const scrubTask = probe.videoStreams.length > 0 ? (async () => {
+		try {
+			log("Generating scrub track fragment index");
+			const scrubStream = probe.createScrubTrackReadstream();
+			const scrubTrackId = -1;
+			const result = await require_generateFragmentIndex.generateFragmentIndex(scrubStream, startTimeOffsetMs, { 0: scrubTrackId });
 			log("Scrub track fragment index generated successfully");
+			return result;
+		} catch (error) {
+			log(`Failed to generate scrub track fragment index: ${error}`);
+			return null;
 		}
-	} catch (error) {
-		log(`Failed to generate scrub track fragment index: ${error}`);
-	}
+	})() : Promise.resolve(null);
+	const [trackResults, scrubResult] = await Promise.all([Promise.all(trackTasks), scrubTask]);
+	const trackFragmentIndexes = {};
+	for (const result of trackResults) Object.assign(trackFragmentIndexes, result);
+	if (scrubResult) Object.assign(trackFragmentIndexes, scrubResult);
 	return trackFragmentIndexes;
 };
 const generateTrackFragmentIndexTask = require_idempotentTask.idempotentTask({