@freqhole/haruspex 0.0.0

package/dist/solid/auth-form.test.js

@@ -0,0 +1,131 @@
+import { createRoot } from "solid-js";
+import { describe, expect, it, vi } from "vitest";
+import { createAuthForm } from "./auth-form.js";
+describe("createAuthForm", () => {
+    it("defaults to login mode", () => {
+        createRoot((dispose) => {
+            const form = createAuthForm();
+            expect(form.mode()).toBe("login");
+            dispose();
+        });
+    });
+    it("honors an initialMode", () => {
+        createRoot((dispose) => {
+            const form = createAuthForm({ initialMode: "register" });
+            expect(form.mode()).toBe("register");
+            dispose();
+        });
+    });
+    it("isSubmitDisabled is true until a username is entered", () => {
+        createRoot((dispose) => {
+            const form = createAuthForm();
+            expect(form.isSubmitDisabled()).toBe(true);
+            form.setUsername("viz");
+            expect(form.isSubmitDisabled()).toBe(false);
+            dispose();
+        });
+    });
+    it("register mode also requires an invite code", () => {
+        createRoot((dispose) => {
+            const form = createAuthForm({ initialMode: "register" });
+            form.setUsername("viz");
+            expect(form.isSubmitDisabled()).toBe(true);
+            form.setInviteCode("abc123");
+            expect(form.isSubmitDisabled()).toBe(false);
+            dispose();
+        });
+    });
+    it("isSubmitDisabled is true while loading, regardless of field state", () => {
+        createRoot((dispose) => {
+            const form = createAuthForm({ loading: () => true });
+            form.setUsername("viz");
+            expect(form.isSubmitDisabled()).toBe(true);
+            dispose();
+        });
+    });
+    it("switchMode flips login <-> register and calls onModeChange", () => {
+        createRoot((dispose) => {
+            const onModeChange = vi.fn();
+            const form = createAuthForm({ onModeChange });
+            form.switchMode();
+            expect(form.mode()).toBe("register");
+            expect(onModeChange).toHaveBeenCalledWith("register");
+            form.switchMode();
+            expect(form.mode()).toBe("login");
+            expect(onModeChange).toHaveBeenCalledWith("login");
+            dispose();
+        });
+    });
+    it("handleSubmit calls onSubmit with the current field values, omitting inviteCode in login mode", async () => {
+        await createRoot(async (dispose) => {
+            const onSubmit = vi.fn();
+            const form = createAuthForm({ onSubmit });
+            form.setUsername("viz");
+            form.setInviteCode("should-be-ignored");
+            await form.handleSubmit();
+            expect(onSubmit).toHaveBeenCalledWith({
+                username: "viz",
+                inviteCode: undefined,
+                mode: "login",
+            });
+            dispose();
+        });
+    });
+    it("handleSubmit includes inviteCode in register mode", async () => {
+        await createRoot(async (dispose) => {
+            const onSubmit = vi.fn();
+            const form = createAuthForm({ initialMode: "register", onSubmit });
+            form.setUsername("viz");
+            form.setInviteCode("abc123");
+            await form.handleSubmit();
+            expect(onSubmit).toHaveBeenCalledWith({
+                username: "viz",
+                inviteCode: "abc123",
+                mode: "register",
+            });
+            dispose();
+        });
+    });
+    it("handleSubmit no-ops while loading", async () => {
+        await createRoot(async (dispose) => {
+            const onSubmit = vi.fn();
+            const form = createAuthForm({ loading: () => true, onSubmit });
+            form.setUsername("viz");
+            await form.handleSubmit();
+            expect(onSubmit).not.toHaveBeenCalled();
+            dispose();
+        });
+    });
+    it("handleSubmit calls preventDefault on a passed event", async () => {
+        await createRoot(async (dispose) => {
+            const form = createAuthForm();
+            const preventDefault = vi.fn();
+            await form.handleSubmit({ preventDefault });
+            expect(preventDefault).toHaveBeenCalled();
+            dispose();
+        });
+    });
+    it("handlePasskeyClick calls onPasskeyClick with the current field values", async () => {
+        await createRoot(async (dispose) => {
+            const onPasskeyClick = vi.fn();
+            const form = createAuthForm({ onPasskeyClick });
+            form.setUsername("viz");
+            await form.handlePasskeyClick();
+            expect(onPasskeyClick).toHaveBeenCalledWith({
+                username: "viz",
+                inviteCode: undefined,
+                mode: "login",
+            });
+            dispose();
+        });
+    });
+    it("handlePasskeyClick no-ops while loading", async () => {
+        await createRoot(async (dispose) => {
+            const onPasskeyClick = vi.fn();
+            const form = createAuthForm({ loading: () => true, onPasskeyClick });
+            await form.handlePasskeyClick();
+            expect(onPasskeyClick).not.toHaveBeenCalled();
+            dispose();
+        });
+    });
+});

