1tube 0.2.0 → 0.3.0

package/dist/test/api.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The `1tube/test` contract every runner binding implements.
+ *
+ * Edge function tests import `test`, `describe`, hooks and assertions from
+ * `1tube/test` instead of a specific runner, so the same files run under
+ * `bun test` today and under another runtime's runner (node:test, a workerd
+ * pool) later. Keep this surface to what every runner can express: no test
+ * context argument, no runner-specific options.
+ */
+export type TestFn = () => void | Promise<unknown>;
+export type HookFn = () => void | Promise<unknown>;
+export interface TestOptions {
+    /** Per-test timeout in milliseconds (runner default when omitted). */
+    timeout?: number;
+    /** Register but do not run. */
+    skip?: boolean;
+    /** Run only tests marked `only` (where the runner supports focusing). */
+    only?: boolean;
+}
+export interface TestFunction {
+    (name: string, fn: TestFn, options?: TestOptions): void;
+    skip(name: string, fn: TestFn, options?: TestOptions): void;
+    only(name: string, fn: TestFn, options?: TestOptions): void;
+    /** A placeholder for a test that is not written yet. */
+    todo(name: string): void;
+}
+export interface DescribeFunction {
+    (name: string, fn: () => void): void;
+    skip(name: string, fn: () => void): void;
+    only(name: string, fn: () => void): void;
+}
+export type Hook = (fn: HookFn) => void;
+/** Which runner the active binding drives. */
+export type TestRuntime = "bun" | "node";

package/dist/test/api.js

@@ -0,0 +1,10 @@
+/**
+ * The `1tube/test` contract every runner binding implements.
+ *
+ * Edge function tests import `test`, `describe`, hooks and assertions from
+ * `1tube/test` instead of a specific runner, so the same files run under
+ * `bun test` today and under another runtime's runner (node:test, a workerd
+ * pool) later. Keep this surface to what every runner can express: no test
+ * context argument, no runner-specific options.
+ */
+export {};

package/dist/test/assert.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Runtime-agnostic assertions for `1tube/test`.
+ *
+ * Pure TypeScript with no runtime imports, so the same assertions run under
+ * `bun test`, `node --test`, or a workerd test pool. The surface follows the
+ * familiar `assertX(actual, expected, msg?)` shape (the one Supabase-style
+ * edge function tests are written against), so test files only change their
+ * import line when moving between runners.
+ */
+export declare class AssertionError extends Error {
+    name: string;
+    constructor(message: string);
+}
+type AnyConstructor = abstract new (...args: never[]) => unknown;
+type ErrorClass<E extends Error = Error> = abstract new (...args: never[]) => E;
+/** Readable, deterministic rendering of a value for failure messages. */
+export declare function format(value: unknown): string;
+/**
+ * Deep structural equality: same constructor, same own enumerable keys
+ * (strings and symbols), recursively equal values. `NaN` equals `NaN`;
+ * `0` and `-0` differ. Maps and Sets compare by content, order-insensitive.
+ */
+export declare function equal(a: unknown, b: unknown): boolean;
+/** Assert that `expr` is truthy. */
+export declare function assert(expr: unknown, msg?: string): asserts expr;
+/** Assert that `expr` is falsy. */
+export declare function assertFalse(expr: unknown, msg?: string): void;
+/** Deep equality (see {@link equal}). */
+export declare function assertEquals<T>(actual: T, expected: T, msg?: string): void;
+export declare function assertNotEquals<T>(actual: T, expected: T, msg?: string): void;
+/** Identity (`Object.is`). */
+export declare function assertStrictEquals<T>(actual: unknown, expected: T, msg?: string): asserts actual is T;
+export declare function assertNotStrictEquals<T>(actual: T, expected: T, msg?: string): void;
+/** |actual - expected| <= tolerance (default 1e-7). */
+export declare function assertAlmostEquals(actual: number, expected: number, tolerance?: number, msg?: string): void;
+/** Not `null` and not `undefined`. */
+export declare function assertExists<T>(actual: T, msg?: string): asserts actual is NonNullable<T>;
+export declare function assertInstanceOf<T extends AnyConstructor>(actual: unknown, expectedType: T, msg?: string): asserts actual is InstanceType<T>;
+export declare function assertNotInstanceOf<T extends AnyConstructor>(actual: unknown, unexpectedType: T, msg?: string): void;
+export declare function assertStringIncludes(actual: string, expected: string, msg?: string): void;
+export declare function assertMatch(actual: string, expected: RegExp, msg?: string): void;
+export declare function assertNotMatch(actual: string, expected: RegExp, msg?: string): void;
+/** Every element of `expected` is deep-equal to some element of `actual`. */
+export declare function assertArrayIncludes<T>(actual: ArrayLike<T>, expected: ArrayLike<T>, msg?: string): void;
+/** `actual` contains (recursively) every key/value of `expected`. */
+export declare function assertObjectMatch(actual: Record<PropertyKey, unknown>, expected: Record<PropertyKey, unknown>, msg?: string): void;
+export declare function assertGreater<T>(actual: T, expected: T, msg?: string): void;
+export declare function assertGreaterOrEqual<T>(actual: T, expected: T, msg?: string): void;
+export declare function assertLess<T>(actual: T, expected: T, msg?: string): void;
+export declare function assertLessOrEqual<T>(actual: T, expected: T, msg?: string): void;
+/** Assert `fn` throws; returns the thrown value. */
+export declare function assertThrows(fn: () => unknown, msg?: string): unknown;
+export declare function assertThrows<E extends Error = Error>(fn: () => unknown, ErrorClass: ErrorClass<E>, msgIncludes?: string, msg?: string): E;
+/** Assert the promise (or `fn()`'s promise) rejects; resolves to the reason. */
+export declare function assertRejects(fn: (() => PromiseLike<unknown>) | PromiseLike<unknown>, msg?: string): Promise<unknown>;
+export declare function assertRejects<E extends Error = Error>(fn: (() => PromiseLike<unknown>) | PromiseLike<unknown>, ErrorClass: ErrorClass<E>, msgIncludes?: string, msg?: string): Promise<E>;
+/** Unconditionally fail. */
+export declare function fail(msg?: string): never;
+export declare function unreachable(msg?: string): never;
+export declare function unimplemented(msg?: string): never;
+export {};

