@freqhole/haruspex 0.0.0

package/dist/solid/reauth-flow.d.ts

@@ -0,0 +1,26 @@
+import { type Accessor } from "solid-js";
+import type { AuthFormData } from "./auth-form.js";
+export interface ReauthFlowDeps {
+    /** performs the actual re-authentication against whatever transport the
+     *  caller is using. resolve with `{ success: false }` (or reject) on
+     *  failure - both are treated as failures and surface `error`. */
+    authenticate(data: AuthFormData): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** called once `authenticate` resolves with `success: true`. */
+    onSuccess(): void;
+    /** called from `close()`, but only when not currently loading. */
+    onClose(): void;
+}
+export interface ReauthFlowState {
+    isLoading: Accessor<boolean>;
+    error: Accessor<string | null>;
+    /** runs `authenticate`, calling `onSuccess` on success or setting
+     *  `error` on failure. */
+    submit(data: AuthFormData): Promise<void>;
+    /** clears any error and calls `onClose`, unless a submit is in flight. */
+    close(): void;
+}
+export declare function createReauthFlow(deps: ReauthFlowDeps): ReauthFlowState;
+//# sourceMappingURL=reauth-flow.d.ts.map

package/dist/solid/reauth-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reauth-flow.d.ts","sourceRoot":"","sources":["../../src/solid/reauth-flow.ts"],"names":[],"mappings":"AAMA,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,MAAM,WAAW,cAAc;IAC7B;;sEAEkE;IAClE,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAChF,gEAAgE;IAChE,SAAS,IAAI,IAAI,CAAC;IAClB,kEAAkE;IAClE,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC7B,KAAK,EAAE,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC/B;8BAC0B;IAC1B,MAAM,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,0EAA0E;IAC1E,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,eAAe,CA2BtE"}

package/dist/solid/reauth-flow.js

@@ -0,0 +1,34 @@
+// headless re-authentication flow: loading/error state around a single
+// injected `authenticate` call, plus a close guard that refuses to close
+// while a request is in flight. pairs naturally with `createAuthForm` -
+// pass this flow's `isLoading`/`submit` straight through as that
+// primitive's `loading`/`onSubmit` deps.
+import { createSignal } from "solid-js";
+export function createReauthFlow(deps) {
+    const [isLoading, setIsLoading] = createSignal(false);
+    const [error, setError] = createSignal(null);
+    async function submit(data) {
+        setError(null);
+        setIsLoading(true);
+        try {
+            const result = await deps.authenticate(data);
+            if (!result.success) {
+                throw new Error(result.error ?? "authentication failed");
+            }
+            deps.onSuccess();
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : "authentication failed");
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }
+    function close() {
+        if (isLoading())
+            return;
+        setError(null);
+        deps.onClose();
+    }
+    return { isLoading, error, submit, close };
+}

package/dist/solid/reauth-flow.test.d.ts

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

package/dist/solid/reauth-flow.test.d.ts.map

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

package/dist/solid/reauth-flow.test.js