package/dist/solid/auth-status.d.ts

@@ -0,0 +1,21 @@
+import { type Accessor } from "solid-js";
+export interface AuthStatusStore<T> {
+    /** reactive snapshot of every tracked key's entry. */
+    status: Accessor<Map<string, T | null>>;
+    /** snapshot lookup for one key. `undefined` means never queried. */
+    get(key: string): T | null | undefined;
+    /** mark one key as pending (query in flight), without touching others. */
+    markPending(key: string): void;
+    /** mark every one of the given keys as pending in a single update. */
+    resetPending(keys: string[]): void;
+    /** store a resolved entry for one key. */
+    patch(key: string, entry: T): void;
+    /** drop one key's entry entirely (e.g. after the remote is deleted). */
+    clear(key: string): void;
+}
+/**
+ * creates a reactive `key -> resolved-entry-or-pending` cache for any
+ * number of independently-tracked remotes/resources.
+ */
+export declare function createAuthStatus<T>(): AuthStatusStore<T>;
+//# sourceMappingURL=auth-status.d.ts.map

package/dist/solid/auth-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth-status.d.ts","sourceRoot":"","sources":["../../src/solid/auth-status.ts"],"names":[],"mappings":"AAeA,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEvD,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,sDAAsD;IACtD,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;IACxC,oEAAoE;IACpE,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC;IACvC,0EAA0E;IAC1E,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,sEAAsE;IACtE,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACnC,0CAA0C;IAC1C,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IACnC,wEAAwE;IACxE,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,KAAK,eAAe,CAAC,CAAC,CAAC,CAsCxD"}

package/dist/solid/auth-status.js

@@ -0,0 +1,58 @@
+// a reactive per-remote auth-status cache: tracks whether each remote
+// (keyed by an arbitrary string id) is logged in, being checked, or has
+// never been queried yet, without any vocabulary of its own for how a
+// remote is reached or how "logged in" gets determined.
+//
+// three states per key:
+//   - absent from the map: never queried
+//   - `null`: a query is in flight (or was reset to pending)
+//   - `T`: resolved (the caller decides what a resolved entry looks like -
+//     typically something like `{ loggedIn: boolean; username?: string }`)
+//
+// the caller supplies the actual resolution logic (whoami calls, offline
+// heuristics, retry-on-cold-boot timing, and so on) - this module only
+// owns the reactive map itself.
+import { createSignal } from "solid-js";
+/**
+ * creates a reactive `key -> resolved-entry-or-pending` cache for any
+ * number of independently-tracked remotes/resources.
+ */
+export function createAuthStatus() {
+    const [status, setStatus] = createSignal(new Map());
+    function patchMap(key, entry) {
+        setStatus((prev) => {
+            const next = new Map(prev);
+            next.set(key, entry);
+            return next;
+        });
+    }
+    return {
+        status,
+        get(key) {
+            return status().get(key);
+        },
+        markPending(key) {
+            patchMap(key, null);
+        },
+        resetPending(keys) {
+            setStatus(() => {
+                const next = new Map();
+                for (const key of keys)
+                    next.set(key, null);
+                return next;
+            });
+        },
+        patch(key, entry) {
+            patchMap(key, entry);
+        },
+        clear(key) {
+            setStatus((prev) => {
+                if (!prev.has(key))
+                    return prev;
+                const next = new Map(prev);
+                next.delete(key);
+                return next;
+            });
+        },
+    };
+}

package/dist/solid/auth-status.test.d.ts

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

package/dist/solid/auth-status.test.d.ts.map

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

package/dist/solid/auth-status.test.js

