@computekit/core 0.1.2 → 0.2.0

package/dist/index.d.cts

@@ -1,5 +1,95 @@
-import { W as WasmModuleConfig, C as ComputeKitOptions, a as ComputeOptions, P as PoolStats, b as ComputeKitEvents, c as ComputeResult } from './types-2XRPtzH9.cjs';
-export { e as ComputeFunction, d as ComputeProgress, f as WorkerInfo } from './types-2XRPtzH9.cjs';
+import { W as WasmModuleConfig, C as ComputeKitOptions, a as ComputeOptions, P as PoolStats, b as ComputeKitEvents, c as ComputeResult } from './types-BNUPDwV-.cjs';
+export { B as BatchItemResult, e as ComputeFunction, d as ComputeProgress, o as ParallelBatchConfig, p as ParallelBatchResult, n as PipelineEvents, l as PipelineMetrics, i as PipelineMode, m as PipelineOptions, k as PipelineState, j as PipelineStatus, h as StageConfig, g as StageInfo, S as StageStatus, f as WorkerInfo } from './types-BNUPDwV-.cjs';
+
+/**
+ * ComputeKit Typed Registry
+ *
+ * This module provides type-safe function registration and execution.
+ * Users can extend the ComputeFunctionRegistry interface to get autocomplete
+ * and type safety for their registered functions.
+ *
+ * @example
+ * ```ts
+ * // Extend the registry interface (in a .d.ts file or at the top of your file)
+ * declare module '@computekit/core' {
+ *   interface ComputeFunctionRegistry {
+ *     fibonacci: { input: number; output: number };
+ *     sum: { input: number[]; output: number };
+ *     processData: { input: { items: string[] }; output: { count: number } };
+ *   }
+ * }
+ *
+ * // Now you get autocomplete and type safety!
+ * const kit = new ComputeKit();
+ * kit.register('fibonacci', (n) => ...);  // n is inferred as number
+ * const result = await kit.run('fibonacci', 42);  // result is number
+ * ```
+ */
+/**
+ * Registry interface for compute functions.
+ * Extend this interface using module augmentation to add your own functions.
+ *
+ * Each entry should be in the format:
+ * ```ts
+ * functionName: { input: InputType; output: OutputType }
+ * ```
+ *
+ * @example
+ * ```ts
+ * declare module '@computekit/core' {
+ *   interface ComputeFunctionRegistry {
+ *     myFunction: { input: string; output: number };
+ *   }
+ * }
+ * ```
+ */
+interface ComputeFunctionRegistry {
+}
+/**
+ * Helper type to get all registered function names.
+ * If no functions are registered, falls back to string.
+ */
+type RegisteredFunctionName = keyof ComputeFunctionRegistry extends never ? string : keyof ComputeFunctionRegistry;
+/**
+ * Helper type to check if the registry has any entries.
+ */
+type HasRegisteredFunctions = keyof ComputeFunctionRegistry extends never ? false : true;
+/**
+ * Get the input type for a registered function.
+ * Falls back to TFallback if the function is not registered.
+ */
+type FunctionInput<TName extends string, TFallback = unknown> = TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['input'] : TFallback;
+/**
+ * Get the output type for a registered function.
+ * Falls back to TFallback if the function is not registered.
+ */
+type FunctionOutput<TName extends string, TFallback = unknown> = TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['output'] : TFallback;
+/**
+ * Type for a compute function based on registry or explicit types.
+ */
+type ComputeFn<TInput, TOutput> = (input: TInput) => TOutput | Promise<TOutput>;
+/**
+ * Infer the compute function type for a registered function name.
+ */
+type InferComputeFn<TName extends string> = TName extends keyof ComputeFunctionRegistry ? ComputeFn<ComputeFunctionRegistry[TName]['input'], ComputeFunctionRegistry[TName]['output']> : ComputeFn<unknown, unknown>;
+/**
+ * Type helper for creating registry entries.
+ * Use this to define your function types more easily.
+ *
+ * @example
+ * ```ts
+ * declare module '@computekit/core' {
+ *   interface ComputeFunctionRegistry {
+ *     fibonacci: DefineFunction<number, number>;
+ *     sum: DefineFunction<number[], number>;
+ *   }
+ * }
+ * ```
+ */
+type DefineFunction<TInput, TOutput> = {
+    input: TInput;
+    output: TOutput;
+};
 
 /**
  * Check if SharedArrayBuffer is available
@@ -199,34 +289,46 @@ declare class ComputeKit extends EventEmitter<ComputeKitEvents> {
     /**
      * Register a compute function
      *
-     * @param name - Unique name for the function
+     * @param name - Unique name for the function (autocompletes if registry is extended)
      * @param fn - The function to execute (will run in a Web Worker)
      *
      * @example
      * ```ts
+     * // Basic usage
      * kit.register('sum', (arr: number[]) => arr.reduce((a, b) => a + b, 0));
+     *
+     * // With typed registry (extend ComputeFunctionRegistry for autocomplete)
+     * // declare module '@computekit/core' {
+     * //   interface ComputeFunctionRegistry {
+     * //     sum: { input: number[]; output: number };
+     * //   }
+     * // }
+     * // kit.register('sum', (arr) => arr.reduce((a, b) => a + b, 0));
      * ```
      */