@@ -0,0 +1,91 @@
+import { createRoot } from "solid-js";
+import { describe, expect, it, vi } from "vitest";
+import { createReauthFlow } from "./reauth-flow.js";
+describe("createReauthFlow", () => {
+    it("submit calls authenticate and onSuccess on success", async () => {
+        await createRoot(async (dispose) => {
+            const authenticate = vi.fn().mockResolvedValue({ success: true });
+            const onSuccess = vi.fn();
+            const onClose = vi.fn();
+            const flow = createReauthFlow({ authenticate, onSuccess, onClose });
+            await flow.submit({ username: "viz", mode: "login" });
+            expect(authenticate).toHaveBeenCalledWith({ username: "viz", mode: "login" });
+            expect(onSuccess).toHaveBeenCalled();
+            expect(flow.error()).toBeNull();
+            expect(flow.isLoading()).toBe(false);
+            dispose();
+        });
+    });
+    it("submit sets error and does not call onSuccess when authenticate resolves unsuccessfully", async () => {
+        await createRoot(async (dispose) => {
+            const authenticate = vi.fn().mockResolvedValue({ success: false, error: "bad credentials" });
+            const onSuccess = vi.fn();
+            const flow = createReauthFlow({ authenticate, onSuccess, onClose: vi.fn() });
+            await flow.submit({ username: "viz", mode: "login" });
+            expect(onSuccess).not.toHaveBeenCalled();
+            expect(flow.error()).toBe("bad credentials");
+            expect(flow.isLoading()).toBe(false);
+            dispose();
+        });
+    });
+    it("submit sets a generic error message when authenticate throws a non-Error", async () => {
+        await createRoot(async (dispose) => {
+            const authenticate = vi.fn().mockRejectedValue("network down");
+            const flow = createReauthFlow({ authenticate, onSuccess: vi.fn(), onClose: vi.fn() });
+            await flow.submit({ username: "viz", mode: "login" });
+            expect(flow.error()).toBe("authentication failed");
+            dispose();
+        });
+    });
+    it("submit surfaces a thrown Error's message", async () => {
+        await createRoot(async (dispose) => {
+            const authenticate = vi.fn().mockRejectedValue(new Error("peer unreachable"));
+            const flow = createReauthFlow({ authenticate, onSuccess: vi.fn(), onClose: vi.fn() });
+            await flow.submit({ username: "viz", mode: "login" });
+            expect(flow.error()).toBe("peer unreachable");
+            dispose();
+        });
+    });
+    it("submit clears a previous error before retrying", async () => {
+        await createRoot(async (dispose) => {
+            const authenticate = vi
+                .fn()
+                .mockResolvedValueOnce({ success: false, error: "first failure" })
+                .mockResolvedValueOnce({ success: true });
+            const flow = createReauthFlow({ authenticate, onSuccess: vi.fn(), onClose: vi.fn() });
+            await flow.submit({ username: "viz", mode: "login" });
+            expect(flow.error()).toBe("first failure");
+            await flow.submit({ username: "viz", mode: "login" });
+            expect(flow.error()).toBeNull();
+            dispose();
+        });
+    });
+    it("close calls onClose and clears any error when not loading", () => {
+        createRoot((dispose) => {
+            const onClose = vi.fn();
+            const flow = createReauthFlow({
+                authenticate: vi.fn(),
+                onSuccess: vi.fn(),
+                onClose,
+            });
+            flow.close();
+            expect(onClose).toHaveBeenCalled();
+            dispose();
+        });
+    });
+    it("close is a no-op while a submit is in flight", async () => {
+        await createRoot(async (dispose) => {
+            const onClose = vi.fn();
+            let resolveAuth;
+            const authenticate = vi.fn(() => new Promise((resolve) => (resolveAuth = resolve)));
+            const flow = createReauthFlow({ authenticate, onSuccess: vi.fn(), onClose });
+            const submitPromise = flow.submit({ username: "viz", mode: "login" });
+            expect(flow.isLoading()).toBe(true);
+            flow.close();
+            expect(onClose).not.toHaveBeenCalled();
+            resolveAuth({ success: true });
+            await submitPromise;
+            dispose();
+        });
+    });
+});

package/dist/state/endpoint-control.d.ts

@@ -0,0 +1,22 @@
+/** the p2p endpoint's lifecycle state, for ui display. */
+export type EndpointState = "off" | "starting" | "online" | "error";
+/** the structural surface this subpath needs from a p2p transport adapter. */
+export interface EndpointAdapter {
+    stop(): void;
+    restart(): Promise<void>;
+    getEndpointState(): EndpointState;
+    onEndpointStateChange(handler: (state: EndpointState) => void): () => void;
+}
+/** register the adapter - call once, after the adapter is created. */
+export declare function registerEndpointAdapter(next: EndpointAdapter): void;
+/** forget the registered adapter (teardown, test isolation). */
+export declare function clearEndpointAdapter(): void;
+/** stop the p2p endpoint; can be resumed with restartEndpoint(). */
+export declare function stopEndpoint(): void;
+/** restart the p2p endpoint after it was stopped. */
+export declare function restartEndpoint(): Promise<void>;
+/** the current endpoint state, synchronously. "off" when no adapter is registered. */
+export declare function getEndpointState(): EndpointState;
+/** subscribe to endpoint state changes. returns an unsubscribe function. */
+export declare function onEndpointStateChange(handler: (state: EndpointState) => void): () => void;
+//# sourceMappingURL=endpoint-control.d.ts.map

