comisai 1.0.11 → 1.0.12

package/node_modules/@comis/memory/dist/sqlite-secret-store.test.d.ts

@@ -1,8 +0,0 @@
-/**
- * Tests for SqliteSecretStore — SecretStorePort implementation with
- * AES-256-GCM encrypted BLOB storage in SQLite.
- *
- * Uses real crypto (no mocks) and temp files for persistence testing.
- * Each test gets a unique temp DB path cleaned up in afterEach.
- */
-export {};

package/node_modules/@comis/memory/dist/sqlite-secret-store.test.js

@@ -1,245 +0,0 @@
-/**
- * Tests for SqliteSecretStore — SecretStorePort implementation with
- * AES-256-GCM encrypted BLOB storage in SQLite.
- *
- * Uses real crypto (no mocks) and temp files for persistence testing.
- * Each test gets a unique temp DB path cleaned up in afterEach.
- */
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import Database from "better-sqlite3";
-import { randomBytes } from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import { createSecretsCrypto } from "@comis/core";
-import { createSqliteSecretStore } from "./sqlite-secret-store.js";
-function makeCrypto() {
-    return createSecretsCrypto(randomBytes(32));
-}
-function tempDbPath() {
-    const dir = os.tmpdir();
-    const name = `comis-test-secrets-${randomBytes(8).toString("hex")}.db`;
-    return `${dir}/${name}`;
-}
-/** Unwrap a Result or fail the test. */
-function unwrap(result) {
-    if (!result.ok) {
-        throw new Error(`Expected ok result, got error: ${result.error.message}`);
-    }
-    return result.value;
-}
-describe("createSqliteSecretStore", () => {
-    let dbPath;
-    let crypto;
-    beforeEach(() => {
-        dbPath = tempDbPath();
-        crypto = makeCrypto();
-    });
-    afterEach(() => {
-        // Clean up temp database files
-        for (const suffix of ["", "-wal", "-shm"]) {
-            try {
-                fs.unlinkSync(dbPath + suffix);
-            }
-            catch {
-                // File may not exist
-            }
-        }
-    });
-    describe("set + getDecrypted round-trip", () => {
-        it("stores and retrieves a secret", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            const setResult = store.set("API_KEY", "sk-secret-123");
-            expect(setResult.ok).toBe(true);
-            const plaintext = unwrap(store.getDecrypted("API_KEY"));
-            expect(plaintext).toBe("sk-secret-123");
-            store.close();
-        });
-    });
-    describe("UPSERT behavior", () => {
-        it("preserves created_at on update, changes updated_at", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            store.set("MY_SECRET", "original-value");
-            // Get metadata before update
-            const beforeItems = unwrap(store.list());
-            const beforeMeta = beforeItems.find((m) => m.name === "MY_SECRET");
-            expect(beforeMeta).toBeDefined();
-            const createdBefore = beforeMeta.createdAt;
-            // Small delay to ensure timestamp difference
-            const now = Date.now();
-            while (Date.now() === now) {
-                // busy-wait for at least 1ms
-            }
-            store.set("MY_SECRET", "updated-value");
-            const afterItems = unwrap(store.list());
-            const afterMeta = afterItems.find((m) => m.name === "MY_SECRET");
-            expect(afterMeta).toBeDefined();
-            // created_at preserved
-            expect(afterMeta.createdAt).toBe(createdBefore);
-            // updated_at changed
-            expect(afterMeta.updatedAt).toBeGreaterThanOrEqual(createdBefore);
-            // Value updated
-            const plaintext = unwrap(store.getDecrypted("MY_SECRET"));
-            expect(plaintext).toBe("updated-value");
-            store.close();
-        });
-    });
-    describe("getDecrypted", () => {
-        it("returns ok(undefined) for missing secret", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            const plaintext = unwrap(store.getDecrypted("NONEXISTENT"));
-            expect(plaintext).toBeUndefined();
-            store.close();
-        });
-    });
-    describe("decryptAll", () => {
-        it("returns all stored secrets as Map", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            store.set("KEY_A", "value-a");
-            store.set("KEY_B", "value-b");
-            store.set("KEY_C", "value-c");
-            const map = unwrap(store.decryptAll());
-            expect(map.size).toBe(3);
-            expect(map.get("KEY_A")).toBe("value-a");
-            expect(map.get("KEY_B")).toBe("value-b");
-            expect(map.get("KEY_C")).toBe("value-c");
-            store.close();
-        });
-        it("returns empty Map on empty store", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            const map = unwrap(store.decryptAll());
-            expect(map.size).toBe(0);
-            store.close();
-        });
-        it("excludes canary from results", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            store.set("USER_SECRET", "my-value");
-            const map = unwrap(store.decryptAll());
-            // Should only contain user secret, not canary
-            expect(map.has("__comis_canary__")).toBe(false);
-            expect(map.size).toBe(1);
-            expect(map.get("USER_SECRET")).toBe("my-value");
-            store.close();
-        });
-    });
-    describe("exists", () => {
-        it("returns true for stored secret, false for missing", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            expect(store.exists("ABSENT")).toBe(false);
-            store.set("PRESENT", "value");
-            expect(store.exists("PRESENT")).toBe(true);
-            store.close();
-        });
-    });
-    describe("list", () => {
-        it("returns metadata without secret values", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            store.set("DB_PASSWORD", "secret123", {
-                provider: "postgres",
-                description: "Main database password",
-            });
-            const items = unwrap(store.list());
-            expect(items).toHaveLength(1);
-            const item = items[0];
-            expect(item.name).toBe("DB_PASSWORD");
-            expect(item.provider).toBe("postgres");
-            expect(item.description).toBe("Main database password");
-            expect(item.usageCount).toBe(0);
-            expect(item.createdAt).toBeTypeOf("number");
-            expect(item.updatedAt).toBeTypeOf("number");
-            // No secret value in metadata
-            expect(item).not.toHaveProperty("ciphertext");
-            expect(item).not.toHaveProperty("iv");
-            expect(item).not.toHaveProperty("authTag");
-            expect(item).not.toHaveProperty("salt");
-            expect(item).not.toHaveProperty("plaintext");
-            store.close();
-        });
-        it("excludes canary from list results", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            store.set("VISIBLE_SECRET", "hello");
-            const items = unwrap(store.list());
-            const names = items.map((i) => i.name);
-            expect(names).not.toContain("__comis_canary__");
-            expect(names).toContain("VISIBLE_SECRET");
-            store.close();
-        });
-    });
-    describe("delete", () => {
-        it("returns ok(true) for existing secret", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            store.set("TO_DELETE", "value");
-            const deleted = unwrap(store.delete("TO_DELETE"));
-            expect(deleted).toBe(true);
-            // Confirm deleted
-            expect(store.exists("TO_DELETE")).toBe(false);
-            store.close();
-        });
-        it("returns ok(false) for non-existent secret", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            const deleted = unwrap(store.delete("DOES_NOT_EXIST"));
-            expect(deleted).toBe(false);
-            store.close();
-        });
-    });
-    describe("recordUsage", () => {
-        it("increments usage_count and updates last_used_at", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            store.set("TRACKED", "value");
-            // Initial state
-            const beforeItems = unwrap(store.list());
-            const before = beforeItems.find((m) => m.name === "TRACKED");
-            expect(before.usageCount).toBe(0);
-            expect(before.lastUsedAt).toBeUndefined();
-            // Record usage
-            store.recordUsage("TRACKED");
-            const afterItems = unwrap(store.list());
-            const after = afterItems.find((m) => m.name === "TRACKED");
-            expect(after.usageCount).toBe(1);
-            expect(after.lastUsedAt).toBeTypeOf("number");
-            // Record again
-            store.recordUsage("TRACKED");
-            const finalItems = unwrap(store.list());
-            const final = finalItems.find((m) => m.name === "TRACKED");
-            expect(final.usageCount).toBe(2);
-            store.close();
-        });
-    });
-    describe("close", () => {
-        it("does not throw", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            expect(() => store.close()).not.toThrow();
-        });
-    });
-    describe("WAL mode", () => {
-        it("enables WAL journal mode", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            // Open a new connection to verify WAL mode persists
-            const db = new Database(dbPath);
-            const row = db.prepare("PRAGMA journal_mode").get();
-            expect(row.journal_mode).toBe("wal");
-            db.close();
-            store.close();
-        });
-    });
-    describe("file permissions", () => {
-        it("sets 0o600 on secrets.db", () => {
-            const store = createSqliteSecretStore(dbPath, crypto);
-            const stat = fs.statSync(dbPath);
-            // Check file mode (lower 9 bits)
-            const mode = stat.mode & 0o777;
-            expect(mode).toBe(0o600);
-            store.close();
-        });
-    });
-    describe("persistence", () => {
-        it("survives close and reopen", () => {
-            const store1 = createSqliteSecretStore(dbPath, crypto);
-            store1.set("PERSIST_KEY", "persist-value");
-            store1.close();
-            const store2 = createSqliteSecretStore(dbPath, crypto);
-            const plaintext = unwrap(store2.getDecrypted("PERSIST_KEY"));
-            expect(plaintext).toBe("persist-value");
-            store2.close();
-        });
-    });
-});

