@freqhole/haruspex 0.0.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/identity/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE7D,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,uBAAuB,EACvB,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,GAChB,MAAM,eAAe,CAAC;AAEvB,YAAY,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEhE,YAAY,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC"}

package/dist/identity/index.js

@@ -0,0 +1,3 @@
+export { createIdbIdentityStore, databaseExists, identitySourceAvailable, openExistingDatabase, readIdentityFrom, writeIdentityTo, } from "./idbStore.js";
+export { persistIdentity, resolveIdentity } from "./resolve.js";
+export { acquireNodeLeadership, LOCK_NAME } from "./webLocks.js";

package/dist/identity/resolve.d.ts

@@ -0,0 +1,31 @@
+import type { IdentitySource } from "./idbStore.js";
+import type { IdentityStore, P2PIdentity } from "./types.js";
+export interface ResolveIdentityOptions {
+    /**
+     * other apps' databases to check first, read-only - never created or
+     * upgraded. checked in order; the first source with a stored identity
+     * wins over the local store. this is how, e.g., a newly-installed app can
+     * pick up an identity an already-installed sibling app created for this
+     * origin, without either app depending on the other's schema beyond the
+     * shared identity record shape.
+     */
+    fallbackSources?: IdentitySource[];
+}
+/**
+ * resolve the p2p identity for this origin.
+ *
+ * checks each fallback source in order (without creating any of them), then
+ * falls back to the local store. the first fallback source that already has
+ * an identity wins over the local store, even if the local store also has
+ * one - this lets a newly-added app adopt an existing sibling app's identity
+ * on first run.
+ */
+export declare function resolveIdentity(local: IdentityStore, options?: ResolveIdentityOptions): Promise<P2PIdentity | null>;
+/**
+ * persist a p2p identity.
+ *
+ * writes to the first available fallback source (matching resolveIdentity's
+ * preference order); otherwise writes to the local store.
+ */
+export declare function persistIdentity(identity: P2PIdentity, local: IdentityStore, options?: ResolveIdentityOptions): Promise<void>;
+//# sourceMappingURL=resolve.d.ts.map

package/dist/identity/resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/identity/resolve.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE7D,MAAM,WAAW,sBAAsB;IACrC;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,cAAc,EAAE,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,aAAa,EACpB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAU7B;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,aAAa,EACpB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,IAAI,CAAC,CASf"}

package/dist/identity/resolve.js

@@ -0,0 +1,37 @@
+import { identitySourceAvailable, readIdentityFrom, writeIdentityTo } from "./idbStore.js";
+/**
+ * resolve the p2p identity for this origin.
+ *
+ * checks each fallback source in order (without creating any of them), then
+ * falls back to the local store. the first fallback source that already has
+ * an identity wins over the local store, even if the local store also has
+ * one - this lets a newly-added app adopt an existing sibling app's identity
+ * on first run.
+ */
+export async function resolveIdentity(local, options = {}) {
+    for (const source of options.fallbackSources ?? []) {
+        if (!(await identitySourceAvailable(source)))
+            continue;
+        const identity = await readIdentityFrom(source);
+        if (identity)
+            return identity;
+        // source exists but has no identity yet - keep checking the remaining
+        // sources, then fall through to local
+    }
+    return local.get();
+}
+/**
+ * persist a p2p identity.
+ *
+ * writes to the first available fallback source (matching resolveIdentity's
+ * preference order); otherwise writes to the local store.
+ */
+export async function persistIdentity(identity, local, options = {}) {
+    for (const source of options.fallbackSources ?? []) {
+        if (await identitySourceAvailable(source)) {
+            await writeIdentityTo(source, identity);
+            return;
+        }
+    }
+    await local.set(identity);
+}

package/dist/identity/resolve.test.d.ts

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

package/dist/identity/resolve.test.d.ts.map

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

package/dist/identity/resolve.test.js

