@mutineerjs/mutineer 0.1.0

package/dist/mutators/__tests__/registry.spec.js

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import { getRegistry } from '../registry.js';
+const ALL_NAMES = [
+    'relaxLE',
+    'relaxGE',
+    'tightenLT',
+    'tightenGT',
+    'andToOr',
+    'orToAnd',
+    'nullishToOr',
+    'flipEQ',
+    'flipNEQ',
+    'flipStrictEQ',
+    'flipStrictNEQ',
+    'addToSub',
+    'subToAdd',
+    'mulToDiv',
+    'divToMul',
+    'modToMul',
+    'powerToMul',
+];
+describe('mutator registry', () => {
+    it('returns all mutators by default in declared order', () => {
+        const all = getRegistry().map((m) => m.name);
+        expect(all).toEqual([...ALL_NAMES]);
+    });
+    it('can include only specified mutators', () => {
+        const only = getRegistry(['andToOr', 'flipEQ', 'subToAdd']).map((m) => m.name);
+        expect(only).toEqual(['andToOr', 'flipEQ', 'subToAdd']);
+    });
+    it('can exclude specific mutators', () => {
+        const filtered = getRegistry(undefined, [
+            'flipEQ',
+            'relaxGE',
+            'modToMul',
+        ]).map((m) => m.name);
+        expect(filtered).toEqual(ALL_NAMES.filter((n) => !['flipEQ', 'relaxGE', 'modToMul'].includes(n)));
+    });
+    it('exclude still filters after include selection', () => {
+        const filtered = getRegistry(['flipEQ', 'relaxGE', 'nullishToOr'], ['flipEQ']).map((m) => m.name);
+        expect(filtered).toEqual(['relaxGE', 'nullishToOr']);
+    });
+});

package/dist/mutators/__tests__/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mutators/__tests__/utils.spec.js

@@ -0,0 +1,15 @@
+import { describe, it, expect } from 'vitest';
+import { collectOperatorTargets } from '../utils.js';
+describe('collectOperatorTargets', () => {
+    it('honors mutineer disable comments', () => {
+        const src = `// mutineer-disable-next-line
+const a = b && c
+const b = c && d // mutineer-disable-line
+const c = d && e /* mutineer-disable */
+const d = e && f
+`;
+        const targets = collectOperatorTargets(src, '&&');
+        const lines = targets.map((t) => t.line);
+        expect(lines).toEqual([5]);
+    });
+});

package/dist/mutators/registry.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Mutator registry and factory.
+ *
+ * Provides functions to create operator mutators and retrieve registered mutators
+ * with optional include/exclude filtering.
+ */
+import type { ASTMutator } from './types.js';
+export declare const relaxLE: ASTMutator;
+export declare const relaxGE: ASTMutator;
+export declare const tightenLT: ASTMutator;
+export declare const tightenGT: ASTMutator;
+export declare const andToOr: ASTMutator;
+export declare const orToAnd: ASTMutator;
+export declare const nullishToOr: ASTMutator;
+export declare const flipEQ: ASTMutator;
+export declare const flipNEQ: ASTMutator;
+export declare const flipStrictEQ: ASTMutator;
+export declare const flipStrictNEQ: ASTMutator;
+export declare const addToSub: ASTMutator;
+export declare const subToAdd: ASTMutator;
+export declare const mulToDiv: ASTMutator;
+export declare const divToMul: ASTMutator;
+export declare const modToMul: ASTMutator;
+export declare const powerToMul: ASTMutator;
+/**
+ * Get a filtered registry of mutators based on include/exclude options.
+ *
+ * If include list provided, only those mutators are returned.
+ * If exclude list provided, those mutators are filtered out.
+ * Include list takes precedence over exclude list.
+ *
+ * @param include - Optional list of mutator names to include
+ * @param exclude - Optional list of mutator names to exclude
+ * @returns Filtered array of mutators
+ */
+export declare function getRegistry(include?: readonly string[], exclude?: readonly string[]): ASTMutator[];
+export type { ASTMutator, AnyMutator, MutationOutput } from './types.js';

package/dist/mutators/registry.js

