vimonkey 0.2.0 → 0.2.1

package/dist/fuzz/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fuzz/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAGH,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AAGrE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACtE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAGjG,OAAO,EACL,WAAW,EACX,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,WAAW,GACjB,MAAM,cAAc,CAAA;AAGrB,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,aAAa,CAAA;AAGvG,OAAO,EACL,QAAQ,EACR,SAAS,EACT,gBAAgB,EAChB,UAAU,EACV,UAAU,EACV,eAAe,EACf,KAAK,SAAS,GACf,MAAM,iBAAiB,CAAA;AAGxB,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,SAAS,EACT,YAAY,EACZ,WAAW,EACX,KAAK,YAAY,GAClB,MAAM,cAAc,CAAA"}

package/dist/fuzz/index.js

@@ -1,62 +0,0 @@
-/**
- * Fuzz testing API
- *
- * @example
- * ```typescript
- * import { test, gen, take, createSeededRandom } from 'vimonkey/fuzz'
- *
- * // Simple random from array
- * test('navigation', async () => {
- *   const handle = await run(<Board />, { cols: 80, rows: 24 })
- *   for await (const key of take(gen(['j','k','h','l']), 100)) {
- *     await handle.press(key)
- *     expect(handle.locator('[data-cursor]').count()).toBe(1)
- *   }
- * })
- *
- * // Weighted random
- * test('weighted', async () => {
- *   for await (const key of take(gen([[40,'j'], [40,'k'], [20,'Enter']]), 100)) {
- *     await handle.press(key)
- *   }
- * })
- *
- * // Stateful with closure
- * test('stateful', async () => {
- *   const handle = await app.run(<Board />)
- *   const random = createSeededRandom(Date.now())
- *
- *   const keys = async function*() {
- *     while (true) {
- *       const state = handle.store.getState()
- *       yield state.cursor === 0 ? random.pick(['j','l']) : random.pick(['j','k','h','l'])
- *     }
- *   }
- *
- *   for await (const key of take(keys(), 100)) {
- *     await handle.press(key)
- *   }
- * })
- *
- * // With auto-tracking and shrinking
- * test.fuzz('cursor invariants', async () => {
- *   for await (const key of take(gen(['j','k']), 100)) {
- *     await handle.press(key)
- *     expect(...)  // On failure: shrinks, saves to __fuzz_cases__/
- *   }
- * })
- * ```
- */
-// Core API
-export { gen, take } from "./gen.js";
-// test.fuzz wrapper
-export { test, FuzzError } from "./test-fuzz.js";
-export { describe, expect, it, beforeAll, afterAll, beforeEach, afterEach } from "./test-fuzz.js";
-// Context (for advanced use)
-export { fuzzContext, getFuzzContext, isInFuzzContext, createFuzzContext, createReplayContext, } from "./context.js";
-// Shrinking (for advanced use)
-export { shrinkSequence, formatShrinkResult } from "./shrink.js";
-// Regression (for advanced use)
-export { saveCase, loadCases, loadCasesForTest, deleteCase, clearCases, getFuzzCasesDir, } from "./regression.js";
-// Re-export random utilities
-export { createSeededRandom, weightedPickFromTuples, parseSeed, parseRepeats, deriveSeeds, } from "../random.js";

package/dist/fuzz/regression.d.ts

@@ -1,47 +0,0 @@
-/**
- * Regression testing - save and load failing sequences
- *
- * Failing fuzz test sequences are saved to __fuzz_cases__/ directory
- * like Jest/Vitest snapshots. On subsequent runs, saved sequences
- * are replayed first to ensure bugs don't regress.
- */
-/** Failure case saved to disk */
-export interface SavedCase {
-    /** Test name */
-    test: string;
-    /** Seed used for generation */
-    seed: number;
-    /** Minimal failing sequence */
-    sequence: unknown[];
-    /** Error message */
-    error: string;
-    /** When the failure was recorded */
-    timestamp: string;
-    /** Original sequence length before shrinking */
-    originalLength?: number;
-}
-/**
- * Get the __fuzz_cases__ directory path for a test file
- */
-export declare function getFuzzCasesDir(testFilePath: string): string;
-/**
- * Save a failing case to __fuzz_cases__/
- */
-export declare function saveCase(testFilePath: string, testName: string, failure: SavedCase): string;
-/**
- * Load all saved cases for a test file
- */
-export declare function loadCases(testFilePath: string): SavedCase[];
-/**
- * Load saved cases for a specific test name
- */
-export declare function loadCasesForTest(testFilePath: string, testName: string): SavedCase[];
-/**
- * Delete a saved case (when bug is fixed)
- */
-export declare function deleteCase(testFilePath: string, filename: string): void;
-/**
- * Clear all saved cases for a test file
- */
-export declare function clearCases(testFilePath: string): void;
-//# sourceMappingURL=regression.d.ts.map