package/node_modules/@comis/shared/dist/abort.test.d.ts

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

package/node_modules/@comis/shared/dist/abort.test.js

@@ -1,71 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { checkAborted } from "./abort.js";
-describe("checkAborted", () => {
-    it("returns ok when signal is undefined", () => {
-        const result = checkAborted(undefined);
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            expect(result.value).toBeUndefined();
-        }
-    });
-    it("returns ok when signal is not aborted", () => {
-        const controller = new AbortController();
-        const result = checkAborted(controller.signal);
-        expect(result.ok).toBe(true);
-        if (result.ok) {
-            expect(result.value).toBeUndefined();
-        }
-    });
-    it("returns err when signal is aborted", () => {
-        const controller = new AbortController();
-        controller.abort("custom reason");
-        const result = checkAborted(controller.signal);
-        expect(result.ok).toBe(false);
-        if (!result.ok) {
-            expect(result.error).toBeInstanceOf(Error);
-            expect(result.error.message).toBe("custom reason");
-        }
-    });
-    it("preserves Error reason directly when signal.reason is an Error", () => {
-        const controller = new AbortController();
-        const originalError = new Error("specific abort reason");
-        controller.abort(originalError);
-        const result = checkAborted(controller.signal);
-        expect(result.ok).toBe(false);
-        if (!result.ok) {
-            expect(result.error).toBe(originalError);
-            expect(result.error.message).toBe("specific abort reason");
-        }
-    });
-    it("wraps string reason in Error", () => {
-        const controller = new AbortController();
-        controller.abort("string reason");
-        const result = checkAborted(controller.signal);
-        expect(result.ok).toBe(false);
-        if (!result.ok) {
-            expect(result.error).toBeInstanceOf(Error);
-            expect(result.error.message).toBe("string reason");
-        }
-    });
-    it("defaults to 'Aborted' when no reason is set", () => {
-        const controller = new AbortController();
-        controller.abort();
-        const result = checkAborted(controller.signal);
-        expect(result.ok).toBe(false);
-        if (!result.ok) {
-            expect(result.error).toBeInstanceOf(Error);
-            // AbortController.abort() without args sets reason to a DOMException
-            // in Node.js, but our function handles the general case
-            expect(result.error.message).toBeTruthy();
-        }
-    });
-    it("returns err immediately for pre-aborted signal (AbortSignal.abort())", () => {
-        const signal = AbortSignal.abort("pre-aborted");
-        const result = checkAborted(signal);
-        expect(result.ok).toBe(false);
-        if (!result.ok) {
-            expect(result.error).toBeInstanceOf(Error);
-            expect(result.error.message).toBe("pre-aborted");
-        }
-    });
-});