@@ -0,0 +1,101 @@
+/**
+ * Mutator registry and factory.
+ *
+ * Provides functions to create operator mutators and retrieve registered mutators
+ * with optional include/exclude filtering.
+ */
+import { collectOperatorTargets } from './utils.js';
+/**
+ * Factory to build an operator mutator using AST traversal and token analysis.
+ * Creates a reusable mutator that finds and replaces a specific operator throughout the code.
+ *
+ * @param name - Name of the mutator (e.g., 'andToOr')
+ * @param description - Human-readable description
+ * @param fromOp - The operator to find (e.g., '&&')
+ * @param toOp - The operator to replace it with (e.g., '||')
+ * @returns An ASTMutator that applies this transformation
+ */
+function makeOperatorMutator(name, description, fromOp, toOp) {
+    return {
+        name,
+        description,
+        apply(src) {
+            // 1) Collect exact operator token locations from matching nodes
+            const targets = collectOperatorTargets(src, fromOp);
+            // 2) For each occurrence, produce a mutated version of the programme
+            const outputs = [];
+            for (const target of targets) {
+                const code = src.slice(0, target.start) + toOp + src.slice(target.end);
+                outputs.push({
+                    line: target.line,
+                    col: target.col1,
+                    code,
+                });
+            }
+            return outputs;
+        },
+    };
+}
+/* === Concrete mutators (AST-safe) === */
+export const relaxLE = makeOperatorMutator('relaxLE', "Change '<=' to '<' (relax boundary)", '<=', '<');
+export const relaxGE = makeOperatorMutator('relaxGE', "Change '>=' to '>' (relax boundary)", '>=', '>');
+export const tightenLT = makeOperatorMutator('tightenLT', "Change '<' to '<=' (tighten boundary)", '<', '<=');
+export const tightenGT = makeOperatorMutator('tightenGT', "Change '>' to '>=' (tighten boundary)", '>', '>=');
+export const andToOr = makeOperatorMutator('andToOr', "Change '&&' to '||' in boolean expressions", '&&', '||');
+export const orToAnd = makeOperatorMutator('orToAnd', "Change '||' to '&&' in boolean expressions", '||', '&&');
+export const nullishToOr = makeOperatorMutator('nullishToOr', "Change '??' to '||' to prefer boolean fallback", '??', '||');
+export const flipEQ = makeOperatorMutator('flipEQ', "Change '==' to '!='", '==', '!=');
+export const flipNEQ = makeOperatorMutator('flipNEQ', "Change '!=' to '=='", '!=', '==');
+export const flipStrictEQ = makeOperatorMutator('flipStrictEQ', "Change '===' to '!=='", '===', '!==');
+export const flipStrictNEQ = makeOperatorMutator('flipStrictNEQ', "Change '!==' to '==='", '!==', '===');
+export const addToSub = makeOperatorMutator('addToSub', "Change '+' to '-' in arithmetic expressions", '+', '-');
+export const subToAdd = makeOperatorMutator('subToAdd', "Change '-' to '+' in arithmetic expressions", '-', '+');
+export const mulToDiv = makeOperatorMutator('mulToDiv', "Change '*' to '/' in arithmetic expressions", '*', '/');
+export const divToMul = makeOperatorMutator('divToMul', "Change '/' to '*' in arithmetic expressions", '/', '*');
+export const modToMul = makeOperatorMutator('modToMul', "Change '%' to '*' in arithmetic expressions", '%', '*');
+export const powerToMul = makeOperatorMutator('powerToMul', "Change '**' to '*' in arithmetic expressions", '**', '*');
+/**
+ * All registered mutators in order of precedence.
+ */
+const ALL = [
+    relaxLE,
+    relaxGE,
+    tightenLT,
+    tightenGT,
+    andToOr,
+    orToAnd,
+    nullishToOr,
+    flipEQ,
+    flipNEQ,
+    flipStrictEQ,
+    flipStrictNEQ,
+    addToSub,
+    subToAdd,
+    mulToDiv,
+    divToMul,
+    modToMul,
+    powerToMul,
+];
+/**
+ * Get a filtered registry of mutators based on include/exclude options.
+ *
+ * If include list provided, only those mutators are returned.
+ * If exclude list provided, those mutators are filtered out.
+ * Include list takes precedence over exclude list.
+ *
+ * @param include - Optional list of mutator names to include
+ * @param exclude - Optional list of mutator names to exclude
+ * @returns Filtered array of mutators
+ */
+export function getRegistry(include, exclude) {
+    let list = ALL;
+    // If include list provided, filter to only those mutators
+    if (include?.length) {
+        list = list.filter((m) => include.includes(m.name));
+    }
+    // If exclude list provided, remove those mutators
+    if (exclude?.length) {
+        list = list.filter((m) => !exclude.includes(m.name));
+    }
+    return list;
+}