package/dist/state/endpoint-control.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint-control.d.ts","sourceRoot":"","sources":["../../src/state/endpoint-control.ts"],"names":[],"mappings":"AAUA,0DAA0D;AAC1D,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,UAAU,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEpE,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC9B,IAAI,IAAI,IAAI,CAAC;IACb,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACzB,gBAAgB,IAAI,aAAa,CAAC;IAClC,qBAAqB,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,MAAM,IAAI,CAAC;CAC5E;AAID,sEAAsE;AACtE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAEnE;AAED,gEAAgE;AAChE,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED,oEAAoE;AACpE,wBAAgB,YAAY,IAAI,IAAI,CAEnC;AAED,qDAAqD;AACrD,wBAAgB,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC,CAE/C;AAED,sFAAsF;AACtF,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AAED,4EAA4E;AAC5E,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GAAG,MAAM,IAAI,CAEzF"}

package/dist/state/endpoint-control.js

@@ -0,0 +1,34 @@
+// endpoint-control - a module-level singleton bridging a p2p transport
+// adapter to any ui code that needs to read or toggle its lifecycle state
+// without holding a direct reference to the adapter itself. an app calls
+// registerEndpointAdapter() once at startup; anything else (a settings
+// panel, a status pill) imports the helpers below to read/toggle.
+//
+// the adapter is a structural type, not an import of any concrete
+// transport - this subpath never depends on midden or any particular p2p
+// implementation, only on something shaped like `EndpointAdapter`.
+let adapter = null;
+/** register the adapter - call once, after the adapter is created. */
+export function registerEndpointAdapter(next) {
+    adapter = next;
+}
+/** forget the registered adapter (teardown, test isolation). */
+export function clearEndpointAdapter() {
+    adapter = null;
+}
+/** stop the p2p endpoint; can be resumed with restartEndpoint(). */
+export function stopEndpoint() {
+    adapter?.stop();
+}
+/** restart the p2p endpoint after it was stopped. */
+export function restartEndpoint() {
+    return adapter?.restart() ?? Promise.resolve();
+}
+/** the current endpoint state, synchronously. "off" when no adapter is registered. */
+export function getEndpointState() {
+    return adapter?.getEndpointState() ?? "off";
+}
+/** subscribe to endpoint state changes. returns an unsubscribe function. */
+export function onEndpointStateChange(handler) {
+    return adapter?.onEndpointStateChange(handler) ?? (() => { });
+}

package/dist/state/endpoint-control.test.d.ts

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

package/dist/state/endpoint-control.test.d.ts.map

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

package/dist/state/endpoint-control.test.js

@@ -0,0 +1,63 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { clearEndpointAdapter, getEndpointState, onEndpointStateChange, registerEndpointAdapter, restartEndpoint, stopEndpoint, } from "./endpoint-control.js";
+function makeAdapter(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;
+}
+afterEach(() => {
+    clearEndpointAdapter();
+});
+describe("endpoint-control", () => {
+    it("reports 'off' when no adapter is registered", () => {
+        expect(getEndpointState()).toBe("off");
+    });
+    it("no-ops stop/restart/subscribe when no adapter is registered", async () => {
+        expect(() => stopEndpoint()).not.toThrow();
+        await expect(restartEndpoint()).resolves.toBeUndefined();
+        const unsubscribe = onEndpointStateChange(() => { });
+        expect(() => unsubscribe()).not.toThrow();
+    });
+    it("delegates state reads to the registered adapter", () => {
+        const adapter = makeAdapter("online");
+        registerEndpointAdapter(adapter);
+        expect(getEndpointState()).toBe("online");
+    });
+    it("delegates stop/restart to the registered adapter", async () => {
+        const adapter = makeAdapter("online");
+        registerEndpointAdapter(adapter);
+        stopEndpoint();
+        expect(adapter.stop).toHaveBeenCalledOnce();
+        expect(getEndpointState()).toBe("off");
+        await restartEndpoint();
+        expect(adapter.restart).toHaveBeenCalledOnce();
+        expect(getEndpointState()).toBe("online");
+    });
+    it("subscribes to state changes through the registered adapter", () => {
+        const adapter = makeAdapter("online");
+        registerEndpointAdapter(adapter);
+        const seen = [];
+        const unsubscribe = onEndpointStateChange((state) => seen.push(state));
+        stopEndpoint();
+        expect(seen).toEqual(["off"]);
+        unsubscribe();
+        void restartEndpoint();
+    });
+});