@@ -0,0 +1,105 @@
+import { IDBFactory } from "fake-indexeddb";
+import { beforeEach, describe, expect, it } from "vitest";
+import { createIdbIdentityStore } from "./idbStore.js";
+import { persistIdentity, resolveIdentity } from "./resolve.js";
+function makeIdentity(nodeId = "node-abc") {
+    return {
+        secret_key: new Uint8Array([1, 2, 3]),
+        node_id: nodeId,
+        created_at: 1000,
+    };
+}
+function makeLocalStore(initial = null) {
+    let stored = initial;
+    return {
+        get stored() {
+            return stored;
+        },
+        async get() {
+            return stored;
+        },
+        async set(identity) {
+            stored = identity;
+        },
+    };
+}
+beforeEach(() => {
+    globalThis.indexedDB = new IDBFactory();
+});
+describe("resolveIdentity", () => {
+    it("returns the local identity when there are no fallback sources", async () => {
+        const local = makeLocalStore(makeIdentity("node-local"));
+        expect((await resolveIdentity(local))?.node_id).toBe("node-local");
+    });
+    it("returns the local identity when configured fallback sources don't exist", async () => {
+        const local = makeLocalStore(makeIdentity("node-local"));
+        const result = await resolveIdentity(local, {
+            fallbackSources: [{ databaseName: "sibling-app", storeName: "app_state" }],
+        });
+        expect(result?.node_id).toBe("node-local");
+    });
+    it("prefers a fallback source's identity over the local one", async () => {
+        const siblingStore = createIdbIdentityStore({
+            databaseName: "sibling-app",
+            storeName: "app_state",
+        });
+        await siblingStore.set(makeIdentity("node-sibling"));
+        const local = makeLocalStore(makeIdentity("node-local"));
+        const result = await resolveIdentity(local, {
+            fallbackSources: [{ databaseName: "sibling-app", storeName: "app_state" }],
+        });
+        expect(result?.node_id).toBe("node-sibling");
+    });
+    it("falls back to local when the fallback source exists but has no identity yet", async () => {
+        // create the sibling db/store without writing an identity into it
+        const db = await new Promise((resolve, reject) => {
+            const req = indexedDB.open("sibling-app", 1);
+            req.onupgradeneeded = () => req.result.createObjectStore("app_state");
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => reject(req.error);
+        });
+        db.close();
+        const local = makeLocalStore(makeIdentity("node-local"));
+        const result = await resolveIdentity(local, {
+            fallbackSources: [{ databaseName: "sibling-app", storeName: "app_state" }],
+        });
+        expect(result?.node_id).toBe("node-local");
+    });
+    it("checks fallback sources in order, taking the first hit", async () => {
+        const second = createIdbIdentityStore({ databaseName: "second-app", storeName: "app_state" });
+        await second.set(makeIdentity("node-second"));
+        const local = makeLocalStore(makeIdentity("node-local"));
+        const result = await resolveIdentity(local, {
+            fallbackSources: [
+                { databaseName: "first-app", storeName: "app_state" },
+                { databaseName: "second-app", storeName: "app_state" },
+            ],
+        });
+        expect(result?.node_id).toBe("node-second");
+    });
+});
+describe("persistIdentity", () => {
+    it("writes to the local store when there are no fallback sources", async () => {
+        const local = makeLocalStore(null);
+        await persistIdentity(makeIdentity("node-new"), local);
+        expect(local.stored?.node_id).toBe("node-new");
+    });
+    it("writes to the local store when configured fallback sources don't exist", async () => {
+        const local = makeLocalStore(null);
+        await persistIdentity(makeIdentity("node-new"), local, {
+            fallbackSources: [{ databaseName: "sibling-app", storeName: "app_state" }],
+        });
+        expect(local.stored?.node_id).toBe("node-new");
+    });
+    it("writes to an existing fallback source instead of local", async () => {
+        const sibling = createIdbIdentityStore({ databaseName: "sibling-app", storeName: "app_state" });
+        // seed the sibling db/store so it "exists" from persistIdentity's perspective
+        await sibling.set(makeIdentity("node-placeholder"));
+        const local = makeLocalStore(null);
+        await persistIdentity(makeIdentity("node-new"), local, {
+            fallbackSources: [{ databaseName: "sibling-app", storeName: "app_state" }],
+        });
+        expect(local.stored).toBeNull();
+        expect((await sibling.get())?.node_id).toBe("node-new");
+    });
+});

package/dist/identity/types.d.ts