-    register<TInput, TOutput>(name: string, fn: (input: TInput) => TOutput | Promise<TOutput>): this;
+    register<TName extends RegisteredFunctionName, TInput = FunctionInput<TName extends string ? TName : never>, TOutput = FunctionOutput<TName extends string ? TName : never>>(name: TName, fn: TName extends keyof ComputeFunctionRegistry ? ComputeFn<ComputeFunctionRegistry[TName]['input'], ComputeFunctionRegistry[TName]['output']> : ComputeFn<TInput, TOutput>): this;
     /**
      * Execute a registered compute function
      *
-     * @param name - Name of the registered function
-     * @param input - Input data for the function
+     * @param name - Name of the registered function (autocompletes if registry is extended)
+     * @param input - Input data for the function (type-safe if registry is extended)
      * @param options - Execution options
-     * @returns Promise resolving to the function result
+     * @returns Promise resolving to the function result (type-safe if registry is extended)
      *
      * @example
      * ```ts
      * const sum = await kit.run('sum', [1, 2, 3, 4, 5]);
+     *
+     * // With typed registry, input/output types are inferred:
+     * // const result = await kit.run('fibonacci', 50); // result: number
      * ```
      */
-    run<TInput, TOutput>(name: string, input: TInput, options?: ComputeOptions): Promise<TOutput>;
+    run<TName extends RegisteredFunctionName, TInput = FunctionInput<TName extends string ? TName : never>, TOutput = FunctionOutput<TName extends string ? TName : never>>(name: TName, input: TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['input'] : TInput, options?: ComputeOptions): Promise<TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['output'] : TOutput>;
     /**
      * Execute a registered compute function with full result metadata
      *
-     * @param name - Name of the registered function
-     * @param input - Input data for the function
+     * @param name - Name of the registered function (autocompletes if registry is extended)
+     * @param input - Input data for the function (type-safe if registry is extended)
      * @param options - Execution options
      * @returns Promise resolving to ComputeResult with metadata
      *
@@ -236,7 +338,7 @@ declare class ComputeKit extends EventEmitter<ComputeKitEvents> {
      * console.log(`Took ${result.duration}ms`);
      * ```
      */
-    runWithMetadata<TInput, TOutput>(name: string, input: TInput, options?: ComputeOptions): Promise<ComputeResult<TOutput>>;
+    runWithMetadata<TName extends RegisteredFunctionName, TInput = FunctionInput<TName extends string ? TName : never>, TOutput = FunctionOutput<TName extends string ? TName : never>>(name: TName, input: TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['input'] : TInput, options?: ComputeOptions): Promise<ComputeResult<TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['output'] : TOutput>>;
     /**
      * Get pool statistics
      */
