Add TypeScript type definitions for package exports

.eslintrc.cjs

@@ -1,6 +1,8 @@
 module.exports = {
   extends: ['@exodus/eslint-config/typescript'],
   rules: {
+    '@typescript-eslint/ban-types': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
     '@typescript-eslint/no-unnecessary-condition': 'off',
     'unicorn/consistent-function-scoping': 'off',
   },

.gitignore

@@ -1,5 +1,6 @@
 *~
 node_modules
+package-lock.json
 coverage
 playground
 *.tgz

package.json

@@ -28,12 +28,28 @@
   "exports": {
     "./node-test-reporter": "./bin/reporter.js",
     "./loader/jest": "./loader/jest.js",
-    "./benchmark": "./src/benchmark.js",
-    "./expect": "./src/expect.cjs",
-    "./jest": "./src/jest.js",
-    "./mock": "./src/mock.js",
-    "./node": "./src/node.js",
+    "./benchmark": {
+      "types": "./src/benchmark.d.ts",
+      "default": "./src/benchmark.js"
+    },
+    "./expect": {
+      "types": "./src/expect.d.ts",
+      "default": "./src/expect.cjs"
+    },
+    "./jest": {
+      "types": "./src/jest.d.ts",
+      "default": "./src/jest.js"
+    },
+    "./mock": {
+      "types": "./src/mock.d.ts",
+      "default": "./src/mock.js"
+    },
+    "./node": {
+      "types": "./src/node.d.ts",
+      "default": "./src/node.js"
+    },
     "./tape": {
+      "types": "./src/tape.d.ts",
       "import": "./src/tape.js",
       "require": "./src/tape.cjs"
     }
@@ -57,6 +73,7 @@
     "loader/typescript.js",
     "loader/typescript.loader.js",
     "src/benchmark.js",
+    "src/benchmark.d.ts",
     "src/dark.cjs",
     "src/engine.js",
     "src/engine.node.cjs",
@@ -65,8 +82,10 @@
     "src/engine.select.cjs",
     "src/exodus.js",
     "src/expect.cjs",
+    "src/expect.d.ts",
     "src/glob.cjs",
     "src/jest.js",
+    "src/jest.d.ts",
     "src/jest.config.js",
     "src/jest.config.fs.js",
     "src/jest.environment.js",
@@ -76,10 +95,13 @@
     "src/jest.snapshot.js",
     "src/jest.timers.js",
     "src/mock.js",
+    "src/mock.d.ts",
     "src/node.js",
+    "src/node.d.ts",
     "src/pretty-format.cjs",
     "src/replay.js",
     "src/tape.js",
+    "src/tape.d.ts",
     "src/tape.cjs",
     "src/timers-track.js",
     "src/version.js",

src/benchmark.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Type definitions for @exodus/test/benchmark
+ * Provides benchmark utilities for performance testing
+ */
+
+/// <reference types="node" />
+
+/**
+ * Benchmark options
+ */
+export interface BenchmarkOptions {
+  /** Array of arguments to pass to the benchmark function */
+  args?: any[]
+
+  /** Timeout in milliseconds (default: 1000) */
+  timeout?: number
+
+  /** Skip this benchmark */
+  skip?: boolean
+}
+
+/**
+ * Runs a benchmark
+ * @param name - Name of the benchmark
+ * @param options - Benchmark options
+ * @param fn - Function to benchmark
+ */
+export declare function benchmark(
+  name: string,
+  options: BenchmarkOptions,
+  fn: (arg?: any) => any | Promise<any>
+): Promise<void>
+
+export declare function benchmark(
+  name: string,
+  fn: (arg?: any) => any | Promise<any>
+): Promise<void>

src/expect.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Type definitions for @exodus/test/expect
+ * Re-exports types from the expect package
+ */
+
+export type { Expect } from 'expect'
+export declare const expect: import('expect').Expect
+
+/** Load the expect library (for internal use) */
+export declare function loadExpect(reason?: string): import('expect').Expect

src/jest.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Type definitions for @exodus/test/jest
+ * Re-exports types from @jest/globals where possible
+ */
+
+import type { Expect } from './expect.d.ts'
+
+// Re-export Jest types from @jest/globals
+export { describe, test, it, beforeEach, afterEach, beforeAll, afterAll } from '@jest/globals'
+
+// Re-export jest object
+export declare const jest: typeof import('@jest/globals').jest
+
+/** Alias for test() */
+export declare function should(name: string, fn: () => void | Promise<void>, timeout?: number): void
+
+export type { Expect } from './expect.d.ts'
+export declare const expect: Expect

src/mock.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Type definitions for @exodus/test/mock
+ * Provides mocking and testing utilities
+ */
+
+/// <reference types="node" />
+
+/**
+ * Network replay utilities
+ */
+
+/** Records fetch calls and returns a fetch function */
+export declare function fetchRecord(options?: any): typeof fetch
+
+/** Replays fetch calls from recording and returns a fetch function */
+export declare function fetchReplay(): typeof fetch
+
+/** Records WebSocket calls and returns a WebSocket constructor */
+export declare function websocketRecord(options?: any): typeof WebSocket
+
+/** Replays WebSocket calls from recording and returns a WebSocket constructor */
+export declare function websocketReplay(options?: any): typeof WebSocket
+
+/**
+ * Timer tracking and debugging utilities
+ */
+
+/** Enables timer tracking */
+export declare function timersTrack(): void
+
+/** Outputs debug information about active timers */
+export declare function timersDebug(): void
+
+/** Lists all active timers */
+export declare function timersList(): any[]
+
+/** Asserts no timers are active */
+export declare function timersAssert(): void
+
+/**
+ * Speeds up timers by the given rate
+ * @param rate - Speed multiplier (e.g., 2 means 2x faster)
+ * @param options - Configuration options
+ * @param options.apis - Array of APIs to speed up (default: ['setTimeout', 'setInterval', 'Date'])
+ */
+export declare function timersSpeedup(
+  rate: number,
+  options?: { apis?: ('setTimeout' | 'setInterval' | 'Date')[] }
+): void

src/node.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Type definitions for @exodus/test/node
+ * Re-exports types from @types/node where possible
+ */
+
+/// <reference types="node" />
+
+// Re-export from node:test module
+export { mock, describe, test, it, beforeEach, afterEach, before, after } from 'node:test'
+
+/**
+ * Snapshot utilities
+ */
+export declare const snapshot: {
+  /** Sets default snapshot serializers */
+  setDefaultSnapshotSerializers(serializers: any[]): void
+
+  /** Sets the snapshot path resolver (not supported) */
+  setResolveSnapshotPath(): never
+}

src/tape.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Type definitions for @exodus/test/tape
+ * Provides tape-compatible testing APIs
+ */
+
+/// <reference types="node" />
+
+/**
+ * Tape test context/assertion object
+ */
+export interface Test {
+  /** Plans the number of assertions */
+  plan(count: number): void
+
+  /** Ends the test */
+  end(): void
+
+  /** Skips the test */
+  skip(msg?: string): void
+
+  /** Marks test as todo */
+  todo(msg?: string): void
+
+  /** Adds a comment */
+  comment(msg: string): void
+
+  /** Nested test */
+  test(name: string, cb: (t: Test) => void): void
+  test(name: string, opts: TestOptions, cb: (t: Test) => void): void
+
+  /** Assertions */
+
+  /** Assert that value is truthy */
+  ok(value: any, msg?: string): void
+  true(value: any, msg?: string): void
+  assert(value: any, msg?: string): void
+
+  /** Assert that value is falsy */
+  notOk(value: any, msg?: string): void
+  false(value: any, msg?: string): void
+  notok(value: any, msg?: string): void
+
+  /** Assert strict equality */
+  equal(actual: any, expected: any, msg?: string): void
+  equals(actual: any, expected: any, msg?: string): void
+  isEqual(actual: any, expected: any, msg?: string): void
+  is(actual: any, expected: any, msg?: string): void
+  strictEqual(actual: any, expected: any, msg?: string): void
+  strictEquals(actual: any, expected: any, msg?: string): void
+
+  /** Assert strict inequality */
+  notEqual(actual: any, expected: any, msg?: string): void
+  notEquals(actual: any, expected: any, msg?: string): void
+  notStrictEqual(actual: any, expected: any, msg?: string): void
+  notStrictEquals(actual: any, expected: any, msg?: string): void
+  doesNotEqual(actual: any, expected: any, msg?: string): void
+  isNotEqual(actual: any, expected: any, msg?: string): void
+  isNot(actual: any, expected: any, msg?: string): void
+  not(actual: any, expected: any, msg?: string): void
+  isInequal(actual: any, expected: any, msg?: string): void
+
+  /** Assert loose equality */
+  looseEqual(actual: any, expected: any, msg?: string): void
+  looseEquals(actual: any, expected: any, msg?: string): void
+
+  /** Assert loose inequality */
+  notLooseEqual(actual: any, expected: any, msg?: string): void
+  notLooseEquals(actual: any, expected: any, msg?: string): void
+
+  /** Assert deep strict equality */
+  deepEqual(actual: any, expected: any, msg?: string): void
+  deepEquals(actual: any, expected: any, msg?: string): void
+  isEquivalent(actual: any, expected: any, msg?: string): void
+  same(actual: any, expected: any, msg?: string): void
+
+  /** Assert deep strict inequality */
+  notDeepEqual(actual: any, expected: any, msg?: string): void
+  notDeepEquals(actual: any, expected: any, msg?: string): void
+  notEquivalent(actual: any, expected: any, msg?: string): void
+  notDeeply(actual: any, expected: any, msg?: string): void
+  notSame(actual: any, expected: any, msg?: string): void
+  isNotDeepEqual(actual: any, expected: any, msg?: string): void
+  isNotDeeply(actual: any, expected: any, msg?: string): void
+  isNotEquivalent(actual: any, expected: any, msg?: string): void
+  isInequivalent(actual: any, expected: any, msg?: string): void
+
+  /** Assert deep loose equality */
+  deepLooseEqual(actual: any, expected: any, msg?: string): void
+
+  /** Assert deep loose inequality */
+  notDeepLooseEqual(actual: any, expected: any, msg?: string): void
+
+  /** Assert function throws */
+  throws(fn: () => any, expected?: RegExp | Function, msg?: string): void
+
+  /** Assert function does not throw */
+  doesNotThrow(fn: () => any, expected?: RegExp | Function, msg?: string): void
+
+  /** Assert promise rejects */
+  rejects(promise: Promise<any>, expected?: RegExp | Function, msg?: string): Promise<void>
+
+  /** Assert promise resolves */
+  resolves(promise: Promise<any>, msg?: string): Promise<void>
+  doesNotReject(promise: Promise<any>, expected?: RegExp | Function, msg?: string): Promise<void>
+
+  /** Force a passing assertion */
+  pass(msg?: string): void
+
+  /** Force a failing assertion */
+  fail(msg?: string): void
+
+  /** Assert no error */
+  error(err: any, msg?: string): void
+  ifError(err: any, msg?: string): void
+  ifErr(err: any, msg?: string): void
+  iferror(err: any, msg?: string): void
+
+  /** Custom assertion function */
+  assertion(fn: Function, ...args: any[]): void
+}
+
+/**
+ * Test options
+ */
+export interface TestOptions {
+  skip?: boolean
+  todo?: boolean
+  timeout?: number
+  concurrency?: number
+}
+
+/**
+ * Test function
+ */
+export interface TestFunction {
+  /** Run a test */
+  (name: string, cb: (t: Test) => void): void
+  (name: string, opts: TestOptions, cb: (t: Test) => void): void
+  (cb: (t: Test) => void): void
+  (opts: TestOptions, cb: (t: Test) => void): void
+
+  /** Only run this test */
+  only: TestFunction
+
+  /** Skip this test */
+  skip: TestFunction
+
+  /** Register a callback to run after all tests finish */
+  onFinish(fn: () => void): void
+}
+
+declare const test: TestFunction
+
+export { test }
+
+export default test