@volter/tabnode 0.2.14-volter.88

package/src/transform.ts

@@ -0,0 +1,324 @@
+/**
+ * ESM to CJS Transformer using esbuild-wasm
+ *
+ * Transforms ES modules to CommonJS format during npm install,
+ * so require() can work synchronously.
+ */
+
+import { VirtualFS } from './virtual-fs';
+import { ESBUILD_WASM_ESM_CDN, ESBUILD_WASM_BINARY_CDN } from './config/cdn';
+// The dev servers and this transformer took a realm without a window for no
+// browser at all and served a file untransformed. A realm with an esbuild
+// host installed, the engine's worker among them, transforms through it
+// wherever it is.
+import { getEsbuildInstance } from './shims/esbuild';
+
+// Check if we're in a browser environment
+const isBrowser = typeof window !== 'undefined';
+
+// Window.__esbuild type is declared in src/types/external.d.ts
+
+/**
+ * Node's builtin specifiers, for the dynamic imports the transformer lowers.
+ *
+ * A CommonJS module's `import("fs/promises")` reaches the browser's own import
+ * and fails on the bare specifier, so the subpath builtins are on this list
+ * too. `stream/web` is the web streams the worker already has as globals,
+ * which file-type, on Dub's middleware path, could not find; and `constants`
+ * is Node's old flat table of fs, os and signal numbers, which graceful-fs
+ * still requires on its way into every React Router build.
+ *
+ * There was one of these lists per lowering path and they drifted: the path
+ * for a package that is already CommonJS carried only the twenty-nine
+ * top-level names, so a pre-bundled package's `import("fs/promises")`,
+ * `import("stream/web")` or `import("constants")` went to the browser
+ * untouched and the import rejected. One list serves both.
+ */
+const NODE_DYNAMIC_IMPORT_BUILTINS = [
+  'stream/web', 'fs/promises', 'stream/promises', 'stream/consumers',
+  'timers/promises', 'dns/promises', 'readline/promises', 'path/posix',
+  'path/win32', 'util/types', 'assert/strict',
+  'assert', 'buffer', 'constants', 'child_process', 'cluster', 'crypto', 'dgram', 'dns',
+  'events', 'fs', 'http', 'http2', 'https', 'net', 'os', 'path', 'perf_hooks',
+  'querystring', 'readline', 'stream', 'string_decoder', 'timers', 'tls',
+  'url', 'util', 'v8', 'vm', 'worker_threads', 'zlib', 'async_hooks', 'inspector', 'module',
+];
+
+/** `import("node:x")` and `import("x")` for a builtin, lowered to `require`. */
+function lowerDynamicBuiltinImports(code: string): string {
+  // The browser fetches `node:http` as a URL, so the prefixed form goes first.
+  let lowered = code.replace(
+    /\bimport\s*\(\s*["']node:([^"']+)["']\s*\)/g,
+    'Promise.resolve(require("node:$1"))'
+  );
+  for (const builtin of NODE_DYNAMIC_IMPORT_BUILTINS) {
+    // Match import("fs") or import('fs') but not import("fs-extra") etc
+    const pattern = new RegExp(`\\bimport\\s*\\(\\s*["']${builtin}["']\\s*\\)`, 'g');
+    lowered = lowered.replace(pattern, `Promise.resolve(require("${builtin}"))`);
+  }
+  return lowered;
+}
+
+/**
+ * Initialize esbuild-wasm (reuses existing instance if already initialized)
+ */
+export async function initTransformer(): Promise<void> {
+  if (getEsbuildInstance()) return;
+  // Skip in non-browser environments (tests)
+  if (!isBrowser) {
+    console.log('[transform] Skipping esbuild init (not in browser)');
+    return;
+  }
+
+  // Reuse existing esbuild instance from window (may have been initialized by next-dev-server)
+  if (window.__esbuild) {
+    console.log('[transform] Reusing existing esbuild instance');
+    return;
+  }
+
+  // If another init is in progress, wait for it
+  if (window.__esbuildInitPromise) {
+    return window.__esbuildInitPromise;
+  }
+
+  window.__esbuildInitPromise = (async () => {
+    try {
+      console.log('[transform] Loading esbuild-wasm...');
+
+      // Load esbuild-wasm from CDN
+      const mod = await import(
+        /* @vite-ignore */
+        ESBUILD_WASM_ESM_CDN
+      );
+
+      // esm.sh wraps the module - get the actual esbuild object
+      const esbuildMod = mod.default || mod;
+
+      try {
+        await esbuildMod.initialize({
+          wasmURL: ESBUILD_WASM_BINARY_CDN,
+        });
+        console.log('[transform] esbuild-wasm initialized');
+      } catch (initError) {
+        // Handle "already initialized" error gracefully
+        if (initError instanceof Error && initError.message.includes('Cannot call "initialize" more than once')) {
+          console.log('[transform] esbuild-wasm already initialized, reusing');
+        } else {
+          throw initError;
+        }
+      }
+
+      window.__esbuild = esbuildMod;
+    } catch (error) {
+      console.error('[transform] Failed to initialize esbuild:', error);
+      window.__esbuildInitPromise = undefined;
+      throw error;
+    }
+  })();
+
+  return window.__esbuildInitPromise;
+}
+
+/**
+ * Check if transformer is ready
+ */
+export function isTransformerReady(): boolean {
+  if (getEsbuildInstance()) return true;
+  // In non-browser, we skip transformation
+  if (!isBrowser) return true;
+  return window.__esbuild !== undefined;
+}
+
+/**
+ * Transform a single file from ESM to CJS
+ */
+export async function transformFile(
+  code: string,
+  filename: string
+): Promise<string> {
+  // Skip in non-browser environments
+  if (!getEsbuildInstance() && !isBrowser) {
+    return code;
+  }
+
+  if (!getEsbuildInstance() && !window.__esbuild) {
+    await initTransformer();
+  }
+
+  const esbuild = getEsbuildInstance() ?? window.__esbuild;
+  if (!esbuild) {
+    throw new Error('esbuild not initialized');
+  }
+
+  // Determine loader based on file extension
+  let loader: 'js' | 'jsx' | 'ts' | 'tsx' = 'js';
+  if (filename.endsWith('.jsx')) loader = 'jsx';
+  else if (filename.endsWith('.ts')) loader = 'ts';
+  else if (filename.endsWith('.tsx')) loader = 'tsx';
+  else if (filename.endsWith('.mjs')) loader = 'js';
+
+  try {
+    const result = await esbuild.transform(code, {
+      loader,
+      format: 'cjs',
+      target: 'esnext',
+      platform: 'neutral',
+      // Replace import.meta with our runtime-provided variable
+      // This is the proper esbuild way to handle import.meta in CJS
+      define: {
+        'import.meta.url': 'import_meta.url',
+        'import.meta.dirname': 'import_meta.dirname',
+        'import.meta.filename': 'import_meta.filename',
+        'import.meta': 'import_meta',
+      },
+    });
+
+    // Dynamic imports of Node's builtins are lowered to `require`, the
+    // prefixed and bare forms alike; the list and the rewrite are shared with
+    // the already-CommonJS path below.
+    const transformed = lowerDynamicBuiltinImports(result.code);
+
+    return transformed;
+  } catch (error: unknown) {
+    // Check if it's a top-level await error - these files are usually CLI entry points
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    if (errorMsg.includes('Top-level await')) {
+      console.log(`[transform] Skipping ${filename} (has top-level await, likely CLI entry point)`);
+      // Return original code - it won't be require()'d directly anyway
+      return code;
+    }
+
+    console.warn(`[transform] Failed to transform ${filename}:`, error);
+    // Return original code if transform fails
+    return code;
+  }
+}
+
+/**
+ * Check if a file needs ESM to CJS transformation
+ */
+function needsTransform(filename: string, code: string): boolean {
+  // .mjs files are always ESM
+  if (filename.endsWith('.mjs')) {
+    return true;
+  }
+
+  // .cjs files are always CJS
+  if (filename.endsWith('.cjs')) {
+    return false;
+  }
+
+  // Check for ESM syntax
+  const hasImport = /\bimport\s+[\w{*'"]/m.test(code);
+  const hasExport = /\bexport\s+(?:default|const|let|var|function|class|{|\*)/m.test(code);
+  const hasImportMeta = /\bimport\.meta\b/.test(code);
+
+  return hasImport || hasExport || hasImportMeta;
+}
+
+/**
+ * Check if a file has dynamic imports that need patching
+ */
+function hasDynamicNodeImports(code: string): boolean {
+  // Check for import("node:...") or import('node:...')
+  if (/\bimport\s*\(\s*["']node:/.test(code)) {
+    return true;
+  }
+  // Any builtin the lowering knows, not the eleven names this test used to
+  // carry: a package whose only dynamic builtin import was `child_process` or
+  // `fs/promises` was never offered to the lowering at all.
+  const names = NODE_DYNAMIC_IMPORT_BUILTINS.map((name) => name.replace('/', '\\/')).join('|');
+  return new RegExp(`\\bimport\\s*\\(\\s*["'](?:${names})["']\\s*\\)`).test(code);
+}
+
+/**
+ * Patch dynamic imports in already-CJS code (e.g., pre-bundled packages)
+ */
+function patchDynamicImports(code: string): string {
+  return lowerDynamicBuiltinImports(code);
+}
+
+/**
+ * Transform all ESM files in a package directory to CJS
+ */
+export async function transformPackage(
+  vfs: VirtualFS,
+  pkgPath: string,
+  onProgress?: (msg: string) => void
+): Promise<number> {
+  let transformedCount = 0;
+
+  // Find all JS files in the package
+  const jsFiles = findJsFiles(vfs, pkgPath);
+
+  onProgress?.(`  Transforming ${jsFiles.length} files in ${pkgPath}...`);
+
+  // Transform files in batches
+  const BATCH_SIZE = 10;
+  for (let i = 0; i < jsFiles.length; i += BATCH_SIZE) {
+    const batch = jsFiles.slice(i, i + BATCH_SIZE);
+
+    await Promise.all(
+      batch.map(async (filePath) => {
+        try {
+          const code = vfs.readFileSync(filePath, 'utf8');
+
+          if (needsTransform(filePath, code)) {
+            // Full ESM to CJS transformation
+            const transformed = await transformFile(code, filePath);
+            vfs.writeFileSync(filePath, transformed);
+            transformedCount++;
+          } else if (hasDynamicNodeImports(code)) {
+            // Just patch dynamic imports in already-CJS code
+            const patched = patchDynamicImports(code);
+            vfs.writeFileSync(filePath, patched);
+            transformedCount++;
+          }
+        } catch (error) {
+          // Skip files that can't be read/transformed
+          console.warn(`[transform] Skipping ${filePath}:`, error);
+        }
+      })
+    );
+  }
+
+  return transformedCount;
+}
+
+/**
+ * Find all JavaScript files in a directory recursively
+ */
+function findJsFiles(vfs: VirtualFS, dir: string): string[] {
+  const files: string[] = [];
+
+  try {
+    const entries = vfs.readdirSync(dir);
+
+    for (const entry of entries) {
+      const fullPath = dir + '/' + entry;
+
+      try {
+        const stat = vfs.statSync(fullPath);
+
+        if (stat.isDirectory()) {
+          // Skip node_modules inside packages (nested deps)
+          if (entry !== 'node_modules') {
+            files.push(...findJsFiles(vfs, fullPath));
+          }
+        } else if (
+          entry.endsWith('.js') ||
+          entry.endsWith('.mjs') ||
+          entry.endsWith('.jsx')
+        ) {
+          files.push(fullPath);
+        }
+      } catch {
+        // Skip files we can't stat
+      }
+    }
+  } catch {
+    // Skip directories we can't read
+  }
+
+  return files;
+}

package/src/types/external.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Type declarations for CDN-loaded modules
+ *
+ * Dynamic imports use variable URLs from src/config/cdn.ts, so we declare
+ * types on the base module names. TypeScript resolves them via the
+ * `esbuild-wasm` and `@rollup/browser` module declarations below.
+ */
+
+// Type declarations for esbuild-wasm to support dynamic import from CDN
+interface EsbuildTransformOptions {
+  loader?: string;
+  jsx?: string;
+  jsxFactory?: string;
+  jsxFragment?: string;
+  jsxImportSource?: string;
+  sourcemap?: boolean | 'inline' | 'external' | 'both';
+  sourcefile?: string;
+  target?: string | string[];
+  format?: 'iife' | 'cjs' | 'esm';
+  minify?: boolean;
+  tsconfigRaw?: string | object;
+  platform?: 'browser' | 'node' | 'neutral';
+  define?: Record<string, string>;
+}
+
+interface EsbuildTransformResult {
+  code: string;
+  map: string;
+  warnings: unknown[];
+}
+
+// Declare the esbuild-wasm module for type-only imports
+declare module 'esbuild-wasm' {
+  export function initialize(options?: { wasmURL?: string; worker?: boolean }): Promise<void>;
+  export function transform(input: string, options?: EsbuildTransformOptions): Promise<EsbuildTransformResult>;
+  export function build(options: unknown): Promise<unknown>;
+  export function formatMessages(messages: unknown[], options: unknown): Promise<string[]>;
+  export const version: string;
+}
+
+// Centralized Window interface augmentation for esbuild
+interface Window {
+  __esbuild?: typeof import('esbuild-wasm');
+  __esbuildInitPromise?: Promise<void>;
+}
+
+/**
+ * Vite's `?raw` import: the file's text, as a string. The engine uses it to
+ * carry Node's own vendored library sources (src/node-lib/*.js) into the
+ * bundle unmodified, to be evaluated on a binding.
+ */
+declare module '*?raw' {
+  const content: string;
+  export default content;
+}

package/src/types/package-json.ts

@@ -0,0 +1,17 @@
+/**
+ * Type definition for package.json files
+ */
+export interface PackageJson {
+  name?: string;
+  version?: string;
+  main?: string;
+  module?: string;
+  browser?: string | Record<string, string | false>;
+  types?: string;
+  exports?: Record<string, unknown> | string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  scripts?: Record<string, string>;
+  [key: string]: unknown;
+}

package/src/types/pako-zlib.d.ts

@@ -0,0 +1,30 @@
+/**
+ * pako's zlib layer has no types of its own: it is zlib's C ported to
+ * JavaScript, and DefinitelyTyped describes only pako's public API. The
+ * shapes the engine relies on are stated where they are used, in
+ * `src/node-lib/binding/zlib-pako.ts`; this says the modules exist.
+ */
+declare module 'pako/lib/zlib/zstream.js' {
+  const ZStream: new () => Record<string, unknown>;
+  export default ZStream;
+}
+declare module 'pako/lib/zlib/inflate.js' {
+  const value: Record<string, unknown>;
+  export = value;
+}
+declare module 'pako/lib/zlib/deflate.js' {
+  const value: Record<string, unknown>;
+  export = value;
+}
+declare module 'pako/lib/zlib/constants.js' {
+  const value: Record<string, number>;
+  export default value;
+}
+declare module 'pako/lib/zlib/crc32.js' {
+  const value: (crc: number, buffer: Uint8Array, length: number, position: number) => number;
+  export default value;
+}
+declare module 'pako/lib/zlib/messages.js' {
+  const value: Record<number, string>;
+  export default value;
+}

package/src/types/sha.js.d.ts

@@ -0,0 +1,14 @@
+/**
+ * sha.js ships no types. It is a CommonJS factory: SHA(algorithm) returns a
+ * streaming hash whose state lives in own fields, which crypto.ts copies by
+ * value for Hash.copy() because sha.js has no clone.
+ */
+declare module 'sha.js' {
+  interface ShaHash {
+    update(data: Uint8Array | string, encoding?: string): ShaHash;
+    digest(): Uint8Array;
+    [field: string]: unknown;
+  }
+  function SHA(algorithm: string): ShaHash;
+  export = SHA;
+}

package/src/utils/binary-encoding.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared binary encoding utilities.
+ * Replaces O(n²) string concatenation patterns used throughout the codebase.
+ */
+
+const CHUNK = 8192;
+
+/** Convert Uint8Array to base64 string */
+export function uint8ToBase64(bytes: Uint8Array): string {
+  const parts: string[] = [];
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    parts.push(String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK))));
+  }
+  return btoa(parts.join(''));
+}
+
+/** Convert base64 string to Uint8Array */
+export function base64ToUint8(base64: string): Uint8Array {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+
+/** Convert Uint8Array to hex string */
+export function uint8ToHex(bytes: Uint8Array): string {
+  const hex = new Array(bytes.length);
+  for (let i = 0; i < bytes.length; i++) {
+    hex[i] = bytes[i].toString(16).padStart(2, '0');
+  }
+  return hex.join('');
+}
+
+/** Convert Uint8Array to binary (latin1) string */
+export function uint8ToBinaryString(bytes: Uint8Array): string {
+  const parts: string[] = [];
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    parts.push(String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK))));
+  }
+  return parts.join('');
+}

