@hanzogui/static-worker 8.3.0 → 8.3.2

package/dist/esm/index.js

@@ -1,278 +1,349 @@
-import { fileURLToPath } from "node:url";
-import Piscina from "piscina";
-import * as extractablePathModule from "@hanzogui/static/extractablePath";
+/**
+ * @hanzogui/static-worker
+ *
+ * Pure worker-based API for Gui static extraction.
+ * All operations run in a worker thread for better performance and isolation.
+ *
+ * This package provides a clean async API that wraps @hanzogui/static's worker
+ * implementation without exposing any sync/legacy APIs.
+ */
+import Piscina from 'piscina';
+import { worker } from './here.js';
+/**
+ * Which files the compiler may read styles out of. Pure path logic, so it is
+ * handed straight across rather than run in the worker: a bundler plugin needs
+ * the answer before it decides whether a round-trip is worth making, and the
+ * extractor needs the same answer for real.
+ *
+ * @hanzogui/static is CJS-only, and Node's lexer does not find named exports
+ * through esbuild's `__export` wrapper, so an ESM `export { x } from` of the
+ * subpath throws at load. The namespace always carries `default` —
+ * module.exports — in both of this package's builds, so read the names off it
+ * once, here, instead of teaching every caller the same trick.
+ */
+import * as extractablePathModule from '@hanzogui/static/extractablePath';
 const extractablePath = extractablePathModule.default ?? extractablePathModule;
