@freqhole/haruspex 0.0.0

package/dist/testing/identity-fixtures.js

@@ -0,0 +1,21 @@
+// deterministic identity fixture builder for tests that need
+// valid-shaped identity records without real crypto or a running node.
+/** creates a test identity with deterministic fields. `nodeId` defaults to
+ *  a repeating pattern for easy recognition in test output; `secretKey` is
+ *  a short byte sequence sufficient for shape validation but not usable for
+ *  real crypto. */
+export function makeIdentity(nodeId = "ab".repeat(32), createdAt = 1000) {
+    return {
+        secret_key: new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]),
+        node_id: nodeId,
+        created_at: createdAt,
+    };
+}
+/** creates a batch of distinct test identities, each with a unique node id
+ *  derived from the given prefix and an incrementing counter. */
+export function makeIdentities(count, nodeIdPrefix = "node") {
+    return Array.from({ length: count }, (_, i) => {
+        const nodeId = `${nodeIdPrefix}-${i.toString().padStart(2, "0")}`.padEnd(64, "0");
+        return makeIdentity(nodeId, 1000 + i);
+    });
+}

package/dist/testing/identity-fixtures.test.d.ts

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

package/dist/testing/identity-fixtures.test.d.ts.map

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

package/dist/testing/identity-fixtures.test.js

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import { makeIdentities, makeIdentity } from "./identity-fixtures.js";
+describe("makeIdentity", () => {
+    it("produces a valid-shaped identity with default values", () => {
+        const identity = makeIdentity();
+        expect(identity.node_id).toHaveLength(64);
+        expect(identity.secret_key).toBeInstanceOf(Uint8Array);
+        expect(identity.created_at).toBe(1000);
+    });
+    it("accepts custom node id and timestamp", () => {
+        const identity = makeIdentity("custom-node-id".padEnd(64, "x"), 5000);
+        expect(identity.node_id).toBe("custom-node-id".padEnd(64, "x"));
+        expect(identity.created_at).toBe(5000);
+    });
+});
+describe("makeIdentities", () => {
+    it("creates a batch of distinct identities", () => {
+        const identities = makeIdentities(3);
+        expect(identities).toHaveLength(3);
+        const nodeIds = identities.map((i) => i.node_id);
+        expect(new Set(nodeIds).size).toBe(3);
+    });
+    it("uses the given prefix in node ids", () => {
+        const identities = makeIdentities(2, "test");
+        expect(identities[0].node_id).toMatch(/^test-00/);
+        expect(identities[1].node_id).toMatch(/^test-01/);
+    });
+});

package/dist/testing/index.d.ts

@@ -0,0 +1,7 @@
+export { makeIdentity, makeIdentities } from "./identity-fixtures.js";
+export { createFakeWebauthnTransport, FAKE_CEREMONY_DEPS, FAKE_CREDENTIAL, FAKE_REGISTRATION_CHALLENGE, FAKE_AUTHENTICATION_CHALLENGE, resetFakeCeremonyDeps, } from "./webauthn-mocks.js";
+export { makeKnockScope, makeKnockRecord, makeKnockDecision, makeKnockRecords, } from "./knock-fixtures.js";
+export { makeFriendDirectoryEntry, makeFriendDirectoryEntries, makeSavedRemote, makePendingRemote, createFakeEndpointAdapter, type SavedRemote, type PendingRemote, } from "./state-fixtures.js";
+export { loadProtocolFixtures, loadProtocolFixture } from "./protocol-fixtures.js";
+export { setupFakeIndexedDB, teardownFakeIndexedDB } from "./idb-harness.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/testing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EACL,2BAA2B,EAC3B,kBAAkB,EAClB,eAAe,EACf,2BAA2B,EAC3B,6BAA6B,EAC7B,qBAAqB,GACtB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,wBAAwB,EACxB,0BAA0B,EAC1B,eAAe,EACf,iBAAiB,EACjB,yBAAyB,EACzB,KAAK,WAAW,EAChB,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AACnF,OAAO,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/testing/index.js