package/node_modules/@comis/shared/dist/result.test.d.ts

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

package/node_modules/@comis/shared/dist/result.test.js

@@ -1,178 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { ok, err, tryCatch, fromPromise } from "./result.js";
-describe("Result<T, E>", () => {
-    describe("ok()", () => {
-        it("returns { ok: true, value: T }", () => {
-            const result = ok(42);
-            expect(result).toEqual({ ok: true, value: 42 });
-        });
-        it("allows access to .value when narrowed via ok === true", () => {
-            const result = ok(42);
-            if (result.ok) {
-                // TypeScript narrows to { ok: true, value: number }
-                expect(result.value).toBe(42);
-            }
-            else {
-                throw new Error("Should not reach here");
-            }
-        });
-        it("works with complex types", () => {
-            const result = ok({ name: "test", count: 3 });
-            expect(result.ok).toBe(true);
-            if (result.ok) {
-                expect(result.value.name).toBe("test");
-                expect(result.value.count).toBe(3);
-            }
-        });
-    });
-    describe("err()", () => {
-        it("returns { ok: false, error: E }", () => {
-            const error = new Error("fail");
-            const result = err(error);
-            expect(result).toEqual({ ok: false, error });
-        });
-        it("allows access to .error when narrowed via ok === false", () => {
-            const result = err(new Error("fail"));
-            if (!result.ok) {
-                // TypeScript narrows to { ok: false, error: Error }
-                expect(result.error.message).toBe("fail");
-            }
-            else {
-                throw new Error("Should not reach here");
-            }
-        });
-        it("works with custom error types", () => {
-            const result = err({ code: "NOT_FOUND", message: "not found" });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error.code).toBe("NOT_FOUND");
-            }
-        });
-    });
-    describe("tryCatch()", () => {
-        it("returns ok(value) when function succeeds", () => {
-            const result = tryCatch(() => 42);
-            expect(result).toEqual({ ok: true, value: 42 });
-        });
-        it("returns err(Error) when function throws Error", () => {
-            const result = tryCatch(() => {
-                throw new Error("boom");
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error).toBeInstanceOf(Error);
-                expect(result.error.message).toBe("boom");
-            }
-        });
-        it("wraps non-Error thrown values in Error", () => {
-            const result = tryCatch(() => {
-                throw "string error";
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error).toBeInstanceOf(Error);
-                expect(result.error.message).toBe("string error");
-            }
-        });
-        it("wraps thrown numbers in Error", () => {
-            const result = tryCatch(() => {
-                throw 404;
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error).toBeInstanceOf(Error);
-                expect(result.error.message).toBe("404");
-            }
-        });
-        it("handles malicious object with toString() that throws", () => {
-            const malicious = {
-                toString() {
-                    throw new Error("toString attack");
-                },
-            };
-            const result = tryCatch(() => {
-                throw malicious;
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error).toBeInstanceOf(Error);
-                expect(result.error.message).toBe("[non-stringifiable value]");
-            }
-        });
-    });
-    describe("fromPromise()", () => {
-        it("returns ok(value) when promise resolves", async () => {
-            const result = await fromPromise(Promise.resolve(42));
-            expect(result).toEqual({ ok: true, value: 42 });
-        });
-        it("returns err(Error) when promise rejects with Error", async () => {
-            const result = await fromPromise(Promise.reject(new Error("boom")));
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error).toBeInstanceOf(Error);
-                expect(result.error.message).toBe("boom");
-            }
-        });
-        it("wraps non-Error rejection in Error", async () => {
-            const result = await fromPromise(Promise.reject("string"));
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error).toBeInstanceOf(Error);
-                expect(result.error.message).toBe("string");
-            }
-        });
-        it("wraps null rejection in Error", async () => {
-            const result = await fromPromise(Promise.reject(null));
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error).toBeInstanceOf(Error);
-                expect(result.error.message).toBe("null");
-            }
-        });
-        it("handles malicious object with toString() that throws", async () => {
-            const malicious = {
-                toString() {
-                    throw new Error("toString attack");
-                },
-            };
-            const result = await fromPromise(Promise.reject(malicious));
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error).toBeInstanceOf(Error);
-                expect(result.error.message).toBe("[non-stringifiable value]");
-            }
-        });
-        it("wraps undefined rejection in Error", async () => {
-            const result = await fromPromise(Promise.reject(undefined));
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error).toBeInstanceOf(Error);
-                expect(result.error.message).toBe("undefined");
-            }
-        });
-    });
-    describe("tryCatch() - undefined edge cases", () => {
-        it("wraps thrown undefined in Error", () => {
-            const result = tryCatch(() => {
-                throw undefined;
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error).toBeInstanceOf(Error);
-                expect(result.error.message).toBe("undefined");
-            }
-        });
-        it("wraps thrown void (undefined) in Error", () => {
-            // eslint-disable-next-line @typescript-eslint/no-throw-literal
-            const result = tryCatch(() => {
-                // This explicitly tests the edge case of a void throw
-                throw void 0;
-            });
-            expect(result.ok).toBe(false);
-            if (!result.ok) {
-                expect(result.error).toBeInstanceOf(Error);
-                expect(result.error.message).toBe("undefined");
-            }
-        });
-    });
-});