package/dist/state/friend-directory.d.ts

@@ -0,0 +1,37 @@
+/** one raw friend entry, as read from wherever an app stores its friend list. */
+export interface FriendDirectoryEntry {
+    /** a display name override the local user set for this friend, if any. */
+    alias?: string;
+    /** the friend's own reported username, if known. */
+    username?: string;
+    /** every node id this friend is known to use, each with its own optional
+     *  profile doc pointer and reported username. */
+    nodeIds: Array<{
+        nodeId: string;
+        profileDocId?: string;
+        username?: string;
+    }>;
+}
+/** one friend candidate for a "pick a friend" picker ui. */
+export interface FriendPickerCandidate {
+    nodeId: string;
+    profileDocId: string;
+    displayName: string;
+}
+/**
+ * pure filter/map step: turn raw friend entries into picker candidates.
+ * a friend is only offered as a candidate once it has at least one node id
+ * with a known profile doc pointer - there'd be nothing for the picker to
+ * open otherwise. display name preference: alias, then the friend's own
+ * username, then the chosen node id's reported username, then "friend".
+ */
+export declare function buildFriendDirectory(entries: FriendDirectoryEntry[]): FriendPickerCandidate[];
+/**
+ * best-effort candidate list for a "pick a friend" picker: calls the
+ * injected loader for the raw friend entries and runs them through
+ * buildFriendDirectory(). returns `[]` on any failure (no friend list yet,
+ * the loader's own backend unreachable) rather than throwing - matches
+ * this kind of picker's usual "best effort, no error ui" convention.
+ */
+export declare function getFriendsForPicker(loadEntries: () => Promise<FriendDirectoryEntry[]>): Promise<FriendPickerCandidate[]>;
+//# sourceMappingURL=friend-directory.d.ts.map

package/dist/state/friend-directory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"friend-directory.d.ts","sourceRoot":"","sources":["../../src/state/friend-directory.ts"],"names":[],"mappings":"AAOA,iFAAiF;AACjF,MAAM,WAAW,oBAAoB;IACnC,0EAA0E;IAC1E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;qDACiD;IACjD,OAAO,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC9E;AAED,4DAA4D;AAC5D,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,qBAAqB,EAAE,CAa7F;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,MAAM,OAAO,CAAC,oBAAoB,EAAE,CAAC,GACjD,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAOlC"}

package/dist/state/friend-directory.js