package/dist/test/assert.js

@@ -0,0 +1,430 @@
+/**
+ * Runtime-agnostic assertions for `1tube/test`.
+ *
+ * Pure TypeScript with no runtime imports, so the same assertions run under
+ * `bun test`, `node --test`, or a workerd test pool. The surface follows the
+ * familiar `assertX(actual, expected, msg?)` shape (the one Supabase-style
+ * edge function tests are written against), so test files only change their
+ * import line when moving between runners.
+ */
+export class AssertionError extends Error {
+    name = "AssertionError";
+    constructor(message) {
+        super(message);
+    }
+}
+// ---------------------------------------------------------------------------
+// Formatting
+// ---------------------------------------------------------------------------
+/** Readable, deterministic rendering of a value for failure messages. */
+export function format(value) {
+    const seen = new WeakSet();
+    const indent = (s) => s.replace(/\n/g, "\n  ");
+    const render = (v) => {
+        switch (typeof v) {
+            case "string":
+                return JSON.stringify(v);
+            case "bigint":
+                return `${v}n`;
+            case "symbol":
+            case "undefined":
+            case "boolean":
+                return String(v);
+            case "number":
+                return Object.is(v, -0) ? "-0" : String(v);
+            case "function":
+                return `[Function: ${v.name || "anonymous"}]`;
+        }
+        if (v === null)
+            return "null";
+        const obj = v;
+        if (seen.has(obj))
+            return "[Circular]";
+        if (obj instanceof Date)
+            return `Date(${Number.isNaN(obj.getTime()) ? "Invalid" : obj.toISOString()})`;
+        if (obj instanceof RegExp)
+            return String(obj);
+        if (obj instanceof Error)
+            return `${obj.name}: ${obj.message}`;
+        if (typeof URL !== "undefined" && obj instanceof URL)
+            return `URL(${obj.href})`;
+        seen.add(obj);
+        try {
+            if (Array.isArray(obj)) {
+                if (obj.length === 0)
+                    return "[]";
+                return `[\n  ${obj.map((x) => indent(render(x))).join(",\n  ")},\n]`;
+            }
+            if (ArrayBuffer.isView(obj) && !(obj instanceof DataView)) {
+                const items = Array.from(obj, (x) => render(x));
+                return `${obj.constructor.name}(${items.length}) [${items.join(", ")}]`;
+            }
+            if (obj instanceof Map) {
+                if (obj.size === 0)
+                    return "Map(0) {}";
+                const rows = [...obj].map(([k, x]) => `${indent(render(k))} => ${indent(render(x))}`);
+                return `Map(${obj.size}) {\n  ${rows.join(",\n  ")},\n}`;
+            }
+            if (obj instanceof Set) {
+                if (obj.size === 0)
+                    return "Set(0) {}";
+                return `Set(${obj.size}) {\n  ${[...obj].map((x) => indent(render(x))).join(",\n  ")},\n}`;
+            }
+            const keys = [
+                ...Object.keys(obj),
+                ...Object.getOwnPropertySymbols(obj).filter((s) => Object.prototype.propertyIsEnumerable.call(obj, s)),
+            ];
+            const proto = Object.getPrototypeOf(obj);
+            const tag = proto === null
+                ? "[Object: null prototype] "
+                : proto !== Object.prototype && proto?.constructor?.name
+                    ? `${proto.constructor.name} `
+                    : "";
+            if (keys.length === 0)
+                return `${tag}{}`;
+            const rows = keys.map((k) => {
+                const name = typeof k === "symbol"
+                    ? `[${String(k)}]`
+                    : /^[A-Za-z_$][\w$]*$/.test(k)
+                        ? k
+                        : JSON.stringify(k);
+                return `${name}: ${indent(render(obj[k]))}`;
+            });
+            return `${tag}{\n  ${rows.join(",\n  ")},\n}`;
+        }
+        finally {
+            seen.delete(obj);
+        }
+    };
+    return render(value);
+}
+/** Line-level diff of two formatted values (`-` actual, `+` expected). */
+function diff(actual, expected) {
+    const a = format(actual).split("\n");
+    const b = format(expected).split("\n");
+    // LCS over lines: values printed for assertion failures are small.
+    const lcs = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+    for (let i = a.length - 1; i >= 0; i--) {
+        for (let j = b.length - 1; j >= 0; j--) {
+            lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length || j < b.length) {
+        if (i < a.length && j < b.length && a[i] === b[j]) {
+            out.push(`    ${a[i]}`);
+            i++;
+            j++;
+        }
+        else if (j < b.length && (i >= a.length || lcs[i][j + 1] >= lcs[i + 1][j])) {
+            out.push(`+   ${b[j++]}`);
+        }
+        else {
+            out.push(`-   ${a[i++]}`);
+        }
+    }
+    return out.join("\n");
+}
+const suffix = (msg) => (msg ? `: ${msg}` : "");
+// ---------------------------------------------------------------------------
+// Equality
+// ---------------------------------------------------------------------------
+/**
+ * Deep structural equality: same constructor, same own enumerable keys
+ * (strings and symbols), recursively equal values. `NaN` equals `NaN`;
+ * `0` and `-0` differ. Maps and Sets compare by content, order-insensitive.
+ */
+export function equal(a, b) {
+    const seen = new Map();
+    const eq = (x, y) => {
+        if (Object.is(x, y))
+            return true;
+        if (typeof x !== "object" || typeof y !== "object" || x === null || y === null) {
+            return false;
+        }
+        if (seen.get(x) === y)
+            return true;
+        if (Object.getPrototypeOf(x) !== Object.getPrototypeOf(y))
+            return false;
+        seen.set(x, y);
+        if (x instanceof Date)
+            return Object.is(x.getTime(), y.getTime());
+        if (x instanceof RegExp)
+            return String(x) === String(y);
+        if (typeof URL !== "undefined" && x instanceof URL)
+            return x.href === y.href;
+        if (x instanceof WeakMap || x instanceof WeakSet || x instanceof WeakRef) {
+            throw new TypeError("cannot compare WeakMap, WeakSet or WeakRef instances");
+        }
+        if (x instanceof Number || x instanceof String || x instanceof Boolean) {
+            if (!Object.is(x.valueOf(), y.valueOf()))
+                return false;
+        }
+        if (x instanceof ArrayBuffer) {
+            return eq(new Uint8Array(x), new Uint8Array(y));
+        }
+        if (x instanceof DataView) {
+            return eq(new Uint8Array(x.buffer, x.byteOffset, x.byteLength), new Uint8Array(y.buffer, y.byteOffset, y.byteLength));
+        }
+        if (ArrayBuffer.isView(x)) {
+            const xa = x;
+            const ya = y;
+            if (xa.length !== ya.length)
+                return false;
+            for (let i = 0; i < xa.length; i++)
+                if (!Object.is(xa[i], ya[i]))
+                    return false;
+            return true;
+        }
+        if (x instanceof Map) {
+            const ym = y;
+            if (x.size !== ym.size)
+                return false;
+            const unmatched = [...ym];
+            for (const [k, v] of x) {
+                const idx = unmatched.findIndex(([k2, v2]) => eq(k, k2) && eq(v, v2));
+                if (idx === -1)
+                    return false;
+                unmatched.splice(idx, 1);
+            }
+            return true;
+        }
+        if (x instanceof Set) {
+            const ys = y;
+            if (x.size !== ys.size)
+                return false;
+            const unmatched = [...ys];
+            for (const v of x) {
+                const idx = unmatched.findIndex((v2) => eq(v, v2));
+                if (idx === -1)
+                    return false;
+                unmatched.splice(idx, 1);
+            }
+            return true;
+        }
+        if (x instanceof Error) {
+            const ye = y;
+            if (x.name !== ye.name || x.message !== ye.message)
+                return false;
+        }
+        const keysOf = (o) => [
+            ...Object.keys(o),
+            ...Object.getOwnPropertySymbols(o).filter((s) => Object.prototype.propertyIsEnumerable.call(o, s)),
+        ];
+        const xk = keysOf(x);
+        const yk = keysOf(y);
+        if (xk.length !== yk.length)
+            return false;
+        const rec = (o, k) => o[k];
+        for (const k of xk) {
+            if (!Object.prototype.hasOwnProperty.call(y, k))
+                return false;
+            if (!eq(rec(x, k), rec(y, k)))
+                return false;
+        }
+        return true;
+    };
+    return eq(a, b);
+}
+// ---------------------------------------------------------------------------
+// Assertions
+// ---------------------------------------------------------------------------
+/** Assert that `expr` is truthy. */
+export function assert(expr, msg = "") {
+    if (!expr)
+        throw new AssertionError(msg || "Expected value to be truthy");
+}
+/** Assert that `expr` is falsy. */
+export function assertFalse(expr, msg = "") {
+    if (expr)
+        throw new AssertionError(msg || `Expected value to be falsy, got ${format(expr)}`);
+}
+/** Deep equality (see {@link equal}). */
+export function assertEquals(actual, expected, msg) {
+    if (equal(actual, expected))
+        return;
+    throw new AssertionError(`Values are not equal${suffix(msg)}\n\n    [Diff] Actual / Expected\n\n${diff(actual, expected)}\n`);
+}
+export function assertNotEquals(actual, expected, msg) {
+    if (!equal(actual, expected))
+        return;
+    throw new AssertionError(`Expected actual: ${format(actual)} not to be: ${format(expected)}${suffix(msg)}`);
+}
+/** Identity (`Object.is`). */
+export function assertStrictEquals(actual, expected, msg) {
+    if (Object.is(actual, expected))
+        return;
+    const sameRendering = format(actual) === format(expected);
+    throw new AssertionError(sameRendering
+        ? `Values have the same structure but are not reference-equal${suffix(msg)}\n\n    ${format(actual).replace(/\n/g, "\n    ")}\n`
+        : `Values are not strictly equal${suffix(msg)}\n\n    [Diff] Actual / Expected\n\n${diff(actual, expected)}\n`);
+}
+export function assertNotStrictEquals(actual, expected, msg) {
+    if (!Object.is(actual, expected))
+        return;
+    throw new AssertionError(`Expected "actual" to not be strictly equal to: ${format(expected)}${suffix(msg)}`);
+}
+/** |actual - expected| <= tolerance (default 1e-7). */
+export function assertAlmostEquals(actual, expected, tolerance = 1e-7, msg) {
+    if (Object.is(actual, expected))
+        return;
+    const delta = Math.abs(expected - actual);
+    if (delta <= tolerance)
+        return;
+    throw new AssertionError(`Expected actual: "${actual}" to be close to "${expected}": delta "${delta}" is greater than "${tolerance}"${suffix(msg)}`);
+}
+/** Not `null` and not `undefined`. */
+export function assertExists(actual, msg) {
+    if (actual === undefined || actual === null) {
+        throw new AssertionError(msg || `Expected actual: "${actual}" to not be null or undefined`);
+    }
+}
+export function assertInstanceOf(actual, expectedType, msg) {
+    if (actual instanceof expectedType)
+        return;
+    const got = actual === null
+        ? "null"
+        : typeof actual === "object"
+            ? (Object.getPrototypeOf(actual)?.constructor?.name ?? "Object")
+            : typeof actual;
+    throw new AssertionError(`Expected object to be an instance of "${expectedType.name}" but was "${got}"${suffix(msg)}`);
+}
+export function assertNotInstanceOf(actual, unexpectedType, msg) {
+    if (!(actual instanceof unexpectedType))
+        return;
+    throw new AssertionError(`Expected object to not be an instance of "${unexpectedType.name}"${suffix(msg)}`);
+}
+export function assertStringIncludes(actual, expected, msg) {
+    if (typeof actual === "string" && actual.includes(expected))
+        return;
+    throw new AssertionError(msg || `Expected actual: ${format(actual)} to contain: ${format(expected)}`);
+}
+export function assertMatch(actual, expected, msg) {
+    expected.lastIndex = 0;
+    if (expected.test(actual))
+        return;
+    throw new AssertionError(msg || `Expected actual: ${format(actual)} to match: ${expected}`);
+}
+export function assertNotMatch(actual, expected, msg) {
+    expected.lastIndex = 0;
+    if (!expected.test(actual))
+        return;
+    throw new AssertionError(msg || `Expected actual: ${format(actual)} to not match: ${expected}`);
+}
+/** Every element of `expected` is deep-equal to some element of `actual`. */
+export function assertArrayIncludes(actual, expected, msg) {
+    const missing = [];
+    for (const e of Array.from(expected)) {
+        if (!Array.from(actual).some((a) => equal(a, e)))
+            missing.push(e);
+    }
+    if (missing.length === 0)
+        return;
+    throw new AssertionError(msg || `Expected actual: ${format(actual)} to include: ${format(expected)}\nmissing: ${format(missing)}`);
+}
+/** `actual` contains (recursively) every key/value of `expected`. */
+export function assertObjectMatch(actual, expected, msg) {
+    const pick = (a, e) => {
+        if (Array.isArray(e) && Array.isArray(a))
+            return a.map((x, i) => (i < e.length ? pick(x, e[i]) : x));
+        if (e && typeof e === "object" && a && typeof a === "object" && !(e instanceof Date) && !(e instanceof RegExp)) {
+            const out = {};
+            for (const k of Reflect.ownKeys(e)) {
+                if (k in a)
+                    out[k] = pick(a[k], e[k]);
+            }
+            return out;
+        }
+        return a;
+    };
+    assertEquals(pick(actual, expected), expected, msg);
+}
+export function assertGreater(actual, expected, msg) {
+    if (actual > expected)
+        return;
+    throw new AssertionError(msg || `Expect ${format(actual)} > ${format(expected)}`);
+}
+export function assertGreaterOrEqual(actual, expected, msg) {
+    if (actual >= expected)
+        return;
+    throw new AssertionError(msg || `Expect ${format(actual)} >= ${format(expected)}`);
+}
+export function assertLess(actual, expected, msg) {
+    if (actual < expected)
+        return;
+    throw new AssertionError(msg || `Expect ${format(actual)} < ${format(expected)}`);
+}
+export function assertLessOrEqual(actual, expected, msg) {
+    if (actual <= expected)
+        return;
+    throw new AssertionError(msg || `Expect ${format(actual)} <= ${format(expected)}`);
+}
+function checkError(err, ErrorClass, msgIncludes, msg) {
+    if (!ErrorClass)
+        return;
+    if (!(err instanceof ErrorClass)) {
+        throw new AssertionError(`Expected error to be instance of "${ErrorClass.name}", but was "${err instanceof Error ? err.constructor.name : typeof err}"${suffix(msg)}`);
+    }
+    if (msgIncludes !== undefined && !String(err.message).includes(msgIncludes)) {
+        throw new AssertionError(`Expected error message to include ${format(msgIncludes)}, but got ${format(err.message)}${suffix(msg)}`);
+    }
+}
+export function assertThrows(fn, classOrMsg, msgIncludes, msg) {
+    const ErrorClass = typeof classOrMsg === "function" ? classOrMsg : undefined;
+    if (typeof classOrMsg === "string")
+        msg = classOrMsg;
+    let thrown = false;
+    let error;
+    try {
+        fn();
+    }
+    catch (err) {
+        thrown = true;
+        error = err;
+    }
+    if (!thrown)
+        throw new AssertionError(`Expected function to throw${suffix(msg)}`);
+    checkError(error, ErrorClass, msgIncludes, msg);
+    return error;
+}
+export async function assertRejects(fn, classOrMsg, msgIncludes, msg) {
+    const ErrorClass = typeof classOrMsg === "function" ? classOrMsg : undefined;
+    if (typeof classOrMsg === "string")
+        msg = classOrMsg;
+    let p;
+    try {
+        p = typeof fn === "function" ? fn() : fn;
+    }
+    catch {
+        // A synchronous throw is not a rejection (an async function never does this).
+        throw new AssertionError(`Function throws when expected to reject${suffix(msg)}`);
+    }
+    if (!p || typeof p.then !== "function") {
+        throw new AssertionError(`Function returns a non-promise when expected to reject${suffix(msg)}`);
+    }
+    let rejected = false;
+    let error;
+    try {
+        await p;
+    }
+    catch (err) {
+        rejected = true;
+        error = err;
+    }
+    if (!rejected)
+        throw new AssertionError(`Expected function to reject${suffix(msg)}`);
+    checkError(error, ErrorClass, msgIncludes, msg);
+    return error;
+}
+/** Unconditionally fail. */
+export function fail(msg) {
+    throw new AssertionError(`Failed assertion${suffix(msg)}`);
+}
+export function unreachable(msg) {
+    throw new AssertionError(msg ?? "Unreachable");
+}
+export function unimplemented(msg) {
+    throw new AssertionError(msg ?? "Unimplemented");
+}

package/dist/test/node.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `1tube/test` everywhere else (the default export condition): drives the
+ * standard `node:test` runner, which Node runs natively and other runtimes
+ * implement for compatibility.
+ */
+import type { DescribeFunction, Hook, TestFunction, TestRuntime } from "./api.ts";
+export * from "./assert.ts";
+export type * from "./api.ts";
+export declare const runtime: TestRuntime;
+export declare const test: TestFunction;
+export declare const describe: DescribeFunction;
+export declare const beforeAll: Hook;
+export declare const afterAll: Hook;
+export declare const beforeEach: Hook;
+export declare const afterEach: Hook;

package/dist/test/node.js

@@ -0,0 +1,29 @@
+/**
+ * `1tube/test` everywhere else (the default export condition): drives the
+ * standard `node:test` runner, which Node runs natively and other runtimes
+ * implement for compatibility.
+ */
+import * as node from "node:test";
+export * from "./assert.js";
+export const runtime = "node";
+// node:test passes a context (and a `done` callback to 2-arity functions);
+// the 1tube contract has neither, so wrap to keep the arity at zero.
+const register = (name, fn, options) => node.test(name, { timeout: options.timeout, skip: options.skip, only: options.only }, async () => {
+    await fn();
+});
+export const test = Object.assign((name, fn, options = {}) => void register(name, fn, options), {
+    skip: (name, fn, options = {}) => void register(name, fn, { ...options, skip: true }),
+    only: (name, fn, options = {}) => void register(name, fn, { ...options, only: true }),
+    todo: (name) => void node.test(name, { todo: true }),
+});
+export const describe = Object.assign((name, fn) => void node.describe(name, fn), {
+    skip: (name, fn) => void node.describe(name, { skip: true }, fn),
+    only: (name, fn) => void node.describe(name, { only: true }, fn),
+});
+const hook = (register) => (fn) => register(async () => {
+    await fn();
+});
+export const beforeAll = hook((fn) => node.before(fn));
+export const afterAll = hook((fn) => node.after(fn));
+export const beforeEach = hook((fn) => node.beforeEach(fn));
+export const afterEach = hook((fn) => node.afterEach(fn));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "1tube",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "private": false,
   "description": "Self-hosted Supabase Edge Functions gateway on Bun, plus an ESLint plugin for consumers",
   "license": "MIT",
@@ -29,6 +29,12 @@
       "import": "./dist/warmup-client.js",
       "default": "./dist/warmup-client.js"
     },
