@interncom/diplomatic 0.7.0 → 0.8.0

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

@@ -11,6 +11,7 @@ export declare class IDBMessageStore implements IMessageStore {
     get(key: Hash): Promise<IStoredMessage | undefined>;
     has(key: Hash): Promise<boolean>;
     list(apld?: ApldState): Promise<IStoredMessage[]>;
+    listKeys(): Promise<Hash[]>;
     last(eid: EntityID): Promise<IStoredMessage | undefined>;
     markApplied(keys: Iterable<Hash>): Promise<void>;
     markFailed(entries: Iterable<{

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

@@ -28,5 +28,6 @@ export declare class IDBStore implements IStore<URL> {
     constructor(db: IDBDatabase, crypto: ICrypto);
     wipe(): Promise<void>;
 }
+export declare const DIPLOMATIC_STORE_DB_NAME = "diplomatic-store-db";
 export declare function openIDBStoreDB(): Promise<IDBDatabase>;
 export declare function openIDBStore(crypto: ICrypto): Promise<IDBStore>;

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

@@ -11,6 +11,7 @@ export declare class MemoryMessageStore implements IMessageStore {
     get(key: Hash): Promise<IStoredMessage | undefined>;
     has(key: Hash): Promise<boolean>;
     list(apld?: ApldState): Promise<IStoredMessage[]>;
+    listKeys(): Promise<Hash[]>;
     last(eid: EntityID): Promise<IStoredMessage | undefined>;
     markApplied(keys: Iterable<Hash>): Promise<void>;
     markFailed(entries: Iterable<{

package/dist/web/types.d.ts

@@ -159,6 +159,8 @@ export interface IMessageStore {
      * diagnostics). Omit for all messages.
      */
     list: (apld?: ApldState) => Promise<IStoredMessage[]>;
+    /** 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 +204,21 @@ 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>;
     wipe(): Promise<void>;
     import(file: File): Promise<Status>;
     export(filename: string, extension?: string): Promise<Status>;

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

@@ -1,6 +1,6 @@
 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";
 /**
@@ -113,6 +113,16 @@ 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>;
+    /** 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";
@@ -64,6 +74,11 @@ export type WorkerReply = {
 };
 export type WorkerEvent = {
     kind: "ready";
+}
+/** Worker init failed (e.g. IDB open); main should fail handshake, not hang. */
+ | {
+    kind: "initError";
+    message: string;
 } | {
     kind: "clientState";
     state: IDiplomaticClientState;

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;