package/dist/fuzz/regression.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"regression.d.ts","sourceRoot":"","sources":["../../src/fuzz/regression.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,iCAAiC;AACjC,MAAM,WAAW,SAAS;IACxB,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,+BAA+B;IAC/B,QAAQ,EAAE,OAAO,EAAE,CAAA;IACnB,oBAAoB;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,oCAAoC;IACpC,SAAS,EAAE,MAAM,CAAA;IACjB,gDAAgD;IAChD,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAI5D;AAgBD;;GAEG;AACH,wBAAgB,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,GAAG,MAAM,CAS3F;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,EAAE,CAe3D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CAEpF;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAMvE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CASrD"}

package/dist/fuzz/regression.js

@@ -1,91 +0,0 @@
-/**
- * Regression testing - save and load failing sequences
- *
- * Failing fuzz test sequences are saved to __fuzz_cases__/ directory
- * like Jest/Vitest snapshots. On subsequent runs, saved sequences
- * are replayed first to ensure bugs don't regress.
- */
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync } from "node:fs";
-import { dirname, join, basename } from "node:path";
-/**
- * Get the __fuzz_cases__ directory path for a test file
- */
-export function getFuzzCasesDir(testFilePath) {
-    const dir = dirname(testFilePath);
-    const file = basename(testFilePath);
-    return join(dir, "__fuzz_cases__", file);
-}
-/**
- * Generate a filename for a saved case
- */
-function getCaseFilename(testName) {
-    // Sanitize test name for filesystem
-    const safe = testName
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-|-$/g, "")
-        .slice(0, 50);
-    const timestamp = Date.now();
-    return `${safe}-${timestamp}.json`;
-}
-/**
- * Save a failing case to __fuzz_cases__/
- */
-export function saveCase(testFilePath, testName, failure) {
-    const dir = getFuzzCasesDir(testFilePath);
-    mkdirSync(dir, { recursive: true });
-    const filename = getCaseFilename(testName);
-    const filepath = join(dir, filename);
-    writeFileSync(filepath, JSON.stringify(failure, null, 2));
-    return filepath;
-}
-/**
- * Load all saved cases for a test file
- */
-export function loadCases(testFilePath) {
-    const dir = getFuzzCasesDir(testFilePath);
-    if (!existsSync(dir))
-        return [];
-    const cases = [];
-    for (const file of readdirSync(dir)) {
-        if (!file.endsWith(".json"))
-            continue;
-        try {
-            const content = readFileSync(join(dir, file), "utf-8");
-            cases.push(JSON.parse(content));
-        }
-        catch {
-            // Skip invalid files
-        }
-    }
-    return cases;
-}
-/**
- * Load saved cases for a specific test name
- */
-export function loadCasesForTest(testFilePath, testName) {
-    return loadCases(testFilePath).filter((c) => c.test === testName);
-}
-/**
- * Delete a saved case (when bug is fixed)
- */
-export function deleteCase(testFilePath, filename) {
-    const dir = getFuzzCasesDir(testFilePath);
-    const filepath = join(dir, filename);
-    if (existsSync(filepath)) {
-        unlinkSync(filepath);
-    }
-}
-/**
- * Clear all saved cases for a test file
- */
-export function clearCases(testFilePath) {
-    const dir = getFuzzCasesDir(testFilePath);
-    if (!existsSync(dir))
-        return;
-    for (const file of readdirSync(dir)) {
-        if (file.endsWith(".json")) {
-            unlinkSync(join(dir, file));
-        }
-    }
-}

package/dist/fuzz/shrink.d.ts