@@ -0,0 +1,60 @@
+import { createRoot } from "solid-js";
+import { describe, expect, it } from "vitest";
+import { createAuthStatus } from "./auth-status.js";
+describe("createAuthStatus", () => {
+    it("starts empty - get returns undefined for an unqueried key", () => {
+        createRoot((dispose) => {
+            const store = createAuthStatus();
+            expect(store.get("remote-a")).toBeUndefined();
+            expect(store.status().size).toBe(0);
+            dispose();
+        });
+    });
+    it("markPending sets the entry to null (in flight)", () => {
+        createRoot((dispose) => {
+            const store = createAuthStatus();
+            store.markPending("remote-a");
+            expect(store.get("remote-a")).toBeNull();
+            dispose();
+        });
+    });
+    it("patch stores a resolved entry", () => {
+        createRoot((dispose) => {
+            const store = createAuthStatus();
+            store.patch("remote-a", { loggedIn: true, username: "viz" });
+            expect(store.get("remote-a")).toEqual({ loggedIn: true, username: "viz" });
+            dispose();
+        });
+    });
+    it("resetPending marks exactly the given keys as pending, dropping others", () => {
+        createRoot((dispose) => {
+            const store = createAuthStatus();
+            store.patch("remote-a", { loggedIn: true });
+            store.resetPending(["remote-b", "remote-c"]);
+            expect(store.get("remote-a")).toBeUndefined();
+            expect(store.get("remote-b")).toBeNull();
+            expect(store.get("remote-c")).toBeNull();
+            dispose();
+        });
+    });
+    it("clear drops one key without touching others", () => {
+        createRoot((dispose) => {
+            const store = createAuthStatus();
+            store.patch("remote-a", { loggedIn: true });
+            store.patch("remote-b", { loggedIn: false });
+            store.clear("remote-a");
+            expect(store.get("remote-a")).toBeUndefined();
+            expect(store.get("remote-b")).toEqual({ loggedIn: false });
+            dispose();
+        });
+    });
+    it("clear is a no-op when the key was never present", () => {
+        createRoot((dispose) => {
+            const store = createAuthStatus();
+            const before = store.status();
+            store.clear("nonexistent");
+            expect(store.status()).toBe(before);
+            dispose();
+        });
+    });
+});

package/dist/solid/index.d.ts

@@ -0,0 +1,5 @@
+export { createAuthForm, type AuthMode, type AuthFormData, type AuthFormDeps, type AuthFormState, } from "./auth-form.js";
+export { createReauthFlow, type ReauthFlowDeps, type ReauthFlowState, } from "./reauth-flow.js";
+export { createAuthStatus, type AuthStatusStore } from "./auth-status.js";
+export { createKnockInbox, type KnockAcceptDecision, type KnockRowError, type KnockInboxDeps, type KnockInboxState, } from "./knock-inbox.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/solid/index.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,cAAc,EACd,KAAK,QAAQ,EACb,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,GACnB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,gBAAgB,EAChB,KAAK,cAAc,EACnB,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,EACL,gBAAgB,EAChB,KAAK,mBAAmB,EACxB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,eAAe,GACrB,MAAM,kBAAkB,CAAC"}

package/dist/solid/index.js

@@ -0,0 +1,10 @@
+// solid-js integration module: headless auth-form/reauth-flow/auth-status/
+// knock-inbox state primitives (behavior + accessibility-relevant state
+// only, zero markup or styling opinions - consumers render their own
+// components around these), and the AddPeerFlow FSM lives in ./flows for
+// a rendered shell to be built over later. solid-js is an optional peer
+// dep - keep this the only subpath that imports it.
+export { createAuthForm, } from "./auth-form.js";
+export { createReauthFlow, } from "./reauth-flow.js";
+export { createAuthStatus } from "./auth-status.js";
+export { createKnockInbox, } from "./knock-inbox.js";

package/dist/solid/knock-inbox.d.ts

