type-a-bin 0.1.1 → 0.1.3

package/dist/mock-bin-behaviour.d.ts

@@ -0,0 +1,84 @@
+import type { MockBinCleanup } from "./mock-bin.js";
+interface MockBinRecordOptions {
+    /**
+     * Read stdin to end-of-file and record it as `call.stdin`. Off by
+     * default: a mock that drains stdin waits for the caller to close it.
+     */
+    stdin?: boolean;
+}
+interface MockBinLifetimeOptions {
+    /** How long to stay alive before exiting, in ms. Default 120000. */
+    lifetimeMs?: number;
+}
+interface MockBinBehaviour {
+    /**
+     * Record every invocation for `handle.calls`. On by default; pass
+     * `false` to skip recording, or `{ stdin: true }` to capture stdin
+     * as well.
+     */
+    record?: boolean | MockBinRecordOptions;
+    /** Line(s) written to stdout, each followed by a newline. */
+    stdout?: string | readonly string[];
+    /** Line(s) written to stderr, after the stdout lines. */
+    stderr?: string | readonly string[];
+    /** Exit code the mock finishes with. Default 0. */
+    exitCode?: number;
+    /** Delay before the mock writes anything, in milliseconds. */
+    delayMs?: number;
+    /**
+     * Gap between stdout lines, in milliseconds, so a consumer tailing
+     * the stream sees them arrive one at a time instead of in one burst.
+     */
+    lineDelayMs?: number;
+    /**
+     * Spawn a long-lived descendant in the mock's process group and
+     * record its pid as `call.childPid`, so a test can prove a stop reaps
+     * the whole process tree rather than the mock alone.
+     */
+    spawnChild?: boolean | MockBinLifetimeOptions;
+    /**
+     * Ignore SIGINT and SIGTERM, so stopping the mock has to escalate to
+     * SIGKILL. The mock then runs until it is killed, or until its
+     * lifetime runs out — the bound keeps a mock a test forgets to stop
+     * from outliving the suite.
+     */
+    trapSignals?: boolean | MockBinLifetimeOptions;
+}
+interface MockBinCall {
+    /** Arguments the mock was invoked with, excluding the binary name. */
+    args: string[];
+    /** Working directory the mock ran in. */
+    cwd: string;
+    /** Environment the mock ran with. */
+    env: Record<string, string>;
+    /** Process id of the mock itself. */
+    pid: number;
+    /** Stdin, when the behaviour recorded it. */
+    stdin?: string;
+    /** Pid of the descendant, when the behaviour spawned one. */
+    childPid?: number;
+}
+/**
+ * The cleanup function every `mockBin` call returns, carrying the
+ * invocations a scripted behaviour recorded. `calls` is read fresh on
+ * every access — a still-running mock shows up as soon as it has been
+ * recorded — and keeps serving the last reading after cleanup.
+ */
+type MockBinHandle = MockBinCleanup & {
+    readonly calls: MockBinCall[];
+};
+/**
+ * Compiles a behaviour into the mock's script, creating the directory
+ * its invocations are recorded into when recording is on.
+ */
+declare const prepareBehaviour: (binName: string, pattern: string | undefined, behaviour: MockBinBehaviour) => Promise<{
+    code: string;
+    recordDir: string | undefined;
+}>;
+/**
+ * Turns a cleanup function into the handle a scripted behaviour
+ * returns. Cleanup snapshots the recorded calls before removing the
+ * record directory, so assertions still read after teardown.
+ */
+declare const withCalls: (cleanup: MockBinCleanup, recordDir: string | undefined) => MockBinHandle;
+export { type MockBinBehaviour, type MockBinCall, type MockBinHandle, type MockBinLifetimeOptions, type MockBinRecordOptions, prepareBehaviour, withCalls, };

package/dist/mock-bin-behaviour.js