package/dist/mutators/types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Type definitions for mutation strategies.
+ *
+ * Defines the interface that all mutators must implement and the output format
+ * for mutations. This allows for different mutator implementations to be plugged in.
+ */
+/**
+ * Output of a single mutation, including location info and mutated code.
+ */
+export interface MutationOutput {
+    readonly line: number;
+    readonly col: number;
+    readonly code: string;
+}
+/**
+ * Base interface for AST-based mutators.
+ * Implementations should parse source code and generate mutations by analyzing the AST.
+ */
+export interface ASTMutator {
+    readonly name: string;
+    readonly description: string;
+    apply(src: string): readonly MutationOutput[];
+}
+/**
+ * Union type for different mutator kinds.
+ * Potentially extensible in future to RegexMutator, TextMutator, etc.
+ */
+export type AnyMutator = ASTMutator;
+/**
+ * Internal interface for operator target locations.
+ * Used by operator mutators to track exact positions of operators in source code.
+ */
+export interface OperatorTarget {
+    readonly start: number;
+    readonly end: number;
+    readonly line: number;
+    readonly col1: number;
+    readonly op: string;
+}

package/dist/mutators/types.js

@@ -0,0 +1,7 @@
+/**
+ * Type definitions for mutation strategies.
+ *
+ * Defines the interface that all mutators must implement and the output format
+ * for mutations. This allows for different mutator implementations to be plugged in.
+ */
+export {};

package/dist/mutators/utils.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Shared utilities for AST-based mutation.
+ *
+ * Provides functions for parsing, traversing, and analyzing code ASTs.
+ * These utilities are used by operator mutators to locate and replace operators.
+ */
+import * as t from '@babel/types';
+import type { OperatorTarget } from './types.js';
+export declare const traverse: typeof import('@babel/traverse').default;
+/**
+ * Tab width used for converting character columns to visual columns.
+ * This helps report correct column positions for terminals that render tabs.
+ */
+export declare const TAB_WIDTH = 4;
+/**
+ * Convert a character-based column offset to a visual column, accounting for tabs.
+ * For example, a tab at the start of a line counts as multiple spaces visually.
+ *
+ * @param src - The source code
+ * @param charOffset - The character offset (0-based)
+ * @returns The visual column (1-based)
+ */
+export declare function getVisualColumn(src: string, charOffset: number): number;
+/**
+ * Type guard to check if a node is a BinaryExpression or LogicalExpression.
+ */
+export declare function isBinaryOrLogical(node: t.Node): node is t.BinaryExpression | t.LogicalExpression;
+/**
+ * Collect the operator tokens for a given operator and return their exact locations.
+ * Uses AST traversal to find BinaryExpression/LogicalExpression nodes, then maps them
+ * to token positions for accurate column reporting.
+ *
+ * @param src - The source code
+ * @param opValue - The operator to search for (e.g., '&&', '<=')
+ * @returns Array of target locations for the operator
+ */
+export declare function collectOperatorTargets(src: string, opValue: string): OperatorTarget[];

package/dist/mutators/utils.js

