@interncom/diplomatic 0.19.2 → 0.21.1

package/dist/web/openClient.d.ts

@@ -6,6 +6,11 @@ type OpenDiplomaticClientBase = {
     clock?: IClock;
     /** Max wait for setSeed → Enclave.spawnSyncWorker handshake (default 15s). */
     readyTimeoutMs?: number;
+    /**
+     * Timed `[dip]` traces for local writes, EntDB, and watchers (default false).
+     * Process-wide; same flag as {@link openEntDB}.
+     */
+    verbose?: boolean;
     /**
      * Debounce local write → worker sync (default `defaultSyncDebounceMs`).
      * Use `0` in tests for an immediate upload-queue handoff.

package/dist/web/react/useClient.d.ts

@@ -17,6 +17,11 @@ type UseClientBase = {
      * Set false to notify only after durable commit.
      */
     optimistic?: boolean;
+    /**
+     * Timed `[dip]` traces (default false). See {@link openEntDB} /
+     * {@link openDiplomaticClient}.
+     */
+    verbose?: boolean;
 };
 /**
  * Worker path: IndexedDB on main; sync Worker appears on setSeed via Enclave.

package/dist/web/shared/codecs/messageHead.d.ts

@@ -1,12 +1,6 @@
 import { ICodecStruct } from "../codec.ts";
-import { EntityID } from "../types.ts";
-export interface IMessageHead {
-    eid: EntityID;
-    off: number;
-    ctr: number;
-    len: number;
-    hsh?: Uint8Array;
-}
+import { EntityID, IMessageHead } from "../types.ts";
+export type { IMessageHead };
 export declare const messageHeadCodec: ICodecStruct<IMessageHead>;
 export interface IMinimalMessageHead {
     eid: EntityID;

package/dist/web/shared/crypto/enclave.d.ts

@@ -60,6 +60,7 @@ export type Identity = {
     kdmFor: (msgHeadEnc: Uint8Array) => Promise<Uint8Array>;
 };
 declare const SEAL_BIND_DOMAIN: Uint8Array<ArrayBufferLike>;
+declare const FP_MODE: Uint8Array<ArrayBufferLike>;
 declare const SEAL_KEY_LEN = 32;
 declare const SEAL_PRF_MIN_LEN = 16;
 /** Minimum musec length (Mandatory User-Space Entropy Contribution). */
@@ -142,6 +143,12 @@ export declare class Enclave {
     }>>;
     /** UV + overwrite largeBlob with zeros (destroys stored seed material). */
     static clearLargeBlob(credId: Uint8Array, opts?: LargeBlobRp): Promise<Status>;
+    /**
+     * Write numbered `n] xxxx xxxx` hex lines plus a # check to /dev/tty.
+     * Paced mode erases the previous line before the next (Enter between).
+     * Web bundles set DIP_CLI_DUMP=false; the write is compiled out.
+     */
+    dumpToTty(): Promise<Status>;
     /**
      * Absorb seed‖hosts plaintext (pair AEAD inner).
      * Encoder/Decoder never see the seed.
@@ -178,4 +185,4 @@ export declare class Enclave {
 }
 /** Derive seal key from PRF output (domain-separated). Used by enclave seal/unseal. */
 export declare function sealKeyFromPrf(crypto: ICrypto, prf: Uint8Array, domain?: Uint8Array): Promise<ValStat<Uint8Array>>;
-export { MASTER_SEED_LEN, MUSEC_MIN_LEN, SEAL_BIND_DOMAIN, SEAL_KEY_LEN, SEAL_PRF_MIN_LEN, };
+export { FP_MODE, MASTER_SEED_LEN, MUSEC_MIN_LEN, SEAL_BIND_DOMAIN, SEAL_KEY_LEN, SEAL_PRF_MIN_LEN, };

package/dist/web/shared/crypto/noble.d.ts

@@ -1,5 +1,5 @@
 import { type X25519Sk } from "./x25519.ts";