@@ -0,0 +1,109 @@
+import { readdirSync, readFileSync, rmSync } from "node:fs";
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+// Test-side half of the scripted-behaviour convention: it compiles a
+// MockBinBehaviour into the tiny node mock that mock-bin installs, and
+// reads back the invocations that mock recorded. The behaviour itself
+// runs in the mocked binary's process — see mock-bin-behaviour-runtime.
+/** Default life of a mock kept alive on purpose, and of its child. */
+const LIFETIME_MS = 120_000;
+// The runtime twin ships next to this module: the .js build in the
+// published package, the .ts source when tests run from source (node
+// strips the types in the spawned mock process).
+const ownPath = fileURLToPath(import.meta.url);
+const runtimeUrl = pathToFileURL(path.join(path.dirname(ownPath), `mock-bin-behaviour-runtime${path.extname(ownPath)}`)).href;
+const toLines = (value) => {
+    if (value === undefined)
+        return [];
+    return typeof value === "string" ? [value] : [...value];
+};
+const toLifetimeMs = (option) => {
+    if (option === undefined || option === false)
+        return undefined;
+    if (option === true)
+        return LIFETIME_MS;
+    return option.lifetimeMs ?? LIFETIME_MS;
+};
+/**
+ * Builds the mock script: a bootstrap that imports the runtime twin by
+ * absolute URL and hands it the scripted behaviour. Keeping the logic
+ * in a real module — rather than generating it as source — leaves it
+ * type-checked and linted, and the dynamic import runs the same from
+ * the extensionless POSIX mock and the Windows `.cjs` shim entry, both
+ * of which node parses as CommonJS.
+ */
+const bootstrapCode = (script) => `import(${JSON.stringify(runtimeUrl)}).then((runtime) =>\n` +
+    `  runtime.runMockBehaviour(${JSON.stringify(script)}),\n);\n`;
+/**
+ * Compiles a behaviour into the mock's script, creating the directory
+ * its invocations are recorded into when recording is on.
+ */
+const prepareBehaviour = async (binName, pattern, behaviour) => {
+    const record = behaviour.record ?? true;
+    const recordDir = record === false
+        ? undefined
+        : await mkdtemp(path.join(tmpdir(), "type-a-bin-calls-"));
+    const spawnChildMs = toLifetimeMs(behaviour.spawnChild);
+    const trapSignalsMs = toLifetimeMs(behaviour.trapSignals);
+    const script = {
+        binName,
+        stdout: toLines(behaviour.stdout),
+        stderr: toLines(behaviour.stderr),
+        exitCode: behaviour.exitCode ?? 0,
+        delayMs: behaviour.delayMs ?? 0,
+        lineDelayMs: behaviour.lineDelayMs ?? 0,
+        recordStdin: typeof record === "object" && record.stdin === true,
+        ...(pattern === undefined ? {} : { pattern }),
+        ...(recordDir === undefined ? {} : { recordDir }),
+        ...(spawnChildMs === undefined ? {} : { spawnChildMs }),
+        ...(trapSignalsMs === undefined ? {} : { trapSignalsMs }),
+    };
+    return { code: bootstrapCode(script), recordDir };
+};
+/**
+ * Reads the recorded invocations in the order the mock was called: the
+ * runtime numbers each record as it claims a slot. A claimed-but-empty
+ * slot is skipped, and the `.json` suffix filters out records still
+ * being written to their `.pending` sidecar.
+ */
+const readCalls = (recordDir) => readdirSync(recordDir)
+    .filter((name) => name.endsWith(".json"))
+    .sort((left, right) => Number.parseInt(left, 10) - Number.parseInt(right, 10))
+    .flatMap((name) => {
+    const content = readFileSync(path.join(recordDir, name), "utf-8");
+    return content === "" ? [] : [JSON.parse(content)];
+});
+/**
+ * Turns a cleanup function into the handle a scripted behaviour
+ * returns. Cleanup snapshots the recorded calls before removing the
+ * record directory, so assertions still read after teardown.
+ */
+const withCalls = (cleanup, recordDir) => {
+    let snapshot;
+    const handle = () => {
+        if (snapshot === undefined && recordDir !== undefined)
+            snapshot = readCalls(recordDir);
+        cleanup();
+        if (recordDir !== undefined)
+            // Windows can transiently deny deleting a file a just-exited mock
+            // still holds, so the removal retries like mock-bin's own.
+            rmSync(recordDir, {
+                recursive: true,
+                force: true,
+                maxRetries: 40,
+                retryDelay: 250,
+            });
+    };
+    Object.defineProperty(handle, "calls", {
+        enumerable: true,
+        get: () => {
+            if (snapshot !== undefined)
+                return snapshot;
+            return recordDir === undefined ? [] : readCalls(recordDir);
+        },
+    });
+    return handle;
+};
+export { prepareBehaviour, withCalls, };

