@interncom/diplomatic 0.19.2 → 0.21.1

package/dist/web/client.d.ts

@@ -20,8 +20,9 @@ export declare class SyncClient<Handle extends HostHandle> implements IClient<Ha
     private onScheduleSync?;
     connections: Map<string, DiplomaticClientAPI<Handle>>;
     /**
-     * Serializes local mutates + exec so concurrent drainApplyQueue / apply do
-     * not interleave markApplied (each job runs fully, in order).
+     * Serializes archive + markApplied so concurrent drainApplyQueue / apply
+     * do not interleave those IDB writes. Mem notify is kicked before this
+     * chain so a prior persist cannot delay the list.
      */
     private applyChain;
     /**
@@ -62,20 +63,20 @@ export declare class SyncClient<Handle extends HostHandle> implements IClient<Ha
      * Persist msgs (APLD_PENDING), exec into app state, then optionally enq upload.
      *
      * Order (do not invert — UI notify depends on it):
-     * 1) Kick off state.apply (CachedEntDB emits in the sync prefix of apply;
-     *    the returned Promise is durable EntDB + reconcile).
-     * 2) Durable archive (messages.add).
-     * 3) Await apply + mark APLD_APPLIED/APLD_ERROR.
-     * 4) Upload queue.
-     * Crash between 2–3 → drainApplyQueue recovers.
-     * Awaiting apply before archive makes the UI wait on EntDB IDB.
-     *
-     * Serialized on applyChain (with local mutates).
+     * 1) Kick state.apply *before* applyChain. CachedEntDB patches mem and
+     *    notifies after the next paint. A prior job's
+     *    archive / persist / markApplied must not delay the list.
+     * 2) Serialize archive (messages.add) + await apply + markApplied on
+     *    applyChain (crash between archive and mark → drainApplyQueue).
+     * 3) Upload queue.
+     * Awaiting apply before archive, or waiting on applyChain before kicking
+     * apply, makes the UI wait on IndexedDB.
      */
     private apply;
     /**
-     * Core apply without enqueue. Caller must already hold applyChain when
-     * composing makeUpdate + apply in one job.
+     * Archive + await a pre-kicked state.apply + markApplied.
+     * Caller must already hold applyChain. `applyP` is kicked first so mem
+     * notify is not serialized behind a prior job's IDB.
      */
     private doApply;
     private enqueueApplyJob;
@@ -101,7 +102,7 @@ export declare class SyncClient<Handle extends HostHandle> implements IClient<Ha
     private applyStored;
     /** Mark archive rows APPLIED / ERROR from apply stats (aligned with keys). */
     private markApplyStats;
-    insertRaw(bod: EncodedMessage): Promise<ValStat<IMessageHead>>;
+    insertRaw(bod: EncodedMessage, typ?: string): Promise<ValStat<IMessageHead>>;
     /**
      * Build the next update/delete msg from prior. Pure: no archive I/O.
      * Returns ClockOutOfSync if prior is in the future (caller handles force).
@@ -119,7 +120,7 @@ export declare class SyncClient<Handle extends HostHandle> implements IClient<Ha
      * Replacement keeps the same id bytes with a new created-at of now.
      */
     private updateWithSkew;
-    updateRaw(prior: IEntRev, bod: EncodedMessage | undefined, force?: boolean): Promise<ValStat<IMessageHead>>;
+    updateRaw(prior: IEntRev, bod: EncodedMessage | 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/entdb/cached.d.ts

@@ -20,6 +20,11 @@ export type OpenEntDBOptions = {
      * Set false to notify only after durable commit. Ignored when `cache` is false.
      */
     optimistic?: boolean;
+    /**
+     * Timed `[dip]` traces for apply / list / persist (default false).
+     * Process-wide; also accepted on openDiplomaticClient / useClient.
+     */
+    verbose?: boolean;
 };
 export type CachedEntDBOptions = {
     /** Secondary mem indexes (default true). See {@link OpenEntDBOptions.indexes}. */
@@ -32,6 +37,7 @@ export type CachedEntDBOptions = {
  * Default: cached with mem indexes and optimistic notify.
  * Pass `{ cache: false }` for durable IDB only.
  * Pass `{ optimistic: false }` to notify only after durable commit.
+ * Pass `{ verbose: true }` for `[dip]` timings (apply, list, persist).
  */
 export declare function openEntDB(opts?: OpenEntDBOptions): Promise<IEntDB>;
 export declare class CachedEntDB implements IEntDB {
@@ -41,14 +47,18 @@ export declare class CachedEntDB implements IEntDB {
     private listeners;
     private chain;
     private optimistic;
+    /** Optimistic applies whose durable persist has not finished. */
+    private inflight;
+    /** In-flight warmType per type (not on the persist/ingest chain). */
+    private warmP;
     constructor(durable: IEntDB, init?: IEntity[], opts?: CachedEntDBOptions);
     /** UI / StateManager: fired when mem changes (immediate apply or durable ingest). */
     subscribe(listener: EntChangeListener): () => void;
     private emit;
     private run;
     /**
-     * Fan-out write: patch mem, queue durable, notify UI on a microtask,
-     * then reconcile. Not `async`: mem patch must run before any await.
+     * Fan-out write: patch mem, queue durable, notify UI after the next paint.
+     * Not `async`: mem patch must run before any await.
      * `{ optimistic: false }`: skip the mem prefix; notify after durable.
      */
     apply(ops: IOp[]): Promise<import("./entdb").ApplyResult>;
@@ -67,6 +77,13 @@ export declare class CachedEntDB implements IEntDB {
      */
     private pullEids;
     private warmType;
+    /**
+     * Load a type from durable into mem. Not on the persist/ingest chain —
+     * first UI list must not wait for dirty-eid pull after worker sync.
+     */
+    private beginWarm;
+    /** Background warm + notify. Does not block the caller. */
+    private ensureWarm;
     getRow<T>(eid: EntityID): Promise<ValStat<IEntRow<T> | undefined>>;
     getEnt<T>(eid: EntityID): Promise<ValStat<IEntity<T> | undefined>>;
     getEntities<T>(query: EntitiesQuery): Promise<ValStat<IEntity<T>[]>>;

package/dist/web/entdb/entdb.d.ts

@@ -3,6 +3,7 @@ import { ValStat } from "../shared/valstat";
 import { EntityID, Hash, ICrypto, IEntRev, IMessageHead, IMsgEntBody, IOp } from "../shared/types";
 export { entStateManager } from "./manager.ts";
 export interface IEntity<T = unknown> extends Omit<IMsgEntBody<T>, "body"> {
+    type: string;
     eid: EntityID;
     updatedAt: Date;
     createdAt: Date;

package/dist/web/entdb/manager.d.ts

@@ -3,8 +3,8 @@ import type { IEntDB } from "./entdb";
 /**
  * Build a StateManager for an EntDB.
  * When `edb` is a {@link CachedEntDB}, type notifies come from the cache
- * subscribe path (mem patch + microtask notify, then durable reconcile /
- * peer ingest). cacheDriven: StateManager.apply must not emit after the
- * applier Promise settles — that would delay UI until durable IDB.
+ * subscribe path (mem patch + notify after paint, then durable persist).
+ * cacheDriven: StateManager.apply must not emit after the applier Promise
+ * settles — that emit would wait until durable IDB.
  */
 export declare function entStateManager(edb: IEntDB): StateManager;