veryfront 0.1.324 → 0.1.326

package/esm/src/testing/bdd.js

@@ -0,0 +1,401 @@
+/**
+ * Portable BDD testing utilities (describe, it, beforeEach, afterEach).
+ *
+ * In Deno: Direct re-export from @std/testing/bdd (no wrapper)
+ * In Node.js: Uses node:test
+ * In Bun: Uses bun:test
+ *
+ * @module
+ */
+import "../../_dnt.polyfills.js";
+import * as dntShim from "../../_dnt.shims.js";
+import { isBun, isDeno } from "../platform/compat/runtime.js";
+import { getEnvOverlayStorage } from "../platform/compat/process.js";
+function getActiveEnvOverlay() {
+    const storage = getEnvOverlayStorage();
+    const store = storage?.getStore();
+    return store instanceof Map ? store : null;
+}
+function applyEnvOverlay(base, overlay) {
+    if (!overlay)
+        return { ...base };
+    const merged = { ...base };
+    for (const [key, value] of overlay.entries()) {
+        if (value === null) {
+            delete merged[key];
+            continue;
+        }
+        merged[key] = value;
+    }
+    return merged;
+}
+function installDenoEnvOverlayFacade() {
+    if (!isDeno || typeof dntShim.Deno === "undefined" || typeof dntShim.Deno.env === "undefined")
+        return;
+    const globalAny = dntShim.dntGlobalThis;
+    if (globalAny["__vfTestDenoEnvOverlayFacadeInstalled"])
+        return;
+    globalAny["__vfTestDenoEnvOverlayFacadeInstalled"] = true;
+    const originalDenoEnv = {
+        get: dntShim.Deno.env.get.bind(dntShim.Deno.env),
+        set: dntShim.Deno.env.set.bind(dntShim.Deno.env),
+        delete: dntShim.Deno.env.delete.bind(dntShim.Deno.env),
+        has: dntShim.Deno.env.has.bind(dntShim.Deno.env),
+        toObject: dntShim.Deno.env.toObject.bind(dntShim.Deno.env),
+    };
+    dntShim.Deno.env.get = (key) => {
+        const overlay = getActiveEnvOverlay();
+        if (overlay?.has(key))
+            return overlay.get(key) ?? undefined;
+        return originalDenoEnv.get(key);
+    };
+    dntShim.Deno.env.set = (key, value) => {
+        const overlay = getActiveEnvOverlay();
+        if (overlay) {
+            overlay.set(key, value);
+            return;
+        }
+        originalDenoEnv.set(key, value);
+    };
+    dntShim.Deno.env.delete = (key) => {
+        const overlay = getActiveEnvOverlay();
+        if (overlay) {
+            overlay.set(key, null);
+            return;
+        }
+        originalDenoEnv.delete(key);
+    };
+    dntShim.Deno.env.has = (key) => {
+        const overlay = getActiveEnvOverlay();
+        if (overlay?.has(key))
+            return overlay.get(key) !== null;
+        return originalDenoEnv.has(key);
+    };
+    dntShim.Deno.env.toObject = () => {
+        return applyEnvOverlay(originalDenoEnv.toObject(), getActiveEnvOverlay());
+    };
+    const processAny = globalAny["process"];
+    if (!processAny?.env)
+        return;
+    const baseProcessEnv = processAny.env;
+    processAny.env = new Proxy(baseProcessEnv, {
+        get(target, prop, receiver) {
+            if (typeof prop !== "string")
+                return Reflect.get(target, prop, receiver);
+            return dntShim.Deno.env.get(prop);
+        },
+        set(target, prop, value, receiver) {
+            if (typeof prop !== "string")
+                return Reflect.set(target, prop, value, receiver);
+            dntShim.Deno.env.set(prop, String(value));
+            return true;
+        },
+        deleteProperty(target, prop) {
+            if (typeof prop !== "string")
+                return Reflect.deleteProperty(target, prop);
+            dntShim.Deno.env.delete(prop);
+            return true;
+        },
+        has(target, prop) {
+            if (typeof prop !== "string")
+                return Reflect.has(target, prop);
+            return dntShim.Deno.env.has(prop);
+        },
+        ownKeys() {
+            return Object.keys(dntShim.Deno.env.toObject());
+        },
+        getOwnPropertyDescriptor(target, prop) {
+            if (typeof prop !== "string")
+                return Reflect.getOwnPropertyDescriptor(target, prop);
+            const value = dntShim.Deno.env.get(prop);
+            if (value === undefined)
+                return undefined;
+            return {
+                configurable: true,
+                enumerable: true,
+                writable: true,
+                value,
+            };
+        },
+    });
+}
+async function installDenoEnvOverlayStorage() {
+    if (!isDeno)
+        return;
+    const globalAny = dntShim.dntGlobalThis;
+    if (!globalAny["__vfTestDenoEnvOverlay"]) {
+        const { AsyncLocalStorage } = await import("node:async_hooks");
+        const storage = new AsyncLocalStorage();
+        globalAny["__vfTestDenoEnvOverlay"] = {
+            storage: {
+                getStore: () => storage.getStore(),
+                run: (store, fn) => storage.run(store, fn),
+                enterWith: (store) => storage.enterWith(store),
+            },
+        };
+    }
+    installDenoEnvOverlayFacade();
+}
+function withEnvOverlay(fn) {
+    const overlay = getEnvOverlayStorage();
+    if (!overlay)
+        return fn;
+    return ((...args) => {
+        if (overlay.run) {
+            return overlay.run(new Map(), () => Promise.resolve().then(() => fn(...args)));
+        }
+        if (overlay.enterWith) {
+            overlay.enterWith(new Map());
+        }
+        return fn(...args);
+    });
+}
+// For Deno, we directly use @std/testing/bdd - no wrapper needed
+// This avoids creating a "global" test suite from top-level await
+let denoBdd = null;
+if (isDeno) {
+    await installDenoEnvOverlayStorage();
+    denoBdd = await import("../../deps/jsr.io/@std/testing/1.0.18/bdd.js");
+}
+let _impl = null;
+function parseBddArgs(nameOrOptions, optionsOrFn, fn) {
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions.name;
+    let options = {};
+    if (typeof nameOrOptions === "object") {
+        options = nameOrOptions;
+    }
+    else if (typeof optionsOrFn === "object" && typeof optionsOrFn !== "function") {
+        options = optionsOrFn;
+    }
+    const testFn = typeof optionsOrFn === "function" ? optionsOrFn : fn;
+    return { name, options, testFn };
+}
+function createNodeImpl(nodeTest) {
+    return {
+        describe(nameOrOptions, optionsOrFn, fn) {
+            const { name, options, testFn } = parseBddArgs(nameOrOptions, optionsOrFn, fn);
+            if (!testFn)
+                throw new Error("describe requires a test function");
+            if (options.skip || options.ignore) {
+                nodeTest.describe.skip(name, testFn);
+                return;
+            }
+            if (options.only && nodeTest.describe.only) {
+                nodeTest.describe.only(name, testFn);
+                return;
+            }
+            nodeTest.describe(name, testFn);
+        },
+        it(nameOrOptions, optionsOrFn, fn) {
+            const { name, options, testFn } = parseBddArgs(nameOrOptions, optionsOrFn, fn);
+            if (!testFn)
+                throw new Error("it requires a test function");
+            if (options.skip || options.ignore) {
+                nodeTest.it.skip(name, testFn);
+                return;
+            }
+            if (options.only && nodeTest.it.only) {
+                nodeTest.it.only(name, testFn);
+                return;
+            }
+            if (options.timeout !== undefined) {
+                nodeTest.it(name, { timeout: options.timeout }, testFn);
+                return;
+            }
+            nodeTest.it(name, testFn);
+        },
+        beforeEach: nodeTest.beforeEach,
+        afterEach: nodeTest.afterEach,
+        beforeAll: nodeTest.before,
+        afterAll: nodeTest.after,
+    };
+}
+function createBunImpl(bunTest) {
+    const defaultTimeout = (() => {
+        const env = dntShim.dntGlobalThis.process;
+        const raw = env?.env?.BUN_TEST_TIMEOUT ?? env?.env?.VF_TEST_TIMEOUT ?? "30000";
+        const parsed = Number(raw);
+        return Number.isFinite(parsed) && parsed > 0 ? parsed : 30000;
+    })();
+    return {
+        describe(nameOrOptions, optionsOrFn, fn) {
+            const { name, options, testFn } = parseBddArgs(nameOrOptions, optionsOrFn, fn);
+            if (!testFn)
+                throw new Error("describe requires a test function");
+            if ((options.skip || options.ignore) && bunTest.describe.skip) {
+                bunTest.describe.skip(name, testFn);
+                return;
+            }
+            if (options.only && bunTest.describe.only) {
+                bunTest.describe.only(name, testFn);
+                return;
+            }
+            bunTest.describe(name, testFn);
+        },
+        it(nameOrOptions, optionsOrFn, fn) {
+            const { name, options, testFn } = parseBddArgs(nameOrOptions, optionsOrFn, fn);
+            if (!testFn)
+                throw new Error("it requires a test function");
+            const testWithEnv = withEnvOverlay(testFn);
+            const isSkip = options.skip || options.ignore;
+            let runner = bunTest.it;
+            if (isSkip)
+                runner = (bunTest.it.skip ?? bunTest.it);
+            else if (options.only && bunTest.it.only)
+                runner = bunTest.it.only;
+            if (isSkip) {
+                runner(name, testWithEnv);
+                return;
+            }
+            const timeout = options.timeout ?? defaultTimeout;
+            if (Number.isFinite(timeout) && timeout > 0) {
+                runner(name, { timeout }, testWithEnv);
+                return;
+            }
+            runner(name, testWithEnv);
+        },
+        beforeEach: bunTest.beforeEach,
+        afterEach: bunTest.afterEach,
+        beforeAll: bunTest.beforeAll,
+        afterAll: bunTest.afterAll,
+    };
+}
+async function getImpl() {
+    if (_impl)
+        return _impl;
+    if (isBun) {
+        const importBunTest = new Function("return import('bun:test')");
+        const bunTestModule = await importBunTest();
+        _impl = createBunImpl(bunTestModule.default);
+        return _impl;
+    }
+    const importNodeTest = new Function("return import('node:test')");
+    const nodeTest = await importNodeTest();
+    _impl = createNodeImpl(nodeTest);
+    return _impl;
+}
+function hasOptions(options) {
+    return Object.values(options).some((v) => v !== undefined);
+}
+function normalizeDenoOptions(options) {
+    if (!options.skip)
+        return options;
+    const { skip: _skip, ...rest } = options;
+    return { ...rest, ignore: true };
+}
+function requireImpl() {
+    if (_impl)
+        return _impl;
+    throw new Error("BDD implementation not initialized. For Node/Bun, call initBdd() first, or import from #veryfront/testing which auto-initializes.");
+}
+function getNameAndFn(nameOrOptions, optionsOrFn, fn) {
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions.name;
+    const testFn = typeof optionsOrFn === "function" ? optionsOrFn : fn;
+    if (!testFn)
+        throw new Error("Missing test function");
+    return { name, testFn };
+}
+export function describe(nameOrOptions, optionsOrFn, fn) {
+    if (!denoBdd) {
+        requireImpl().describe(nameOrOptions, optionsOrFn, fn);
+        return;
+    }
+    const { name, options, testFn } = parseBddArgs(nameOrOptions, optionsOrFn, fn);
+    if (!testFn)
+        throw new Error("describe requires a test function");
+    const denoOptions = normalizeDenoOptions(options);
+    if (hasOptions(denoOptions)) {
+        denoBdd.describe({ name, ...denoOptions }, testFn);
+        return;
+    }
+    denoBdd.describe(name, testFn);
+}
+describe.skip = function skip(nameOrOptions, optionsOrFn, fn) {
+    const { name, testFn } = getNameAndFn(nameOrOptions, optionsOrFn, fn);
+    if (denoBdd) {
+        denoBdd.describe({ name, ignore: true }, testFn);
+        return;
+    }
+    requireImpl().describe({ name, ignore: true }, testFn);
+};
+describe.ignore = describe.skip;
+describe.only = function only(nameOrOptions, optionsOrFn, fn) {
+    const { name, testFn } = getNameAndFn(nameOrOptions, optionsOrFn, fn);
+    if (denoBdd) {
+        denoBdd.describe({ name, only: true }, testFn);
+        return;
+    }
+    requireImpl().describe({ name, only: true }, testFn);
+};
+export function it(nameOrOptions, optionsOrFn, fn) {
+    if (!denoBdd) {
+        requireImpl().it(nameOrOptions, optionsOrFn, fn);
+        return;
+    }
+    const { name, options, testFn } = parseBddArgs(nameOrOptions, optionsOrFn, fn);
+    if (!testFn)
+        throw new Error("it requires a test function");
+    const testWithEnv = withEnvOverlay(testFn);
+    const denoOptions = normalizeDenoOptions(options);
+    if (hasOptions(denoOptions)) {
+        denoBdd.it({ name, ...denoOptions }, testWithEnv);
+        return;
+    }
+    denoBdd.it(name, testWithEnv);
+}
+it.skip = function skip(nameOrOptions, optionsOrFn, fn) {
+    const { name, testFn } = getNameAndFn(nameOrOptions, optionsOrFn, fn);
+    const testWithEnv = withEnvOverlay(testFn);
+    if (denoBdd) {
+        denoBdd.it({ name, ignore: true }, testWithEnv);
+        return;
+    }
+    requireImpl().it({ name, ignore: true }, testWithEnv);
+};
+it.ignore = it.skip;
+it.only = function only(nameOrOptions, optionsOrFn, fn) {
+    const { name, testFn } = getNameAndFn(nameOrOptions, optionsOrFn, fn);
+    const testWithEnv = withEnvOverlay(testFn);
+    if (denoBdd) {
+        denoBdd.it({ name, only: true }, testWithEnv);
+        return;
+    }
+    requireImpl().it({ name, only: true }, testWithEnv);
+};
+export function beforeEach(fn) {
+    if (denoBdd) {
+        denoBdd.beforeEach(fn);
+        return;
+    }
+    requireImpl().beforeEach(fn);
+}
+export function afterEach(fn) {
+    if (denoBdd) {
+        denoBdd.afterEach(fn);
+        return;
+    }
+    requireImpl().afterEach(fn);
+}
+export function beforeAll(fn) {
+    if (denoBdd) {
+        denoBdd.beforeAll(fn);
+        return;
+    }
+    requireImpl().beforeAll(fn);
+}
+export function afterAll(fn) {
+    if (denoBdd) {
+        denoBdd.afterAll(fn);
+        return;
+    }
+    requireImpl().afterAll(fn);
+}
+export const test = it;
+export async function initBdd() {
+    if (denoBdd)
+        return;
+    await getImpl();
+}
+if (!isDeno) {
+    await initBdd();
+}