package/src/utils/glob.ts

@@ -0,0 +1,54 @@
+/**
+ * Node's glob, for `path.matchesGlob` and for `fs.glob`: `**` crosses
+ * separators, `*` and `?` do not, `[...]` is a character class and `{a,b}` is
+ * an alternation, and the whole path is matched.
+ *
+ * It lives here because both the builtin table in `runtime.ts` and the fs
+ * shim's `globSync` need it. It used to be a function declared in
+ * `runtime.ts` and merely `declare`d in `src/shims/fs.ts`, on the belief that
+ * the bundle gives every module one shared scope; it does not, so a guest
+ * that called `fs.globSync` — the vitest and Prisma CLIs glob for their own
+ * files — died on `__browserRuntimeNodeGlob is not defined`. A module both
+ * import is the same helper in either build.
+ *
+ * This is not npm's package.json glob, which anchors a pattern without a
+ * separator at any segment; that one stays with the installer, since each
+ * source system keeps its own semantics.
+ */
+export function globToRegExp(glob: string, nocase = false): RegExp {
+  return new RegExp("^" + globBody(glob) + "$", nocase ? "i" : "");
+}
+
+function globBody(glob: string): string {
+  let out = "";
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i];
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        i++;
+        if (glob[i + 1] === "/") { i++; out += "(?:[^/]*\\/)*"; } else out += ".*";
+      } else out += "[^/]*";
+    } else if (ch === "?") {
+      out += "[^/]";
+    } else if (ch === "[") {
+      let end = i + 1;
+      let body = "";
+      if (glob[end] === "!" || glob[end] === "^") { body += "^"; end++; }
+      for (; end < glob.length && glob[end] !== "]"; end++) body += glob[end] === "\\" ? "\\\\" : glob[end];
+      if (end >= glob.length) out += "\\["; else { out += "[" + body + "]"; i = end; }
+    } else if (ch === "{") {
+      let depth = 1;
+      let end = i + 1;
+      let body = "";
+      for (; end < glob.length; end++) {
+        if (glob[end] === "{") depth++;
+        else if (glob[end] === "}") { depth--; if (depth === 0) break; }
+        body += glob[end];
+      }
+      if (depth !== 0) out += "\\{"; else { out += "(?:" + body.split(",").map(globBody).join("|") + ")"; i = end; }
+    } else {
+      out += ch.replace(/[.+^$()|\]}\\]/g, "\\$&");
+    }
+  }
+  return out;
+}

package/src/utils/hash.ts

@@ -0,0 +1,12 @@
+/**
+ * Simple hash function for content-based cache invalidation.
+ * Uses djb2-style hashing for fast string hashing.
+ */
+export function simpleHash(str: string): string {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = ((hash << 5) - hash) + str.charCodeAt(i);
+    hash |= 0;
+  }
+  return hash.toString(36);
+}