package/dist/mock-bin-env.d.ts

@@ -0,0 +1,22 @@
+declare const MOCKS_VAR = "TYPE_A_BIN_MOCKS";
+/**
+ * Copies an environment without the mock registry.
+ *
+ * A child spawned from inside a mock inherits the registry, and on
+ * Windows a spawn through the shim executable (`process.execPath` *is*
+ * the shim there) would be redirected back into a mock. Passing
+ * `withoutMocks(process.env)` as the child's `env` leaves the preload
+ * loaded but inert: it finds no registry and lets the child run
+ * untouched.
+ *
+ * With the Windows trampoline launcher, mocks already run inside a real
+ * Node executable, so ordinary helper spawns escape interception on
+ * their own; the copy remains for children spawned through a legacy
+ * hard-link shim, and for trampoline spawns that must reach the real
+ * binary instead of the mock.
+ *
+ * @param env - The environment to copy, usually `process.env`
+ * @returns A copy of `env` with the mock registry variable removed
+ */
+declare const withoutMocks: (env: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
+export { MOCKS_VAR, withoutMocks };

package/dist/mock-bin-env.js

@@ -0,0 +1,31 @@
+const MOCKS_VAR = "TYPE_A_BIN_MOCKS";
+// The mock registry travels from mockBin to the Windows dispatch in
+// this env var. mock-bin-runtime keeps its own copy of the name — it
+// runs inside child processes, as a compiled module or a type-stripped
+// source file, and cannot import library code — so the two must stay
+// in sync.
+/**
+ * Copies an environment without the mock registry.
+ *
+ * A child spawned from inside a mock inherits the registry, and on
+ * Windows a spawn through the shim executable (`process.execPath` *is*
+ * the shim there) would be redirected back into a mock. Passing
+ * `withoutMocks(process.env)` as the child's `env` leaves the preload
+ * loaded but inert: it finds no registry and lets the child run
+ * untouched.
+ *
+ * With the Windows trampoline launcher, mocks already run inside a real
+ * Node executable, so ordinary helper spawns escape interception on
+ * their own; the copy remains for children spawned through a legacy
+ * hard-link shim, and for trampoline spawns that must reach the real
+ * binary instead of the mock.
+ *
+ * @param env - The environment to copy, usually `process.env`
+ * @returns A copy of `env` with the mock registry variable removed
+ */
+const withoutMocks = (env) => {
+    const childEnv = { ...env };
+    delete childEnv[MOCKS_VAR];
+    return childEnv;
+};
+export { MOCKS_VAR, withoutMocks };

package/dist/mock-bin-preload.d.ts

@@ -1,21 +1 @@
-interface MockTarget {
-    /** "node" redirects the main entry in-process; "spawn" runs a script. */
-    kind: "node" | "spawn";
-    /** Absolute path of the mock script to run. */
-    entry: string;
-    /** Interpreter name for "spawn" targets (e.g. "bash", "python"). */
-    interpreter?: string;
-    /** Regex source; only matching commands run the mock. */
-    pattern?: string;
-    /** PATH snapshot from before this mock was installed. */
-    originalPath?: string;
-}
-interface RunOriginalTarget {
-    binName: string;
-    originalPath: string;
-}
-interface MocksEnv {
-    targets?: Record<string, MockTarget>;
-    runOriginal?: RunOriginalTarget;
-}
-export type { MocksEnv, MockTarget };
+export type { MocksEnv, MockTarget, RunOriginalTarget, } from "./mock-bin-runtime.js";

package/dist/mock-bin-preload.js

@@ -1,221 +1,28 @@
-import { spawnSync } from "node:child_process";
-import { statSync } from "node:fs";
-import Module, { createRequire, registerHooks } from "node:module";
-import { basename, delimiter, extname, join, relative } from "node:path";
+import path from "node:path";
 import process from "node:process";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { threadId } from "node:worker_threads";
-// Loaded through `NODE_OPTIONS --import` into every Node process a test
-// spawns while Windows mocks are active. A mock binary is a hard link of
-// node.exe renamed <bin>.exe, so the command line ("status", "--porcelain",
-// ...) is not a real module. This preload swaps the shim's main entry for
-// the mock script named in TYPE_A_BIN_MOCKS — argv, stdin, stdout, stderr,
-// and exit codes all pass through unchanged.
+// Fallback Windows entry point, loaded through `NODE_OPTIONS --import`
+// into every Node process spawned while mocks are active. A legacy shim
+// is a hard link of node.exe renamed <bin>.exe, so the command line
+// ("status", "--porcelain", ...) is not a real module; the dispatch in
+// mock-bin-runtime swaps the shim's main entry for the mock script
+// named in TYPE_A_BIN_MOCKS — argv, stdin, stdout, stderr, and exit
+// codes all pass through unchanged. The default Windows mechanism is
+// the argv-preserving trampoline launcher (see mock-bin-windows); this
+// preload remains for the escape hatch that forces the old hardlinks
+// while the launcher rolls out.
+//
+// The dispatch lives in mock-bin-runtime — its sibling module — and is
+// loaded here dynamically by absolute URL so the same code runs from
+// the compiled .js in the published package and the .ts source under
+// node's native type stripping (spawned processes cannot rely on the
+// .js → .ts specifier rewriting a bundler or test runner provides).
+// Only a shim's own main thread may intercept: loaders such as tsx
+// spawn workers whose entry-point load must pass through untouched,
+// and processes without the registry are not mocks at all.
 const MOCKS_VAR = "TYPE_A_BIN_MOCKS";
-const HELPER_NAME = "mock-a-bin-run-original";
-const PATH_EXTENSIONS = ["", ".exe", ".cmd", ".bat", ".com"];
-const TS_EXTENSIONS = [".cts", ".mts", ".ts", ".tsx"];
-const BASH_LIKE_INTERPRETERS = ["bash", "dash", "ksh", "sh", "zsh"];
-const readMocks = () => {
-    try {
-        return JSON.parse(process.env[MOCKS_VAR] ?? "{}");
-    }
-    catch {
-        return {};
-    }
-};
-const mocks = readMocks();
-const invokedName = basename(process.argv[0] ?? "", extname(process.argv[0] ?? ""));
-// Node rewrites the CLI entry in argv[1] to an absolute path before
-// preloads run, losing the argument as the caller typed it. Recover it
-// relative to the working directory when possible, so mocks, patterns,
-// and spawned interpreters see "pr" instead of "C:\repo\pr".
-const denormalizeEntry = (entry) => {
-    const relativePath = relative(process.cwd(), entry);
-    if (relativePath === "" || relativePath.startsWith(".."))
-        return entry;
-    return relativePath;
-};
-// The shim's whole command line after the exe are CLI arguments: unlike
-// a Node script there is no "entry" consuming the first positional.
-const cliArgs = process.argv.length === 1
-    ? []
-    : [denormalizeEntry(process.argv[1] ?? ""), ...process.argv.slice(2)];
-const writeError = (message) => {
-    process.stderr.write(`${message}\n`);
-};
-// Lookup failures exit 127, matching the POSIX mock scripts.
-const fail = (message) => {
-    writeError(message);
-    process.exit(127);
-};
-const isFile = (candidate) => {
-    try {
-        return statSync(candidate).isFile();
-    }
-    catch {
-        return false;
-    }
-};
-const searchPathDirs = (originalPath) => (originalPath ?? process.env.PATH ?? "")
-    .split(delimiter)
-    .filter((dir) => dir !== "" && !dir.includes("mock-bin-"));
-const pathCandidates = (name, dirs) => {
-    const candidates = [];
-    for (const dir of dirs)
-        for (const extension of PATH_EXTENSIONS) {
-            const candidate = join(dir, `${name}${extension}`);
-            if (isFile(candidate))
-                candidates.push(candidate);
-        }
-    return candidates;
-};
-const findExecutable = (name, dirs) => pathCandidates(name, dirs)[0] ?? null;
-const spawnRealAndExit = (command, args) => {
-    // The real binary must not be re-intercepted by this preload.
-    delete process.env[MOCKS_VAR];
-    const result = spawnSync(command, args, { stdio: "inherit" });
-    if (result.error !== undefined)
-        writeError(`Error: '${command}' failed to start: ${String(result.error)}`);
-    process.exit(result.status ?? 127);
-};
-const runOriginalCommand = (spec) => {
-    if (spec === undefined)
-        return fail(`Error: ${HELPER_NAME} used outside a mockBin context`);
-    const real = findExecutable(spec.binName, searchPathDirs(spec.originalPath));
-    if (real === null)
-        return fail(`Error: Original '${spec.binName}' command not found in PATH`);
-    return spawnRealAndExit(real, cliArgs);
-};
-const runRealBinary = (target) => {
-    const real = findExecutable(invokedName, searchPathDirs(target.originalPath));
-    if (real === null)
-        return fail(`Error: Real binary '${invokedName}' not found in PATH`);
-    return spawnRealAndExit(real, cliArgs);
-};
-// WSL's bash launcher lives in the Windows system directories; it cannot
-// run Windows-path scripts, so bash-like interpreters prefer a native
-// shell (e.g. Git for Windows) and fall back to well-known Git installs.
-const isWslLauncher = (candidate) => {
-    const lower = candidate.toLowerCase();
-    return (lower.includes("\\windows\\system32\\") || lower.includes("\\windowsapps\\"));
-};
-const gitBashCandidates = () => {
-    const roots = [
-        process.env.ProgramFiles ?? "",
-        process.env["ProgramFiles(x86)"] ?? "",
-        join(process.env.LOCALAPPDATA ?? "", "Programs"),
-    ];
-    const locations = [];
-    for (const root of roots)
-        if (root !== "") {
-            locations.push(join(root, "Git", "bin", "bash.exe"));
-            locations.push(join(root, "Git", "usr", "bin", "bash.exe"));
-        }
-    return locations;
-};
-const resolveInterpreter = (interpreter) => {
-    const dirs = (process.env.PATH ?? "")
-        .split(delimiter)
-        .filter((dir) => dir !== "");
-    const candidates = pathCandidates(interpreter, dirs);
-    if (BASH_LIKE_INTERPRETERS.includes(interpreter)) {
-        const native = candidates.find((candidate) => !isWslLauncher(candidate));
-        if (native !== undefined)
-            return native;
-        for (const location of gitBashCandidates())
-            if (isFile(location))
-                return location;
-    }
-    return candidates[0] ?? null;
-};
-const runInterpreterAndExit = (interpreter, entry) => {
-    const interpreterPath = resolveInterpreter(interpreter);
-    if (interpreterPath === null)
-        return fail(`Error: Interpreter '${interpreter}' not found in PATH`);
-    const result = spawnSync(interpreterPath, [entry, ...cliArgs], {
-        stdio: "inherit",
-    });
-    if (result.error !== undefined)
-        writeError(`Error: Interpreter '${interpreter}' failed: ${String(result.error)}`);
-    process.exit(result.status ?? 127);
-};
-const asPath = (specifier) => specifier.startsWith("file:") ? fileURLToPath(specifier) : specifier;
-// tsx registers its CommonJS hooks from a separate entry point; load it
-// lazily so non-TypeScript mocks never require the tsx package.
-const loadTsxCommonJs = (entry) => {
-    if (!TS_EXTENSIONS.includes(extname(entry).toLowerCase()))
-        return;
-    try {
-        createRequire(import.meta.url)("tsx/cjs");
-    }
-    catch {
-        // tsx is not installed: node's native type stripping applies instead.
-    }
-};
-const redirectNodeEntry = (entry) => {
-    // Node normalizes the CLI entry to an absolute path in argv[1] before
-    // preloads run. Capture it, then reposition argv so the mock sees the
-    // CLI arguments at process.argv.slice(2) like a real Node CLI script.
-    const originalEntry = process.argv[1] ?? "";
-    process.argv.length = 1;
-    process.argv.push(entry, ...cliArgs);
-    // ESM main entry: resolve hooks see the main module with no parent URL,
-    // so redirect that one resolution to the mock script. The tsx loader
-    // (registered before this preload in NODE_OPTIONS) transforms .ts
-    // entries as part of the same resolve chain.
-    registerHooks({
-        resolve: (specifier, context, nextResolve) => {
-            if (context.parentURL == null && asPath(specifier) === originalEntry)
-                return nextResolve(pathToFileURL(entry).href, context);
-            return nextResolve(specifier, context);
-        },
-    });
-    // CommonJS main entry: Module._load receives the CLI entry with isMain
-    // set — load the mock through the CommonJS loader instead.
-    const moduleApi = Module;
-    const originalLoad = moduleApi._load;
-    moduleApi._load = (request, parent, isMain) => {
-        if (isMain && request === originalEntry) {
-            moduleApi._load = originalLoad;
-            loadTsxCommonJs(entry);
-            return originalLoad(entry, null, true);
-        }
-        return originalLoad(request, parent, isMain);
-    };
-};
-// A spawn with no CLI arguments leaves node without an entry (the REPL
-// would start), so the mock module is imported directly instead.
-const runEntryDirectly = async (entry) => {
-    process.argv.length = 1;
-    process.argv.push(entry, ...cliArgs);
-    await import(pathToFileURL(entry).href);
-    process.exit(process.exitCode);
-};
-const intercept = async () => {
-    if (invokedName === HELPER_NAME)
-        return runOriginalCommand(mocks.runOriginal);
-    const target = mocks.targets?.[invokedName];
-    if (target === undefined)
-        return;
-    // A process whose CLI entry is a real file is not a shim: mock scripts
-    // spawned through process.execPath (tsx's esbuild service, `node -e`
-    // helpers) inherit the shim exe's name, but their entry exists on disk
-    // while a shim's "subcommand" entry never does.
-    if (isFile(process.argv[1] ?? ""))
-        return;
-    const commandLine = `${invokedName} ${cliArgs.join(" ")}`;
-    const mocked = target.pattern === undefined ||
-        new RegExp(target.pattern).test(commandLine);
-    if (!mocked)
-        return runRealBinary(target);
-    if (target.kind !== "node")
-        return runInterpreterAndExit(target.interpreter ?? "bash", target.entry);
-    if (process.argv[1] === undefined)
-        return runEntryDirectly(target.entry);
-    return redirectNodeEntry(target.entry);
-};
-// Only a shim's own main thread may intercept: loaders such as tsx spawn
-// workers whose entry-point load must pass through untouched.
+const ownPath = fileURLToPath(import.meta.url);
+const runtimeUrl = pathToFileURL(path.join(path.dirname(ownPath), `mock-bin-runtime${path.extname(ownPath)}`)).href;
 if (process.env[MOCKS_VAR] !== undefined && threadId === 0)
-    await intercept();
+    await (await import(runtimeUrl)).interceptShim();

package/dist/mock-bin-runtime.d.ts

@@ -0,0 +1,41 @@
+interface MockTarget {
+    /** "node" redirects the main entry in-process; "spawn" runs a script. */
+    kind: "node" | "spawn";
+    /** Absolute path of the mock script to run. */
+    entry: string;
+    /** Interpreter name for "spawn" targets (e.g. "bash", "python"). */
+    interpreter?: string;
+    /** Regex source; only matching commands run the mock. */
+    pattern?: string;
+    /** PATH snapshot from before this mock was installed. */
+    originalPath?: string;
+    /**
+     * Absolute file URL of the tsx loader for TypeScript entries. The
+     * trampoline bootstrap imports it before the entry so `.ts` mocks
+     * load through tsx without a NODE_OPTIONS preload.
+     */
+    tsxImportUrl?: string;
+}
+interface RunOriginalTarget {
+    binName: string;
+    originalPath: string;
+}
+interface MocksEnv {
+    targets?: Record<string, MockTarget>;
+    runOriginal?: RunOriginalTarget;
+}
+/**
+ * Trampoline entry point. The native launcher starts Node as
+ * `[node, mock-bin-trampoline.cjs, <mock>.exe, ...originalArgs]`, so the
+ * invoked binary is the path in argv[2] and every argument after it is
+ * the caller's original argv — Node's option parser never sees it.
+ */
+declare const runTrampoline: () => Promise<void>;
+/**
+ * Shim entry point for the NODE_OPTIONS preload: the process itself is
+ * a hard link of node.exe named after the mocked binary, so the main
+ * entry is redirected in-process once the registry recognizes the
+ * invocation. Kept as the fallback behind the trampoline rollout.
+ */
+declare const interceptShim: () => Promise<void>;
+export { interceptShim, type MocksEnv, type MockTarget, type RunOriginalTarget, runTrampoline, };