package/esm/src/testing/deno-compat.d.ts

@@ -0,0 +1,26 @@
+export { chmod, createFileSystem, exists, isAlreadyExistsError, isNotFoundError, makeTempDir, mkdir, readDir, readFile, readTextFile, remove, stat, writeFile, writeTextFile, } from "../platform/compat/fs.js";
+export { cwd, deleteEnv, env, getArgs, getEnv, setEnv, } from "../platform/compat/process.js";
+export declare function makeTempFile(options?: {
+    prefix?: string;
+    suffix?: string;
+}): Promise<string>;
+export declare function makeTempDirWithOptions(options?: {
+    prefix?: string;
+    dir?: string;
+}): Promise<string>;
+export declare function waitFor(condition: () => boolean | Promise<boolean>, options?: {
+    timeout?: number;
+    interval?: number;
+    message?: string;
+}): Promise<void>;
+export declare function delay(ms: number): Promise<void>;
+export declare function exit(code: number): never;
+export declare function withTempDir<T>(fn: (tempDir: string) => Promise<T>, options?: {
+    prefix?: string;
+}): Promise<T>;
+export declare function withTempFile<T>(fn: (tempFile: string) => Promise<T>, options?: {
+    prefix?: string;
+    suffix?: string;
+}): Promise<T>;
+export declare function withEnv<T>(vars: Record<string, string>, fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=deno-compat.d.ts.map

package/esm/src/testing/deno-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deno-compat.d.ts","sourceRoot":"","sources":["../../../src/src/testing/deno-compat.ts"],"names":[],"mappings":"AAsBA,OAAO,EACL,KAAK,EACL,gBAAgB,EAChB,MAAM,EACN,oBAAoB,EACpB,eAAe,EACf,WAAW,EACX,KAAK,EACL,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,IAAI,EACJ,SAAS,EACT,aAAa,GACd,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,GAAG,EACH,SAAS,EACT,GAAG,EACH,OAAO,EACP,MAAM,EACN,MAAM,GACP,MAAM,+BAA+B,CAAC;AAEvC,wBAAsB,YAAY,CAChC,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7C,OAAO,CAAC,MAAM,CAAC,CAoBjB;AAED,wBAAsB,sBAAsB,CAAC,OAAO,CAAC,EAAE;IACrD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,OAAO,CAAC,MAAM,CAAC,CAoBlB;AAED,wBAAsB,OAAO,CAC3B,SAAS,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EAC3C,OAAO,CAAC,EAAE;IACR,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GACA,OAAO,CAAC,IAAI,CAAC,CAaf;AAGD,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAOxC;AAED,wBAAsB,WAAW,CAAC,CAAC,EACjC,EAAE,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EACnC,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B,OAAO,CAAC,CAAC,CAAC,CAkBZ;AAED,wBAAsB,YAAY,CAAC,CAAC,EAClC,EAAE,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,EACpC,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7C,OAAO,CAAC,CAAC,CAAC,CAkBZ;AAED,wBAAsB,OAAO,CAAC,CAAC,EAC7B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAuBZ"}

package/esm/src/testing/deno-compat.js

@@ -0,0 +1,146 @@
+/**
+ * Deno API compatibility shims for cross-runtime testing.
+ *
+ * Provides portable implementations of common Deno testing APIs:
+ * - Deno.makeTempDir() → makeTempDir()
+ * - Deno.makeTempFile() → makeTempFile()
+ * - Deno.writeTextFile() → writeTextFile()
+ * - Deno.readTextFile() → readTextFile()
+ * - Deno.remove() → remove()
+ * - Deno.mkdir() → mkdir()
+ * - Deno.stat() → stat()
+ * - Deno.env.get/set/delete → getEnv/setEnv/deleteEnv
+ *
+ * @module
+ */
+import * as dntShim from "../../_dnt.shims.js";
+import { isDeno } from "../platform/compat/runtime.js";
+import { scaleMs } from "./timing.js";
+import { TIMEOUT_ERROR } from "../errors/index.js";
+export { chmod, createFileSystem, exists, isAlreadyExistsError, isNotFoundError, makeTempDir, mkdir, readDir, readFile, readTextFile, remove, stat, writeFile, writeTextFile, } from "../platform/compat/fs.js";
+export { cwd, deleteEnv, env, getArgs, getEnv, setEnv, } from "../platform/compat/process.js";
+export async function makeTempFile(options) {
+    if (isDeno) {
+        // @ts-ignore - Deno global
+        return await dntShim.Deno.makeTempFile(options);
+    }
+    const [{ default: os }, { default: fs }, { default: path }] = await Promise.all([
+        import("node:os"),
+        import("node:fs/promises"),
+        import("node:path"),
+    ]);
+    const prefix = options?.prefix ?? "tmp-";
+    const suffix = options?.suffix ?? "";
+    const randomPart = Math.random().toString(36).substring(2, 10);
+    const filename = `${prefix}${randomPart}${suffix}`;
+    const tempPath = path.join(os.tmpdir(), filename);
+    await fs.writeFile(tempPath, "");
+    return tempPath;
+}
+export async function makeTempDirWithOptions(options) {
+    if (isDeno) {
+        // @ts-ignore - Deno global
+        return await dntShim.Deno.makeTempDir(options);
+    }
+    const [{ default: os }, { default: fs }, { default: path }] = await Promise.all([
+        import("node:os"),
+        import("node:fs/promises"),
+        import("node:path"),
+    ]);
+    const baseDir = options?.dir ?? os.tmpdir();
+    const prefix = options?.prefix ?? "tmp-";
+    const randomPart = Math.random().toString(36).substring(2, 10);
+    const dirname = `${prefix}${randomPart}`;
+    const tempPath = path.join(baseDir, dirname);
+    await fs.mkdir(tempPath, { recursive: true });
+    return tempPath;
+}
+export async function waitFor(condition, options) {
+    const timeout = scaleMs(options?.timeout ?? 5000, 10);
+    const interval = scaleMs(options?.interval ?? 100, 5);
+    const message = options?.message ?? "Condition not met within timeout";
+    const start = Date.now();
+    while (Date.now() - start < timeout) {
+        if (await condition())
+            return;
+        // no cleanup needed: one-shot
+        await new Promise((resolve) => dntShim.setTimeout(resolve, interval));
+    }
+    throw TIMEOUT_ERROR.create({ detail: `${message} (timeout: ${timeout}ms)` });
+}
+// no cleanup needed: one-shot
+export function delay(ms) {
+    return new Promise((resolve) => dntShim.setTimeout(resolve, scaleMs(ms)));
+}
+export function exit(code) {
+    if (isDeno) {
+        // @ts-ignore - Deno global
+        dntShim.Deno.exit(code);
+    }
+    process.exit(code);
+}
+export async function withTempDir(fn, options) {
+    const tempDir = await makeTempDirWithOptions({ prefix: options?.prefix ?? "test-" });
+    try {
+        return await fn(tempDir);
+    }
+    finally {
+        try {
+            if (isDeno) {
+                // @ts-ignore - Deno global
+                await dntShim.Deno.remove(tempDir, { recursive: true });
+            }
+            else {
+                const { default: fs } = await import("node:fs/promises");
+                await fs.rm(tempDir, { recursive: true, force: true });
+            }
+        }
+        catch (_) {
+            /* expected: temp dir may already be removed or inaccessible */
+        }
+    }
+}
+export async function withTempFile(fn, options) {
+    const tempFile = await makeTempFile({ prefix: options?.prefix, suffix: options?.suffix });
+    try {
+        return await fn(tempFile);
+    }
+    finally {
+        try {
+            if (isDeno) {
+                // @ts-ignore - Deno global
+                await dntShim.Deno.remove(tempFile);
+            }
+            else {
+                const { default: fs } = await import("node:fs/promises");
+                await fs.rm(tempFile, { force: true });
+            }
+        }
+        catch (_) {
+            /* expected: temp file may already be removed or inaccessible */
+        }
+    }
+}
+export async function withEnv(vars, fn) {
+    const { getEnv, setEnv, deleteEnv } = await import("../platform/compat/process.js");
+    const original = {};
+    for (const key of Object.keys(vars)) {
+        original[key] = getEnv(key);
+    }
+    for (const [key, value] of Object.entries(vars)) {
+        setEnv(key, value);
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        for (const [key, value] of Object.entries(original)) {
+            if (value === undefined) {
+                deleteEnv(key);
+            }
+            else {
+                setEnv(key, value);
+            }
+        }
+    }
+}

package/esm/src/testing/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Cross-runtime test utilities — BDD framework (describe/it), assertions,
+ * test isolation, filesystem/env helpers, and timing utilities for Deno, Node, and Bun.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals, describe, it } from "veryfront/testing";
+ *
+ * describe("math", () => {
+ *   it("adds numbers", () => {
+ *     assertEquals(1 + 1, 2);
+ *   });
+ * });
+ * ```
+ *
+ * @module testing
+ */
+import "../../_dnt.polyfills.js";
+import "./init.js";
+export { assert, assertEquals, assertExists, assertGreater, assertGreaterOrEqual, assertInstanceOf, assertLess, assertLessOrEqual, assertMatch, assertNotEquals, assertNotStrictEquals, assertObjectMatch, assertRejects, assertStrictEquals, assertStringIncludes, assertThrows, fail, } from "./assert.js";
+export { deepEquals, safeStringify } from "./utils.js";
+export { afterAll, afterEach, beforeAll, beforeEach, describe, it, test, } from "./bdd.js";
+export type { BddTestContext, TestOptions } from "./bdd.js";
+export { registerTestCleanup, resetAllTestState } from "./isolation.js";
+export { chmod, createFileSystem, cwd, delay, deleteEnv, env, exists, exit, getArgs, getEnv, isAlreadyExistsError, isNotFoundError, makeTempDir, makeTempDirWithOptions, makeTempFile, mkdir, readDir, readFile, readTextFile, remove, setEnv, stat, waitFor, withEnv, withTempDir, withTempFile, writeFile, writeTextFile, } from "./deno-compat.js";
+export { getTestTimeScale, scaleMs, testDelay } from "./timing.js";
+export { isBun, isDeno, isNode } from "../platform/compat/runtime.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/src/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/src/testing/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,yBAAyB,CAAC;AAEjC,OAAO,WAAW,CAAC;AAEnB,OAAO,EACL,MAAM,EACN,YAAY,EACZ,YAAY,EACZ,aAAa,EACb,oBAAoB,EACpB,gBAAgB,EAChB,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,eAAe,EACf,qBAAqB,EACrB,iBAAiB,EACjB,aAAa,EACb,kBAAkB,EAClB,oBAAoB,EACpB,YAAY,EACZ,IAAI,GACL,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEvD,OAAO,EACL,QAAQ,EACR,SAAS,EACT,SAAS,EACT,UAAU,EACV,QAAQ,EACR,EAAE,EACF,IAAI,GACL,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAE5D,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAExE,OAAO,EACL,KAAK,EACL,gBAAgB,EAChB,GAAG,EACH,KAAK,EACL,SAAS,EACT,GAAG,EACH,MAAM,EACN,IAAI,EACJ,OAAO,EACP,MAAM,EACN,oBAAoB,EACpB,eAAe,EACf,WAAW,EACX,sBAAsB,EACtB,YAAY,EACZ,KAAK,EACL,OAAO,EACP,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,MAAM,EACN,IAAI,EACJ,OAAO,EACP,OAAO,EACP,WAAW,EACX,YAAY,EACZ,SAAS,EACT,aAAa,GACd,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAEnE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC"}

package/esm/src/testing/index.js

@@ -0,0 +1,27 @@
+/**
+ * Cross-runtime test utilities — BDD framework (describe/it), assertions,
+ * test isolation, filesystem/env helpers, and timing utilities for Deno, Node, and Bun.
+ *
+ * @example
+ * ```ts
+ * import { assertEquals, describe, it } from "veryfront/testing";
+ *
+ * describe("math", () => {
+ *   it("adds numbers", () => {
+ *     assertEquals(1 + 1, 2);
+ *   });
+ * });
+ * ```
+ *
+ * @module testing
+ */
+// Initialize test environment before any other imports
+import "../../_dnt.polyfills.js";
+import "./init.js";
+export { assert, assertEquals, assertExists, assertGreater, assertGreaterOrEqual, assertInstanceOf, assertLess, assertLessOrEqual, assertMatch, assertNotEquals, assertNotStrictEquals, assertObjectMatch, assertRejects, assertStrictEquals, assertStringIncludes, assertThrows, fail, } from "./assert.js";
+export { deepEquals, safeStringify } from "./utils.js";
+export { afterAll, afterEach, beforeAll, beforeEach, describe, it, test, } from "./bdd.js";
+export { registerTestCleanup, resetAllTestState } from "./isolation.js";
+export { chmod, createFileSystem, cwd, delay, deleteEnv, env, exists, exit, getArgs, getEnv, isAlreadyExistsError, isNotFoundError, makeTempDir, makeTempDirWithOptions, makeTempFile, mkdir, readDir, readFile, readTextFile, remove, setEnv, stat, waitFor, withEnv, withTempDir, withTempFile, writeFile, writeTextFile, } from "./deno-compat.js";
+export { getTestTimeScale, scaleMs, testDelay } from "./timing.js";
+export { isBun, isDeno, isNode } from "../platform/compat/runtime.js";

package/esm/src/testing/init.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=init.d.ts.map

package/esm/src/testing/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/src/testing/init.ts"],"names":[],"mappings":""}

package/esm/src/testing/init.js

@@ -0,0 +1,18 @@
+/**
+ * Test environment initialization.
+ *
+ * This module sets up the testing environment by disabling features
+ * that can cause resource leaks in tests, like LRU cache cleanup intervals.
+ *
+ * IMPORTANT: Import this module before any other veryfront imports in test files
+ * to ensure the flags are set before module-level caches are initialized.
+ *
+ * @module
+ */
+import * as dntShim from "../../_dnt.shims.js";
+const g = dntShim.dntGlobalThis;
+g.__vfDisableLruInterval = true;
+g.__vfTestEnv = true;
+g.__vfTestEnvMask = {
+    prefixes: ["VERYFRONT_", "OTEL_", "OAUTH_", "GITHUB_", "OPENAI_", "ANTHROPIC_", "GOOGLE_"],
+};