@@ -260,11 +362,33 @@ declare function createComputeKit(options?: ComputeKitOptions): ComputeKit;
 declare function getDefaultInstance(): ComputeKit;
 /**
  * Register a function on the default instance
+ *
+ * @example
+ * ```ts
+ * import { register } from '@computekit/core';
+ *
+ * register('fibonacci', (n: number) => {
+ *   if (n <= 1) return n;
+ *   let a = 0, b = 1;
+ *   for (let i = 2; i <= n; i++) {
+ *     [a, b] = [b, a + b];
+ *   }
+ *   return b;
+ * });
+ * ```
  */
-declare function register<TInput, TOutput>(name: string, fn: (input: TInput) => TOutput | Promise<TOutput>): void;
+declare function register<TName extends RegisteredFunctionName, TInput = FunctionInput<TName extends string ? TName : never>, TOutput = FunctionOutput<TName extends string ? TName : never>>(name: TName, fn: TName extends keyof ComputeFunctionRegistry ? ComputeFn<ComputeFunctionRegistry[TName]['input'], ComputeFunctionRegistry[TName]['output']> : ComputeFn<TInput, TOutput>): void;
 /**
  * Run a function on the default instance
+ *
+ * @example
+ * ```ts
+ * import { run } from '@computekit/core';
+ *
+ * const result = await run('fibonacci', 50);
+ * console.log(result); // Type is inferred if registry is extended
+ * ```
  */
-declare function run<TInput, TOutput>(name: string, input: TInput, options?: ComputeOptions): Promise<TOutput>;
+declare function run<TName extends RegisteredFunctionName, TInput = FunctionInput<TName extends string ? TName : never>, TOutput = FunctionOutput<TName extends string ? TName : never>>(name: TName, input: TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['input'] : TInput, options?: ComputeOptions): Promise<TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['output'] : TOutput>;
 
-export { ComputeKit, ComputeKitEvents, ComputeKitOptions, ComputeOptions, ComputeResult, PoolStats, WasmModuleConfig, WorkerPool, clearWasmCache, copyFromWasmMemory, copyToWasmMemory, createComputeKit, findTransferables, getDefaultInstance, getHardwareConcurrency, getMemoryView, getWasmCacheStats, isSharedArrayBufferAvailable, isWasmSupported, loadAndInstantiate, loadAssemblyScript, loadWasmModule, register, run, wrapWasmExports };
+export { type ComputeFn, type ComputeFunctionRegistry, ComputeKit, ComputeKitEvents, ComputeKitOptions, ComputeOptions, ComputeResult, type DefineFunction, type FunctionInput, type FunctionOutput, type HasRegisteredFunctions, type InferComputeFn, PoolStats, type RegisteredFunctionName, WasmModuleConfig, WorkerPool, clearWasmCache, copyFromWasmMemory, copyToWasmMemory, createComputeKit, findTransferables, getDefaultInstance, getHardwareConcurrency, getMemoryView, getWasmCacheStats, isSharedArrayBufferAvailable, isWasmSupported, loadAndInstantiate, loadAssemblyScript, loadWasmModule, register, run, wrapWasmExports };

package/dist/index.d.ts