@@ -0,0 +1,151 @@
+/**
+ * Shared utilities for AST-based mutation.
+ *
+ * Provides functions for parsing, traversing, and analyzing code ASTs.
+ * These utilities are used by operator mutators to locate and replace operators.
+ */
+import { parse } from '@babel/parser';
+import traverseModule from '@babel/traverse';
+// Normalize the default export shape of @babel/traverse
+const traverseModuleNormalized = traverseModule;
+export const traverse = traverseModuleNormalized.default ?? traverseModuleNormalized;
+/**
+ * Parser configuration for Babel.
+ * Enables support for TypeScript, JSX, decorators, and modern JavaScript features.
+ */
+const parserOptsTs = {
+    sourceType: 'unambiguous',
+    plugins: [
+        'typescript',
+        'jsx',
+        ['decorators', { decoratorsBeforeExport: true }],
+        'classProperties',
+        'classPrivateProperties',
+        'classPrivateMethods',
+        'objectRestSpread',
+        'optionalChaining',
+        'nullishCoalescingOperator',
+    ],
+    tokens: true,
+};
+const parserOptsFlow = {
+    sourceType: 'unambiguous',
+    plugins: [
+        'flow',
+        'flowComments',
+        'jsx',
+        ['decorators', { decoratorsBeforeExport: true }],
+        'classProperties',
+        'classPrivateProperties',
+        'classPrivateMethods',
+        'objectRestSpread',
+        'optionalChaining',
+        'nullishCoalescingOperator',
+    ],
+    tokens: true,
+};
+/**
+ * Tab width used for converting character columns to visual columns.
+ * This helps report correct column positions for terminals that render tabs.
+ */
+export const TAB_WIDTH = 4;
+/**
+ * Convert a character-based column offset to a visual column, accounting for tabs.
+ * For example, a tab at the start of a line counts as multiple spaces visually.
+ *
+ * @param src - The source code
+ * @param charOffset - The character offset (0-based)
+ * @returns The visual column (1-based)
+ */
+export function getVisualColumn(src, charOffset) {
+    const lineStartIdx = src.lastIndexOf('\n', charOffset - 1) + 1;
+    const linePrefix = src.slice(lineStartIdx, charOffset);
+    let visualCol = 1;
+    for (const ch of linePrefix) {
+        if (ch === '\t') {
+            // Advance to next tab stop (multiples of TAB_WIDTH)
+            const nextStop = (Math.floor((visualCol - 1) / TAB_WIDTH) + 1) * TAB_WIDTH + 1;
+            visualCol = nextStop;
+        }
+        else {
+            visualCol++;
+        }
+    }
+    return visualCol;
+}
+/**
+ * Type guard to check if a node is a BinaryExpression or LogicalExpression.
+ */
+export function isBinaryOrLogical(node) {
+    return node.type === 'BinaryExpression' || node.type === 'LogicalExpression';
+}
+/**
+ * Collect the operator tokens for a given operator and return their exact locations.
+ * Uses AST traversal to find BinaryExpression/LogicalExpression nodes, then maps them
+ * to token positions for accurate column reporting.
+ *
+ * @param src - The source code
+ * @param opValue - The operator to search for (e.g., '&&', '<=')
+ * @returns Array of target locations for the operator
+ */
+export function collectOperatorTargets(src, opValue) {
+    let ast;
+    try {
+        ast = parse(src, parserOptsTs);
+    }
+    catch {
+        // Flow-typed React sources fail under TS parsing; fall back to Flow plugins.
+        ast = parse(src, parserOptsFlow);
+    }
+    const fileAst = ast;
+    const tokens = fileAst.tokens ?? [];
+    const comments = fileAst.comments ?? [];
+    const out = [];
+    const ignoreLines = new Set();
+    for (const comment of comments) {
+        const text = comment.value.trim();
+        if (!text)
+            continue;
+        if (!comment.loc)
+            continue;
+        const startLine = comment.loc.start.line;
+        const endLine = comment.loc.end.line;
+        if (text.includes('mutineer-disable-next-line')) {
+            ignoreLines.add(endLine + 1);
+        }
+        if (text.includes('mutineer-disable-line') ||
+            text.includes('mutineer-disable')) {
+            for (let line = startLine; line <= endLine; line++) {
+                ignoreLines.add(line);
+            }
+        }
+    }
+    traverse(ast, {
+        enter(p) {
+            if (!isBinaryOrLogical(p.node))
+                return;
+            const n = p.node;
+            if (n.operator !== opValue)
+                return;
+            // Find the exact operator token inside the node span
+            const nodeStart = n.start ?? 0;
+            const nodeEnd = n.end ?? 0;
+            const tok = tokens.find((tk) => tk.start >= nodeStart && tk.end <= nodeEnd && tk.value === opValue);
+            if (tok) {
+                // Convert Babel's character-based column to a visual column for accurate reporting
+                const line = tok.loc.start.line;
+                if (ignoreLines.has(line))
+                    return;
+                const visualCol = getVisualColumn(src, tok.start);
+                out.push({
+                    start: tok.start,
+                    end: tok.end,
+                    line,
+                    col1: visualCol, // convert to 1-based
+                    op: opValue,
+                });
+            }
+        },
+    });
+    return out;
+}

package/dist/plugin/viteMutate.d.ts