@@ -0,0 +1,61 @@
+import { type Accessor, type Resource } from "solid-js";
+/** one decision made when accepting a knock. */
+export interface KnockAcceptDecision {
+    role: string;
+    username?: string | null;
+    userId?: string | null;
+}
+/** one error surfaced by a row-level action. */
+export interface KnockRowError {
+    action: string;
+    title?: string;
+    detail: string;
+    errorType?: string;
+}
+export interface KnockInboxDeps<TRow> {
+    /** fetches the current list. `includeAll` reflects the inbox's own
+     *  toggle (e.g. "show resolved knocks too"). */
+    listKnocks(includeAll: boolean): Promise<TRow[]>;
+    acceptKnock(knock: TRow, decision: KnockAcceptDecision): Promise<void>;
+    rejectKnock(knock: TRow): Promise<void>;
+    deleteKnock(knock: TRow): Promise<void>;
+    /** optional bulk reject; omit if the caller's api has no such endpoint. */
+    rejectAllKnocks?(): Promise<{
+        rejected: number;
+    }>;
+    /** extracts a stable key from a row, used for per-row loading/error
+     *  tracking. */
+    getId(knock: TRow): string;
+    /** maps a thrown error into one or more row errors. defaults to a
+     *  single generic error built from `error.message`/`String(error)`. */
+    mapError?(action: string, error: unknown): KnockRowError[];
+    /** fired after any successful mutation (accept/reject/delete/rejectAll). */
+    onChanged?(): void;
+    /** fired on any action's success, for toast-like side effects. */
+    onActionSuccess?(action: string, knock: TRow | null, result?: unknown): void;
+    /** fired on any action's failure, for toast-like side effects. */
+    onActionError?(action: string, knock: TRow | null, error: unknown): void;
+}
+export interface KnockInboxState<TRow> {
+    /** the current list resource (undefined while first loading). */
+    knocks: Resource<TRow[]>;
+    /** true while the list itself is (re)loading. */
+    loading: Accessor<boolean>;
+    includeAll: Accessor<boolean>;
+    setIncludeAll(value: boolean): void;
+    /** id of the row currently being accepted, or null. */
+    accepting: Accessor<string | null>;
+    /** id of the row currently being rejected, or null. */
+    rejecting: Accessor<string | null>;
+    /** id of the row currently being deleted, or null. */
+    deleting: Accessor<string | null>;
+    rowErrors: Accessor<Record<string, KnockRowError[]>>;
+    clearRowError(id: string): void;
+    accept(knock: TRow, decision: KnockAcceptDecision): Promise<void>;
+    reject(knock: TRow): Promise<void>;
+    remove(knock: TRow): Promise<void>;
+    rejectAll(): Promise<void>;
+    refetch(): TRow[] | Promise<TRow[] | undefined> | undefined | null;
+}
+export declare function createKnockInbox<TRow>(deps: KnockInboxDeps<TRow>): KnockInboxState<TRow>;
+//# sourceMappingURL=knock-inbox.d.ts.map

package/dist/solid/knock-inbox.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"knock-inbox.d.ts","sourceRoot":"","sources":["../../src/solid/knock-inbox.ts"],"names":[],"mappings":"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"}

package/dist/solid/knock-inbox.js

@@ -0,0 +1,123 @@
+// headless knock-inbox state: lists pending (or all) knocks for a
+// resource the caller administers, tracks per-row accept/reject/delete
+// loading state and per-row errors, and exposes accept/reject/delete/
+// reject-all actions - all with zero markup, list-transport, or error-
+// shape opinions of its own.
+//
+// the caller supplies how a row is listed/decided (any admin api, any
+// row shape) and how to identify a row's key; this module only owns the
+// resource-loading/action/error-tracking state around those calls.
+import { createResource, createSignal } from "solid-js";
+const defaultMapError = (action, error) => [
+    { action, detail: error instanceof Error ? error.message : String(error) },
+];
+export function createKnockInbox(deps) {
+    const mapError = deps.mapError ?? defaultMapError;
+    const [includeAll, setIncludeAll] = createSignal(false);
+    // createResource skips its fetcher when the source returns a falsy
+    // value (false/null/undefined) - wrapping in an object so the initial
+    // `false` still triggers the first fetch.
+    const [knocks, { refetch }] = createResource(() => ({ all: includeAll() }), async ({ all }) => {
+        try {
+            return await deps.listKnocks(all);
+        }
+        catch (error) {
+            deps.onActionError?.("list", null, error);
+            return [];
+        }
+    });
+    const [accepting, setAccepting] = createSignal(null);
+    const [rejecting, setRejecting] = createSignal(null);
+    const [deleting, setDeleting] = createSignal(null);
+    const [rowErrors, setRowErrors] = createSignal({});
+    function setRowError(id, action, error) {
+        setRowErrors({ ...rowErrors(), [id]: mapError(action, error) });
+    }
+    function clearRowError(id) {
+        const { [id]: _removed, ...rest } = rowErrors();
+        setRowErrors(rest);
+    }
+    async function notifyChanged() {
+        await refetch();
+        deps.onChanged?.();
+    }
+    async function accept(knock, decision) {
+        const id = deps.getId(knock);
+        setAccepting(id);
+        clearRowError(id);
+        try {
+            await deps.acceptKnock(knock, decision);
+            deps.onActionSuccess?.("accept", knock);
+            await notifyChanged();
+        }
+        catch (error) {
+            setRowError(id, "accept", error);
+            deps.onActionError?.("accept", knock, error);
+        }
+        finally {
+            setAccepting(null);
+        }
+    }
+    async function reject(knock) {
+        const id = deps.getId(knock);
+        setRejecting(id);
+        clearRowError(id);
+        try {
+            await deps.rejectKnock(knock);
+            deps.onActionSuccess?.("reject", knock);
+            await notifyChanged();
+        }
+        catch (error) {
+            setRowError(id, "reject", error);
+            deps.onActionError?.("reject", knock, error);
+        }
+        finally {
+            setRejecting(null);
+        }
+    }
+    async function remove(knock) {
+        const id = deps.getId(knock);
+        setDeleting(id);
+        clearRowError(id);
+        try {
+            await deps.deleteKnock(knock);
+            deps.onActionSuccess?.("delete", knock);
+            await notifyChanged();
+        }
+        catch (error) {
+            setRowError(id, "delete", error);
+            deps.onActionError?.("delete", knock, error);
+        }
+        finally {
+            setDeleting(null);
+        }
+    }
+    async function rejectAll() {
+        if (!deps.rejectAllKnocks)
+            return;
+        try {
+            const result = await deps.rejectAllKnocks();
+            deps.onActionSuccess?.("rejectAll", null, result);
+            await notifyChanged();
+        }
+        catch (error) {
+            deps.onActionError?.("rejectAll", null, error);
+        }
+    }
+    return {
+        knocks,
+        loading: () => knocks.loading,
+        includeAll,
+        setIncludeAll,
+        accepting,
+        rejecting,
+        deleting,
+        rowErrors,
+        clearRowError,
+        accept,
+        reject,
+        remove,
+        rejectAll,
+        refetch,
+    };
+}