@@ -0,0 +1,44 @@
+// friend-directory - a best-effort friend list for "pick one of your
+// friends" pickers, kept framework-free: this subpath never touches
+// automerge/pixi/solid directly. resolving the actual friend records
+// (wherever they live - an automerge doc, a sqlite table, an api call) is
+// always the caller's job; this module only owns the pure candidate
+// shape/selection logic and a best-effort async wrapper around it.
+/**
+ * pure filter/map step: turn raw friend entries into picker candidates.
+ * a friend is only offered as a candidate once it has at least one node id
+ * with a known profile doc pointer - there'd be nothing for the picker to
+ * open otherwise. display name preference: alias, then the friend's own
+ * username, then the chosen node id's reported username, then "friend".
+ */
+export function buildFriendDirectory(entries) {
+    const candidates = [];
+    for (const entry of entries) {
+        const nodeEntry = entry.nodeIds.find((n) => n.profileDocId);
+        if (!nodeEntry || !nodeEntry.profileDocId)
+            continue;
+        const displayName = entry.alias || entry.username || nodeEntry.username || "friend";
+        candidates.push({
+            nodeId: nodeEntry.nodeId,
+            profileDocId: nodeEntry.profileDocId,
+            displayName,
+        });
+    }
+    return candidates;
+}
+/**
+ * best-effort candidate list for a "pick a friend" picker: calls the
+ * injected loader for the raw friend entries and runs them through
+ * buildFriendDirectory(). returns `[]` on any failure (no friend list yet,
+ * the loader's own backend unreachable) rather than throwing - matches
+ * this kind of picker's usual "best effort, no error ui" convention.
+ */
+export async function getFriendsForPicker(loadEntries) {
+    try {
+        const entries = await loadEntries();
+        return buildFriendDirectory(entries);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/state/friend-directory.test.d.ts

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

package/dist/state/friend-directory.test.d.ts.map

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

package/dist/state/friend-directory.test.js

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { buildFriendDirectory, getFriendsForPicker, } from "./friend-directory.js";
+describe("buildFriendDirectory", () => {
+    it("excludes friends with no profile-doc-bearing node id", () => {
+        const entries = [
+            { username: "alice", nodeIds: [{ nodeId: "node-1" }] },
+        ];
+        expect(buildFriendDirectory(entries)).toEqual([]);
+    });
+    it("prefers alias, then username, then the node's own username, then 'friend'", () => {
+        const entries = [
+            {
+                alias: "besty",
+                username: "alice",
+                nodeIds: [{ nodeId: "node-1", profileDocId: "doc-1", username: "alice-node" }],
+            },
+            {
+                username: "bob",
+                nodeIds: [{ nodeId: "node-2", profileDocId: "doc-2", username: "bob-node" }],
+            },
+            {
+                nodeIds: [{ nodeId: "node-3", profileDocId: "doc-3", username: "carol-node" }],
+            },
+            {
+                nodeIds: [{ nodeId: "node-4", profileDocId: "doc-4" }],
+            },
+        ];
+        expect(buildFriendDirectory(entries)).toEqual([
+            { nodeId: "node-1", profileDocId: "doc-1", displayName: "besty" },
+            { nodeId: "node-2", profileDocId: "doc-2", displayName: "bob" },
+            { nodeId: "node-3", profileDocId: "doc-3", displayName: "carol-node" },
+            { nodeId: "node-4", profileDocId: "doc-4", displayName: "friend" },
+        ]);
+    });
+    it("picks the first node id that has a profile doc pointer", () => {
+        const entries = [
+            {
+                nodeIds: [
+                    { nodeId: "node-1" },
+                    { nodeId: "node-2", profileDocId: "doc-2" },
+                ],
+            },
+        ];
+        expect(buildFriendDirectory(entries)).toEqual([
+            { nodeId: "node-2", profileDocId: "doc-2", displayName: "friend" },
+        ]);
+    });
+});
+describe("getFriendsForPicker", () => {
+    it("resolves candidates from the injected loader", async () => {
+        const entries = [
+            { username: "alice", nodeIds: [{ nodeId: "node-1", profileDocId: "doc-1" }] },
+        ];
+        const result = await getFriendsForPicker(async () => entries);
+        expect(result).toEqual([{ nodeId: "node-1", profileDocId: "doc-1", displayName: "alice" }]);
+    });
+    it("returns [] when the loader throws", async () => {
+        const result = await getFriendsForPicker(async () => {
+            throw new Error("no friend list yet");
+        });
+        expect(result).toEqual([]);
+    });
+});

package/dist/state/index.d.ts

@@ -0,0 +1,6 @@
+export { registerPeerName, peerNameFor, clearPeerNames } from "./peer-names.js";
+export type { EndpointAdapter, EndpointState } from "./endpoint-control.js";
+export { clearEndpointAdapter, getEndpointState, onEndpointStateChange, registerEndpointAdapter, restartEndpoint, stopEndpoint, } from "./endpoint-control.js";
+export type { FriendDirectoryEntry, FriendPickerCandidate } from "./friend-directory.js";
+export { buildFriendDirectory, getFriendsForPicker } from "./friend-directory.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/state/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEhF,YAAY,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC5E,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACvB,eAAe,EACf,YAAY,GACb,MAAM,uBAAuB,CAAC;AAE/B,YAAY,EAAE,oBAAoB,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACzF,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/state/index.js

@@ -0,0 +1,3 @@
+export { registerPeerName, peerNameFor, clearPeerNames } from "./peer-names.js";
+export { clearEndpointAdapter, getEndpointState, onEndpointStateChange, registerEndpointAdapter, restartEndpoint, stopEndpoint, } from "./endpoint-control.js";
+export { buildFriendDirectory, getFriendsForPicker } from "./friend-directory.js";

package/dist/state/peer-names.d.ts

@@ -0,0 +1,7 @@
+/** register (or update) a display name for a node id. empty values are ignored. */
+export declare function registerPeerName(nodeId: string, name: string): void;
+/** the display name for a node id, or null when unknown. */
+export declare function peerNameFor(nodeId: string): string | null;
+/** clear the registry (identity switch, sign-out, test teardown). */
+export declare function clearPeerNames(): void;
+//# sourceMappingURL=peer-names.d.ts.map

package/dist/state/peer-names.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peer-names.d.ts","sourceRoot":"","sources":["../../src/state/peer-names.ts"],"names":[],"mappings":"AASA,mFAAmF;AACnF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAGnE;AAED,4DAA4D;AAC5D,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEzD;AAED,qEAAqE;AACrE,wBAAgB,cAAc,IAAI,IAAI,CAErC"}

package/dist/state/peer-names.js

@@ -0,0 +1,21 @@
+// peer-names - a tiny session-scoped registry mapping node ids to display
+// names. exists so deep ui code (a property tray, a picker row, a log
+// line) can show a human name without threading a social/friends doc
+// through every mount context. read-side consumers must always have a
+// fallback (e.g. a shortened node id) for a node id the registry hasn't
+// seen a name for yet - it only knows about peers registered this session.
+const names = new Map();
+/** register (or update) a display name for a node id. empty values are ignored. */
+export function registerPeerName(nodeId, name) {
+    if (!nodeId || !name)
+        return;
+    names.set(nodeId, name);
+}
+/** the display name for a node id, or null when unknown. */
+export function peerNameFor(nodeId) {
+    return names.get(nodeId) ?? null;
+}
+/** clear the registry (identity switch, sign-out, test teardown). */
+export function clearPeerNames() {
+    names.clear();
+}

package/dist/state/peer-names.test.d.ts

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

package/dist/state/peer-names.test.d.ts.map

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

package/dist/state/peer-names.test.js

@@ -0,0 +1,29 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { clearPeerNames, peerNameFor, registerPeerName } from "./peer-names.js";
+afterEach(() => {
+    clearPeerNames();
+});
+describe("peer-names", () => {
+    it("returns null for an unknown node id", () => {
+        expect(peerNameFor("node-unknown")).toBeNull();
+    });
+    it("registers and looks up a display name", () => {
+        registerPeerName("node-abc", "alice");
+        expect(peerNameFor("node-abc")).toBe("alice");
+    });
+    it("updates an existing registration", () => {
+        registerPeerName("node-abc", "alice");
+        registerPeerName("node-abc", "alice-2");
+        expect(peerNameFor("node-abc")).toBe("alice-2");
+    });
+    it("ignores empty node ids or names", () => {
+        registerPeerName("", "alice");
+        registerPeerName("node-abc", "");
+        expect(peerNameFor("node-abc")).toBeNull();
+    });
+    it("clears every registration", () => {
+        registerPeerName("node-abc", "alice");
+        clearPeerNames();
+        expect(peerNameFor("node-abc")).toBeNull();
+    });
+});

package/dist/testing/idb-harness.d.ts

@@ -0,0 +1,9 @@
+/** installs fake-indexeddb's `IDBFactory` and `IDBKeyRange` as globals,
+ *  so idb-based code runs in a node test environment. call this in
+ *  `beforeEach` for tests that use idb stores. */
+export declare function setupFakeIndexedDB(): void;
+/** clears the fake idb instance (useful in `afterEach` if you want a
+ *  fresh db for each test, though most tests just call `setupFakeIndexedDB`
+ *  in `beforeEach` and let the instance get replaced). */
+export declare function teardownFakeIndexedDB(): void;
+//# sourceMappingURL=idb-harness.d.ts.map

package/dist/testing/idb-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idb-harness.d.ts","sourceRoot":"","sources":["../../src/testing/idb-harness.ts"],"names":[],"mappings":"AAKA;;kDAEkD;AAClD,wBAAgB,kBAAkB,IAAI,IAAI,CAGzC;AAED;;0DAE0D;AAC1D,wBAAgB,qBAAqB,IAAI,IAAI,CAK5C"}

package/dist/testing/idb-harness.js

@@ -0,0 +1,19 @@
+// helper to set up fake-indexeddb for tests that need idb stores without a
+// real browser environment.
+import { IDBFactory, IDBKeyRange } from "fake-indexeddb";
+/** installs fake-indexeddb's `IDBFactory` and `IDBKeyRange` as globals,
+ *  so idb-based code runs in a node test environment. call this in
+ *  `beforeEach` for tests that use idb stores. */
+export function setupFakeIndexedDB() {
+    globalThis.indexedDB = new IDBFactory();
+    globalThis.IDBKeyRange = IDBKeyRange;
+}
+/** clears the fake idb instance (useful in `afterEach` if you want a
+ *  fresh db for each test, though most tests just call `setupFakeIndexedDB`
+ *  in `beforeEach` and let the instance get replaced). */
+export function teardownFakeIndexedDB() {
+    // @ts-expect-error - clearing the global
+    globalThis.indexedDB = undefined;
+    // @ts-expect-error - clearing the global
+    globalThis.IDBKeyRange = undefined;
+}

package/dist/testing/idb-harness.test.d.ts

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

package/dist/testing/idb-harness.test.d.ts.map

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

package/dist/testing/idb-harness.test.js

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { setupFakeIndexedDB, teardownFakeIndexedDB } from "./idb-harness.js";
+describe("setupFakeIndexedDB", () => {
+    it("installs fake globals", () => {
+        setupFakeIndexedDB();
+        expect(globalThis.indexedDB).toBeDefined();
+        expect(globalThis.IDBKeyRange).toBeDefined();
+        teardownFakeIndexedDB();
+    });
+});
+describe("teardownFakeIndexedDB", () => {
+    it("clears the fake globals", () => {
+        setupFakeIndexedDB();
+        teardownFakeIndexedDB();
+        expect(globalThis.indexedDB).toBeUndefined();
+        expect(globalThis.IDBKeyRange).toBeUndefined();
+    });
+});

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

@@ -0,0 +1,10 @@
+import type { P2PIdentity } from "../identity/types.js";
+/** 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 declare function makeIdentity(nodeId?: string, createdAt?: number): P2PIdentity;
+/** creates a batch of distinct test identities, each with a unique node id
+ *  derived from the given prefix and an incrementing counter. */
+export declare function makeIdentities(count: number, nodeIdPrefix?: string): P2PIdentity[];
+//# sourceMappingURL=identity-fixtures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"identity-fixtures.d.ts","sourceRoot":"","sources":["../../src/testing/identity-fixtures.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;mBAGmB;AACnB,wBAAgB,YAAY,CAAC,MAAM,SAAkB,EAAE,SAAS,SAAO,GAAG,WAAW,CAMpF;AAED;iEACiE;AACjE,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,SAAS,GAAG,WAAW,EAAE,CAKlF"}