@@ -0,0 +1,21 @@
+export interface P2PIdentity {
+    /** 32-byte iroh secret key. */
+    secret_key: Uint8Array;
+    /** public node id (iroh public key, hex-encoded). */
+    node_id: string;
+    /** unix epoch millis when the identity was first created. */
+    created_at: number;
+}
+/**
+ * per-app identity persistence.
+ *
+ * apps supply their own storage behind this narrow interface - idb, a
+ * generic key/value store, secure platform storage, whatever fits. this
+ * package's idb-backed implementation (see idbStore.ts) is one convenient
+ * option, not a requirement.
+ */
+export interface IdentityStore {
+    get(): Promise<P2PIdentity | null>;
+    set(identity: P2PIdentity): Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/identity/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/identity/types.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,WAAW;IAC1B,+BAA+B;IAC/B,UAAU,EAAE,UAAU,CAAC;IACvB,qDAAqD;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,aAAa;IAC5B,GAAG,IAAI,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IACnC,GAAG,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3C"}

package/dist/identity/types.js

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

package/dist/identity/webLocks.d.ts

@@ -0,0 +1,22 @@
+/** lock name used for node leader election. */
+export declare const LOCK_NAME = "freqhole-iroh-node";
+export interface AcquireNodeLeadershipOpts {
+    /** called when this tab becomes the node leader. */
+    onAcquired: () => void | Promise<void>;
+    /** called with state transitions; optional. */
+    onStateChange?: (state: "leader" | "waiting" | "unsupported") => void;
+}
+/**
+ * attempt to acquire exclusive leadership of the p2p node.
+ *
+ * behavior:
+ *   - tries ifAvailable first; if the lock is free, holds it and calls onAcquired
+ *   - if already held, reports "waiting" and queues a normal request with an AbortController
+ *     so leadership transfers when the current leader tab closes
+ *   - if navigator.locks is absent (e.g. non-secure context), reports "unsupported"
+ *     and calls onAcquired immediately (single-tab fallback)
+ *
+ * returns a cancel/release function; call it to give up leadership or cancel the wait.
+ */
+export declare function acquireNodeLeadership(opts: AcquireNodeLeadershipOpts): () => void;
+//# sourceMappingURL=webLocks.d.ts.map

package/dist/identity/webLocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webLocks.d.ts","sourceRoot":"","sources":["../../src/identity/webLocks.ts"],"names":[],"mappings":"AAGA,+CAA+C;AAC/C,eAAO,MAAM,SAAS,uBAAuB,CAAC;AAE9C,MAAM,WAAW,yBAAyB;IACxC,oDAAoD;IACpD,UAAU,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvC,+CAA+C;IAC/C,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,GAAG,aAAa,KAAK,IAAI,CAAC;CACvE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,yBAAyB,GAAG,MAAM,IAAI,CAqDjF"}

package/dist/identity/webLocks.js

@@ -0,0 +1,67 @@
+// web locks leader election for a p2p node.
+// only one tab per origin should run the node at a time.
+/** lock name used for node leader election. */
+export const LOCK_NAME = "freqhole-iroh-node";
+/**
+ * attempt to acquire exclusive leadership of the p2p node.
+ *
+ * behavior:
+ *   - tries ifAvailable first; if the lock is free, holds it and calls onAcquired
+ *   - if already held, reports "waiting" and queues a normal request with an AbortController
+ *     so leadership transfers when the current leader tab closes
+ *   - if navigator.locks is absent (e.g. non-secure context), reports "unsupported"
+ *     and calls onAcquired immediately (single-tab fallback)
+ *
+ * returns a cancel/release function; call it to give up leadership or cancel the wait.
+ */
+export function acquireNodeLeadership(opts) {
+    const { onAcquired, onStateChange } = opts;
+    // single-tab fallback for environments without web locks
+    if (typeof navigator === "undefined" || !navigator.locks) {
+        onStateChange?.("unsupported");
+        void Promise.resolve().then(() => onAcquired());
+        return () => { };
+    }
+    let released = false;
+    // resolving this promise releases the held lock
+    let releaseLock = null;
+    // used to cancel the waiting queue request
+    const waitAbort = new AbortController();
+    function cancel() {
+        released = true;
+        waitAbort.abort();
+        releaseLock?.();
+    }
+    // try to grab the lock immediately without queuing
+    navigator.locks.request(LOCK_NAME, { ifAvailable: true }, async (lock) => {
+        if (released)
+            return;
+        if (lock !== null) {
+            // we are now the leader - call onAcquired, then hold the lock until released
+            onStateChange?.("leader");
+            await onAcquired();
+            await new Promise((resolve) => {
+                releaseLock = resolve;
+            });
+        }
+        else {
+            // another tab holds the lock - queue up for leadership
+            onStateChange?.("waiting");
+            try {
+                await navigator.locks.request(LOCK_NAME, { signal: waitAbort.signal }, async () => {
+                    if (released)
+                        return;
+                    onStateChange?.("leader");
+                    await onAcquired();
+                    await new Promise((resolve) => {
+                        releaseLock = resolve;
+                    });
+                });
+            }
+            catch {
+                // aborted by cancel() or context destroyed - not an error
+            }
+        }
+    });
+    return cancel;
+}

package/dist/identity/webLocks.test.d.ts

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

package/dist/identity/webLocks.test.d.ts.map

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

package/dist/identity/webLocks.test.js

@@ -0,0 +1,125 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { acquireNodeLeadership, LOCK_NAME } from "./webLocks.js";
+/** navigator is read-only on globalThis in node; use defineProperty to stub it. */
+function stubNavigator(value) {
+    const descriptor = Object.getOwnPropertyDescriptor(globalThis, "navigator");
+    Object.defineProperty(globalThis, "navigator", {
+        configurable: true,
+        writable: true,
+        value,
+    });
+    return () => {
+        if (descriptor) {
+            Object.defineProperty(globalThis, "navigator", descriptor);
+        }
+        else {
+            Object.defineProperty(globalThis, "navigator", {
+                configurable: true,
+                writable: true,
+                value: undefined,
+            });
+        }
+    };
+}
+const restores = [];
+afterEach(() => {
+    while (restores.length)
+        restores.pop()?.();
+});
+describe("acquireNodeLeadership", () => {
+    it("exports the expected lock name", () => {
+        expect(LOCK_NAME).toBe("freqhole-iroh-node");
+    });
+    it("calls onAcquired immediately when navigator.locks is absent", async () => {
+        restores.push(stubNavigator(undefined));
+        const states = [];
+        let acquired = false;
+        const cancel = acquireNodeLeadership({
+            onAcquired: () => {
+                acquired = true;
+            },
+            onStateChange: (s) => states.push(s),
+        });
+        await Promise.resolve();
+        expect(states[0]).toBe("unsupported");
+        expect(acquired).toBe(true);
+        cancel();
+    });
+    it("calls onAcquired when the lock is granted immediately", async () => {
+        restores.push(stubNavigator({
+            locks: {
+                request: async (_name, opts, cb) => {
+                    if (opts.ifAvailable) {
+                        await cb({ name: _name, mode: "exclusive" });
+                    }
+                },
+            },
+        }));
+        const states = [];
+        let acquired = false;
+        const cancel = acquireNodeLeadership({
+            onAcquired: () => {
+                acquired = true;
+            },
+            onStateChange: (s) => states.push(s),
+        });
+        await new Promise((r) => setTimeout(r, 10));
+        cancel();
+        expect(states).toContain("leader");
+        expect(acquired).toBe(true);
+    });
+    it("reports waiting when the lock is held elsewhere, then transfers leadership", async () => {
+        restores.push(stubNavigator({
+            locks: {
+                request: async (_name, opts, cb) => {
+                    if (opts.ifAvailable) {
+                        // lock held elsewhere
+                        await cb(null);
+                    }
+                    else {
+                        // queued request: resolve once the current leader "closes"
+                        await new Promise((resolve, reject) => {
+                            opts.signal?.addEventListener("abort", () => reject(new DOMException("aborted", "AbortError")));
+                            setTimeout(() => resolve(cb(null)), 5);
+                        });
+                    }
+                },
+            },
+        }));
+        const states = [];
+        const cancel = acquireNodeLeadership({
+            onAcquired: () => { },
+            onStateChange: (s) => states.push(s),
+        });
+        await new Promise((r) => setTimeout(r, 10));
+        expect(states).toContain("waiting");
+        cancel();
+        await new Promise((r) => setTimeout(r, 10));
+    });
+    it("cancel() aborts a pending wait without throwing", async () => {
+        restores.push(stubNavigator({
+            locks: {
+                request: async (_name, opts, cb) => {
+                    if (opts.ifAvailable) {
+                        await cb(null);
+                    }
+                    else {
+                        await new Promise((_, reject) => {
+                            opts.signal?.addEventListener("abort", () => reject(new DOMException("aborted", "AbortError")));
+                        });
+                    }
+                },
+            },
+        }));
+        const states = [];
+        const cancel = acquireNodeLeadership({
+            onAcquired: () => { },
+            onStateChange: (s) => states.push(s),
+        });
+        await new Promise((r) => setTimeout(r, 10));
+        expect(states).toContain("waiting");
+        cancel();
+        await new Promise((r) => setTimeout(r, 10));
+        // no unhandled rejection - the AbortError is swallowed internally
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export declare const HARUSPEX_VERSION = "0.1.0";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export const HARUSPEX_VERSION = "0.1.0";

package/dist/index.test.d.ts

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

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

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

package/dist/index.test.js

@@ -0,0 +1,7 @@
+import { describe, expect, it } from "vitest";
+import { HARUSPEX_VERSION } from "./index.js";
+describe("haruspex skeleton", () => {
+    it("exports something so vitest + tsc have a real target", () => {
+        expect(HARUSPEX_VERSION).toBe("0.1.0");
+    });
+});

package/dist/knock/index.d.ts

@@ -0,0 +1,10 @@
+export type { CreateKnockInput, KnockDecision, KnockDirection, KnockPolicy, KnockPolicyResult, KnockRecord, KnockRequest, KnockScope, KnockStatus, KnockStatusReply, KnockStore, KnockTransport, } from "./types.js";
+export { KnockConflictError } from "./types.js";
+export type { KnockStoreOptions } from "./store.js";
+export { createIdbKnockStore } from "./store.js";
+export type { CheckKnockStatusOptions } from "./requester.js";
+export { checkKnockStatus, sendKnock } from "./requester.js";
+export { acceptKnock, denyKnock } from "./responder.js";
+export type { PendingKnockCheckerDeps } from "./pending-checker.js";
+export { checkPendingKnocks } from "./pending-checker.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/knock/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,WAAW,EACX,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,UAAU,EACV,WAAW,EACX,gBAAgB,EAChB,UAAU,EACV,cAAc,GACf,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEhD,YAAY,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEjD,YAAY,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE7D,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAExD,YAAY,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/knock/index.js

@@ -0,0 +1,5 @@
+export { KnockConflictError } from "./types.js";
+export { createIdbKnockStore } from "./store.js";
+export { checkKnockStatus, sendKnock } from "./requester.js";
+export { acceptKnock, denyKnock } from "./responder.js";
+export { checkPendingKnocks } from "./pending-checker.js";

package/dist/knock/pending-checker.d.ts

@@ -0,0 +1,19 @@
+import type { KnockRecord, KnockStore, KnockTransport } from "./types.js";
+export interface PendingKnockCheckerDeps {
+    store: KnockStore;
+    transport: KnockTransport;
+    /**
+     * fired once per outbound knock that has just resolved to accepted - a
+     * toast/notification hook is the typical use. this sweep never acts on
+     * the result itself beyond persisting the decision.
+     */
+    onAccepted: (record: KnockRecord) => void | Promise<void>;
+    onDenied?: (record: KnockRecord) => void | Promise<void>;
+}
+/**
+ * re-checks every pending outbound knock and fires the injected callback
+ * for any that has resolved since the app was last open. peers that are
+ * unreachable are left pending, retried on the next sweep.
+ */
+export declare function checkPendingKnocks(deps: PendingKnockCheckerDeps): Promise<void>;
+//# sourceMappingURL=pending-checker.d.ts.map

package/dist/knock/pending-checker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pending-checker.d.ts","sourceRoot":"","sources":["../../src/knock/pending-checker.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE1E,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE,cAAc,CAAC;IAC1B;;;;OAIG;IACH,UAAU,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D;AAED;;;;GAIG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,uBAAuB,GAAG,OAAO,CAAC,IAAI,CAAC,CAmBrF"}

package/dist/knock/pending-checker.js

@@ -0,0 +1,27 @@
+// boot-time sweep that promotes any outbound knock that has been accepted
+// (or denied) while the app was closed.
+import { checkKnockStatus } from "./requester.js";
+/**
+ * re-checks every pending outbound knock and fires the injected callback
+ * for any that has resolved since the app was last open. peers that are
+ * unreachable are left pending, retried on the next sweep.
+ */
+export async function checkPendingKnocks(deps) {
+    const pending = await deps.store.listPending();
+    const outbound = pending.filter((record) => record.direction === "outbound");
+    await Promise.all(outbound.map(async (record) => {
+        let updated;
+        try {
+            updated = await checkKnockStatus(deps.store, deps.transport, record.id);
+        }
+        catch {
+            return;
+        }
+        if (updated.status === "accepted") {
+            await deps.onAccepted(updated);
+        }
+        else if (updated.status === "denied") {
+            await deps.onDenied?.(updated);
+        }
+    }));
+}

package/dist/knock/pending-checker.test.d.ts

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

package/dist/knock/pending-checker.test.d.ts.map

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