@@ -0,0 +1,11 @@
+// exported test utilities: doubles and fixtures consuming apps use in
+// their own suites instead of re-rolling mocks. no restriction on what
+// this subpath imports at runtime (it is only ever imported by test
+// files), but its exports stay framework-free - none of these doubles
+// need solid-js.
+export { makeIdentity, makeIdentities } from "./identity-fixtures.js";
+export { createFakeWebauthnTransport, FAKE_CEREMONY_DEPS, FAKE_CREDENTIAL, FAKE_REGISTRATION_CHALLENGE, FAKE_AUTHENTICATION_CHALLENGE, resetFakeCeremonyDeps, } from "./webauthn-mocks.js";
+export { makeKnockScope, makeKnockRecord, makeKnockDecision, makeKnockRecords, } from "./knock-fixtures.js";
+export { makeFriendDirectoryEntry, makeFriendDirectoryEntries, makeSavedRemote, makePendingRemote, createFakeEndpointAdapter, } from "./state-fixtures.js";
+export { loadProtocolFixtures, loadProtocolFixture } from "./protocol-fixtures.js";
+export { setupFakeIndexedDB, teardownFakeIndexedDB } from "./idb-harness.js";

package/dist/testing/knock-fixtures.d.ts

@@ -0,0 +1,13 @@
+import type { KnockDecision, KnockRecord, KnockScope } from "../knock/types.js";
+/** creates a deterministic knock scope for the given kind. */
+export declare function makeKnockScope(kind: "account" | "browse" | "resource", resourceId?: string): KnockScope;
+/** creates a knock record with default test values. all fields are
+ *  overridable via the optional `overrides` argument. */
+export declare function makeKnockRecord(overrides?: Partial<KnockRecord>): KnockRecord;
+/** creates a knock decision for test scenarios where the full audit log
+ *  matters. */
+export declare function makeKnockDecision(outcome: "accepted" | "denied", byNodeId?: string, at?: number, grantedRole?: string): KnockDecision;
+/** creates a batch of knock records with distinct node ids and optional
+ *  shared overrides. */
+export declare function makeKnockRecords(count: number, overrides?: Partial<KnockRecord>): KnockRecord[];
+//# sourceMappingURL=knock-fixtures.d.ts.map

package/dist/testing/knock-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knock-fixtures.d.ts","sourceRoot":"","sources":["../../src/testing/knock-fixtures.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,aAAa,EAEb,WAAW,EACX,UAAU,EAEX,MAAM,mBAAmB,CAAC;AAE3B,8DAA8D;AAC9D,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,UAAU,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,UAAU,CAKvG;AAED;yDACyD;AACzD,wBAAgB,eAAe,CAC7B,SAAS,GAAE,OAAO,CAAC,WAAW,CAAM,GACnC,WAAW,CAeb;AAED;eACe;AACf,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,UAAU,GAAG,QAAQ,EAC9B,QAAQ,SAAkB,EAC1B,EAAE,SAAa,EACf,WAAW,CAAC,EAAE,MAAM,GACnB,aAAa,CAOf;AAED;wBACwB;AACxB,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,OAAO,CAAC,WAAW,CAAM,GACnC,WAAW,EAAE,CAKf"}

package/dist/testing/knock-fixtures.js

@@ -0,0 +1,45 @@
+// fixture builders for knock records and scopes - deterministic test data
+// for exercising knock logic without a live transport or real store.
+/** creates a deterministic knock scope for the given kind. */
+export function makeKnockScope(kind, resourceId) {
+    if (kind === "resource") {
+        return { kind: "resource", resourceId: resourceId ?? "doc-1" };
+    }
+    return { kind };
+}
+/** creates a knock record with default test values. all fields are
+ *  overridable via the optional `overrides` argument. */
+export function makeKnockRecord(overrides = {}) {
+    const direction = overrides.direction ?? "outbound";
+    const scope = overrides.scope ?? { kind: "browse" };
+    return {
+        id: `knock-${Math.random().toString(36).slice(2, 9)}`,
+        nodeId: "ab".repeat(32),
+        direction,
+        scope,
+        message: "",
+        status: "pending",
+        createdAt: Date.now(),
+        decisions: [],
+        grantedResourceIds: [],
+        ...overrides,
+    };
+}
+/** creates a knock decision for test scenarios where the full audit log
+ *  matters. */
+export function makeKnockDecision(outcome, byNodeId = "cd".repeat(32), at = Date.now(), grantedRole) {
+    return {
+        byNodeId,
+        outcome,
+        at,
+        ...(grantedRole && { grantedRole }),
+    };
+}
+/** creates a batch of knock records with distinct node ids and optional
+ *  shared overrides. */
+export function makeKnockRecords(count, overrides = {}) {
+    return Array.from({ length: count }, (_, i) => {
+        const nodeId = `node-${i.toString().padStart(2, "0")}`.padEnd(64, "0");
+        return makeKnockRecord({ ...overrides, nodeId });
+    });
+}

