@computekit/core 0.1.0

package/dist/worker.js

@@ -0,0 +1,143 @@
+// src/utils.ts
+function generateId() {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
+}
+function findTransferables(data) {
+  const transferables = [];
+  const seen = /* @__PURE__ */ new WeakSet();
+  function traverse(obj) {
+    if (obj === null || typeof obj !== "object") return;
+    if (seen.has(obj)) return;
+    seen.add(obj);
+    if (obj instanceof ArrayBuffer) {
+      transferables.push(obj);
+      return;
+    }
+    if (ArrayBuffer.isView(obj)) {
+      transferables.push(obj.buffer);
+      return;
+    }
+    if (obj instanceof MessagePort) {
+      transferables.push(obj);
+      return;
+    }
+    if (typeof ImageBitmap !== "undefined" && obj instanceof ImageBitmap) {
+      transferables.push(obj);
+      return;
+    }
+    if (typeof OffscreenCanvas !== "undefined" && obj instanceof OffscreenCanvas) {
+      transferables.push(obj);
+      return;
+    }
+    if (Array.isArray(obj)) {
+      obj.forEach(traverse);
+      return;
+    }
+    if (obj instanceof Map) {
+      obj.forEach((value, key) => {
+        traverse(key);
+        traverse(value);
+      });
+      return;
+    }
+    if (obj instanceof Set) {
+      obj.forEach(traverse);
+      return;
+    }
+    Object.values(obj).forEach(traverse);
+  }
+  traverse(data);
+  return transferables;
+}
+
+// src/worker/runtime.ts
+var functionRegistry = /* @__PURE__ */ new Map();
+var currentTaskId = null;
+function reportProgress(progress) {
+  if (!currentTaskId) {
+    console.warn("reportProgress called outside of compute function");
+    return;
+  }
+  const message = {
+    id: generateId(),
+    type: "progress",
+    payload: {
+      taskId: currentTaskId,
+      progress: {
+        percent: progress.percent ?? 0,
+        phase: progress.phase,
+        estimatedTimeRemaining: progress.estimatedTimeRemaining,
+        data: progress.data
+      }
+    },
+    timestamp: Date.now()
+  };
+  self.postMessage(message);
+}
+function registerFunction(name, fn) {
+  functionRegistry.set(name, fn);
+}
+async function executeFunction(functionName, input) {
+  const fn = functionRegistry.get(functionName);
+  if (!fn) {
+    throw new Error(`Function "${functionName}" not found in worker`);
+  }
+  return fn(input);
+}
+async function handleMessage(event) {
+  const { id, type, payload } = event.data;
+  if (type === "execute") {
+    const { functionName, input } = payload;
+    const startTime = performance.now();
+    currentTaskId = id;
+    try {
+      const result = await executeFunction(functionName, input);
+      const duration = performance.now() - startTime;
+      const transfer = findTransferables(result);
+      const response = {
+        id,
+        type: "result",
+        payload: {
+          data: result,
+          duration
+        },
+        timestamp: Date.now()
+      };
+      self.postMessage(response, transfer);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      const response = {
+        id,
+        type: "error",
+        payload: {
+          message: error.message,
+          stack: error.stack
+        },
+        timestamp: Date.now()
+      };
+      self.postMessage(response);
+    } finally {
+      currentTaskId = null;
+    }
+  } else if (type === "init") {
+    const response = {
+      id,
+      type: "ready",
+      timestamp: Date.now()
+    };
+    self.postMessage(response);
+  }
+}
+function initWorkerRuntime() {
+  self.onmessage = handleMessage;
+  const readyMessage = {
+    id: generateId(),
+    type: "ready",
+    timestamp: Date.now()
+  };
+  self.postMessage(readyMessage);
+}
+
+export { functionRegistry, initWorkerRuntime, registerFunction, reportProgress };
+//# sourceMappingURL=worker.js.map
+//# sourceMappingURL=worker.js.map