@@ -1,41 +0,0 @@
-/**
- * Shrinking - find minimal failing sequence via delta debugging
- *
- * Uses binary search to reduce a failing sequence to the smallest
- * subsequence that still triggers the failure.
- */
-export interface ShrinkOptions {
-    /** Maximum shrinking attempts (default: 100) */
-    maxAttempts?: number;
-    /** Minimum sequence length to try (default: 1) */
-    minLength?: number;
-}
-export interface ShrinkResult<T> {
-    /** Original sequence */
-    original: T[];
-    /** Shrunk (minimal) sequence */
-    shrunk: T[];
-    /** Number of shrinking attempts made */
-    attempts: number;
-    /** Whether shrinking found a smaller sequence */
-    reduced: boolean;
-}
-/**
- * Shrink a failing sequence to its minimal form
- *
- * Uses delta debugging algorithm:
- * 1. Try removing first half - if still fails, keep only first half
- * 2. Try removing second half - if still fails, keep only second half
- * 3. Try removing individual elements from start/end
- * 4. Repeat until no reduction possible
- *
- * @param sequence - The original failing sequence
- * @param runTest - Function that returns true if sequence passes, false if fails
- * @param options - Shrinking options
- */
-export declare function shrinkSequence<T>(sequence: T[], runTest: (seq: T[]) => Promise<boolean>, options?: ShrinkOptions): Promise<ShrinkResult<T>>;
-/**
- * Format shrink result for display
- */
-export declare function formatShrinkResult<T>(result: ShrinkResult<T>): string;
-//# sourceMappingURL=shrink.d.ts.map

package/dist/fuzz/shrink.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shrink.d.ts","sourceRoot":"","sources":["../../src/fuzz/shrink.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,kDAAkD;IAClD,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,wBAAwB;IACxB,QAAQ,EAAE,CAAC,EAAE,CAAA;IACb,gCAAgC;IAChC,MAAM,EAAE,CAAC,EAAE,CAAA;IACX,wCAAwC;IACxC,QAAQ,EAAE,MAAM,CAAA;IAChB,iDAAiD;IACjD,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAAC,CAAC,EACpC,QAAQ,EAAE,CAAC,EAAE,EACb,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,EACvC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CA0D1B;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,MAAM,CASrE"}

package/dist/fuzz/shrink.js

@@ -1,80 +0,0 @@
-/**
- * Shrinking - find minimal failing sequence via delta debugging
- *
- * Uses binary search to reduce a failing sequence to the smallest
- * subsequence that still triggers the failure.
- */
-/**
- * Shrink a failing sequence to its minimal form
- *
- * Uses delta debugging algorithm:
- * 1. Try removing first half - if still fails, keep only first half
- * 2. Try removing second half - if still fails, keep only second half
- * 3. Try removing individual elements from start/end
- * 4. Repeat until no reduction possible
- *
- * @param sequence - The original failing sequence
- * @param runTest - Function that returns true if sequence passes, false if fails
- * @param options - Shrinking options
- */
-export async function shrinkSequence(sequence, runTest, options = {}) {
-    const { maxAttempts = 100, minLength = 1 } = options;
-    let current = [...sequence];
-    let attempts = 0;
-    let changed = true;
-    while (changed && attempts < maxAttempts && current.length > minLength) {
-        changed = false;
-        // Try removing first half
-        if (current.length > 1) {
-            const half = Math.ceil(current.length / 2);
-            const secondHalf = current.slice(half);
-            attempts++;
-            if (secondHalf.length >= minLength && !(await runTest(secondHalf))) {
-                // Second half alone still fails
-                current = secondHalf;
-                changed = true;
-                continue;
-            }
-        }
-        // Try removing second half
-        if (current.length > 1) {
-            const half = Math.floor(current.length / 2);
-            const firstHalf = current.slice(0, half);
-            attempts++;
-            if (firstHalf.length >= minLength && !(await runTest(firstHalf))) {
-                // First half alone still fails
-                current = firstHalf;
-                changed = true;
-                continue;
-            }
-        }
-        // Try removing individual elements
-        for (let i = 0; i < current.length && attempts < maxAttempts; i++) {
-            const without = [...current.slice(0, i), ...current.slice(i + 1)];
-            attempts++;
-            if (without.length >= minLength && !(await runTest(without))) {
-                // Removing element i still fails
-                current = without;
-                changed = true;
-                break;
-            }
-        }
-    }
-    return {
-        original: sequence,
-        shrunk: current,
-        attempts,
-        reduced: current.length < sequence.length,
-    };
-}
-/**
- * Format shrink result for display
- */
-export function formatShrinkResult(result) {
-    const reduction = result.original.length - result.shrunk.length;
-    const percent = Math.round((reduction / result.original.length) * 100);
-    if (!result.reduced) {
-        return `Could not reduce sequence (${result.original.length} steps, ${result.attempts} attempts)`;
-    }
-    return `Shrunk from ${result.original.length} to ${result.shrunk.length} steps (${percent}% reduction, ${result.attempts} attempts)`;
-}