package/dist/testing/knock-fixtures.test.d.ts

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

package/dist/testing/knock-fixtures.test.d.ts.map

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

package/dist/testing/knock-fixtures.test.js

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { makeKnockDecision, makeKnockRecord, makeKnockRecords, makeKnockScope, } from "./knock-fixtures.js";
+describe("makeKnockScope", () => {
+    it("creates account and browse scopes without extra fields", () => {
+        expect(makeKnockScope("account")).toEqual({ kind: "account" });
+        expect(makeKnockScope("browse")).toEqual({ kind: "browse" });
+    });
+    it("creates resource scopes with a resource id", () => {
+        expect(makeKnockScope("resource", "doc-1")).toEqual({
+            kind: "resource",
+            resourceId: "doc-1",
+        });
+    });
+    it("defaults resource id when omitted", () => {
+        const scope = makeKnockScope("resource");
+        expect(scope.kind).toBe("resource");
+        expect(scope.kind === "resource" && scope.resourceId).toBe("doc-1");
+    });
+});
+describe("makeKnockRecord", () => {
+    it("produces a valid knock record with default values", () => {
+        const record = makeKnockRecord();
+        expect(record.id).toMatch(/^knock-/);
+        expect(record.nodeId).toHaveLength(64);
+        expect(record.status).toBe("pending");
+        expect(record.decisions).toEqual([]);
+    });
+    it("accepts overrides for any field", () => {
+        const record = makeKnockRecord({
+            nodeId: "custom".padEnd(64, "0"),
+            status: "accepted",
+            message: "let me in",
+        });
+        expect(record.nodeId).toBe("custom".padEnd(64, "0"));
+        expect(record.status).toBe("accepted");
+        expect(record.message).toBe("let me in");
+    });
+});
+describe("makeKnockDecision", () => {
+    it("creates an accepted decision with optional role", () => {
+        const decision = makeKnockDecision("accepted", "node-id", 5000, "member");
+        expect(decision.outcome).toBe("accepted");
+        expect(decision.byNodeId).toBe("node-id");
+        expect(decision.at).toBe(5000);
+        expect(decision.grantedRole).toBe("member");
+    });
+    it("omits grantedRole when not provided", () => {
+        const decision = makeKnockDecision("denied");
+        expect(decision.outcome).toBe("denied");
+        expect("grantedRole" in decision).toBe(false);
+    });
+});
+describe("makeKnockRecords", () => {
+    it("creates a batch of distinct knock records", () => {
+        const records = makeKnockRecords(3);
+        expect(records).toHaveLength(3);
+        const nodeIds = records.map((r) => r.nodeId);
+        expect(new Set(nodeIds).size).toBe(3);
+    });
+    it("applies shared overrides to all records", () => {
+        const records = makeKnockRecords(2, { direction: "inbound", message: "hi" });
+        expect(records.every((r) => r.direction === "inbound")).toBe(true);
+        expect(records.every((r) => r.message === "hi")).toBe(true);
+    });
+});

package/dist/testing/protocol-fixtures.d.ts