package/node_modules/@comis/shared/dist/suppress-error.test.d.ts

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

package/node_modules/@comis/shared/dist/suppress-error.test.js

@@ -1,50 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { suppressError } from "./suppress-error.js";
-describe("suppressError()", () => {
-    it("does not throw when promise rejects", () => {
-        expect(() => {
-            suppressError(Promise.reject(new Error("test")), "cleanup");
-        }).not.toThrow();
-    });
-    it("logs the error reason at debug level when no logger provided", async () => {
-        const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => { });
-        suppressError(Promise.reject(new Error("test error")), "cleanup task");
-        // Wait for the microtask queue to flush
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(debugSpy).toHaveBeenCalledWith("Suppressed error (cleanup task): test error");
-        expect(debugSpy).toHaveBeenCalledTimes(1);
-        debugSpy.mockRestore();
-    });
-    it("uses custom logger when provided", async () => {
-        const debugSpy = vi.spyOn(console, "debug").mockImplementation(() => { });
-        const customLogger = vi.fn();
-        suppressError(Promise.reject(new Error("custom error")), "custom task", customLogger);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(customLogger).toHaveBeenCalledTimes(1);
-        expect(customLogger).toHaveBeenCalledWith("Suppressed error (custom task): custom error");
-        // console.debug should NOT be called when custom logger is provided
-        expect(debugSpy).not.toHaveBeenCalled();
-        debugSpy.mockRestore();
-    });
-    it("passes formatted error message string to custom logger", async () => {
-        const customLogger = vi.fn();
-        suppressError(Promise.reject(new Error("something broke")), "retry cleanup", customLogger);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(customLogger).toHaveBeenCalledWith("Suppressed error (retry cleanup): something broke");
-    });
-    it("handles non-Error rejection with custom logger", async () => {
-        const customLogger = vi.fn();
-        suppressError(Promise.reject("plain string rejection"), "string reject", customLogger);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        expect(customLogger).toHaveBeenCalledWith("Suppressed error (string reject): plain string rejection");
-    });
-    it("does not cause unhandled rejection", async () => {
-        const unhandledHandler = vi.fn();
-        process.on("unhandledRejection", unhandledHandler);
-        suppressError(Promise.reject(new Error("should be caught")), "test");
-        // Wait enough for unhandledRejection to fire if it were going to
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        expect(unhandledHandler).not.toHaveBeenCalled();
-        process.removeListener("unhandledRejection", unhandledHandler);
-    });
-});