@@ -1,5 +1,95 @@
-import { W as WasmModuleConfig, C as ComputeKitOptions, a as ComputeOptions, P as PoolStats, b as ComputeKitEvents, c as ComputeResult } from './types-2XRPtzH9.js';
-export { e as ComputeFunction, d as ComputeProgress, f as WorkerInfo } from './types-2XRPtzH9.js';
+import { W as WasmModuleConfig, C as ComputeKitOptions, a as ComputeOptions, P as PoolStats, b as ComputeKitEvents, c as ComputeResult } from './types-BNUPDwV-.js';
+export { B as BatchItemResult, e as ComputeFunction, d as ComputeProgress, o as ParallelBatchConfig, p as ParallelBatchResult, n as PipelineEvents, l as PipelineMetrics, i as PipelineMode, m as PipelineOptions, k as PipelineState, j as PipelineStatus, h as StageConfig, g as StageInfo, S as StageStatus, f as WorkerInfo } from './types-BNUPDwV-.js';
+
+/**
+ * ComputeKit Typed Registry
+ *
+ * This module provides type-safe function registration and execution.
+ * Users can extend the ComputeFunctionRegistry interface to get autocomplete
+ * and type safety for their registered functions.
+ *
+ * @example
+ * ```ts
+ * // Extend the registry interface (in a .d.ts file or at the top of your file)
+ * declare module '@computekit/core' {
+ *   interface ComputeFunctionRegistry {
+ *     fibonacci: { input: number; output: number };
+ *     sum: { input: number[]; output: number };
+ *     processData: { input: { items: string[] }; output: { count: number } };
+ *   }
+ * }
+ *
+ * // Now you get autocomplete and type safety!
+ * const kit = new ComputeKit();
+ * kit.register('fibonacci', (n) => ...);  // n is inferred as number
+ * const result = await kit.run('fibonacci', 42);  // result is number
+ * ```
+ */
+/**
+ * Registry interface for compute functions.
+ * Extend this interface using module augmentation to add your own functions.
+ *
+ * Each entry should be in the format:
+ * ```ts
+ * functionName: { input: InputType; output: OutputType }
+ * ```
+ *
+ * @example
+ * ```ts
+ * declare module '@computekit/core' {
+ *   interface ComputeFunctionRegistry {
+ *     myFunction: { input: string; output: number };
+ *   }
+ * }
+ * ```
+ */
+interface ComputeFunctionRegistry {
+}
+/**
+ * Helper type to get all registered function names.
+ * If no functions are registered, falls back to string.
+ */
+type RegisteredFunctionName = keyof ComputeFunctionRegistry extends never ? string : keyof ComputeFunctionRegistry;
+/**
+ * Helper type to check if the registry has any entries.
+ */
+type HasRegisteredFunctions = keyof ComputeFunctionRegistry extends never ? false : true;
+/**
+ * Get the input type for a registered function.
+ * Falls back to TFallback if the function is not registered.
+ */
+type FunctionInput<TName extends string, TFallback = unknown> = TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['input'] : TFallback;
+/**
+ * Get the output type for a registered function.
+ * Falls back to TFallback if the function is not registered.
+ */
+type FunctionOutput<TName extends string, TFallback = unknown> = TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['output'] : TFallback;
+/**
+ * Type for a compute function based on registry or explicit types.
+ */
+type ComputeFn<TInput, TOutput> = (input: TInput) => TOutput | Promise<TOutput>;
+/**
+ * Infer the compute function type for a registered function name.
+ */
+type InferComputeFn<TName extends string> = TName extends keyof ComputeFunctionRegistry ? ComputeFn<ComputeFunctionRegistry[TName]['input'], ComputeFunctionRegistry[TName]['output']> : ComputeFn<unknown, unknown>;
+/**
+ * Type helper for creating registry entries.
+ * Use this to define your function types more easily.
+ *
+ * @example
+ * ```ts
+ * declare module '@computekit/core' {
+ *   interface ComputeFunctionRegistry {
+ *     fibonacci: DefineFunction<number, number>;
+ *     sum: DefineFunction<number[], number>;
+ *   }
+ * }
+ * ```
+ */
+type DefineFunction<TInput, TOutput> = {
+    input: TInput;
+    output: TOutput;
+};
 
 /**
  * Check if SharedArrayBuffer is available
@@ -199,34 +289,46 @@ declare class ComputeKit extends EventEmitter<ComputeKitEvents> {
     /**
      * Register a compute function
      *
-     * @param name - Unique name for the function
+     * @param name - Unique name for the function (autocompletes if registry is extended)
      * @param fn - The function to execute (will run in a Web Worker)
      *
      * @example
      * ```ts
+     * // Basic usage
      * kit.register('sum', (arr: number[]) => arr.reduce((a, b) => a + b, 0));
+     *
+     * // With typed registry (extend ComputeFunctionRegistry for autocomplete)
+     * // declare module '@computekit/core' {
+     * //   interface ComputeFunctionRegistry {
+     * //     sum: { input: number[]; output: number };
+     * //   }
+     * // }
+     * // kit.register('sum', (arr) => arr.reduce((a, b) => a + b, 0));
      * ```
      */