@@ -0,0 +1,7 @@
+/** loads all json fixtures from `rust/fixtures/protocol/` and returns them
+ *  as parsed objects, keyed by filename (without the `.json` extension). */
+export declare function loadProtocolFixtures(): Record<string, unknown>;
+/** loads a single protocol fixture by name (without the `.json`
+ *  extension), throwing if the file doesn't exist. */
+export declare function loadProtocolFixture(name: string): unknown;
+//# sourceMappingURL=protocol-fixtures.d.ts.map

package/dist/testing/protocol-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol-fixtures.d.ts","sourceRoot":"","sources":["../../src/testing/protocol-fixtures.ts"],"names":[],"mappings":"AAOA;4EAC4E;AAC5E,wBAAgB,oBAAoB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAc9D;AAED;sDACsD;AACtD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKzD"}

package/dist/testing/protocol-fixtures.js

@@ -0,0 +1,28 @@
+// helper to load and parse rust-generated protocol fixtures - ensures the
+// ts codec stays in sync with the rust side's serialized message shapes.
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/** loads all json fixtures from `rust/fixtures/protocol/` and returns them
+ *  as parsed objects, keyed by filename (without the `.json` extension). */
+export function loadProtocolFixtures() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const fixturesDir = join(here, "..", "..", "..", "rust", "fixtures", "protocol");
+    const files = readdirSync(fixturesDir)
+        .filter((name) => name.endsWith(".json"))
+        .sort();
+    const fixtures = {};
+    for (const file of files) {
+        const key = file.replace(".json", "");
+        fixtures[key] = JSON.parse(readFileSync(join(fixturesDir, file), "utf8"));
+    }
+    return fixtures;
+}
+/** loads a single protocol fixture by name (without the `.json`
+ *  extension), throwing if the file doesn't exist. */
+export function loadProtocolFixture(name) {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const fixturesDir = join(here, "..", "..", "..", "rust", "fixtures", "protocol");
+    const path = join(fixturesDir, `${name}.json`);
+    return JSON.parse(readFileSync(path, "utf8"));
+}

package/dist/testing/protocol-fixtures.test.d.ts

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

package/dist/testing/protocol-fixtures.test.d.ts.map

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

package/dist/testing/protocol-fixtures.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+import { loadProtocolFixture, loadProtocolFixtures } from "./protocol-fixtures.js";
+describe("loadProtocolFixtures", () => {
+    it("loads all fixtures as a keyed record", () => {
+        const fixtures = loadProtocolFixtures();
+        expect(Object.keys(fixtures).length).toBeGreaterThan(0);
+        expect(fixtures["hello"]).toBeDefined();
+    });
+});
+describe("loadProtocolFixture", () => {
+    it("loads a single fixture by name", () => {
+        const fixture = loadProtocolFixture("hello");
+        expect(fixture).toBeDefined();
+        expect(typeof fixture).toBe("object");
+    });
+    it("throws when the fixture does not exist", () => {
+        expect(() => loadProtocolFixture("nonexistent")).toThrow();
+    });
+});

package/dist/testing/state-fixtures.d.ts

@@ -0,0 +1,33 @@
+import type { EndpointAdapter, EndpointState } from "../state/endpoint-control.js";
+import type { FriendDirectoryEntry } from "../state/friend-directory.js";
+/** saved remote, as apps persist them after a successful connection. */
+export interface SavedRemote {
+    remote_id: string;
+    name: string;
+    base_url?: string;
+    peer_addr: string;
+}
+/** pending remote record (staged during add-peer flow, not yet promoted to
+ *  a saved remote). */
+export interface PendingRemote {
+    id: string;
+    peer_addr: string;
+    stage: string;
+    error_message?: string;
+    server_name?: string;
+    transport?: "wasm" | "http";
+}
+/** creates a friend directory entry with deterministic defaults. */
+export declare function makeFriendDirectoryEntry(overrides?: Partial<FriendDirectoryEntry>): FriendDirectoryEntry;
+/** creates a batch of distinct friend directory entries with unique
+ *  usernames and node ids. */
+export declare function makeFriendDirectoryEntries(count: number): FriendDirectoryEntry[];
+/** creates a saved remote with deterministic defaults. */
+export declare function makeSavedRemote(overrides?: Partial<SavedRemote>): SavedRemote;
+/** creates a pending remote record with deterministic defaults. */
+export declare function makePendingRemote(overrides?: Partial<PendingRemote>): PendingRemote;
+/** creates a scriptable `EndpointAdapter` double - every method is a
+ *  `vi.fn()`, and state-change listeners are managed in-memory so tests
+ *  can drive state transitions by hand. */
+export declare function createFakeEndpointAdapter(initial?: EndpointState): EndpointAdapter;
+//# sourceMappingURL=state-fixtures.d.ts.map