package/node_modules/@comis/shared/dist/timeout.test.d.ts

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

package/node_modules/@comis/shared/dist/timeout.test.js

@@ -1,75 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { withTimeout, TimeoutError } from "./timeout.js";
-describe("TimeoutError", () => {
-    it("has name set to 'TimeoutError'", () => {
-        const error = new TimeoutError(5000);
-        expect(error.name).toBe("TimeoutError");
-    });
-    it("is instanceof Error", () => {
-        const error = new TimeoutError(5000);
-        expect(error).toBeInstanceOf(Error);
-    });
-    it("has correct timeoutMs property", () => {
-        const error = new TimeoutError(3000);
-        expect(error.timeoutMs).toBe(3000);
-    });
-    it("formats message with label", () => {
-        const error = new TimeoutError(5000, "MCP connect");
-        expect(error.message).toBe("MCP connect timed out after 5000ms");
-    });
-    it("formats message without label", () => {
-        const error = new TimeoutError(5000);
-        expect(error.message).toBe("Operation timed out after 5000ms");
-    });
-});
-describe("withTimeout", () => {
-    it("resolves when promise completes before timeout", async () => {
-        const result = await withTimeout(Promise.resolve(42), 1000);
-        expect(result).toBe(42);
-    });
-    it("rejects with TimeoutError when timeout fires first", async () => {
-        const neverResolves = new Promise(() => { });
-        await expect(withTimeout(neverResolves, 10, "test op")).rejects.toThrow(TimeoutError);
-    });
-    it("TimeoutError has correct timeoutMs on rejection", async () => {
-        const neverResolves = new Promise(() => { });
-        try {
-            await withTimeout(neverResolves, 25, "test op");
-            throw new Error("Should not reach here");
-        }
-        catch (e) {
-            expect(e).toBeInstanceOf(TimeoutError);
-            expect(e.timeoutMs).toBe(25);
-        }
-    });
-    it("timer is cleaned up on success", async () => {
-        vi.useFakeTimers();
-        try {
-            const promise = Promise.resolve("ok");
-            await withTimeout(promise, 60_000);
-            // After resolution, advancing time should not cause issues
-            // (timer was cleared, no pending timers)
-            expect(vi.getTimerCount()).toBe(0);
-        }
-        finally {
-            vi.useRealTimers();
-        }
-    });
-    it("propagates original error when promise rejects before timeout", async () => {
-        const originalError = new Error("original failure");
-        const failing = Promise.reject(originalError);
-        await expect(withTimeout(failing, 5000)).rejects.toThrow("original failure");
-        await expect(withTimeout(Promise.reject(originalError), 5000)).rejects.not.toBeInstanceOf(TimeoutError);
-    });
-    it("no unhandled rejection when original promise rejects after timeout", async () => {
-        // Create a promise that rejects after a short delay
-        const delayedReject = new Promise((_resolve, reject) => {
-            setTimeout(() => reject(new Error("late rejection")), 50);
-        });
-        // The timeout fires first (10ms < 50ms)
-        await expect(withTimeout(delayedReject, 10, "test")).rejects.toThrow(TimeoutError);
-        // Wait for the delayed rejection to fire -- if unhandled rejection
-        // suppression is missing, this would crash the test runner
-        await new Promise((r) => setTimeout(r, 100));
-    });
-});

package/node_modules/@comis/shared/dist/ttl-cache.test.d.ts

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