-    register<TInput, TOutput>(name: string, fn: (input: TInput) => TOutput | Promise<TOutput>): this;
+    register<TName extends RegisteredFunctionName, TInput = FunctionInput<TName extends string ? TName : never>, TOutput = FunctionOutput<TName extends string ? TName : never>>(name: TName, fn: TName extends keyof ComputeFunctionRegistry ? ComputeFn<ComputeFunctionRegistry[TName]['input'], ComputeFunctionRegistry[TName]['output']> : ComputeFn<TInput, TOutput>): this;
     /**
      * Execute a registered compute function
      *
-     * @param name - Name of the registered function
-     * @param input - Input data for the function
+     * @param name - Name of the registered function (autocompletes if registry is extended)
+     * @param input - Input data for the function (type-safe if registry is extended)
      * @param options - Execution options
-     * @returns Promise resolving to the function result
+     * @returns Promise resolving to the function result (type-safe if registry is extended)
      *
      * @example
      * ```ts
      * const sum = await kit.run('sum', [1, 2, 3, 4, 5]);
+     *
+     * // With typed registry, input/output types are inferred:
+     * // const result = await kit.run('fibonacci', 50); // result: number
      * ```
      */
-    run<TInput, TOutput>(name: string, input: TInput, options?: ComputeOptions): Promise<TOutput>;
+    run<TName extends RegisteredFunctionName, TInput = FunctionInput<TName extends string ? TName : never>, TOutput = FunctionOutput<TName extends string ? TName : never>>(name: TName, input: TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['input'] : TInput, options?: ComputeOptions): Promise<TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['output'] : TOutput>;
     /**
      * Execute a registered compute function with full result metadata
      *
-     * @param name - Name of the registered function
-     * @param input - Input data for the function
+     * @param name - Name of the registered function (autocompletes if registry is extended)
+     * @param input - Input data for the function (type-safe if registry is extended)
      * @param options - Execution options
      * @returns Promise resolving to ComputeResult with metadata
      *
@@ -236,7 +338,7 @@ declare class ComputeKit extends EventEmitter<ComputeKitEvents> {
      * console.log(`Took ${result.duration}ms`);
      * ```
      */
-    runWithMetadata<TInput, TOutput>(name: string, input: TInput, options?: ComputeOptions): Promise<ComputeResult<TOutput>>;
+    runWithMetadata<TName extends RegisteredFunctionName, TInput = FunctionInput<TName extends string ? TName : never>, TOutput = FunctionOutput<TName extends string ? TName : never>>(name: TName, input: TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['input'] : TInput, options?: ComputeOptions): Promise<ComputeResult<TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['output'] : TOutput>>;
     /**
      * Get pool statistics
      */
@@ -260,11 +362,33 @@ declare function createComputeKit(options?: ComputeKitOptions): ComputeKit;
 declare function getDefaultInstance(): ComputeKit;
 /**
  * Register a function on the default instance
+ *
+ * @example
+ * ```ts
+ * import { register } from '@computekit/core';
+ *
+ * register('fibonacci', (n: number) => {
+ *   if (n <= 1) return n;
+ *   let a = 0, b = 1;
+ *   for (let i = 2; i <= n; i++) {
+ *     [a, b] = [b, a + b];
+ *   }
+ *   return b;
+ * });
+ * ```
  */