package/dist/testing/state-fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-fixtures.d.ts","sourceRoot":"","sources":["../../src/testing/state-fixtures.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AACnF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEzE,wEAAwE;AACxE,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;uBACuB;AACvB,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC7B;AAED,oEAAoE;AACpE,wBAAgB,wBAAwB,CACtC,SAAS,GAAE,OAAO,CAAC,oBAAoB,CAAM,GAC5C,oBAAoB,CAMtB;AAED;8BAC8B;AAC9B,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAShF;AAED,0DAA0D;AAC1D,wBAAgB,eAAe,CAAC,SAAS,GAAE,OAAO,CAAC,WAAW,CAAM,GAAG,WAAW,CAOjF;AAED,mEAAmE;AACnE,wBAAgB,iBAAiB,CAAC,SAAS,GAAE,OAAO,CAAC,aAAa,CAAM,GAAG,aAAa,CAOvF;AAED;;2CAE2C;AAC3C,wBAAgB,yBAAyB,CAAC,OAAO,GAAE,aAAwB,GAAG,eAAe,CAqB5F"}

package/dist/testing/state-fixtures.js

@@ -0,0 +1,67 @@
+// fixture builders for state-module types: friend directory entries,
+// pending/saved remotes, and endpoint adapters - deterministic test data
+// for exercising peer-directory and remote-management logic.
+import { vi } from "vitest";
+/** creates a friend directory entry with deterministic defaults. */
+export function makeFriendDirectoryEntry(overrides = {}) {
+    return {
+        username: "alice",
+        nodeIds: [{ nodeId: "ab".repeat(32), profileDocId: "doc-1" }],
+        ...overrides,
+    };
+}
+/** creates a batch of distinct friend directory entries with unique
+ *  usernames and node ids. */
+export function makeFriendDirectoryEntries(count) {
+    return Array.from({ length: count }, (_, i) => {
+        const username = `user-${i}`;
+        const nodeId = `node-${i.toString().padStart(2, "0")}`.padEnd(64, "0");
+        return makeFriendDirectoryEntry({
+            username,
+            nodeIds: [{ nodeId, profileDocId: `doc-${i}` }],
+        });
+    });
+}
+/** creates a saved remote with deterministic defaults. */
+export function makeSavedRemote(overrides = {}) {
+    return {
+        remote_id: `r-${Math.random().toString(36).slice(2, 7)}`,
+        name: "hub",
+        peer_addr: "cd".repeat(32),
+        ...overrides,
+    };
+}
+/** creates a pending remote record with deterministic defaults. */
+export function makePendingRemote(overrides = {}) {
+    return {
+        id: `p-${Math.random().toString(36).slice(2, 7)}`,
+        peer_addr: "ef".repeat(32),
+        stage: "testing",
+        ...overrides,
+    };
+}
+/** creates a scriptable `EndpointAdapter` double - every method is a
+ *  `vi.fn()`, and state-change listeners are managed in-memory so tests
+ *  can drive state transitions by hand. */
+export function createFakeEndpointAdapter(initial = "online") {
+    let state = initial;
+    const handlers = new Set();
+    const adapter = {
+        stop: vi.fn(() => {
+            state = "off";
+            for (const h of handlers)
+                h(state);
+        }),
+        restart: vi.fn(async () => {
+            state = "online";
+            for (const h of handlers)
+                h(state);
+        }),
+        getEndpointState: () => state,
+        onEndpointStateChange: (handler) => {
+            handlers.add(handler);
+            return () => handlers.delete(handler);
+        },
+    };
+    return adapter;
+}

