@interncom/diplomatic 0.20.0 → 0.21.1

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/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;