@brightbeamai/chap-coordinator 0.3.0 → 0.3.2

package/dist/{api-BkvwN42r.d.cts → api-59aU01Bs.d.cts}

@@ -79,6 +79,12 @@ interface CoordinatorOptions {
     maxEnvelopeBytes?: number;
     onAudit?: AuditListener;
     onAutoEscalate?: (task: Task, to: ParticipantUri) => void;
+    /**
+     * Called when a write to the store fails, with the workspace and the
+     * version the write would have reached. When unset, the failure is written
+     * to stderr. The call itself has already succeeded in memory; the next
+     * write to the workspace carries what this one did not.
+     */
     onStoreError?: (err: unknown, record: {
         id: string;
         version: number;
@@ -95,8 +101,9 @@ interface CoordinatorOptions {
      * Persistence backend. Defaults to MemoryStore (no persistence).
      * Pass SqliteStore or any other Store implementation to persist
      * workspaces between process restarts. The Coordinator calls
-     * `store.load()` once during `start()` and `store.save()` after
-     * every successful mutation.
+     * `store.load()` once when it starts, and after each call that adds to a
+     * workspace's log it calls `store.apply()` with what changed, or
+     * `store.save()` with the whole workspace when the store has no `apply`.
      */
     store?: Store;
 }
@@ -115,6 +122,14 @@ declare class Coordinator {
     readonly store: Store;
     private wsVersions;
     private saveChains;
+    /** Records which objects change, for stores that implement `apply`. */
+    private readonly tracker;
+    /** What the store holds of each workspace, as far as this instance knows. */
+    private persisted;
+    /** Workspaces with entries not yet written in the call being handled. */
+    private unflushed;
+    /** Workspaces with a write queued behind an async write in flight. */
+    private flushQueued;
     private clockMs?;
     private frozenNow?;
     private auditListeners;
@@ -139,8 +154,32 @@ declare class Coordinator {
      */
     start(): Promise<void>;
     private applyRecords;
-    /** Persist the current snapshot of one workspace to the store. */
+    /** A map for a workspace collection, tracked for stores that implement `apply`. */
+    private newMap;
+    /** Record that the store holds this workspace exactly as it is in memory. */
+    private markWritten;
+    /**
+     * What the store holds of a workspace. A workspace this instance did not
+     * create or load, such as one an application put in `workspaces` itself,
+     * or one whose maps an application replaced, is tracked from here on and
+     * written whole once.
+     */
+    private persistedOf;
+    /** Record that a task.create idempotency key was written or removed. */
+    private markKey;
+    /** After an entry is appended: write now, or when the call being handled ends. */
     private persist;
+    private flushUnflushed;
+    /** Write what changed in one workspace since its last write. */
+    private flush;
+    private chainWrite;
+    private writeChange;
+    /** The change since the last write, taking the recorded keys with it. */
+    private takeChange;
+    /** A failed write's keys go back, so the next write carries them again. */
+    private giveBack;
+    /** Persist the whole workspace, for a store that implements only `save`. */
+    private persistSnapshot;
     private trackSave;
     private reportStoreError;
     drainSaves(): Promise<void>;
@@ -172,9 +211,15 @@ declare class Coordinator {
     private requireReviewer;
     /** Serialise all workspaces to a JSON-safe structure for persistence. */
     snapshot(): unknown;
+    /** The workspace's own fields: everything except its collections and log. */
+    private metaOf;
+    /** One workspace as `snapshot()` holds it. Reads nothing as a change. */
+    private snapshotOf;
     /** Restore from a snapshot produced by ``snapshot()``. Replaces
      *  any existing in-memory workspaces. */
     restore(data: unknown): void;
+    /** One workspace from a snapshot entry, its maps tracked. */
+    private rebuild;
     dispatch(envelope: Envelope): Envelope;
     private _dispatch;
     recordAudit(ws: Workspace, envelope: Envelope): void;

package/dist/{api-Ddy9fqkY.d.ts → api-CxciGFHA.d.ts}

@@ -79,6 +79,12 @@ interface CoordinatorOptions {
     maxEnvelopeBytes?: number;
     onAudit?: AuditListener;
     onAutoEscalate?: (task: Task, to: ParticipantUri) => void;
+    /**
+     * Called when a write to the store fails, with the workspace and the
+     * version the write would have reached. When unset, the failure is written
+     * to stderr. The call itself has already succeeded in memory; the next
+     * write to the workspace carries what this one did not.
+     */
     onStoreError?: (err: unknown, record: {
         id: string;
         version: number;
@@ -95,8 +101,9 @@ interface CoordinatorOptions {
      * Persistence backend. Defaults to MemoryStore (no persistence).
      * Pass SqliteStore or any other Store implementation to persist
      * workspaces between process restarts. The Coordinator calls
-     * `store.load()` once during `start()` and `store.save()` after
-     * every successful mutation.
+     * `store.load()` once when it starts, and after each call that adds to a
+     * workspace's log it calls `store.apply()` with what changed, or
+     * `store.save()` with the whole workspace when the store has no `apply`.
      */
     store?: Store;
 }
@@ -115,6 +122,14 @@ declare class Coordinator {
     readonly store: Store;
     private wsVersions;
     private saveChains;
+    /** Records which objects change, for stores that implement `apply`. */
+    private readonly tracker;
+    /** What the store holds of each workspace, as far as this instance knows. */
+    private persisted;
+    /** Workspaces with entries not yet written in the call being handled. */
+    private unflushed;
+    /** Workspaces with a write queued behind an async write in flight. */
+    private flushQueued;
     private clockMs?;
     private frozenNow?;
     private auditListeners;
@@ -139,8 +154,32 @@ declare class Coordinator {
      */
     start(): Promise<void>;
     private applyRecords;
-    /** Persist the current snapshot of one workspace to the store. */
+    /** A map for a workspace collection, tracked for stores that implement `apply`. */
+    private newMap;
+    /** Record that the store holds this workspace exactly as it is in memory. */
+    private markWritten;
+    /**
+     * What the store holds of a workspace. A workspace this instance did not
+     * create or load, such as one an application put in `workspaces` itself,
+     * or one whose maps an application replaced, is tracked from here on and
+     * written whole once.
+     */
+    private persistedOf;
+    /** Record that a task.create idempotency key was written or removed. */
+    private markKey;
+    /** After an entry is appended: write now, or when the call being handled ends. */
     private persist;
+    private flushUnflushed;
+    /** Write what changed in one workspace since its last write. */
+    private flush;
+    private chainWrite;
+    private writeChange;
+    /** The change since the last write, taking the recorded keys with it. */
+    private takeChange;
+    /** A failed write's keys go back, so the next write carries them again. */
+    private giveBack;
+    /** Persist the whole workspace, for a store that implements only `save`. */
+    private persistSnapshot;
     private trackSave;
     private reportStoreError;
     drainSaves(): Promise<void>;
@@ -172,9 +211,15 @@ declare class Coordinator {
     private requireReviewer;
     /** Serialise all workspaces to a JSON-safe structure for persistence. */
     snapshot(): unknown;
+    /** The workspace's own fields: everything except its collections and log. */
+    private metaOf;
+    /** One workspace as `snapshot()` holds it. Reads nothing as a change. */
+    private snapshotOf;
     /** Restore from a snapshot produced by ``snapshot()``. Replaces
      *  any existing in-memory workspaces. */
     restore(data: unknown): void;
+    /** One workspace from a snapshot entry, its maps tracked. */
+    private rebuild;
     dispatch(envelope: Envelope): Envelope;
     private _dispatch;
     recordAudit(ws: Workspace, envelope: Envelope): void;

package/dist/api.d.cts

@@ -1,4 +1,4 @@
 import './methods.cjs';
-export { b as CoordinatorApi, c as CoordinatorError, g as call, m as makeApi } from './api-BkvwN42r.cjs';
+export { b as CoordinatorApi, c as CoordinatorError, g as call, m as makeApi } from './api-59aU01Bs.cjs';
 import './types.cjs';
 import './storage/store.cjs';

package/dist/api.d.ts

@@ -1,4 +1,4 @@
 import './methods.js';
-export { b as CoordinatorApi, c as CoordinatorError, g as call, m as makeApi } from './api-Ddy9fqkY.js';
+export { b as CoordinatorApi, c as CoordinatorError, g as call, m as makeApi } from './api-CxciGFHA.js';
 import './types.js';
 import './storage/store.js';