package/dist/testing/state-fixtures.test.d.ts

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

package/dist/testing/state-fixtures.test.d.ts.map

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

package/dist/testing/state-fixtures.test.js

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+import { createFakeEndpointAdapter, makeFriendDirectoryEntries, makeFriendDirectoryEntry, makePendingRemote, makeSavedRemote, } from "./state-fixtures.js";
+describe("makeFriendDirectoryEntry", () => {
+    it("produces a valid entry with default values", () => {
+        const entry = makeFriendDirectoryEntry();
+        expect(entry.username).toBe("alice");
+        expect(entry.nodeIds).toHaveLength(1);
+        expect(entry.nodeIds[0].nodeId).toHaveLength(64);
+    });
+    it("accepts overrides", () => {
+        const entry = makeFriendDirectoryEntry({ username: "bob", alias: "bobby" });
+        expect(entry.username).toBe("bob");
+        expect(entry.alias).toBe("bobby");
+    });
+});
+describe("makeFriendDirectoryEntries", () => {
+    it("creates a batch of distinct entries", () => {
+        const entries = makeFriendDirectoryEntries(3);
+        expect(entries).toHaveLength(3);
+        const usernames = entries.map((e) => e.username);
+        expect(new Set(usernames).size).toBe(3);
+    });
+});
+describe("makeSavedRemote", () => {
+    it("produces a valid saved remote", () => {
+        const remote = makeSavedRemote();
+        expect(remote.remote_id).toMatch(/^r-/);
+        expect(remote.name).toBe("hub");
+        expect(remote.peer_addr).toHaveLength(64);
+    });
+    it("accepts overrides", () => {
+        const remote = makeSavedRemote({ name: "custom", base_url: "https://test" });
+        expect(remote.name).toBe("custom");
+        expect(remote.base_url).toBe("https://test");
+    });
+});
+describe("makePendingRemote", () => {
+    it("produces a valid pending remote", () => {
+        const pending = makePendingRemote();
+        expect(pending.id).toMatch(/^p-/);
+        expect(pending.stage).toBe("testing");
+    });
+    it("accepts overrides", () => {
+        const pending = makePendingRemote({ stage: "failed", error_message: "timeout" });
+        expect(pending.stage).toBe("failed");
+        expect(pending.error_message).toBe("timeout");
+    });
+});
+describe("createFakeEndpointAdapter", () => {
+    it("starts in the given initial state", () => {
+        const adapter = createFakeEndpointAdapter("off");
+        expect(adapter.getEndpointState()).toBe("off");
+    });
+    it("transitions state on stop and restart", async () => {
+        const adapter = createFakeEndpointAdapter("online");
+        adapter.stop();
+        expect(adapter.getEndpointState()).toBe("off");
+        await adapter.restart();
+        expect(adapter.getEndpointState()).toBe("online");
+    });
+    it("notifies listeners on state changes", () => {
+        const adapter = createFakeEndpointAdapter("online");
+        const seen = [];
+        adapter.onEndpointStateChange((state) => seen.push(state));
+        adapter.stop();
+        expect(seen).toEqual(["off"]);
+    });
+});

package/dist/testing/webauthn-mocks.d.ts