@@ -0,0 +1,15 @@
+import type { PluginOption } from 'vite';
+/**
+ * Vite plugin that intercepts module loading during mutation testing.
+ *
+ * When MUTATE_FILE and MUTATE_CODE environment variables are set, this plugin
+ * will replace the target file's code with the mutated version. This allows
+ * vitest to run tests against each mutation variant.
+ *
+ * Environment Variables:
+ * - MUTATE_FILE: Absolute path to the file being mutated
+ * - MUTATE_CODE: The mutated source code to inject
+ *
+ * @returns Vite plugin option
+ */
+export declare function viteMutineerPlugin(): PluginOption;

package/dist/plugin/viteMutate.js

@@ -0,0 +1,52 @@
+import path from 'node:path';
+/**
+ * Vite plugin that intercepts module loading during mutation testing.
+ *
+ * When MUTATE_FILE and MUTATE_CODE environment variables are set, this plugin
+ * will replace the target file's code with the mutated version. This allows
+ * vitest to run tests against each mutation variant.
+ *
+ * Environment Variables:
+ * - MUTATE_FILE: Absolute path to the file being mutated
+ * - MUTATE_CODE: The mutated source code to inject
+ *
+ * @returns Vite plugin option
+ */
+export function viteMutineerPlugin() {
+    // Normalize and cache the target path during initialization
+    const mutateFile = process.env.MUTATE_FILE;
+    const mutateCode = process.env.MUTATE_CODE;
+    let normalizedTarget = null;
+    if (mutateFile) {
+        try {
+            normalizedTarget = path.resolve(mutateFile);
+        }
+        catch (err) {
+            console.warn(`[mutineer] Failed to resolve MUTATE_FILE: ${mutateFile}`, err);
+        }
+    }
+    return {
+        name: 'mutineer:swap',
+        enforce: 'pre',
+        load(id) {
+            // Early exit if no mutation is active
+            if (!normalizedTarget || !mutateCode) {
+                return null;
+            }
+            // Normalize the module ID, handling query strings
+            const cleanId = id.split('?')[0];
+            let normalizedId;
+            try {
+                normalizedId = path.resolve(cleanId);
+            }
+            catch {
+                return null;
+            }
+            // Return mutated code only if this is the target file
+            if (normalizedId === normalizedTarget) {
+                return mutateCode;
+            }
+            return null;
+        }
+    };
+}

package/dist/plugin/vitest.setup.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Vitest setup file that decorates test titles with mutation metadata.
+ *
+ * When a mutation is active (MUTATE_ACTIVE=1), this file wraps the global
+ * test functions (it, test, describe) to append mutation labels to test titles.
+ * This helps identify which mutation caused which test failures in the output.
+ *
+ * Environment Variables:
+ * - MUTATE_ACTIVE: Set to '1' to enable mutation decoration
+ * - MUTATE_ID: Unique identifier for the mutation (e.g., 'relaxLE#0')
+ * - MUTATE_NAME: Human-readable name of the mutation (e.g., 'relaxLE')
+ *
+ * Example output: "should validate input @relaxLE#0 relaxLE"
+ */
+declare const active: boolean;
+declare const id: string;
+declare const mutationName: string;
+declare const label: string;
+/**
+ * Appends mutation label to test title if not already present.
+ */
+declare function decorateTitle(title: unknown): unknown;
+type ItLike = typeof it;
+type DescribeLike = typeof describe;
+type AnyCallable = (...args: any[]) => unknown;
+type Chainers = 'skip' | 'only' | 'todo' | 'concurrent' | 'sequential' | 'fails' | 'retry' | 'runIf' | 'skipIf';
+type ChainableRecord = {
+    each?: AnyCallable;
+} & Partial<Record<Chainers, AnyCallable>>;
+type ChainableCallable = AnyCallable & ChainableRecord;
+/** Chainers that need to be forwarded from original to wrapped callable. */
+declare const CHAINERS: readonly Chainers[];
+/**
+ * Helper to attach .each(...) method to a callable.
+ * Ensures title decoration applies to parameterized tests.
+ */
+declare function attachEachMethod(callable: AnyCallable, each: AnyCallable): AnyCallable;
+/**
+ * Wraps a test function (it/test/describe) to decorate titles with mutation metadata.
+ * Preserves all chainers, static properties, and symbols from the original function.
+ */
+declare function wrapCallable<T extends AnyCallable>(original: T): T;
+declare const g: typeof globalThis & {
+    it?: ItLike;
+    test?: ItLike;
+    describe?: DescribeLike;
+};