package/dist/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils.ts","../src/worker/runtime.ts"],"names":[],"mappings":"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","file":"worker.js","sourcesContent":["/**\n * ComputeKit Utilities\n * Helper functions for the WASM + Worker toolkit\n */\n\n/**\n * Generate a unique ID\n */\nexport function generateId(): string {\n  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;\n}\n\n/**\n * Check if running in a Web Worker context\n */\nexport function isWorkerContext(): boolean {\n  return (\n    typeof self !== 'undefined' &&\n    typeof Window === 'undefined' &&\n    typeof self.postMessage === 'function'\n  );\n}\n\n/**\n * Check if running in a browser context\n */\nexport function isBrowserContext(): boolean {\n  return typeof window !== 'undefined' && typeof document !== 'undefined';\n}\n\n/**\n * Check if SharedArrayBuffer is available\n */\nexport function isSharedArrayBufferAvailable(): boolean {\n  try {\n    return typeof SharedArrayBuffer !== 'undefined';\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Check if WASM is supported\n */\nexport function isWasmSupported(): boolean {\n  try {\n    if (typeof WebAssembly === 'object') {\n      const module = new WebAssembly.Module(\n        Uint8Array.of(0x0, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00)\n      );\n      return module instanceof WebAssembly.Module;\n    }\n  } catch {\n    // WASM not supported\n  }\n  return false;\n}\n\n/**\n * Get the number of logical processors\n */\nexport function getHardwareConcurrency(): number {\n  if (typeof navigator !== 'undefined' && navigator.hardwareConcurrency) {\n    return navigator.hardwareConcurrency;\n  }\n  return 4; // Reasonable default\n}\n\n/**\n * Create a deferred promise\n */\nexport interface Deferred<T> {\n  promise: Promise<T>;\n  resolve: (value: T | PromiseLike<T>) => void;\n  reject: (reason?: unknown) => void;\n}\n\nexport function createDeferred<T>(): Deferred<T> {\n  let resolve!: (value: T | PromiseLike<T>) => void;\n  let reject!: (reason?: unknown) => void;\n\n  const promise = new Promise<T>((res, rej) => {\n    resolve = res;\n    reject = rej;\n  });\n\n  return { promise, resolve, reject };\n}\n\n/**\n * Create a timeout promise\n */\nexport function createTimeout(ms: number, message?: string): Promise<never> {\n  return new Promise((_, reject) => {\n    setTimeout(() => {\n      reject(new Error(message || `Operation timed out after ${ms}ms`));\n    }, ms);\n  });\n}\n\n/**\n * Race a promise against a timeout\n */\nexport async function withTimeout<T>(\n  promise: Promise<T>,\n  ms: number,\n  message?: string\n): Promise<T> {\n  return Promise.race([promise, createTimeout(ms, message)]);\n}\n\n/**\n * Detect transferable objects in data\n */\nexport function findTransferables(data: unknown): Transferable[] {\n  const transferables: Transferable[] = [];\n  const seen = new WeakSet();\n\n  function traverse(obj: unknown): void {\n    if (obj === null || typeof obj !== 'object') return;\n    if (seen.has(obj as object)) return;\n    seen.add(obj as object);\n\n    if (obj instanceof ArrayBuffer) {\n      transferables.push(obj);\n      return;\n    }\n\n    if (ArrayBuffer.isView(obj)) {\n      transferables.push(obj.buffer);\n      return;\n    }\n\n    if (obj instanceof MessagePort) {\n      transferables.push(obj);\n      return;\n    }\n\n    if (typeof ImageBitmap !== 'undefined' && obj instanceof ImageBitmap) {\n      transferables.push(obj);\n      return;\n    }\n\n    if (typeof OffscreenCanvas !== 'undefined' && obj instanceof OffscreenCanvas) {\n      transferables.push(obj);\n      return;\n    }\n\n    if (Array.isArray(obj)) {\n      obj.forEach(traverse);\n      return;\n    }\n\n    if (obj instanceof Map) {\n      obj.forEach((value, key) => {\n        traverse(key);\n        traverse(value);\n      });\n      return;\n    }\n\n    if (obj instanceof Set) {\n      obj.forEach(traverse);\n      return;\n    }\n\n    Object.values(obj).forEach(traverse);\n  }\n\n  traverse(data);\n  return transferables;\n}\n\n/**\n * Clone data, detaching transferables\n */\nexport function cloneForTransfer<T>(data: T): { data: T; transfer: Transferable[] } {\n  const transfer = findTransferables(data);\n  return { data, transfer };\n}\n\n/**\n * Create a typed event emitter\n */\nexport type EventHandler<T = unknown> = (data: T) => void;\n\nexport class EventEmitter<TEvents extends Record<string, unknown>> {\n  private handlers = new Map<keyof TEvents, Set<EventHandler>>();\n\n  on<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): () => void {\n    if (!this.handlers.has(event)) {\n      this.handlers.set(event, new Set());\n    }\n    this.handlers.get(event)!.add(handler as EventHandler);\n\n    // Return unsubscribe function\n    return () => this.off(event, handler);\n  }\n\n  off<K extends keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): void {\n    this.handlers.get(event)?.delete(handler as EventHandler);\n  }\n\n  emit<K extends keyof TEvents>(event: K, data: TEvents[K]): void {\n    this.handlers.get(event)?.forEach((handler) => {\n      try {\n        handler(data);\n      } catch (err) {\n        console.error(`Error in event handler for ${String(event)}:`, err);\n      }\n    });\n  }\n\n  removeAllListeners(event?: keyof TEvents): void {\n    if (event) {\n      this.handlers.delete(event);\n    } else {\n      this.handlers.clear();\n    }\n  }\n}\n\n/**\n * Simple LRU cache\n */\nexport class LRUCache<K, V> {\n  private cache = new Map<K, V>();\n  private maxSize: number;\n\n  constructor(maxSize: number = 100) {\n    this.maxSize = maxSize;\n  }\n\n  get(key: K): V | undefined {\n    const value = this.cache.get(key);\n    if (value !== undefined) {\n      // Move to end (most recently used)\n      this.cache.delete(key);\n      this.cache.set(key, value);\n    }\n    return value;\n  }\n\n  set(key: K, value: V): void {\n    if (this.cache.has(key)) {\n      this.cache.delete(key);\n    } else if (this.cache.size >= this.maxSize) {\n      // Delete oldest (first) entry\n      const firstKey = this.cache.keys().next().value;\n      if (firstKey !== undefined) {\n        this.cache.delete(firstKey);\n      }\n    }\n    this.cache.set(key, value);\n  }\n\n  has(key: K): boolean {\n    return this.cache.has(key);\n  }\n\n  delete(key: K): boolean {\n    return this.cache.delete(key);\n  }\n\n  clear(): void {\n    this.cache.clear();\n  }\n\n  get size(): number {\n    return this.cache.size;\n  }\n}\n\n/**\n * Serialize function to string for worker\n */\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nexport function serializeFunction(fn: Function): string {\n  return fn.toString();\n}\n\n/**\n * Logger utility\n */\nexport interface Logger {\n  debug(...args: unknown[]): void;\n  info(...args: unknown[]): void;\n  warn(...args: unknown[]): void;\n  error(...args: unknown[]): void;\n}\n\nexport function createLogger(prefix: string, enabled: boolean = false): Logger {\n  const noop = () => {};\n  const log = (level: string) =>\n    enabled ? (...args: unknown[]) => console.log(`[${prefix}:${level}]`, ...args) : noop;\n\n  return {\n    debug: log('debug'),\n    info: log('info'),\n    warn: enabled\n      ? (...args: unknown[]) => console.warn(`[${prefix}:warn]`, ...args)\n      : noop,\n    error: (...args: unknown[]) => console.error(`[${prefix}:error]`, ...args),\n  };\n}\n","/**\n * ComputeKit Worker Runtime\n * Code that runs inside Web Workers\n */\n\nimport type {\n  WorkerMessage,\n  ExecutePayload,\n  ResultPayload,\n  ErrorPayload,\n  ComputeProgress,\n} from '../types';\n\nimport { generateId, findTransferables } from '../utils';\n\n/** Registry of compute functions available in the worker */\n// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\nconst functionRegistry = new Map<string, Function>();\n\n/** Current task context for progress reporting */\nlet currentTaskId: string | null = null;\n\n/**\n * Report progress from within a compute function\n */\nexport function reportProgress(progress: Partial<ComputeProgress>): void {\n  if (!currentTaskId) {\n    console.warn('reportProgress called outside of compute function');\n    return;\n  }\n\n  const message: WorkerMessage = {\n    id: generateId(),\n    type: 'progress',\n    payload: {\n      taskId: currentTaskId,\n      progress: {\n        percent: progress.percent ?? 0,\n        phase: progress.phase,\n        estimatedTimeRemaining: progress.estimatedTimeRemaining,\n        data: progress.data,\n      },\n    },\n    timestamp: Date.now(),\n  };\n\n  self.postMessage(message);\n}\n\n/**\n * Register a compute function in the worker\n */\nexport function registerFunction(\n  name: string,\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n  fn: Function\n): void {\n  functionRegistry.set(name, fn);\n}\n\n/**\n * Execute a registered function\n */\nasync function executeFunction(functionName: string, input: unknown): Promise<unknown> {\n  const fn = functionRegistry.get(functionName);\n\n  if (!fn) {\n    throw new Error(`Function \"${functionName}\" not found in worker`);\n  }\n\n  return fn(input);\n}\n\n/**\n * Handle incoming messages from the main thread\n */\nasync function handleMessage(event: MessageEvent<WorkerMessage>): Promise<void> {\n  const { id, type, payload } = event.data;\n\n  if (type === 'execute') {\n    const { functionName, input } = payload as ExecutePayload;\n    const startTime = performance.now();\n\n    // Set current task for progress reporting\n    currentTaskId = id;\n\n    try {\n      const result = await executeFunction(functionName, input);\n      const duration = performance.now() - startTime;\n\n      // Find transferable objects in result\n      const transfer = findTransferables(result);\n\n      const response: WorkerMessage<ResultPayload> = {\n        id,\n        type: 'result',\n        payload: {\n          data: result,\n          duration,\n        },\n        timestamp: Date.now(),\n      };\n\n      self.postMessage(response, transfer as Transferable[]);\n    } catch (err) {\n      const error = err instanceof Error ? err : new Error(String(err));\n\n      const response: WorkerMessage<ErrorPayload> = {\n        id,\n        type: 'error',\n        payload: {\n          message: error.message,\n          stack: error.stack,\n        },\n        timestamp: Date.now(),\n      };\n\n      self.postMessage(response);\n    } finally {\n      currentTaskId = null;\n    }\n  } else if (type === 'init') {\n    // Handle initialization if needed\n    const response: WorkerMessage = {\n      id,\n      type: 'ready',\n      timestamp: Date.now(),\n    };\n    self.postMessage(response);\n  }\n}\n\n/**\n * Initialize the worker runtime\n */\nexport function initWorkerRuntime(): void {\n  self.onmessage = handleMessage;\n\n  // Signal that worker is ready\n  const readyMessage: WorkerMessage = {\n    id: generateId(),\n    type: 'ready',\n    timestamp: Date.now(),\n  };\n  self.postMessage(readyMessage);\n}\n\n// Export for use in worker entry point\nexport { functionRegistry };\n"]}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@computekit/core",
+  "version": "0.1.0",
+  "description": "Core WASM + Worker toolkit for running heavy computations without blocking the UI",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.js",
+      "require": "./dist/worker.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.1.0"
+  },
+  "peerDependencies": {
+    "assemblyscript": "^0.27.0"
+  },
+  "peerDependenciesMeta": {
+    "assemblyscript": {
+      "optional": true
+    }
+  },
+  "keywords": [
+    "wasm",
+    "webassembly",
+    "workers",
+    "compute",
+    "performance",
+    "async"
+  ],
+  "author": "Ghassen Lassoued <https://github.com/tapava>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tapava/compute-kit",
+    "directory": "packages/core"
+  },
+  "sideEffects": false
+}

package/src/cli.ts

@@ -0,0 +1,246 @@
+/**
+ * ComputeKit CLI
+ * Build tool for compiling AssemblyScript compute functions
+ */
+
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync, readdirSync } from 'fs';
+import { join, basename, dirname, relative } from 'path';
+
+interface BuildOptions {
+  /** Input directory containing .ts files */
+  input: string;
+  /** Output directory for compiled WASM */
+  output: string;
+  /** Enable debug mode */
+  debug?: boolean;
+  /** Optimization level (0-3) */
+  optimize?: number;
+  /** Generate source maps */
+  sourceMap?: boolean;
+  /** Memory configuration */
+  memory?: {
+    initial?: number;
+    maximum?: number;
+  };
+}
+
+interface ComputeFunction {
+  name: string;
+  path: string;
+  wasmPath: string;
+}
+
+/**
+ * Find all compute function files
+ */
+function findComputeFunctions(dir: string): string[] {
+  const files: string[] = [];
+
+  function traverse(currentDir: string): void {
+    if (!existsSync(currentDir)) return;
+
+    const entries = readdirSync(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        traverse(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith('.ts')) {
+        files.push(fullPath);
+      }
+    }
+  }
+
+  traverse(dir);
+  return files;
+}
+
+/**
+ * Compile a single AssemblyScript file to WASM
+ */
+function compileToWasm(
+  inputPath: string,
+  outputPath: string,
+  options: BuildOptions
+): void {
+  const outputDir = dirname(outputPath);
+  if (!existsSync(outputDir)) {
+    mkdirSync(outputDir, { recursive: true });
+  }
+
+  const optimizeLevel = options.optimize ?? 3;
+  const args = [
+    'npx',
+    'asc',
+    inputPath,
+    '-o',
+    outputPath,
+    '--runtime',
+    'stub',
+    `--optimize`,
+    `-O${optimizeLevel}`,
+    '--exportRuntime',
+  ];
+
+  if (options.debug) {
+    args.push('--debug');
+  }
+
+  if (options.sourceMap) {
+    args.push('--sourceMap');
+  }
+
+  if (options.memory?.initial) {
+    args.push('--initialMemory', String(options.memory.initial));
+  }
+
+  if (options.memory?.maximum) {
+    args.push('--maximumMemory', String(options.memory.maximum));
+  }
+
+  const command = args.join(' ');
+  console.log(`Compiling: ${inputPath}`);
+
+  try {
+    execSync(command, { stdio: 'inherit' });
+    console.log(`  → ${outputPath}`);
+  } catch (error) {
+    console.error(`Failed to compile ${inputPath}`);
+    throw error;
+  }
+}
+
+/**
+ * Generate the compute registry file
+ */
+function generateRegistry(functions: ComputeFunction[], outputDir: string): void {
+  const imports = functions
+    .map((fn) => {
+      const relativePath = relative(outputDir, fn.wasmPath).replace(/\\/g, '/');
+      return `  '${fn.name}': () => import('./${relativePath}?url'),`;
+    })
+    .join('\n');
+
+  const registry = `/**
+ * ComputeKit - Auto-generated WASM Registry
+ * Generated at: ${new Date().toISOString()}
+ */
+
+export const wasmModules: Record<string, () => Promise<{ default: string }>> = {
+${imports}
+};
+
+export const moduleNames = ${JSON.stringify(functions.map((fn) => fn.name))};
+`;
+
+  const registryPath = join(outputDir, 'registry.ts');
+  writeFileSync(registryPath, registry);
+  console.log(`Generated registry: ${registryPath}`);
+}
+
+/**
+ * Build all compute functions
+ */
+export async function build(options: BuildOptions): Promise<void> {
+  console.log('\n🔧 ComputeKit Build\n');
+
+  const { input, output } = options;
+
+  // Find all .ts files
+  const files = findComputeFunctions(input);
+  if (files.length === 0) {
+    console.log('No compute functions found.');
+    return;
+  }
+
+  console.log(`Found ${files.length} compute function(s):\n`);
+
+  // Ensure output directory exists
+  if (!existsSync(output)) {
+    mkdirSync(output, { recursive: true });
+  }
+
+  const functions: ComputeFunction[] = [];
+
+  // Compile each file
+  for (const file of files) {
+    const name = basename(file, '.ts');
+    const wasmPath = join(output, `${name}.wasm`);
+
+    compileToWasm(file, wasmPath, options);
+
+    functions.push({
+      name,
+      path: file,
+      wasmPath,
+    });
+  }
+
+  // Generate registry
+  generateRegistry(functions, output);
+
+  console.log(`\n✅ Build complete! ${functions.length} module(s) compiled.\n`);
+}
+
+/**
+ * Watch mode for development
+ */
+export function watch(options: BuildOptions): void {
+  console.log('\n👀 Watching for changes...\n');
+
+  // Initial build
+  build(options);
+
+  // Watch for changes (simplified - in production use chokidar)
+  const checkInterval = setInterval(() => {
+    // In a real implementation, use file watchers
+  }, 1000);
+
+  process.on('SIGINT', () => {
+    clearInterval(checkInterval);
+    process.exit(0);
+  });
+}
+
+// CLI entry point
+if (typeof process !== 'undefined' && process.argv) {
+  const args = process.argv.slice(2);
+
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+ComputeKit Build Tool
+
+Usage:
+  computekit build [options]
+  computekit watch [options]
+
+Options:
+  --input, -i    Input directory (default: ./compute)
+  --output, -o   Output directory (default: ./compute/wasm)
+  --debug        Enable debug mode
+  --optimize     Optimization level 0-3 (default: 3)
+  --sourceMap    Generate source maps
+  --help, -h     Show this help
+    `);
+    process.exit(0);
+  }
+
+  const getArg = (name: string, short?: string): string | undefined => {
+    const idx = args.findIndex((a) => a === `--${name}` || a === `-${short}`);
+    return idx !== -1 ? args[idx + 1] : undefined;
+  };
+
+  const options: BuildOptions = {
+    input: getArg('input', 'i') ?? './compute',
+    output: getArg('output', 'o') ?? './compute/wasm',
+    debug: args.includes('--debug'),
+    optimize: parseInt(getArg('optimize') ?? '3'),
+    sourceMap: args.includes('--sourceMap'),
+  };
+
+  if (args.includes('watch')) {
+    watch(options);
+  } else {
+    build(options).catch(console.error);
+  }
+}

package/src/index.test.ts

@@ -0,0 +1,93 @@
+/**
+ * ComputeKit Core Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ComputeKit, isWasmSupported, getHardwareConcurrency } from '../src';
+
+describe('ComputeKit', () => {
+  let kit: ComputeKit;
+
+  beforeEach(() => {
+    kit = new ComputeKit({ debug: false });
+  });
+
+  afterEach(async () => {
+    await kit.terminate();
+  });
+
+  describe('constructor', () => {
+    it('should create instance with default options', () => {
+      expect(kit).toBeInstanceOf(ComputeKit);
+    });
+
+    it('should accept custom options', () => {
+      const customKit = new ComputeKit({
+        maxWorkers: 2,
+        timeout: 5000,
+        debug: true,
+      });
+      expect(customKit).toBeInstanceOf(ComputeKit);
+    });
+  });
+
+  describe('register', () => {
+    it('should register a function', () => {
+      kit.register('test', (n: number) => n * 2);
+      // Should not throw
+    });
+
+    it('should allow chaining', () => {
+      const result = kit
+        .register('fn1', () => 1)
+        .register('fn2', () => 2);
+      expect(result).toBe(kit);
+    });
+  });
+
+  describe('run', () => {
+    it('should execute a registered function', async () => {
+      kit.register('double', (n: number) => n * 2);
+      // Note: In the mock environment, we get 'mock result' back
+      const result = await kit.run('double', 5);
+      expect(result).toBeDefined();
+    });
+
+    it('should reject for unregistered function', async () => {
+      await expect(kit.run('unknown', {})).rejects.toThrow();
+    });
+  });
+
+  describe('getStats', () => {
+    it('should return pool statistics', () => {
+      const stats = kit.getStats();
+      expect(stats).toHaveProperty('totalWorkers');
+      expect(stats).toHaveProperty('activeWorkers');
+      expect(stats).toHaveProperty('queueLength');
+      expect(stats).toHaveProperty('tasksCompleted');
+    });
+  });
+
+  describe('isWasmSupported', () => {
+    it('should return a boolean', () => {
+      const result = kit.isWasmSupported();
+      expect(typeof result).toBe('boolean');
+    });
+  });
+});
+
+describe('Utility Functions', () => {
+  describe('isWasmSupported', () => {
+    it('should return a boolean', () => {
+      const result = isWasmSupported();
+      expect(typeof result).toBe('boolean');
+    });
+  });
+
+  describe('getHardwareConcurrency', () => {
+    it('should return a positive number', () => {
+      const result = getHardwareConcurrency();
+      expect(result).toBeGreaterThan(0);
+    });
+  });
+});