+    "./test": {
+      "types": "./dist/test/node.d.ts",
+      "bun": "./src/test/bun.ts",
+      "import": "./dist/test/node.js",
+      "default": "./dist/test/node.js"
+    },
     "./eslint-plugin": "./eslint-plugin.js",
     "./package.json": "./package.json"
   },
@@ -56,7 +62,7 @@
     "play:workerd": "bun src/cli.ts --backend workerd --dev --hmr --functions ./playground --port 3199",
     "build": "bun src/cli.ts build",
     "test": "bun test --timeout 60000",
-    "build:edge": "bunx tsc --ignoreConfig --target ES2022 --module ESNext --moduleResolution Bundler --declaration --outDir dist src/edge.ts src/edge-caller.ts src/warmup-client.ts",
+    "build:edge": "bunx tsc --ignoreConfig --target ES2022 --module ESNext --moduleResolution Bundler --declaration --rewriteRelativeImportExtensions --types node --outDir dist src/edge.ts src/edge-caller.ts src/warmup-client.ts src/test/node.ts",
     "prepack": "bun run build:edge",
     "typecheck": "bun check",
     "smoke:bin": "node ./scripts/npm-cli.js --version",

package/src/backends/workerd/backend.ts

@@ -892,7 +892,7 @@ export function createWorkerdBackend(
     : resolvePath(cwd, opts.configPath);
   const configPath = existsSync(requestedConfigPath)
     ? requestedConfigPath
-    : process.env["1TUBE_DENO_CONFIG"] ??
+    : process.env["1TUBE_IMPORT_MAP"] ?? process.env["1TUBE_DENO_CONFIG"] ??
       findDenoConfig(cwd, functionsDir) ?? requestedConfigPath;
   const workerdBin = opts.workerdBin ?? process.env["1TUBE_WORKERD_BIN"] ??
     "workerd";

package/src/cli/build.ts

@@ -563,8 +563,8 @@ export async function runBuild(args: string[]): Promise<number> {
   // Resolve the deno.json import map. Three modes, in priority order:
   //   1. --config <path>          → explicit, must exist (we hard-fail if not)
   //   2. --no-config              → explicit "build with no import map"
-  //   3. <auto-detect>            → cwd/deno.json[c], then
-  //                                 <functions-dir>/deno.json[c] (Supabase
+  //   3. <auto-detect>            → cwd/{import_map,deno}.json[c], then
+  //                                 <functions-dir>/{import_map,deno}.json[c] (Supabase
   //                                 layout), otherwise omit.
   // Auto-detect is the important case: hosts like sciobot-next are Vite/Bun
   // projects with no root deno.json, and the bundler tolerates a missing
@@ -748,8 +748,8 @@ Options:
       --workerd-env A,B,C    Env vars baked into the manifest's allowlist
       --workerd-shared path  Shared module path (repeatable). Defaults include
                              _shared/profile-cache.ts when present.
-      --config <path>        Explicit deno.json path for the import map.
-                             Default: auto-detect cwd/deno.json[c] then
-                             <functions-dir>/deno.json[c] (Supabase layout).
+      --config <path>        Import map path (import_map.json, or deno.json[c]).
+                             Default: auto-detect cwd/{import_map,deno}.json[c] then
+                             <functions-dir>/{import_map,deno}.json[c] (Supabase layout).
       --no-config            Skip the import map entirely.
   -h, --help                 Show this help`;

package/src/cli/deno-config.ts

@@ -8,8 +8,8 @@
  *
  *   1. explicit `--config <path>`  → must exist (hard error otherwise)
  *   2. explicit `--no-config`      → skip the import map entirely
- *   3. auto-detect                 → cwd/deno.json[c] then
- *                                    <functions-dir>/deno.json[c]
+ *   3. auto-detect                 → cwd/{import_map,deno}.json[c] then
+ *                                    <functions-dir>/{import_map,deno}.json[c]
  *
  * The functions-dir fallback is what makes this work for hosts like
  * sciobot-next: a Vite/Bun project whose only `deno.json` lives next to the
@@ -63,11 +63,11 @@ export async function resolveDenoConfigPath(
     : resolvePath(cwd, functionsDir);
   const found = findDenoConfig(cwd, fnDirAbs);
   if (found) {
-    onMessage?.(`using deno config: ${found}`);
+    onMessage?.(`using import map: ${found}`);
     return { configPath: found };
   }
   onMessage?.(
-    `no deno.json / deno.jsonc at ${cwd} or ${fnDirAbs} — bundling ` +
+    `no import_map.json / deno.json[c] at ${cwd} or ${fnDirAbs} — bundling ` +
       `without an import map. Pass --config <path> if you want one.`,
   );
   return {};