@scelar/nodepod 1.0.2 → 1.0.4

package/src/threading/offload.ts

@@ -1,271 +1,271 @@
-// Offload API — routes CPU-heavy tasks (esbuild, tarball extraction, bundling)
-// to a Web Worker pool. Falls back to main-thread if Workers aren't available.
-
-import { WorkerPool } from "./worker-pool";
-import { TaskQueue } from "./task-queue";
-import type {
-  OffloadTask,
-  OffloadResult,
-  PoolConfig,
-  TransformTask,
-  TransformResult,
-  ExtractTask,
-  ExtractResult,
-  BuildTask,
-  BuildResult,
-} from "./offload-types";
-
-export { TaskPriority } from "./offload-types";
-export type {
-  TransformTask,
-  TransformResult,
-  ExtractTask,
-  ExtractResult,
-  BuildTask,
-  BuildResult,
-  OffloadTask,
-  OffloadResult,
-  PoolConfig,
-} from "./offload-types";
-
-// --- Singleton state ---
-
-let pool: WorkerPool | null = null;
-let queue: TaskQueue | null = null;
-let fallbackMode = false;
-let storedConfig: PoolConfig | undefined;
-
-// --- Environment detection ---
-
-function canUseWorkers(): boolean {
-  return (
-    typeof Worker !== "undefined" &&
-    typeof Blob !== "undefined" &&
-    typeof URL !== "undefined" &&
-    typeof URL.createObjectURL === "function"
-  );
-}
-
-// --- Pool lifecycle ---
-
-function ensurePool(): TaskQueue {
-  if (queue) return queue;
-
-  if (!canUseWorkers()) {
-    fallbackMode = true;
-    throw new Error("Workers not available");
-  }
-
-  pool = new WorkerPool(storedConfig);
-  queue = new TaskQueue(pool);
-  return queue;
-}
-
-// --- Main-thread fallback implementations ---
-
-async function mainThreadTransform(
-  task: TransformTask,
-): Promise<TransformResult> {
-  // convertFileDirect, not convertFile — avoids circular: convertFile → offload → fallback → loop
-  const { convertFileDirect, prepareTransformer } = await import(
-    "../module-transformer"
-  );
-  await prepareTransformer();
-
-  const code = await convertFileDirect(task.source, task.filePath);
-  return { type: "transform", id: task.id, code, warnings: [] };
-}
-
-async function mainThreadExtract(
-  task: ExtractTask,
-): Promise<ExtractResult> {
-  const pako = await import("pako");
-  const { parseTarArchive } = await import("../packages/archive-extractor");
-  const { bytesToBase64 } = await import("../helpers/byte-encoding");
-
-  const response = await fetch(task.tarballUrl);
-  if (!response.ok) {
-    throw new Error(
-      `Archive download failed (HTTP ${response.status}): ${task.tarballUrl}`,
-    );
-  }
-
-  const compressed = new Uint8Array(await response.arrayBuffer());
-  const tarBytes = pako.inflate(compressed);
-
-  const files: ExtractResult["files"] = [];
-  for (const entry of parseTarArchive(tarBytes)) {
-    if (entry.kind !== "file" || !entry.payload) continue;
-
-    let relative = entry.filepath;
-    if (task.stripComponents > 0) {
-      const segments = relative.split("/").filter(Boolean);
-      if (segments.length <= task.stripComponents) continue;
-      relative = segments.slice(task.stripComponents).join("/");
-    }
-
-    let data: string;
-    let isBinary = false;
-    try {
-      data = new TextDecoder("utf-8", { fatal: true }).decode(entry.payload);
-    } catch {
-      data = bytesToBase64(entry.payload);
-      isBinary = true;
-    }
-    files.push({ path: relative, data, isBinary });
-  }
-
-  return { type: "extract", id: task.id, files };
-}
-
-async function mainThreadBuild(task: BuildTask): Promise<BuildResult> {
-  const esbuild = await import("../polyfills/esbuild");
-  try {
-    const result = await (esbuild as any).build({
-      entryPoints: task.entryPoints,
-      stdin: task.stdin,
-      bundle: task.bundle,
-      format: task.format,
-      platform: task.platform,
-      target: task.target,
-      minify: task.minify,
-      external: task.external,
-      write: false,
-      absWorkingDir: task.absWorkingDir,
-    });
-    return {
-      type: "build",
-      id: task.id,
-      outputFiles: (result.outputFiles || []).map((f: any) => ({
-        path: f.path,
-        text: f.text || new TextDecoder().decode(f.contents),
-      })),
-      errors: (result.errors || []).map((e: any) => e.text || String(e)),
-      warnings: (result.warnings || []).map(
-        (w: any) => w.text || String(w),
-      ),
-    };
-  } catch (err: any) {
-    return {
-      type: "build",
-      id: task.id,
-      outputFiles: [],
-      errors: [err?.message || "build failed"],
-      warnings: [],
-    };
-  }
-}
-
-// --- Public API ---
-
-export function taskId(): string {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  return `task-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-}
-
-export async function offload<T extends OffloadTask>(
-  task: T,
-): Promise<
-  T extends TransformTask
-    ? TransformResult
-    : T extends ExtractTask
-      ? ExtractResult
-      : T extends BuildTask
-        ? BuildResult
-        : OffloadResult
-> {
-  // Fast path: already know Workers aren't available
-  if (fallbackMode) {
-    return runFallback(task) as any;
-  }
-
-  try {
-    const q = ensurePool();
-    return await q.submit(task) as any;
-  } catch (err) {
-    // Log once so consumers know fallback is active
-    if (!fallbackMode) {
-      console.debug(
-        "[offload] Falling back to main thread:",
-        err instanceof Error ? err.message : err,
-      );
-    }
-    switchToFallback();
-    return runFallback(task) as any;
-  }
-}
-
-export async function offloadBatch(
-  tasks: OffloadTask[],
-): Promise<OffloadResult[]> {
-  if (fallbackMode) {
-    return Promise.all(tasks.map((t) => runFallback(t)));
-  }
-
-  try {
-    const q = ensurePool();
-    return await q.submitBatch(tasks);
-  } catch {
-    switchToFallback();
-    return Promise.all(tasks.map((t) => runFallback(t)));
-  }
-}
-
-function switchToFallback(): void {
-  fallbackMode = true;
-  if (pool) {
-    pool.dispose();
-    pool = null;
-  }
-  queue = null;
-}
-
-async function runFallback(task: OffloadTask): Promise<OffloadResult> {
-  switch (task.type) {
-    case "transform":
-      return mainThreadTransform(task);
-    case "extract":
-      return mainThreadExtract(task);
-    case "build":
-      return mainThreadBuild(task);
-    default:
-      throw new Error(`Unknown task type: ${(task as any).type}`);
-  }
-}
-
-export function cancelTask(id: string): boolean {
-  return queue?.cancel(id) ?? false;
-}
-
-export function poolStats(): {
-  total: number;
-  busy: number;
-  idle: number;
-  initialized: number;
-  fallback: boolean;
-} {
-  const stats = pool?.stats() ?? {
-    total: 0,
-    busy: 0,
-    idle: 0,
-    initialized: 0,
-  };
-  return { ...stats, fallback: fallbackMode };
-}
-
-export function disposePool(): void {
-  queue = null;
-  pool?.dispose();
-  pool = null;
-  fallbackMode = false;
-}
-
-// Must be called before any offload() task is submitted
-export function configurePool(config: PoolConfig): void {
-  if (pool) {
-    throw new Error("Pool already created; call disposePool() first");
-  }
-  storedConfig = config;
-}
+// Offload API — routes CPU-heavy tasks (esbuild, tarball extraction, bundling)
+// to a Web Worker pool. Falls back to main-thread if Workers aren't available.
+
+import { WorkerPool } from "./worker-pool";
+import { TaskQueue } from "./task-queue";
+import type {
+  OffloadTask,
+  OffloadResult,
+  PoolConfig,
+  TransformTask,
+  TransformResult,
+  ExtractTask,
+  ExtractResult,
+  BuildTask,
+  BuildResult,
+} from "./offload-types";
+
+export { TaskPriority } from "./offload-types";
+export type {
+  TransformTask,
+  TransformResult,
+  ExtractTask,
+  ExtractResult,
+  BuildTask,
+  BuildResult,
+  OffloadTask,
+  OffloadResult,
+  PoolConfig,
+} from "./offload-types";
+
+// --- Singleton state ---
+
+let pool: WorkerPool | null = null;
+let queue: TaskQueue | null = null;
+let fallbackMode = false;
+let storedConfig: PoolConfig | undefined;
+
+// --- Environment detection ---
+
+function canUseWorkers(): boolean {
+  return (
+    typeof Worker !== "undefined" &&
+    typeof Blob !== "undefined" &&
+    typeof URL !== "undefined" &&
+    typeof URL.createObjectURL === "function"
+  );
+}
+
+// --- Pool lifecycle ---
+
+function ensurePool(): TaskQueue {
+  if (queue) return queue;
+
+  if (!canUseWorkers()) {
+    fallbackMode = true;
+    throw new Error("Workers not available");
+  }
+
+  pool = new WorkerPool(storedConfig);
+  queue = new TaskQueue(pool);
+  return queue;
+}
+
+// --- Main-thread fallback implementations ---
+
+async function mainThreadTransform(
+  task: TransformTask,
+): Promise<TransformResult> {
+  // convertFileDirect, not convertFile — avoids circular: convertFile → offload → fallback → loop
+  const { convertFileDirect, prepareTransformer } = await import(
+    "../module-transformer"
+  );
+  await prepareTransformer();
+
+  const code = await convertFileDirect(task.source, task.filePath);
+  return { type: "transform", id: task.id, code, warnings: [] };
+}
+
+async function mainThreadExtract(
+  task: ExtractTask,
+): Promise<ExtractResult> {
+  const pako = await import("pako");
+  const { parseTarArchive } = await import("../packages/archive-extractor");
+  const { bytesToBase64 } = await import("../helpers/byte-encoding");
+
+  const response = await fetch(task.tarballUrl);
+  if (!response.ok) {
+    throw new Error(
+      `Archive download failed (HTTP ${response.status}): ${task.tarballUrl}`,
+    );
+  }
+
+  const compressed = new Uint8Array(await response.arrayBuffer());
+  const tarBytes = pako.inflate(compressed);
+
+  const files: ExtractResult["files"] = [];
+  for (const entry of parseTarArchive(tarBytes)) {
+    if (entry.kind !== "file" || !entry.payload) continue;
+
+    let relative = entry.filepath;
+    if (task.stripComponents > 0) {
+      const segments = relative.split("/").filter(Boolean);
+      if (segments.length <= task.stripComponents) continue;
+      relative = segments.slice(task.stripComponents).join("/");
+    }
+
+    let data: string;
+    let isBinary = false;
+    try {
+      data = new TextDecoder("utf-8", { fatal: true }).decode(entry.payload);
+    } catch {
+      data = bytesToBase64(entry.payload);
+      isBinary = true;
+    }
+    files.push({ path: relative, data, isBinary });
+  }
+
+  return { type: "extract", id: task.id, files };
+}
+
+async function mainThreadBuild(task: BuildTask): Promise<BuildResult> {
+  const esbuild = await import("../polyfills/esbuild");
+  try {
+    const result = await (esbuild as any).build({
+      entryPoints: task.entryPoints,
+      stdin: task.stdin,
+      bundle: task.bundle,
+      format: task.format,
+      platform: task.platform,
+      target: task.target,
+      minify: task.minify,
+      external: task.external,
+      write: false,
+      absWorkingDir: task.absWorkingDir,
+    });
+    return {
+      type: "build",
+      id: task.id,
+      outputFiles: (result.outputFiles || []).map((f: any) => ({
+        path: f.path,
+        text: f.text || new TextDecoder().decode(f.contents),
+      })),
+      errors: (result.errors || []).map((e: any) => e.text || String(e)),
+      warnings: (result.warnings || []).map(
+        (w: any) => w.text || String(w),
+      ),
+    };
+  } catch (err: any) {
+    return {
+      type: "build",
+      id: task.id,
+      outputFiles: [],
+      errors: [err?.message || "build failed"],
+      warnings: [],
+    };
+  }
+}
+
+// --- Public API ---
+
+export function taskId(): string {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `task-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+
+export async function offload<T extends OffloadTask>(
+  task: T,
+): Promise<
+  T extends TransformTask
+    ? TransformResult
+    : T extends ExtractTask
+      ? ExtractResult
+      : T extends BuildTask
+        ? BuildResult
+        : OffloadResult
+> {
+  // Fast path: already know Workers aren't available
+  if (fallbackMode) {
+    return runFallback(task) as any;
+  }
+
+  try {
+    const q = ensurePool();
+    return await q.submit(task) as any;
+  } catch (err) {
+    // Log once so consumers know fallback is active
+    if (!fallbackMode) {
+      console.debug(
+        "[offload] Falling back to main thread:",
+        err instanceof Error ? err.message : err,
+      );
+    }
+    switchToFallback();
+    return runFallback(task) as any;
+  }
+}
+
+export async function offloadBatch(
+  tasks: OffloadTask[],
+): Promise<OffloadResult[]> {
+  if (fallbackMode) {
+    return Promise.all(tasks.map((t) => runFallback(t)));
+  }
+
+  try {
+    const q = ensurePool();
+    return await q.submitBatch(tasks);
+  } catch {
+    switchToFallback();
+    return Promise.all(tasks.map((t) => runFallback(t)));
+  }
+}
+
+function switchToFallback(): void {
+  fallbackMode = true;
+  if (pool) {
+    pool.dispose();
+    pool = null;
+  }
+  queue = null;
+}
+
+async function runFallback(task: OffloadTask): Promise<OffloadResult> {
+  switch (task.type) {
+    case "transform":
+      return mainThreadTransform(task);
+    case "extract":
+      return mainThreadExtract(task);
+    case "build":
+      return mainThreadBuild(task);
+    default:
+      throw new Error(`Unknown task type: ${(task as any).type}`);
+  }
+}
+
+export function cancelTask(id: string): boolean {
+  return queue?.cancel(id) ?? false;
+}
+
+export function poolStats(): {
+  total: number;
+  busy: number;
+  idle: number;
+  initialized: number;
+  fallback: boolean;
+} {
+  const stats = pool?.stats() ?? {
+    total: 0,
+    busy: 0,
+    idle: 0,
+    initialized: 0,
+  };
+  return { ...stats, fallback: fallbackMode };
+}
+
+export function disposePool(): void {
+  queue = null;
+  pool?.dispose();
+  pool = null;
+  fallbackMode = false;
+}
+
+// Must be called before any offload() task is submitted
+export function configurePool(config: PoolConfig): void {
+  if (pool) {
+    throw new Error("Pool already created; call disposePool() first");
+  }
+  storedConfig = config;
+}