@@ -0,0 +1,27 @@
+import type { PasskeyCeremonyDeps } from "../webauthn/ceremony.js";
+import type { WebauthnTransport } from "../webauthn/transport.js";
+import type { AuthenticationChallenge, RegistrationChallenge } from "../webauthn/types.js";
+/** a canned registration challenge for tests that don't care about the
+ *  exact shape, just that a challenge flows through the ceremony. */
+export declare const FAKE_REGISTRATION_CHALLENGE: RegistrationChallenge;
+/** a canned authentication challenge. */
+export declare const FAKE_AUTHENTICATION_CHALLENGE: AuthenticationChallenge;
+/** a canned credential returned by `FAKE_CEREMONY_DEPS.createCredential` /
+ *  `.getCredential` - enough structure to satisfy the ceremony's
+ *  serialization logic without touching real browser APIs. */
+export declare const FAKE_CREDENTIAL: PublicKeyCredential;
+/** a scriptable `WebauthnTransport` double. every method is a `vi.fn()`
+ *  defaulting to successful outcomes; override per-call via
+ *  `mockResolvedValueOnce` / `mockRejectedValueOnce` to simulate specific
+ *  failure cases. */
+export declare function createFakeWebauthnTransport(overrides?: Partial<WebauthnTransport>): WebauthnTransport;
+/** fake browser ceremony deps (credential creation/retrieval + origin) that
+ *  return canned values without touching `navigator.credentials`. every
+ *  method is a `vi.fn()` so tests can assert on calls or override
+ *  behavior. */
+export declare const FAKE_CEREMONY_DEPS: PasskeyCeremonyDeps;
+/** resets all `vi.fn()` call counts/mocks on the fake ceremony deps to a
+ *  clean state. call this in `beforeEach` / `afterEach` when reusing the
+ *  same deps object across multiple tests. */
+export declare function resetFakeCeremonyDeps(): void;
+//# sourceMappingURL=webauthn-mocks.d.ts.map

package/dist/testing/webauthn-mocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webauthn-mocks.d.ts","sourceRoot":"","sources":["../../src/testing/webauthn-mocks.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAOV,iBAAiB,EAElB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,uBAAuB,EAGvB,qBAAqB,EACtB,MAAM,sBAAsB,CAAC;AAE9B;qEACqE;AACrE,eAAO,MAAM,2BAA2B,EAAE,qBAOzC,CAAC;AAEF,yCAAyC;AACzC,eAAO,MAAM,6BAA6B,EAAE,uBAE3C,CAAC;AAEF;;8DAE8D;AAC9D,eAAO,MAAM,eAAe,EAIZ,mBAAmB,CAAC;AAEpC;;;qBAGqB;AACrB,wBAAgB,2BAA2B,CACzC,SAAS,GAAE,OAAO,CAAC,iBAAiB,CAAM,GACzC,iBAAiB,CAuCnB;AAED;;;gBAGgB;AAChB,eAAO,MAAM,kBAAkB,EAI1B,mBAAmB,CAAC;AAEzB;;8CAE8C;AAC9C,wBAAgB,qBAAqB,IAAI,IAAI,CAO5C"}

package/dist/testing/webauthn-mocks.js