package/dist/solid/knock-inbox.test.d.ts

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

package/dist/solid/knock-inbox.test.d.ts.map

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

package/dist/solid/knock-inbox.test.js

@@ -0,0 +1,153 @@
+import { createRoot } from "solid-js";
+import { describe, expect, it, vi } from "vitest";
+import { createKnockInbox } from "./knock-inbox.js";
+function flush() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}
+function makeDeps(overrides = {}) {
+    return {
+        listKnocks: vi.fn().mockResolvedValue([{ id: "1", status: "pending" }]),
+        acceptKnock: vi.fn().mockResolvedValue(undefined),
+        rejectKnock: vi.fn().mockResolvedValue(undefined),
+        deleteKnock: vi.fn().mockResolvedValue(undefined),
+        getId: (row) => row.id,
+        ...overrides,
+    };
+}
+describe("createKnockInbox", () => {
+    it("lists knocks on creation with includeAll defaulting to false", async () => {
+        await createRoot(async (dispose) => {
+            const listKnocks = vi.fn().mockResolvedValue([]);
+            createKnockInbox(makeDeps({ listKnocks }));
+            await flush();
+            expect(listKnocks).toHaveBeenCalledWith(false);
+            dispose();
+        });
+    });
+    it("re-lists with includeAll: true when the toggle is set", async () => {
+        await createRoot(async (dispose) => {
+            const listKnocks = vi.fn().mockResolvedValue([]);
+            const inbox = createKnockInbox(makeDeps({ listKnocks }));
+            await flush();
+            inbox.setIncludeAll(true);
+            await flush();
+            expect(listKnocks).toHaveBeenLastCalledWith(true);
+            dispose();
+        });
+    });
+    it("populates knocks() once the list resolves", async () => {
+        await createRoot(async (dispose) => {
+            const inbox = createKnockInbox(makeDeps());
+            await flush();
+            expect(inbox.knocks()).toEqual([{ id: "1", status: "pending" }]);
+            dispose();
+        });
+    });
+    it("accept sets accepting(id) during the call, clears it after, and refetches", async () => {
+        await createRoot(async (dispose) => {
+            const acceptKnock = vi.fn().mockResolvedValue(undefined);
+            const onChanged = vi.fn();
+            const listKnocks = vi.fn().mockResolvedValue([{ id: "1", status: "pending" }]);
+            const inbox = createKnockInbox(makeDeps({ acceptKnock, onChanged, listKnocks }));
+            await flush();
+            const row = { id: "1", status: "pending" };
+            const promise = inbox.accept(row, { role: "viewer" });
+            expect(inbox.accepting()).toBe("1");
+            await promise;
+            expect(acceptKnock).toHaveBeenCalledWith(row, { role: "viewer" });
+            expect(inbox.accepting()).toBeNull();
+            expect(onChanged).toHaveBeenCalled();
+            dispose();
+        });
+    });
+    it("accept records a row error and does not call onChanged when acceptKnock throws", async () => {
+        await createRoot(async (dispose) => {
+            const acceptKnock = vi.fn().mockRejectedValue(new Error("already resolved"));
+            const onChanged = vi.fn();
+            const onActionError = vi.fn();
+            const inbox = createKnockInbox(makeDeps({ acceptKnock, onChanged, onActionError }));
+            await flush();
+            const row = { id: "1", status: "pending" };
+            await inbox.accept(row, { role: "viewer" });
+            expect(inbox.rowErrors()["1"]).toEqual([{ action: "accept", detail: "already resolved" }]);
+            expect(onChanged).not.toHaveBeenCalled();
+            expect(onActionError).toHaveBeenCalledWith("accept", row, expect.any(Error));
+            dispose();
+        });
+    });
+    it("clearRowError removes just the given row's errors", async () => {
+        await createRoot(async (dispose) => {
+            const acceptKnock = vi.fn().mockRejectedValue(new Error("boom"));
+            const inbox = createKnockInbox(makeDeps({ acceptKnock }));
+            await flush();
+            await inbox.accept({ id: "1", status: "pending" }, { role: "viewer" });
+            expect(inbox.rowErrors()["1"]).toBeDefined();
+            inbox.clearRowError("1");
+            expect(inbox.rowErrors()["1"]).toBeUndefined();
+            dispose();
+        });
+    });
+    it("reject and remove wire through to their respective deps", async () => {
+        await createRoot(async (dispose) => {
+            const rejectKnock = vi.fn().mockResolvedValue(undefined);
+            const deleteKnock = vi.fn().mockResolvedValue(undefined);
+            const inbox = createKnockInbox(makeDeps({ rejectKnock, deleteKnock }));
+            await flush();
+            const row = { id: "1", status: "pending" };
+            await inbox.reject(row);
+            expect(rejectKnock).toHaveBeenCalledWith(row);
+            expect(inbox.rejecting()).toBeNull();
+            await inbox.remove(row);
+            expect(deleteKnock).toHaveBeenCalledWith(row);
+            expect(inbox.deleting()).toBeNull();
+            dispose();
+        });
+    });
+    it("rejectAll is a no-op when rejectAllKnocks isn't provided", async () => {
+        await createRoot(async (dispose) => {
+            const inbox = createKnockInbox(makeDeps());
+            await flush();
+            await expect(inbox.rejectAll()).resolves.toBeUndefined();
+            dispose();
+        });
+    });
+    it("rejectAll calls the provided rejectAllKnocks and refetches", async () => {
+        await createRoot(async (dispose) => {
+            const rejectAllKnocks = vi.fn().mockResolvedValue({ rejected: 3 });
+            const onChanged = vi.fn();
+            const onActionSuccess = vi.fn();
+            const inbox = createKnockInbox(makeDeps({ rejectAllKnocks, onChanged, onActionSuccess }));
+            await flush();
+            await inbox.rejectAll();
+            expect(rejectAllKnocks).toHaveBeenCalled();
+            expect(onChanged).toHaveBeenCalled();
+            expect(onActionSuccess).toHaveBeenCalledWith("rejectAll", null, { rejected: 3 });
+            dispose();
+        });
+    });
+    it("uses a custom mapError when provided", async () => {
+        await createRoot(async (dispose) => {
+            const acceptKnock = vi.fn().mockRejectedValue({ title: "conflict", detail: "already taken" });
+            const mapError = vi.fn(() => [{ action: "accept", title: "conflict", detail: "already taken" }]);
+            const inbox = createKnockInbox(makeDeps({ acceptKnock, mapError }));
+            await flush();
+            await inbox.accept({ id: "1", status: "pending" }, { role: "viewer" });
+            expect(mapError).toHaveBeenCalled();
+            expect(inbox.rowErrors()["1"]).toEqual([
+                { action: "accept", title: "conflict", detail: "already taken" },
+            ]);
+            dispose();
+        });
+    });
+    it("list failures surface via onActionError and leave knocks() empty", async () => {
+        await createRoot(async (dispose) => {
+            const listKnocks = vi.fn().mockRejectedValue(new Error("offline"));
+            const onActionError = vi.fn();
+            const inbox = createKnockInbox(makeDeps({ listKnocks, onActionError }));
+            await flush();
+            expect(inbox.knocks()).toEqual([]);
+            expect(onActionError).toHaveBeenCalledWith("list", null, expect.any(Error));
+            dispose();
+        });
+    });
+});