package/dist/fuzz/test-fuzz.d.ts

@@ -1,55 +0,0 @@
-/**
- * test.fuzz wrapper with auto-tracking, shrinking, and regression
- *
- * Usage:
- * ```typescript
- * import { test } from 'vimonkey/fuzz'
- *
- * test.fuzz('cursor invariants', async () => {
- *   const handle = await run(<Board />, { cols: 80, rows: 24 })
- *   for await (const key of take(gen(['j','k','h','l']), 100)) {
- *     await handle.press(key)
- *     expect(handle.locator('[data-cursor]').count()).toBe(1)
- *   }
- * })
- * ```
- */
-import { test as vitestTest, type TestOptions } from "vitest";
-/** Options for test.fuzz */
-export interface FuzzTestOptions extends TestOptions {
-    /** Seed for reproducibility (default: from FUZZ_SEED env or random) */
-    seed?: number;
-    /** Whether to shrink failing sequences (default: true) */
-    shrink?: boolean;
-    /** Whether to save failing sequences to __fuzz_cases__/ (default: true) */
-    save?: boolean;
-    /** Whether to replay saved failing sequences first (default: true) */
-    replay?: boolean;
-    /** Maximum shrinking attempts (default: 100) */
-    maxShrinkAttempts?: number;
-}
-/** Error with fuzz context attached */
-export declare class FuzzError extends Error {
-    readonly sequence: unknown[];
-    readonly seed: number;
-    readonly originalError: Error;
-    constructor(originalError: Error, info: {
-        original: number;
-        shrunk: number;
-        sequence: unknown[];
-        seed: number;
-    });
-}
-type FuzzFn = {
-    (name: string, fn: () => Promise<void>, options?: FuzzTestOptions): void;
-    (name: string, options: FuzzTestOptions, fn: () => Promise<void>): void;
-};
-declare const fuzz: FuzzFn;
-/**
- * Extended test object with fuzz method
- */
-export declare const test: typeof vitestTest & {
-    fuzz: typeof fuzz;
-};
-export { describe, expect, it, beforeAll, afterAll, beforeEach, afterEach } from "vitest";
-//# sourceMappingURL=test-fuzz.d.ts.map

package/dist/fuzz/test-fuzz.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-fuzz.d.ts","sourceRoot":"","sources":["../../src/fuzz/test-fuzz.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,IAAI,IAAI,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,QAAQ,CAAA;AAM7D,4BAA4B;AAC5B,MAAM,WAAW,eAAgB,SAAQ,WAAW;IAClD,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0DAA0D;IAC1D,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,2EAA2E;IAC3E,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,sEAAsE;IACtE,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,gDAAgD;IAChD,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AAED,uCAAuC;AACvC,qBAAa,SAAU,SAAQ,KAAK;IAClC,QAAQ,CAAC,QAAQ,EAAE,OAAO,EAAE,CAAA;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,aAAa,EAAE,KAAK,CAAA;gBAG3B,aAAa,EAAE,KAAK,EACpB,IAAI,EAAE;QACJ,QAAQ,EAAE,MAAM,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;QACd,QAAQ,EAAE,OAAO,EAAE,CAAA;QACnB,IAAI,EAAE,MAAM,CAAA;KACb;CAcJ;AAwJD,KAAK,MAAM,GAAG;IACZ,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,IAAI,CAAA;IACxE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CACxE,CAAA;AAGD,QAAA,MAAM,IAAI,EAAE,MAUX,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,IAAI,EAAE,OAAO,UAAU,GAAG;IAAE,IAAI,EAAE,OAAO,IAAI,CAAA;CAAwC,CAAA;AAGlG,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA"}

package/dist/fuzz/test-fuzz.js