-import type { DerivationSeed, Hash, ICrypto, KeyPair } from "../types.ts";
+import type { Blake3Opts, DerivationSeed, Hash, ICrypto, KeyPair } from "../types.ts";
 /**
  * ICrypto: noble for XSalsa20 + blake3; WebCrypto Ed25519 + X25519
  * (our scalar; RFC 7748 check before trusting pub/DH).
@@ -15,7 +15,7 @@ export declare class NobleCrypto implements ICrypto {
     private importVerifyKey;
     signEd25519(message: Uint8Array | string, secKey: Uint8Array): Promise<Uint8Array>;
     checkSigEd25519(sig: Uint8Array, message: Uint8Array | string, pubKey: Uint8Array): Promise<boolean>;
-    blake3(data: Uint8Array): Promise<Hash>;
+    blake3(data: Uint8Array, opts?: Blake3Opts): Promise<Hash>;
     genX25519(): Promise<{
         priv: X25519Sk;
         pub: Uint8Array;

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

@@ -17,5 +17,8 @@ export declare namespace Exim {
     }>) => Iterable<{
         head: IMessageHead;
         body?: Uint8Array;
-    }>): Promise<ValStat<Uint8Array>>;
+    }> | Promise<Iterable<{
+        head: IMessageHead;
+        body?: Uint8Array;
+    }>>): Promise<ValStat<Uint8Array>>;
 }

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

@@ -5,18 +5,21 @@ interface IInsertParams {
     now: Date;
     bod: SerializedContent;
     crypto: ICrypto;
+    typ?: string;
 }
-export declare function genInsertHead({ now, bod, crypto }: IInsertParams): Promise<ValStat<IMessageHead>>;
-interface IUpsertParams extends Omit<IMessage, "off" | "len" | "hsh"> {
+export declare function genInsertHead({ now, bod, crypto, typ }: IInsertParams): Promise<ValStat<IMessageHead>>;
+interface IUpsertParams extends Omit<IMessage, "off" | "len" | "hsh" | "typ"> {
     now: Date;
     crypto: ICrypto;
+    typ?: string;
 }
-export declare function genUpsertHead({ now, eid, ctr, bod, crypto }: IUpsertParams): Promise<ValStat<IMessageHead>>;
-interface IDeleteParams extends Omit<IMessage, "off" | "len" | "hsh" | "bod"> {
+export declare function genUpsertHead({ now, eid, ctr, typ, bod, crypto }: IUpsertParams): Promise<ValStat<IMessageHead>>;
+interface IDeleteParams extends Omit<IMessage, "off" | "len" | "hsh" | "bod" | "typ"> {
     now: Date;
     crypto: ICrypto;
+    typ?: string;
 }
-export declare function genDeleteHead({ now, eid, ctr, crypto }: IDeleteParams): Promise<ValStat<IMessageHead>>;
+export declare function genDeleteHead({ now, eid, ctr, typ, crypto }: IDeleteParams): Promise<ValStat<IMessageHead>>;
 export declare function genInsert({ now, bod, crypto }: IInsertParams): Promise<ValStat<IUpsertMessage>>;
 export declare function genDelete(params: IDeleteParams): Promise<ValStat<IDeleteMessage>>;
 export {};

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

@@ -21,10 +21,10 @@ export interface IMsgEntBody<T = unknown> {
      * dropped on apply. Omit or [] means no tags.
      */
     tags?: string[];
