@interncom/diplomatic 0.7.1 → 0.8.1

package/dist/web/shared/checksum.d.ts

@@ -0,0 +1,25 @@
+import type { Hash, ICrypto, IEntRev } from "./types.ts";
+import { type ValStat } from "./valstat.ts";
+/** Lexicographic compare of raw bytes (unsigned). */
+export declare function cmpBytes(a: Uint8Array, b: Uint8Array): number;
+/**
+ * Checksum of a set of byte records (hashes, encoded revs, …).
+ *
+ * Preimage: blake3( concat( sort_lexicographic(items) ) ).
+ * Empty set → blake3(empty). Order of the input iterable is ignored.
+ *
+ * Equal-length items: concat is trivially unambiguous.
+ * Variable-length items: only unambiguous if each item is self-delimiting
+ * (e.g. encodeEntRev) so a concat has a unique parse.
+ */
+export declare function checksumSet(items: Iterable<Uint8Array>, crypto: ICrypto): Promise<Hash>;
+/**
+ * Wire preimage for one EntDB frontier row:
+ * varbytes(eid) ‖ date(updatedAt) ‖ varint(ctr). Self-delimiting.
+ */
+export declare function encodeEntRev(rev: IEntRev): ValStat<Uint8Array>;
+/**
+ * Frontier checksum of live EntDB rows: encode each rev, then
+ * {@link checksumSet}.
+ */
+export declare function checksumEntRevs(revs: Iterable<IEntRev>, crypto: ICrypto): Promise<ValStat<Hash>>;

package/dist/web/stores/idb/msgs.d.ts

@@ -1,7 +1,7 @@
 import { Status } from "../../shared/consts";
 import { ICrypto } from "../../shared/types";
 import { EntityID, Hash } from "../../shared/types";