package/dist/plugin/vitest.setup.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Vitest setup file that decorates test titles with mutation metadata.
+ *
+ * When a mutation is active (MUTATE_ACTIVE=1), this file wraps the global
+ * test functions (it, test, describe) to append mutation labels to test titles.
+ * This helps identify which mutation caused which test failures in the output.
+ *
+ * Environment Variables:
+ * - MUTATE_ACTIVE: Set to '1' to enable mutation decoration
+ * - MUTATE_ID: Unique identifier for the mutation (e.g., 'relaxLE#0')
+ * - MUTATE_NAME: Human-readable name of the mutation (e.g., 'relaxLE')
+ *
+ * Example output: "should validate input @relaxLE#0 relaxLE"
+ */
+const active = process.env.MUTATE_ACTIVE === '1';
+// Early exit if mutation is not active
+if (!active) {
+    process.exit(0);
+}
+const id = process.env.MUTATE_ID || '';
+const mutationName = process.env.MUTATE_NAME || '';
+const label = `@${id} ${mutationName}`;
+/**
+ * Appends mutation label to test title if not already present.
+ */
+function decorateTitle(title) {
+    return typeof title === 'string' && !title.includes(label)
+        ? `${title} ${label}`
+        : title;
+}
+/** Chainers that need to be forwarded from original to wrapped callable. */
+const CHAINERS = [
+    'skip',
+    'only',
+    'todo',
+    'concurrent',
+    'sequential',
+    'fails',
+    'retry',
+    'runIf',
+    'skipIf'
+];
+/**
+ * Helper to attach .each(...) method to a callable.
+ * Ensures title decoration applies to parameterized tests.
+ */
+function attachEachMethod(callable, each) {
+    return ((...tableArgs) => {
+        const chain = each(...tableArgs);
+        return (title, fn, timeout) => chain(decorateTitle(title), fn, timeout);
+    });
+}
+/**
+ * Wraps a test function (it/test/describe) to decorate titles with mutation metadata.
+ * Preserves all chainers, static properties, and symbols from the original function.
+ */
+function wrapCallable(original) {
+    // Base wrapper that decorates the title
+    const wrapped = ((title, fn, timeout) => {
+        return original(decorateTitle(title), fn, timeout);
+    });
+    const wrappedChainable = wrapped;
+    const originalChainable = original;
+    // Forward chainers (skip, only, todo, etc.)
+    for (const key of CHAINERS) {
+        const method = originalChainable[key];
+        if (typeof method !== 'function')
+            continue;
+        const forwarded = ((...args) => method.apply(original, args));
+        wrappedChainable[key] = forwarded;
+        // Attach .each(...) to chainers that support it
+        const each = method.each;
+        if (typeof each === 'function') {
+            forwarded.each = attachEachMethod(forwarded, each);
+        }
+    }
+    // Attach top-level .each(...)
+    const topEach = originalChainable.each;
+    if (typeof topEach === 'function') {
+        wrappedChainable.each = attachEachMethod(wrapped, topEach);
+    }
+    // Preserve static properties and symbols from original
+    const wrappedRecord = wrapped;
+    for (const key of Object.getOwnPropertyNames(original)) {
+        if (key in wrappedRecord)
+            continue;
+        try {
+            const desc = Object.getOwnPropertyDescriptor(original, key);
+            if (desc)
+                Object.defineProperty(wrapped, key, desc);
+        }
+        catch {
+            // Silently skip properties that cannot be copied
+        }
+    }
+    for (const sym of Object.getOwnPropertySymbols(original)) {
+        if (sym in wrappedRecord)
+            continue;
+        try {
+            const desc = Object.getOwnPropertyDescriptor(original, sym);
+            if (desc)
+                Object.defineProperty(wrapped, sym, desc);
+        }
+        catch {
+            // Silently skip symbols that cannot be copied
+        }
+    }
+    return wrapped;
+}
+// Wrap global test functions
+const g = globalThis;
+if (g.it)
+    g.it = wrapCallable(g.it);
+if (g.test)
+    g.test = wrapCallable(g.test);
+if (g.describe)
+    g.describe = wrapCallable(g.describe);