@@ -0,0 +1,78 @@
+// scriptable test doubles for webauthn ceremony flows: a fake transport
+// whose responses a test can drive call-by-call, and fake browser deps
+// (credential creation/retrieval) that return canned values without
+// touching `navigator.credentials`.
+//
+// every method is a `vi.fn()` so consuming tests can assert on call
+// counts/arguments or override a single call's behavior
+// (`mockResolvedValueOnce`, `mockRejectedValueOnce`, ...) without
+// replacing the whole double.
+import { vi } from "vitest";
+/** a canned registration challenge for tests that don't care about the
+ *  exact shape, just that a challenge flows through the ceremony. */
+export const FAKE_REGISTRATION_CHALLENGE = {
+    publicKey: {
+        rp: { name: "freqhole" },
+        user: { id: "AA", name: "alice", displayName: "Alice" },
+        challenge: "AQ",
+        pubKeyCredParams: [{ type: "public-key", alg: -7 }],
+    },
+};
+/** a canned authentication challenge. */
+export const FAKE_AUTHENTICATION_CHALLENGE = {
+    publicKey: { challenge: "AQ" },
+};
+/** a canned credential returned by `FAKE_CEREMONY_DEPS.createCredential` /
+ *  `.getCredential` - enough structure to satisfy the ceremony's
+ *  serialization logic without touching real browser APIs. */
+export const FAKE_CREDENTIAL = {
+    id: "cred-id",
+    rawId: new Uint8Array([1]).buffer,
+    response: {},
+};
+/** a scriptable `WebauthnTransport` double. every method is a `vi.fn()`
+ *  defaulting to successful outcomes; override per-call via
+ *  `mockResolvedValueOnce` / `mockRejectedValueOnce` to simulate specific
+ *  failure cases. */
+export function createFakeWebauthnTransport(overrides = {}) {
+    return {
+        registerStart: vi.fn(async (_req) => ({
+            success: true,
+            data: { nonce: "nonce-1", challenge: FAKE_REGISTRATION_CHALLENGE },
+        })),
+        registerFinish: vi.fn(async (_req) => ({
+            success: true,
+            data: { userId: "user-1", username: "alice" },
+        })),
+        loginStart: vi.fn(async (_req) => ({
+            success: true,
+            data: { nonce: "nonce-2", challenge: FAKE_AUTHENTICATION_CHALLENGE },
+        })),
+        loginFinish: vi.fn(async (_req) => ({
+            success: true,
+            data: { userId: "user-1", username: "alice" },
+        })),
+        whoami: vi.fn(async () => ({ authenticated: false })),
+        ...overrides,
+    };
+}
+/** fake browser ceremony deps (credential creation/retrieval + origin) that
+ *  return canned values without touching `navigator.credentials`. every
+ *  method is a `vi.fn()` so tests can assert on calls or override
+ *  behavior. */
+export const FAKE_CEREMONY_DEPS = {
+    origin: "https://example.test",
+    createCredential: vi.fn(async () => FAKE_CREDENTIAL),
+    getCredential: vi.fn(async () => FAKE_CREDENTIAL),
+};
+/** resets all `vi.fn()` call counts/mocks on the fake ceremony deps to a
+ *  clean state. call this in `beforeEach` / `afterEach` when reusing the
+ *  same deps object across multiple tests. */
+export function resetFakeCeremonyDeps() {
+    if (typeof FAKE_CEREMONY_DEPS.createCredential === "function" && "mockClear" in FAKE_CEREMONY_DEPS.createCredential) {
+        FAKE_CEREMONY_DEPS.createCredential.mockClear();
+    }
+    if (typeof FAKE_CEREMONY_DEPS.getCredential === "function" && "mockClear" in FAKE_CEREMONY_DEPS.getCredential) {
+        FAKE_CEREMONY_DEPS.getCredential.mockClear();
+    }
+}

package/dist/testing/webauthn-mocks.test.d.ts

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

package/dist/testing/webauthn-mocks.test.d.ts.map

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

package/dist/testing/webauthn-mocks.test.js

@@ -0,0 +1,40 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createFakeWebauthnTransport, FAKE_CEREMONY_DEPS, resetFakeCeremonyDeps, } from "./webauthn-mocks.js";
+describe("createFakeWebauthnTransport", () => {
+    it("defaults to successful outcomes for all methods", async () => {
+        const transport = createFakeWebauthnTransport();
+        const startResult = await transport.registerStart({ username: "alice", origin: "https://test" });
+        expect(startResult.success).toBe(true);
+        expect(transport.registerStart).toHaveBeenCalledOnce();
+    });
+    it("allows overriding individual methods", async () => {
+        const transport = createFakeWebauthnTransport({
+            registerStart: vi.fn(async () => ({
+                success: false,
+                error: "username taken",
+            })),
+        });
+        const result = await transport.registerStart({ username: "alice", origin: "https://test" });
+        expect(result.success).toBe(false);
+        expect(result.success === false && result.error).toBe("username taken");
+    });
+});
+describe("FAKE_CEREMONY_DEPS", () => {
+    beforeEach(() => {
+        resetFakeCeremonyDeps();
+    });
+    it("provides canned credential responses", async () => {
+        if (!FAKE_CEREMONY_DEPS.createCredential)
+            throw new Error("no createCredential");
+        const cred = await FAKE_CEREMONY_DEPS.createCredential({});
+        expect(cred?.id).toBe("cred-id");
+    });
+    it("can be reset between tests", () => {
+        if (!FAKE_CEREMONY_DEPS.createCredential)
+            throw new Error("no createCredential");
+        void FAKE_CEREMONY_DEPS.createCredential({});
+        expect(FAKE_CEREMONY_DEPS.createCredential).toHaveBeenCalledOnce();
+        resetFakeCeremonyDeps();
+        expect(FAKE_CEREMONY_DEPS.createCredential).not.toHaveBeenCalled();
+    });
+});