-const {
-  DEFAULT_EXTRACT_PACKAGES,
-  installedPackageOf,
-  isExtractable
-} = extractablePath;
-const getPragmaOptions = async props => {
-  const {
-    default: Static
-  } = await import("@hanzogui/static");
-  return Static.getPragmaOptions(props);
+export const { DEFAULT_EXTRACT_PACKAGES, installedPackageOf, isExtractable } = extractablePath;
+export const getPragmaOptions = async (props) => {
+    const { default: Static } = await import('@hanzogui/static');
+    return Static.getPragmaOptions(props);
 };
-const getWorkerPath = () => {
-  if (typeof import.meta !== "undefined" && import.meta.url) {
-    const workerPath = fileURLToPath(import.meta.resolve("@hanzogui/static/worker"));
-    return workerPath.replace(/\.mjs$/, ".js");
-  }
-  return require.resolve("@hanzogui/static/worker").replace(/\.mjs$/, ".js");
-};
-const POOL_KEY = "__hanzogui_piscina_pool__";
-const CLOSING_KEY = "__hanzogui_piscina_closing__";
-const TASK_COUNT_KEY = "__hanzogui_piscina_task_count__";
-const RECYCLING_KEY = "__hanzogui_piscina_recycling__";
-const MAX_TASKS_BEFORE_RECYCLE = 1e3;
+// The worker file, by this package's own resolution of it.
+const getWorkerPath = () => worker;
+// Use globalThis to share pool across module instances (Vite environments)
+const POOL_KEY = '__hanzogui_piscina_pool__';
+const CLOSING_KEY = '__hanzogui_piscina_closing__';
+const TASK_COUNT_KEY = '__hanzogui_piscina_task_count__';
+const RECYCLING_KEY = '__hanzogui_piscina_recycling__';
+// recycle worker after this many tasks to prevent RSS bloat from V8 memory fragmentation
+// Node.js worker threads don't release memory properly - see https://github.com/nodejs/node/issues/51868
+// set high enough that builds (typically 200-400 files) never trigger a recycle,
+// but long-running dev servers still get memory relief eventually
+const MAX_TASKS_BEFORE_RECYCLE = 1000;
 function getSharedPool() {
-  return globalThis[POOL_KEY] ?? null;
+    return globalThis[POOL_KEY] ?? null;
 }
 function setSharedPool(pool) {
-  ;
-  globalThis[POOL_KEY] = pool;
+    ;
+    globalThis[POOL_KEY] = pool;
 }
 function isClosing() {
-  return globalThis[CLOSING_KEY] === true;
+    return globalThis[CLOSING_KEY] === true;
 }
 function setClosing(value) {
-  ;
-  globalThis[CLOSING_KEY] = value;
+    ;
+    globalThis[CLOSING_KEY] = value;
 }
 function isRecycling() {
-  return globalThis[RECYCLING_KEY] === true;
+    return globalThis[RECYCLING_KEY] === true;
 }
 function setRecycling(value) {
-  ;
-  globalThis[RECYCLING_KEY] = value;
+    ;
+    globalThis[RECYCLING_KEY] = value;
 }
 function getTaskCount() {
-  return globalThis[TASK_COUNT_KEY] ?? 0;
+    return globalThis[TASK_COUNT_KEY] ?? 0;
 }
 function incrementTaskCount() {
-  const count = getTaskCount() + 1;
-  globalThis[TASK_COUNT_KEY] = count;
-  return count;
+    const count = getTaskCount() + 1;
+    globalThis[TASK_COUNT_KEY] = count;
+    return count;
 }
 function resetTaskCount() {
-  ;
-  globalThis[TASK_COUNT_KEY] = 0;
+    ;
+    globalThis[TASK_COUNT_KEY] = 0;
 }
+/**
+ * Create a new Piscina pool instance
+ */
 function createPool() {
-  const pool = new Piscina({
-    filename: getWorkerPath(),
-    // each worker loads and caches config independently
-    minThreads: 2,
-    maxThreads: 2,
-    // Never terminate due to idle - worker stays alive until close() or process exit
-    // This prevents "Terminating worker thread" errors from Piscina during idle
-    idleTimeout: Number.POSITIVE_INFINITY
-    // no resourceLimits - we rely on task-based recycling instead
-    // V8 resourceLimits cause "Terminating worker thread" messages when hit
-  });
-  pool.on("error", err => {
-    if (isClosing() || isRecycling()) return;
-    const message = err && typeof err === "object" && "message" in err ? String(err.message) : "";
-    if (message.includes("Terminating worker thread")) return;
-    console.error("[hanzogui] Worker pool error:", err);
-  });
-  return pool;
+    const pool = new Piscina({
+        filename: getWorkerPath(),
+        // each worker loads and caches config independently
+        minThreads: 2,
+        maxThreads: 2,
+        // Never terminate due to idle - worker stays alive until close() or process exit
+        // This prevents "Terminating worker thread" errors from Piscina during idle
+        idleTimeout: Number.POSITIVE_INFINITY,
+        // no resourceLimits - we rely on task-based recycling instead
+        // V8 resourceLimits cause "Terminating worker thread" messages when hit
+    });
+    // Handle error events to prevent uncaught exceptions during pool destruction
+    pool.on('error', (err) => {
+        if (isClosing() || isRecycling())
+            return;
+        const message = err && typeof err === 'object' && 'message' in err ? String(err.message) : '';
+        // Suppress termination errors (can still occur during explicit close/destroy)
+        if (message.includes('Terminating worker thread'))
+            return;
+        console.error('[hanzogui] Worker pool error:', err);
+    });
+    return pool;
 }
+/**
+ * Get or create the Piscina worker pool
+ */
 function getPool() {
-  let pool = getSharedPool();
-  if (!pool) {
-    pool = createPool();
-    setSharedPool(pool);
-  }
-  return pool;
+    let pool = getSharedPool();
+    if (!pool) {
+        pool = createPool();
+        setSharedPool(pool);
+    }
+    return pool;
 }
-async function loadGui(options) {
-  const pool = getPool();
-  const task = {
-    type: "extractToClassNames",
-    source: "// dummy",
-    sourcePath: "__dummy__.tsx",
-    options: {
-      components: ["@hanzo/gui"],
-      ...options
-    },
-    shouldPrintDebug: false
-  };
-  try {
-    await pool.run(task, {
-      name: "runTask"
-    });
-    return {
-      success: true
+/**
+ * Load Gui configuration in worker
+ * Sends a warmup task to trigger config loading
+ * bundleConfig auto-detects if files exist and skips rebuild
+ */
+export async function loadGui(options) {
+    const pool = getPool();
+    // use extractToClassNames with a dummy request to trigger config loading
+    // the worker will cache the config for subsequent requests
+    const task = {
+        type: 'extractToClassNames',
+        source: '// dummy',
+        sourcePath: '__dummy__.tsx',
+        options: {
+            components: ['@hanzo/gui'],
+            ...options,
+        },
+        shouldPrintDebug: false,
     };
-  } catch (error) {
-    console.error("[static-worker] Error loading Gui config:", error);
-    throw error;
-  }
+    try {
+        await pool.run(task, { name: 'runTask' });
+        return { success: true };
+    }
+    catch (error) {
+        console.error('[static-worker] Error loading Gui config:', error);
+        throw error;
+    }
 }
+/**
+ * Recycle the worker pool to release RSS memory
+ * Creates new pool, swaps immediately, then destroys old pool
+ * V8 doesn't return memory to OS, so we need to restart the worker periodically
+ */
 async function recyclePool(options) {
-  if (isClosing() || isRecycling()) return;
-  const oldPool = getSharedPool();
-  if (!oldPool) return;
-  setRecycling(true);
-  const start = Date.now();
-  try {
-    const originalStderr = process.stderr.write.bind(process.stderr);
-    const originalStdout = process.stdout.write.bind(process.stdout);
-    const filter = (chunk, ...args) => {
-      const str = typeof chunk === "string" ? chunk : chunk?.toString?.() || "";
-      if (str.includes("Terminating worker thread")) return true;
-      return false;
-    };
-    process.stderr.write = (chunk, ...args) => {
-      if (filter(chunk)) return true;
-      return originalStderr(chunk, ...args);
-    };
-    process.stdout.write = (chunk, ...args) => {
-      if (filter(chunk)) return true;
-      return originalStdout(chunk, ...args);
-    };
-    const newPool = createPool();
-    setSharedPool(newPool);
-    const warmupTask = {
-      type: "extractToClassNames",
-      source: "// warmup",
-      sourcePath: "__warmup__.tsx",
-      options: {
-        ...options,
-        // skip the "built config" log on warmup since it's a recycle
-        _skipBuildLog: true
-      },
-      shouldPrintDebug: false
-    };
-    await newPool.run(warmupTask, {
-      name: "runTask"
-    });
-    oldPool.removeAllListeners();
-    oldPool.destroy().catch(() => {});
-    setTimeout(() => {
-      process.stderr.write = originalStderr;
-      process.stdout.write = originalStdout;
-    });
-    console.log(`  \u267B\uFE0F  [hanzogui] recycled worker pool (${Date.now() - start}ms)`);
-  } finally {
-    setRecycling(false);
-  }
+    if (isClosing() || isRecycling())
+        return;
+    const oldPool = getSharedPool();
+    if (!oldPool)
+        return;
+    setRecycling(true);
+    const start = Date.now();
+    try {
+        // suppress "Terminating worker thread" messages during recycle
+        const originalStderr = process.stderr.write.bind(process.stderr);
+        const originalStdout = process.stdout.write.bind(process.stdout);
+        const filter = (chunk, ...args) => {
+            const str = typeof chunk === 'string' ? chunk : chunk?.toString?.() || '';
+            if (str.includes('Terminating worker thread'))
+                return true;
+            return false;
+        };
+        process.stderr.write = ((chunk, ...args) => {
+            if (filter(chunk))
+                return true;
+            return originalStderr(chunk, ...args);
+        });
+        process.stdout.write = ((chunk, ...args) => {
+            if (filter(chunk))
+                return true;
+            return originalStdout(chunk, ...args);
+        });
+        // create new pool and swap immediately
+        const newPool = createPool();
+        setSharedPool(newPool);
+        // warm up new pool with config (this caches it in the new worker)
+        const warmupTask = {
+            type: 'extractToClassNames',
+            source: '// warmup',
+            sourcePath: '__warmup__.tsx',
+            options: {
+                ...options,
+                // skip the "built config" log on warmup since it's a recycle
+                _skipBuildLog: true,
+            },
+            shouldPrintDebug: false,
+        };
+        await newPool.run(warmupTask, { name: 'runTask' });
+        // destroy old pool - pending tasks will be rejected
+        oldPool.removeAllListeners();
+        oldPool.destroy().catch(() => { });
+        // restore stderr/stdout after a delay
+        setTimeout(() => {
+            process.stderr.write = originalStderr;
+            process.stdout.write = originalStdout;
+        });
+        console.log(`  ♻️  [hanzogui] recycled worker pool (${Date.now() - start}ms)`);
+    }
+    finally {
+        setRecycling(false);
+    }
 }
-async function loadGuiBuildConfig(hanzoguiOptions) {
-  const {
-    default: Static
-  } = await import("@hanzogui/static");
-  return Static.loadGuiBuildConfigAsync(hanzoguiOptions);
+/**
+ * Load Gui build configuration asynchronously
+ * Uses esbuild-wasm to avoid EPIPE errors from native esbuild service lifecycle
+ */
+export async function loadGuiBuildConfig(hanzoguiOptions) {
+    const { default: Static } = await import('@hanzogui/static');
+    return Static.loadGuiBuildConfigAsync(hanzoguiOptions);
 }
-async function extractToClassNames(params) {
-  const {
-    source,
-    sourcePath = "",
-    options,
-    shouldPrintDebug = false
-  } = params;
-  if (typeof source !== "string") {
-    throw new Error("`source` must be a string of javascript");
-  }
-  const task = {
-    type: "extractToClassNames",
-    source,
-    sourcePath,
-    options,
-    shouldPrintDebug
-  };
-  const pool = getPool();
-  const result = await pool.run(task, {
-    name: "runTask"
-  });
-  if (!result.success) {
-    const errorMessage = [`[hanzogui-extract] Error processing file: ${sourcePath || "(unknown)"}`, ``, result.error, result.stack ? `
-${result.stack}` : ""].filter(Boolean).join("\n");
-    throw new Error(errorMessage);
-  }
-  const count = incrementTaskCount();
-  if (count >= MAX_TASKS_BEFORE_RECYCLE) {
-    resetTaskCount();
-    recyclePool(options).catch(() => {});
-  }
-  return result.data;
+/**
+ * Extract Gui components to className-based CSS for web
+ */
+export async function extractToClassNames(params) {
+    const { source, sourcePath = '', options, shouldPrintDebug = false } = params;
+    if (typeof source !== 'string') {
+        throw new Error('`source` must be a string of javascript');
+    }
+    const task = {
+        type: 'extractToClassNames',
+        source,
+        sourcePath,
+        options,
+        shouldPrintDebug,
+    };
+    const pool = getPool();
+    const result = (await pool.run(task, { name: 'runTask' }));
+    if (!result.success) {
+        const errorMessage = [
+            `[hanzogui-extract] Error processing file: ${sourcePath || '(unknown)'}`,
+            ``,
+            result.error,
+            result.stack ? `\n${result.stack}` : '',
+        ]
+            .filter(Boolean)
+            .join('\n');
+        throw new Error(errorMessage);
+    }
+    // check if we need to recycle the worker to prevent RSS bloat
+    const count = incrementTaskCount();
+    if (count >= MAX_TASKS_BEFORE_RECYCLE) {
+        resetTaskCount();
+        // recycle asynchronously with hot-swap to not block current request
+        recyclePool(options).catch(() => { });
+    }
+    return result.data;
 }
-async function extractToNative(sourceFileName, sourceCode, options) {
-  const task = {
-    type: "extractToNative",
-    sourceFileName,
-    sourceCode,
-    options
-  };
-  const pool = getPool();
-  const result = await pool.run(task, {
-    name: "runTask"
-  });
-  if (!result.success) {
-    const errorMessage = [`[hanzogui-extract] Error processing file: ${sourceFileName || "(unknown)"}`, ``, result.error, result.stack ? `
-${result.stack}` : ""].filter(Boolean).join("\n");
-    throw new Error(errorMessage);
-  }
-  const count = incrementTaskCount();
-  if (count >= MAX_TASKS_BEFORE_RECYCLE) {
-    resetTaskCount();
-    recyclePool(options).catch(() => {});
-  }
-  return result.data;
+/**
+ * Extract Gui components to React Native StyleSheet format
+ */
+export async function extractToNative(sourceFileName, sourceCode, options) {
+    const task = {
+        type: 'extractToNative',
+        sourceFileName,
+        sourceCode,
+        options,
+    };
+    const pool = getPool();
+    const result = (await pool.run(task, { name: 'runTask' }));
+    if (!result.success) {
+        const errorMessage = [
+            `[hanzogui-extract] Error processing file: ${sourceFileName || '(unknown)'}`,
+            ``,
+            result.error,
+            result.stack ? `\n${result.stack}` : '',
+        ]
+            .filter(Boolean)
+            .join('\n');
+        throw new Error(errorMessage);
+    }
+    // check if we need to recycle the worker to prevent RSS bloat
+    const count = incrementTaskCount();
+    if (count >= MAX_TASKS_BEFORE_RECYCLE) {
+        resetTaskCount();
+        // recycle asynchronously with hot-swap to not block current request
+        recyclePool(options).catch(() => { });
+    }
+    return result.data;
 }
-async function watchGuiConfig(options) {
-  const {
-    default: Static
-  } = await import("@hanzogui/static");
-  const watcher = await Static.watchGuiConfig(options);
-  if (!watcher) {
-    return;
-  }
-  const originalDispose = watcher.dispose;
-  return {
-    dispose: () => {
-      originalDispose();
-      if (getSharedPool()) {
-        clearWorkerCache();
-      }
+/**
+ * Watch Gui config for changes and reload when it changes
+ */
+export async function watchGuiConfig(options) {
+    // For now, we'll use the static package's watcher directly
+    // This could be improved to use worker-based watching
+    const { default: Static } = await import('@hanzogui/static');
+    const watcher = await Static.watchGuiConfig(options);
+    if (!watcher) {
+        return;
     }
-  };
+    // Wrap the dispose to also clear worker cache
+    const originalDispose = watcher.dispose;
+    return {
+        dispose: () => {
+            originalDispose();
+            if (getSharedPool()) {
+                // Fire and forget - errors are handled internally
+                clearWorkerCache();
+            }
+        },
+    };
 }
-async function clearWorkerCache() {
-  const pool = getSharedPool();
-  if (!pool || isClosing()) return;
-  const task = {
-    type: "clearCache"
-  };
-  await pool.run(task, {
-    name: "runTask"
-  });
+/**
+ * Clear the worker's config cache
+ * Call this when config files change
+ */
+export async function clearWorkerCache() {
+    const pool = getSharedPool();
+    if (!pool || isClosing())
+        return;
+    const task = { type: 'clearCache' };
+    await pool.run(task, { name: 'runTask' });
 }
-async function destroyPool() {
-  const pool = getSharedPool();
-  if (pool) {
-    setClosing(true);
-    try {
-      await pool.close();
-    } finally {
-      setSharedPool(null);
-      setClosing(false);
+/**
+ * Clean up the worker pool on exit
+ * Should be called when the build process completes
+ */
+export async function destroyPool() {
+    const pool = getSharedPool();
+    if (pool) {
+        setClosing(true);
+        try {
+            await pool.close();
+        }
+        finally {
+            setSharedPool(null);
+            setClosing(false);
+        }
     }
-  }
 }
-function getPoolStats() {
-  const pool = getSharedPool();
-  if (!pool) {
-    return null;
-  }
-  return {
-    threads: pool.threads.length,
-    queueSize: pool.queueSize,
-    completed: pool.completed,
-    duration: pool.duration,
-    utilization: pool.utilization
-  };
+/**
+ * Get pool statistics for debugging
+ */
+export function getPoolStats() {
+    const pool = getSharedPool();
+    if (!pool) {
+        return null;
+    }
+    return {
+        threads: pool.threads.length,
+        queueSize: pool.queueSize,
+        completed: pool.completed,
+        duration: pool.duration,
+        utilization: pool.utilization,
+    };
 }
-export { DEFAULT_EXTRACT_PACKAGES, clearWorkerCache, destroyPool, extractToClassNames, extractToNative, getPoolStats, getPragmaOptions, installedPackageOf, isExtractable, loadGui, loadGuiBuildConfig, watchGuiConfig };
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map