-declare function register<TInput, TOutput>(name: string, fn: (input: TInput) => TOutput | Promise<TOutput>): void;
+declare function register<TName extends RegisteredFunctionName, TInput = FunctionInput<TName extends string ? TName : never>, TOutput = FunctionOutput<TName extends string ? TName : never>>(name: TName, fn: TName extends keyof ComputeFunctionRegistry ? ComputeFn<ComputeFunctionRegistry[TName]['input'], ComputeFunctionRegistry[TName]['output']> : ComputeFn<TInput, TOutput>): void;
 /**
  * Run a function on the default instance
+ *
+ * @example
+ * ```ts
+ * import { run } from '@computekit/core';
+ *
+ * const result = await run('fibonacci', 50);
+ * console.log(result); // Type is inferred if registry is extended
+ * ```
  */
-declare function run<TInput, TOutput>(name: string, input: TInput, options?: ComputeOptions): Promise<TOutput>;
+declare function run<TName extends RegisteredFunctionName, TInput = FunctionInput<TName extends string ? TName : never>, TOutput = FunctionOutput<TName extends string ? TName : never>>(name: TName, input: TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['input'] : TInput, options?: ComputeOptions): Promise<TName extends keyof ComputeFunctionRegistry ? ComputeFunctionRegistry[TName]['output'] : TOutput>;
 
-export { ComputeKit, ComputeKitEvents, ComputeKitOptions, ComputeOptions, ComputeResult, PoolStats, WasmModuleConfig, WorkerPool, clearWasmCache, copyFromWasmMemory, copyToWasmMemory, createComputeKit, findTransferables, getDefaultInstance, getHardwareConcurrency, getMemoryView, getWasmCacheStats, isSharedArrayBufferAvailable, isWasmSupported, loadAndInstantiate, loadAssemblyScript, loadWasmModule, register, run, wrapWasmExports };
+export { type ComputeFn, type ComputeFunctionRegistry, ComputeKit, ComputeKitEvents, ComputeKitOptions, ComputeOptions, ComputeResult, type DefineFunction, type FunctionInput, type FunctionOutput, type HasRegisteredFunctions, type InferComputeFn, PoolStats, type RegisteredFunctionName, WasmModuleConfig, WorkerPool, clearWasmCache, copyFromWasmMemory, copyToWasmMemory, createComputeKit, findTransferables, getDefaultInstance, getHardwareConcurrency, getMemoryView, getWasmCacheStats, isSharedArrayBufferAvailable, isWasmSupported, loadAndInstantiate, loadAssemblyScript, loadWasmModule, register, run, wrapWasmExports };

package/dist/index.js

@@ -160,6 +160,60 @@ var LRUCache = class {
     return this.cache.size;
   }
 };