@@ -1,178 +0,0 @@
-/**
- * test.fuzz wrapper with auto-tracking, shrinking, and regression
- *
- * Usage:
- * ```typescript
- * import { test } from 'vimonkey/fuzz'
- *
- * test.fuzz('cursor invariants', async () => {
- *   const handle = await run(<Board />, { cols: 80, rows: 24 })
- *   for await (const key of take(gen(['j','k','h','l']), 100)) {
- *     await handle.press(key)
- *     expect(handle.locator('[data-cursor]').count()).toBe(1)
- *   }
- * })
- * ```
- */
-import { test as vitestTest } from "vitest";
-import { fuzzContext, createFuzzContext, createReplayContext } from "./context.js";
-import { shrinkSequence, formatShrinkResult } from "./shrink.js";
-import { saveCase, loadCasesForTest } from "./regression.js";
-import { parseSeed, parseRepeats, deriveSeeds } from "../random.js";
-/** Error with fuzz context attached */
-export class FuzzError extends Error {
-    sequence;
-    seed;
-    originalError;
-    constructor(originalError, info) {
-        const msg = `Fuzz test failed after ${info.original} steps (shrunk to ${info.shrunk})
-Minimal failing sequence: ${JSON.stringify(info.sequence)}
-Seed: ${info.seed} (reproduce with FUZZ_SEED=${info.seed})
-
-Original error: ${originalError.message}`;
-        super(msg);
-        this.name = "FuzzError";
-        this.sequence = info.sequence;
-        this.seed = info.seed;
-        this.originalError = originalError;
-    }
-}
-/**
- * Get the test file path from error stack
- * This is a heuristic - it looks for .test.ts or .fuzz.ts files
- */
-function getTestFilePath() {
-    const err = new Error();
-    const stack = err.stack?.split("\n") ?? [];
-    for (const line of stack) {
-        // Look for test file patterns
-        const match = line.match(/\(([^)]+\.(test|fuzz)\.(ts|tsx|js|jsx)):\d+:\d+\)/);
-        if (match)
-            return match[1];
-        // Also try without parentheses
-        const match2 = line.match(/at\s+([^\s]+\.(test|fuzz)\.(ts|tsx|js|jsx)):\d+:\d+/);
-        if (match2)
-            return match2[1];
-    }
-    // Fallback to current working directory
-    return process.cwd() + "/unknown.test.ts";
-}
-/**
- * Run a single fuzz test body with a specific seed.
- * Handles replay, shrinking, and saving of failing cases.
- */
-async function runFuzzBody(name, fn, seed, opts) {
-    const testFilePath = getTestFilePath();
-    // Replay saved failing sequences first
-    if (opts.replay) {
-        const savedCases = loadCasesForTest(testFilePath, name);
-        for (const savedCase of savedCases) {
-            const replayCtx = createReplayContext(savedCase.sequence, savedCase.seed);
-            try {
-                await fuzzContext.run(replayCtx, fn);
-                // If replay passes, the bug might be fixed - but we still run the main test
-            }
-            catch (error) {
-                // Replay still fails - throw with saved context
-                throw new FuzzError(error, {
-                    original: savedCase.originalLength ?? savedCase.sequence.length,
-                    shrunk: savedCase.sequence.length,
-                    sequence: savedCase.sequence,
-                    seed: savedCase.seed,
-                });
-            }
-        }
-    }
-    // Run the main fuzz test
-    const ctx = createFuzzContext(seed);
-    try {
-        await fuzzContext.run(ctx, fn);
-    }
-    catch (error) {
-        // Test failed - attempt shrinking
-        if (ctx.history.length > 0) {
-            let minimalSequence = ctx.history;
-            let shrinkResult;
-            if (opts.shrink) {
-                // Define the test runner for shrinking
-                const runWithSequence = async (seq) => {
-                    const replayCtx = createReplayContext(seq, seed);
-                    try {
-                        await fuzzContext.run(replayCtx, fn);
-                        return true; // passed
-                    }
-                    catch {
-                        return false; // still fails
-                    }
-                };
-                shrinkResult = await shrinkSequence(ctx.history, runWithSequence, {
-                    maxAttempts: opts.maxShrinkAttempts,
-                });
-                minimalSequence = shrinkResult.shrunk;
-                // Log shrink result
-                console.log(formatShrinkResult(shrinkResult));
-            }
-            // Save failing case
-            if (opts.save) {
-                const savedCase = {
-                    test: name,
-                    seed,
-                    sequence: minimalSequence,
-                    error: String(error),
-                    timestamp: new Date().toISOString(),
-                    originalLength: ctx.history.length,
-                };
-                const filepath = saveCase(testFilePath, name, savedCase);
-                console.log(`Saved failing case to: ${filepath}`);
-            }
-            throw new FuzzError(error, {
-                original: ctx.history.length,
-                shrunk: minimalSequence.length,
-                sequence: minimalSequence,
-                seed,
-            });
-        }
-        throw error;
-    }
-}
-/**
- * Create the test.fuzz wrapper
- *
- * When FUZZ_REPEATS > 1, registers multiple vitest tests — one per seed —
- * so each gets its own result in the reporter and failures are independently
- * visible. Seeds are deterministically derived from the base seed.
- */
-function createFuzzTest(name, fn, options = {}) {
-    const { seed = parseSeed("env"), shrink = true, save = true, replay = true, maxShrinkAttempts = 100, ...testOptions } = options;
-    const repeats = parseRepeats();
-    const bodyOpts = { shrink, save, replay, maxShrinkAttempts };
-    if (repeats <= 1) {
-        // Single run (default) — original behavior
-        return vitestTest(name, testOptions, async () => {
-            await runFuzzBody(name, fn, seed, bodyOpts);
-        });
-    }
-    // Multiple runs — register one test per seed
-    const seeds = deriveSeeds(seed, repeats);
-    for (let i = 0; i < seeds.length; i++) {
-        const s = seeds[i];
-        vitestTest(`${name} [seed=${s}]`, testOptions, async () => {
-            await runFuzzBody(name, fn, s, bodyOpts);
-        });
-    }
-}
-// Create the fuzz function with overloads
-const fuzz = (name, fnOrOptions, optionsOrFn) => {
-    if (typeof fnOrOptions === "function") {
-        return createFuzzTest(name, fnOrOptions, optionsOrFn);
-    }
-    else {
-        return createFuzzTest(name, optionsOrFn, fnOrOptions);
-    }
-};
-/**
- * Extended test object with fuzz method
- */
-export const test = Object.assign(vitestTest, { fuzz });
-// Re-export vitest test types
-export { describe, expect, it, beforeAll, afterAll, beforeEach, afterEach } from "vitest";