-import { ApldState, IMessageStore, IStorableMessage, IStoredMessage } from "../../types";
+import { ApldState, IMessageStore, IStorableMessage, IStoredMessage, ListMsgsOpts } from "../../types";
 export declare class IDBMessageStore implements IMessageStore {
     private crypto;
     db: IDBDatabase;
@@ -10,7 +10,9 @@ export declare class IDBMessageStore implements IMessageStore {
     del(keys: Iterable<Hash>): Promise<void>;
     get(key: Hash): Promise<IStoredMessage | undefined>;
     has(key: Hash): Promise<boolean>;
-    list(apld?: ApldState): Promise<IStoredMessage[]>;
+    list(opts?: ListMsgsOpts): Promise<IStoredMessage[]>;
+    count(apld?: ApldState): Promise<number>;
+    listKeys(): Promise<Hash[]>;
     last(eid: EntityID): Promise<IStoredMessage | undefined>;
     markApplied(keys: Iterable<Hash>): Promise<void>;
     markFailed(entries: Iterable<{

package/dist/web/stores/memory/msgs.d.ts

@@ -1,6 +1,6 @@
 import { ICrypto } from "../../shared/types";
 import { EntityID, Hash } from "../../shared/types";
-import { ApldState, IMessageStore, IStorableMessage, IStoredMessage, IStoredMessageData } from "../../types";
+import { ApldState, IMessageStore, IStorableMessage, IStoredMessage, IStoredMessageData, ListMsgsOpts } from "../../types";
 import { Status } from "../../shared/consts";
 export declare class MemoryMessageStore implements IMessageStore {
     private crypto;
@@ -10,7 +10,9 @@ export declare class MemoryMessageStore implements IMessageStore {
     del(keys: Iterable<Hash>): Promise<void>;
     get(key: Hash): Promise<IStoredMessage | undefined>;
     has(key: Hash): Promise<boolean>;
-    list(apld?: ApldState): Promise<IStoredMessage[]>;
+    list(opts?: ListMsgsOpts): Promise<IStoredMessage[]>;
+    count(apld?: ApldState): Promise<number>;
+    listKeys(): Promise<Hash[]>;
     last(eid: EntityID): Promise<IStoredMessage | undefined>;
     markApplied(keys: Iterable<Hash>): Promise<void>;
     markFailed(entries: Iterable<{

package/dist/web/types.d.ts

@@ -147,18 +147,37 @@ export declare function isTerminalApplyFailure(st: Status): boolean;
  * Clears `err` unless setting {@link APLD_ERROR}.
  */
 export declare function setApld(data: IStoredMessageData, apld: ApldState, err?: Status): void;
-export declare function toStoredMessage(hash: Hash, data: IStoredMessageData, crypto: ICrypto): Promise<IStoredMessage>;
+/**
+ * Options for archive list / client diagnostics.
+ * `body` defaults to **true**. Pass `body: false` for heads + apld + err only.
+ */
+export type ListMsgsOpts = {
+    /** Filter by apply lifecycle; omit for all archive rows. */
+    apld?: ApldState;
+    /**
+     * Include msg bodies and derive `head.hsh` from them.
+     * Default `true`. Pass `false` to omit body and `hsh` (cheaper diagnostics);
+     * `head.len` still reflects stored size.
+     */
+    body?: boolean;
+};
+export declare function toStoredMessage(hash: Hash, data: IStoredMessageData, crypto: ICrypto, opts?: {
+    body?: boolean;
+}): Promise<IStoredMessage>;
 export interface IMessageStore {
     add: (messages: IStorableMessage[]) => Promise<Status[]>;
     get: (key: Hash) => Promise<IStoredMessage | undefined>;
     has: (key: Hash) => Promise<boolean>;
     del: (keys: Iterable<Hash>) => Promise<void>;
     /**
-     * List archive rows. Pass {@link ApldState} to filter by apply lifecycle
-     * (e.g. {@link APLD_PENDING} for the apply queue, {@link APLD_ERROR} for
-     * diagnostics). Omit for all messages.
+     * List archive rows. Filter with `apld` (e.g. {@link APLD_ERROR}).
+     * Bodies included by default; pass `body: false` to omit.
      */
-    list: (apld?: ApldState) => Promise<IStoredMessage[]>;
+    list: (opts?: ListMsgsOpts) => Promise<IStoredMessage[]>;
+    /** Count archive rows; optional apld filter (IDB index when available). */
+    count: (apld?: ApldState) => Promise<number>;
+    /** Archive keys only (head hashes). Prefer over {@link list} for checksums. */
+    listKeys: () => Promise<Hash[]>;
     last: (eid: EntityID) => Promise<IStoredMessage | undefined>;
     /** Mark archive rows as applied ({@link APLD_APPLIED}). */
     markApplied: (keys: Iterable<Hash>) => Promise<void>;
@@ -202,6 +221,31 @@ export interface IClient<Handle extends HostHandle> {
     /** Allocate an entity id (optional 8-byte id material; else random). */
     genEID(id?: Uint8Array): Promise<ValStat<EntityID>>;
     sync(): Promise<Status>;
+    /**
+     * Wipe application state (e.g. EntDB) and rebuild it by replaying the local
+     * message archive. By default, first peeks the full host header list (seq 0)
+     * and pulls any missing bags so the archive is complete before replay.
+     * Pass `{ checkHost: false }` to skip the host inventory (local-only).
+     */
+    rebuild(options?: {
+        checkHost?: boolean;
+    }): Promise<Status>;
+    /**
+     * Checksum of the local msg archive as a set of head hashes.
+     * Decodes store keys to raw hashes, sorts lexicographically, blake3(concat).
+     * Key encoding (e.g. b64 in IDB) is independent of this definition.
+     */
+    msgcheck(): Promise<Hash>;
+    /**
+     * List local archive rows for diagnostics (failed apply, pending drain, dump).
+     * Bodies included by default; pass `body: false` for lighter listings.
+     */
+    listMsgs(opts?: ListMsgsOpts): Promise<IStoredMessage[]>;
+    /**
+     * Count archive rows; optional apld filter.
+     * Prefer over list+length for badges.
+     */
+    countMsgs(apld?: ApldState): Promise<number>;
     wipe(): Promise<void>;
     import(file: File): Promise<Status>;
     export(filename: string, extension?: string): Promise<Status>;

package/dist/web/worker/client.d.ts

@@ -1,8 +1,8 @@
 import { IClock } from "../shared/clock";
 import { Status } from "../shared/consts";
-import type { EntityID, IDeleteParams, IEntRev, IHostConnectionInfo, IInsertParams, IMessageHead, IStateManager, IUpdateParams, MasterSeed, SerializedContent } from "../shared/types";
+import type { EntityID, Hash, IDeleteParams, IEntRev, IHostConnectionInfo, IInsertParams, IMessageHead, IStateManager, IUpdateParams, MasterSeed, SerializedContent } from "../shared/types";
 import type { ValStat } from "../shared/valstat";
-import type { IClient, IDiplomaticClientState, IDiplomaticClientXferState, IHostRow, IStateEmitter, IStore } from "../types";
+import type { ApldState, IClient, IDiplomaticClientState, IDiplomaticClientXferState, IHostRow, IStateEmitter, IStore, IStoredMessage, ListMsgsOpts } from "../types";
 /**
  * Options for attaching to an app-owned sync Worker.
  *
@@ -113,6 +113,19 @@ export declare class WorkerClient implements IClient<URL> {
     delete(op: IDeleteParams): Promise<ValStat<IMessageHead>>;
     genEID(id?: Uint8Array): Promise<ValStat<EntityID>>;
     sync(): Promise<Status>;
+    rebuild(options?: {
+        checkHost?: boolean;
+    }): Promise<Status>;
+    /** Shared message IDB on main — no worker RPC. */
+    listMsgs(opts?: ListMsgsOpts): Promise<IStoredMessage[]>;
+    countMsgs(apld?: ApldState): Promise<number>;
+    /** Archive checksum via worker (listKeys + sort + blake3 off main). */
+    msgcheck(): Promise<Hash>;
+    /**
+     * EntDB frontier checksum off main (eid+upd+ctr). Not on IClient —
+     * SyncClient has no EntDB; use entDB.checksum(crypto) on the main path.
+     */
+    entcheck(): Promise<Hash>;
     wipe(): Promise<void>;
     import(file: File): Promise<Status>;
     export(filename: string, _extension?: string): Promise<Status>;

package/dist/web/worker/protocol.d.ts

@@ -34,6 +34,16 @@ export type WorkerCmd = {
 } | {
     id: number;
     op: "sync";
+} | {
+    id: number;
+    op: "rebuild";
+    checkHost?: boolean;
+} | {
+    id: number;
+    op: "msgcheck";
+} | {
+    id: number;
+    op: "entcheck";
 } | {
     id: number;
     op: "wipe";

package/dist/web/worker/runtime.d.ts

@@ -3,6 +3,7 @@ import type { WorkerCmd, WorkerEvent } from "./protocol";
 export type PostFn = (msg: WorkerEvent, transfer?: Transferable[]) => void;
 export declare class WorkerRuntime {
     private client;
+    private entDB;
     private post;
     /** Resolves when init finishes (success or failure). Cmds wait on this. */
     private whenReady;