+function estimatePayloadSize(value) {
+  if (value === null || value === void 0) return 0;
+  if (typeof value === "boolean") return 4;
+  if (typeof value === "number") return 8;
+  if (typeof value === "string") return value.length * 2;
+  if (value instanceof ArrayBuffer) return value.byteLength;
+  if (ArrayBuffer.isView(value)) return value.byteLength;
+  if (value instanceof Blob) return value.size;
+  const seen = /* @__PURE__ */ new WeakSet();
+  function traverse(obj) {
+    if (obj === null || typeof obj !== "object") {
+      if (typeof obj === "boolean") return 4;
+      if (typeof obj === "number") return 8;
+      if (typeof obj === "string") return obj.length * 2;
+      return 0;
+    }
+    if (seen.has(obj)) return 0;
+    seen.add(obj);
+    if (obj instanceof ArrayBuffer) return obj.byteLength;
+    if (ArrayBuffer.isView(obj)) return obj.byteLength;
+    if (obj instanceof Blob) return obj.size;
+    if (obj instanceof Date) return 8;
+    if (obj instanceof RegExp) return obj.source.length * 2;
+    if (Array.isArray(obj)) {
+      return obj.reduce((sum, item) => sum + traverse(item), 0);
+    }
+    if (obj instanceof Map) {
+      let size = 0;
+      obj.forEach((val, key) => {
+        size += traverse(key) + traverse(val);
+      });
+      return size;
+    }
+    if (obj instanceof Set) {
+      let size = 0;
+      obj.forEach((val) => {
+        size += traverse(val);
+      });
+      return size;
+    }
+    return Object.entries(obj).reduce(
+      (sum, [key, val]) => sum + key.length * 2 + traverse(val),
+      0
+    );
+  }
+  return traverse(value);
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${(bytes / Math.pow(k, i)).toFixed(i > 0 ? 1 : 0)} ${sizes[i]}`;
+}
 function createLogger(prefix, enabled = false) {
   const noop = () => {
   };
@@ -451,8 +505,10 @@ self.postMessage({ type: 'ready' });
           poolWorker.lastActiveAt = Date.now();
           this.stats.tasksCompleted++;
           this.stats.totalDuration += resultPayload.duration;
+          const inputSize = estimatePayloadSize(task.input);
+          const outputSize = resultPayload.outputSize ?? 0;
           this.logger.debug(
-            `Task ${id} completed in ${resultPayload.duration.toFixed(2)}ms`
+            `Task ${id} (${task.functionName}): input=${formatBytes(inputSize)}, output=${formatBytes(outputSize)}, duration=${resultPayload.duration.toFixed(2)}ms`
           );
           task.deferred.resolve(resultPayload.data);
           this.processQueue();
@@ -709,12 +765,21 @@ var ComputeKit = class extends EventEmitter {
   /**
    * Register a compute function
    *
-   * @param name - Unique name for the function
+   * @param name - Unique name for the function (autocompletes if registry is extended)
    * @param fn - The function to execute (will run in a Web Worker)
    *
    * @example
    * ```ts
+   * // Basic usage
    * kit.register('sum', (arr: number[]) => arr.reduce((a, b) => a + b, 0));
+   *
+   * // With typed registry (extend ComputeFunctionRegistry for autocomplete)
+   * // declare module '@computekit/core' {
+   * //   interface ComputeFunctionRegistry {
+   * //     sum: { input: number[]; output: number };
+   * //   }
+   * // }
+   * // kit.register('sum', (arr) => arr.reduce((a, b) => a + b, 0));
    * ```
    */
   register(name, fn) {
@@ -724,14 +789,17 @@ var ComputeKit = class extends EventEmitter {
   /**
    * Execute a registered compute function
    *
-   * @param name - Name of the registered function
-   * @param input - Input data for the function
+   * @param name - Name of the registered function (autocompletes if registry is extended)
+   * @param input - Input data for the function (type-safe if registry is extended)
    * @param options - Execution options
-   * @returns Promise resolving to the function result
+   * @returns Promise resolving to the function result (type-safe if registry is extended)
    *
    * @example
    * ```ts
    * const sum = await kit.run('sum', [1, 2, 3, 4, 5]);
+   *
+   * // With typed registry, input/output types are inferred:
+   * // const result = await kit.run('fibonacci', 50); // result: number
    * ```
    */
   async run(name, input, options) {
@@ -740,8 +808,8 @@ var ComputeKit = class extends EventEmitter {
   /**
    * Execute a registered compute function with full result metadata
    *
-   * @param name - Name of the registered function
-   * @param input - Input data for the function
+   * @param name - Name of the registered function (autocompletes if registry is extended)
+   * @param input - Input data for the function (type-safe if registry is extended)
    * @param options - Execution options
    * @returns Promise resolving to ComputeResult with metadata
    *
@@ -753,7 +821,11 @@ var ComputeKit = class extends EventEmitter {
    */
   async runWithMetadata(name, input, options) {
     const startTime = performance.now();
-    const data = await this.pool.execute(name, input, options);
+    const data = await this.pool.execute(
+      name,
+      input,
+      options
+    );
     const duration = performance.now() - startTime;
     return {
       data,