package/dist/index.d.ts

@@ -1,12 +0,0 @@
-/**
- * vimonkey — Fuzz testing and chaos streams for Vitest
- */
-export { gen, take, type Picker, type PickerContext } from "./fuzz/gen.js";
-export { test, FuzzError, type FuzzTestOptions } from "./fuzz/test-fuzz.js";
-export { describe, expect, it, beforeAll, afterAll, beforeEach, afterEach } from "./fuzz/test-fuzz.js";
-export { fuzzContext, getFuzzContext, isInFuzzContext, createFuzzContext, createReplayContext, type FuzzContext, } from "./fuzz/context.js";
-export { shrinkSequence, formatShrinkResult, type ShrinkOptions, type ShrinkResult } from "./fuzz/shrink.js";
-export { saveCase, loadCases, loadCasesForTest, deleteCase, clearCases, getFuzzCasesDir, type SavedCase, } from "./fuzz/regression.js";
-export { createSeededRandom, weightedPickFromTuples, parseSeed, parseRepeats, deriveSeeds, type SeededRandom, } from "./random.js";
-export { getTestSys, type TestSys } from "./env.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,MAAM,eAAe,CAAA;AAC1E,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAA;AAC3E,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACtG,OAAO,EACL,WAAW,EACX,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,WAAW,GACjB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,KAAK,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC5G,OAAO,EACL,QAAQ,EACR,SAAS,EACT,gBAAgB,EAChB,UAAU,EACV,UAAU,EACV,eAAe,EACf,KAAK,SAAS,GACf,MAAM,sBAAsB,CAAA;AAG7B,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,SAAS,EACT,YAAY,EACZ,WAAW,EACX,KAAK,YAAY,GAClB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,UAAU,EAAE,KAAK,OAAO,EAAE,MAAM,UAAU,CAAA"}

package/dist/index.js

@@ -1,13 +0,0 @@
-/**
- * vimonkey — Fuzz testing and chaos streams for Vitest
- */
-// Fuzz API (primary)
-export { gen, take } from "./fuzz/gen.js";
-export { test, FuzzError } from "./fuzz/test-fuzz.js";
-export { describe, expect, it, beforeAll, afterAll, beforeEach, afterEach } from "./fuzz/test-fuzz.js";
-export { fuzzContext, getFuzzContext, isInFuzzContext, createFuzzContext, createReplayContext, } from "./fuzz/context.js";
-export { shrinkSequence, formatShrinkResult } from "./fuzz/shrink.js";
-export { saveCase, loadCases, loadCasesForTest, deleteCase, clearCases, getFuzzCasesDir, } from "./fuzz/regression.js";
-// Utilities
-export { createSeededRandom, weightedPickFromTuples, parseSeed, parseRepeats, deriveSeeds, } from "./random.js";
-export { getTestSys } from "./env.js";