-    type: string;
     body?: T;
 }
 export interface IMessageHead {
+    typ?: string;
     eid: EntityID;
     off: number;
     ctr: number;
@@ -37,15 +37,17 @@ export interface IMessage extends IMessageHead {
 export interface IMessageWithHash extends IMessage {
     headHash: Hash;
 }
-export interface IDeleteOp extends Omit<IMessageHead, "len" | "hsh" | "bod"> {
+export interface IDeleteOp extends Omit<IMessageHead, "len" | "hsh" | "bod" | "typ"> {
 }
 export interface IMutateOp<T = unknown> extends IDeleteOp, Omit<IMsgEntBody<T>, "body"> {
+    type: string;
     body: T;
 }
 export type IOp = IDeleteOp | IMutateOp;
 export declare function isDeleteOp(op: IOp): op is IDeleteOp;
 export declare function isMutateOp(op: IOp): op is IMutateOp;
 export interface IInsertParams<T> extends IMsgEntBody<T> {
+    type: string;
     /** Optional 8-byte id material for the new eid; else random. */
     id?: Uint8Array;
 }
@@ -60,6 +62,7 @@ export interface IEntRev {
     updatedAt: Date;
 }
 export interface IUpdateParams<T> extends IMsgEntBody<T> {
+    type: string;
     prior: IEntRev;
     /** Clock-skew recovery; default client-wide (usually true). */
     force?: boolean;
@@ -122,6 +125,13 @@ export type Hash = Uint8Array & {
 export interface IHostCrypto {
     checkSigEd25519: (sig: Uint8Array, message: Uint8Array | string, pubKey: PublicKey) => Promise<boolean>;
 }
+/** BLAKE3 hash / MAC / KDF (noble: `key` XOR `context`, not both). */
+export type Blake3Opts = {
+    /** 32-byte MAC key. */
+    key?: Uint8Array;
+    /** KDF context (hardcoded, app-specific). */
+    context?: Uint8Array | string;
+};
 export interface ICrypto extends IHostCrypto {
     genRandomBytes: (bytes: number) => Promise<Uint8Array>;
     gen256BitSecureRandomSeed: () => Promise<Uint8Array>;
@@ -129,7 +139,7 @@ export interface ICrypto extends IHostCrypto {
     decryptXSalsa20Poly1305Combined: (headerAndCipher: Uint8Array, key: Uint8Array) => Promise<Uint8Array>;
     deriveEd25519KeyPair: (derivationSeed: DerivationSeed) => Promise<KeyPair>;
     signEd25519: (message: Uint8Array | string, secKey: PrivateKey) => Promise<Uint8Array>;
-    blake3: (data: Uint8Array) => Promise<Hash>;
+    blake3: (data: Uint8Array, opts?: Blake3Opts) => Promise<Hash>;
 }
 export interface IMsgpackCodec {
     encode: (source: unknown) => Uint8Array;

package/dist/web/types.d.ts

@@ -177,6 +177,8 @@ export interface IStoredMessageFields {
     eid: EntityID;
     off?: number;
     ctr?: number;
+    /** Msg head typ. Omit when empty (raw). */
+    typ?: string;
     body?: EncodedMessage;
 }
 /**
@@ -192,7 +194,7 @@ export interface IStoredMessageData extends IStoredMessageFields {
 /**
  * Required shape for every put into the message archive (app/API layer).
  * `apld` is required and must be one of the three {@link ApldState} values.
- * Omit optional fields (`off`, `ctr`, `body`, `err`) rather than storing empties.
+ * Omit optional fields (`off`, `ctr`, `typ`, `body`, `err`) rather than storing empties.
  */
 export type IStoredMessageWrite = IStoredMessageFields & {
     apld: ApldState;
@@ -293,14 +295,14 @@ export interface IStateEmitter<T> {
 export interface IClient<Handle extends HostHandle> {
     /** Install session enclave (master seed stays inside enclave). */
     setSeed(enclave: Enclave, opts?: SetSeedOpts): Promise<void>;
-    link(host: IHostConnectionInfo<Handle>): Promise<void>;
+    link(host: IHostConnectionInfo<Handle>, connect?: boolean): Promise<void>;
     unlink(label: string): Promise<void>;
     /** Linked hosts from the protocol store (handle, label, lastSeq, …). */
     hosts(): Promise<IHostRow<Handle>[]>;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    insertRaw(content: SerializedContent): Promise<ValStat<IMessageHead>>;
-    updateRaw(prior: IEntRev, content: SerializedContent | undefined, force?: boolean): Promise<ValStat<IMessageHead>>;
+    insertRaw(content: SerializedContent, typ?: string): Promise<ValStat<IMessageHead>>;
+    updateRaw(prior: IEntRev, content: SerializedContent | undefined, force?: boolean, typ?: string): Promise<ValStat<IMessageHead>>;
     insert<T = unknown>(op: IInsertParams<T>): Promise<ValStat<IMessageHead>>;
     update<T = unknown>(op: IUpdateParams<T>): Promise<ValStat<IMessageHead>>;
     /**

package/dist/web/verbose.d.ts

@@ -0,0 +1,4 @@
+/** Turn `[dip]` timings on or off. */
+export declare function setVerbose(v: boolean): void;
+/** Timed `[dip]` line when verbose. */
+export declare function dipLog(msg: string, extra?: object): void;

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

@@ -86,8 +86,8 @@ export declare class WorkerClient implements IClient<URL> {
     connect(listen?: boolean, sync?: boolean): Promise<void>;
     disconnect(): Promise<void>;
     /** Local UI write on main (cache notifies in apply's sync prefix); sync via worker. */
-    insertRaw(content: SerializedContent): Promise<ValStat<IMessageHead>>;
-    updateRaw(prior: IEntRev, content: SerializedContent | undefined, force?: boolean): Promise<ValStat<IMessageHead>>;
+    insertRaw(content: SerializedContent, typ?: string): Promise<ValStat<IMessageHead>>;
+    updateRaw(prior: IEntRev, content: SerializedContent | undefined, force?: boolean, typ?: string): Promise<ValStat<IMessageHead>>;
     insert<T = unknown>(op: IInsertParams<T>): Promise<ValStat<IMessageHead>>;
     update<T = unknown>(op: IUpdateParams<T>): Promise<ValStat<IMessageHead>>;
     delete(op: IDeleteParams): Promise<ValStat<IMessageHead>>;