@contember/bindx 0.1.46 → 0.1.48

package/dist/store/SubscriptionManager.d.ts

@@ -1,3 +1,4 @@
+import type { RekeyContext, Rekeyable } from './RekeyOrchestrator.js';
 type Subscriber = () => void;
 /**
  * Callback interface for SubscriptionManager to request snapshot version bumps.
@@ -6,6 +7,15 @@ type Subscriber = () => void;
 export interface SnapshotVersionBumper {
     bumpEntitySnapshotVersion(key: string): void;
 }
+/**
+ * Resolves the parent entity keys that currently have a LIVE relation edge to a
+ * child, so a child-field change can propagate up to its parents. Implemented by
+ * the relation store (the single source of truth for relation membership); this
+ * interface keeps {@link SubscriptionManager} decoupled from its concrete type.
+ */
+export interface ParentKeyLookup {
+    getParentKeysForChild(childId: string): Set<string>;
+}
 /**
  * Manages subscriptions for entity and relation changes.
  *
@@ -13,22 +23,26 @@ export interface SnapshotVersionBumper {
  * - Entity-level subscriptions
  * - Relation-level subscriptions
  * - Global subscriptions (any change)
- * - Parent-child change propagation
+ * - Parent-child change propagation (derived from live relation edges)
  * - Global version tracking for change detection
  */
-export declare class SubscriptionManager {
+export declare class SubscriptionManager implements Rekeyable {
     /** Subscribers per entity key */
     private readonly entitySubscribers;
     /** Subscribers per relation key */
     private readonly relationSubscribers;
     /** Global subscribers (notified on any change) */
     private readonly globalSubscribers;
-    /** Parent-child relationships: childKey -> Set of parentKeys */
-    private readonly childToParents;
     /** Maps old keys → new keys after rekey, so unsubscribe closures can find migrated callbacks */
     private readonly rekeyedKeys;
     /** Global version number for change detection */
     private globalVersion;
+    /**
+     * Resolves a child's parents from live relation edges. Injected after
+     * construction (the relation store and this manager are siblings under
+     * SnapshotStore) via {@link setParentKeyLookup}.
+     */
+    private parentKeyLookup;
     /**
      * Resolves a key through the rekey redirect chain.
      * The rekey() method collapses chains (A→C instead of A→B→C), so this should
@@ -61,22 +75,48 @@ export declare class SubscriptionManager {
      */
     notify(): void;
     /**
-     * Registers a parent-child relationship for change propagation.
-     * When the child entity changes, parent entity subscribers will be notified.
+     * Notifies every registered subscriber — entity, relation and global.
+     *
+     * For store-wide events such as clear(), where every subscription's data is gone at once and
+     * there is no per-key change to notify from. Registrations are left intact: the subscribers
+     * belong to mounted components that must learn their entity is no longer there.
      */
-    registerParentChild(parentKey: string, childKey: string): void;
+    notifyAll(): void;
     /**
-     * Unregisters a parent-child relationship.
+     * Wires the live-edge parent lookup. Parent re-render propagation is derived
+     * from the relation store's edges rather than a separate registry, so there is
+     * one source of truth for the parent-child graph.
      */
-    unregisterParentChild(parentKey: string, childKey: string): void;
+    setParentKeyLookup(lookup: ParentKeyLookup): void;
+    /**
+     * Derives the parent entity keys for a child entity key by reading the live
+     * relation edges via the injected lookup. The child's bare id is the part of
+     * the key after the first ':' ("entityType:id").
+     *
+     * The child's TYPE is intentionally dropped — {@link ParentKeyLookup} matches on
+     * the bare id, relying on the store-wide global-id-uniqueness invariant (see
+     * {@link RelationStore.getParentKeysForChild}).
+     */
+    private getParentKeys;
     /**
      * Notifies entity subscribers and propagates changes to parents.
      * The bumper callback is used to bump parent entity snapshot versions.
      */
-    notifyEntitySubscribers(key: string, bumper: SnapshotVersionBumper, notifiedKeys?: Set<string>): void;
+    notifyEntitySubscribers(key: string, bumper: SnapshotVersionBumper): void;
+    /**
+     * Walks the entity and its live ancestors. The global version is bumped once by the
+     * caller, before the first subscriber runs — a subscriber reading getVersion() from
+     * inside its callback must already see the new value.
+     *
+     * The walk is a transitive closure over live edges, so an entity many rows point at
+     * (a shared lookup entity whose own has-many is loaded) acts as a hub: a write in one
+     * row reaches every other row through it. That is the price of not knowing which part
+     * of the hub each row presents; a selection-aware edge index would be the fix.
+     */
+    private notifyEntityAndParentSubscribers;
     /**
-     * Notifies relation subscribers and the parent entity's subscribers.
-     * The bumper callback is used to bump the parent entity snapshot version.
+     * Notifies relation subscribers, the owning entity, and its ancestors.
+     * The bumper callback is used to bump entity snapshot versions.
      * The entityKey is the parent entity key derived from the relation key.
      */
     notifyRelationSubscribers(key: string, entityKey: string, bumper: SnapshotVersionBumper): void;
@@ -95,11 +135,20 @@ export declare class SubscriptionManager {
      */
     notifyGlobal(): void;
     /**
-     * Moves subscriptions and parent-child relationships from oldKey to newKey.
+     * Moves entity and relation subscriptions from oldKey to newKey.
      * Also rekeys relation subscribers under oldKeyPrefix to newKeyPrefix.
      * Registers redirects so unsubscribe closures can find migrated callbacks.
+     *
+     * Parent-child links are NOT migrated here — they are derived from the
+     * relation store's live edges, which migrate their own id references on rekey.
+     */
+    rekey(ctx: RekeyContext): void;
+    /**
+     * Re-homes a subscriber set under a new key. The destination may already hold
+     * subscribers (a component mounted on the persisted id before the draft was rekeyed
+     * onto it); replacing the set would silently orphan them, so the two are merged.
      */
-    rekey(oldKey: string, newKey: string, oldKeyPrefix: string, newKeyPrefix: string): void;
+    private moveSubscribers;
 }
 export {};
 //# sourceMappingURL=SubscriptionManager.d.ts.map

package/dist/store/SubscriptionManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SubscriptionManager.d.ts","sourceRoot":"","sources":["../../src/store/SubscriptionManager.ts"],"names":[],"mappings":"AAAA,KAAK,UAAU,GAAG,MAAM,IAAI,CAAA;AAE5B;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACrC,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAC5C;AAED;;;;;;;;;GASG;AACH,qBAAa,mBAAmB;IAC/B,iCAAiC;IACjC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqC;IAEvE,mCAAmC;IACnC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqC;IAEzE,kDAAkD;IAClD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAwB;IAE1D,gEAAgE;IAChE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiC;IAEhE,gGAAgG;IAChG,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IAExD,iDAAiD;IACjD,OAAO,CAAC,aAAa,CAAI;IAEzB;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAUlB;;;OAGG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAahE;;;OAGG;IACH,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAalE;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAO3C;;OAEG;IACH,UAAU,IAAI,MAAM;IAIpB;;;OAGG;IACH,MAAM,IAAI,IAAI;IASd;;;OAGG;IACH,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAS9D;;OAEG;IACH,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAYhE;;;OAGG;IACH,uBAAuB,CACtB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,qBAAqB,EAC7B,YAAY,GAAE,GAAG,CAAC,MAAM,CAAa,GACnC,IAAI;IAuCP;;;;OAIG;IACH,yBAAyB,CACxB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,qBAAqB,GAC3B,IAAI;IA4BP;;;OAGG;IACH,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IASrC;;;OAGG;IACH,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IASvC;;OAEG;IACH,YAAY,IAAI,IAAI;IAOpB;;;;OAIG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;CAqDvF"}
+{"version":3,"file":"SubscriptionManager.d.ts","sourceRoot":"","sources":["../../src/store/SubscriptionManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAErE,KAAK,UAAU,GAAG,MAAM,IAAI,CAAA;AAE5B;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACrC,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;CAC5C;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC/B,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAAA;CACnD;AAED;;;;;;;;;GASG;AACH,qBAAa,mBAAoB,YAAW,SAAS;IACpD,iCAAiC;IACjC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqC;IAEvE,mCAAmC;IACnC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAqC;IAEzE,kDAAkD;IAClD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAwB;IAE1D,gGAAgG;IAChG,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4B;IAExD,iDAAiD;IACjD,OAAO,CAAC,aAAa,CAAI;IAEzB;;;;OAIG;IACH,OAAO,CAAC,eAAe,CAA6B;IAEpD;;;;;OAKG;IACH,OAAO,CAAC,UAAU;IAUlB;;;OAGG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAahE;;;OAGG;IACH,mBAAmB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAalE;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAO3C;;OAEG;IACH,UAAU,IAAI,MAAM;IAIpB;;;OAGG;IACH,MAAM,IAAI,IAAI;IAOd;;;;;;OAMG;IACH,SAAS,IAAI,IAAI;IAiBjB;;;;OAIG;IACH,kBAAkB,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI;IAIjD;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IAUrB;;;OAGG;IACH,uBAAuB,CACtB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,qBAAqB,GAC3B,IAAI;IAKP;;;;;;;;;OASG;IACH,OAAO,CAAC,gCAAgC;IA2CxC;;;;OAIG;IACH,yBAAyB,CACxB,GAAG,EAAE,MAAM,EACX,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,qBAAqB,GAC3B,IAAI;IAiBP;;;OAGG;IACH,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IASrC;;;OAGG;IACH,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IASvC;;OAEG;IACH,YAAY,IAAI,IAAI;IAOpB;;;;;;;OAOG;IACH,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI;IAmC9B;;;;OAIG;IACH,OAAO,CAAC,eAAe;CAYvB"}

package/dist/store/TouchedStore.d.ts

@@ -1,3 +1,4 @@
+import type { RekeyContext, Rekeyable } from './RekeyOrchestrator.js';
 /**
  * Manages touched state for entity fields.
  *
@@ -6,7 +7,7 @@
  *
  * Keys are pre-computed composite strings (e.g., "entityType:id:fieldName").
  */
-export declare class TouchedStore {
+export declare class TouchedStore implements Rekeyable {
     /** Touched state keyed by "entityType:id:fieldName" */
     private readonly touchedFields;
     isFieldTouched(key: string): boolean;
@@ -22,7 +23,7 @@ export declare class TouchedStore {
     /**
      * Rekeys all touched fields from oldKeyPrefix to newKeyPrefix.
      */
-    rekey(oldKeyPrefix: string, newKeyPrefix: string): void;
+    rekey(ctx: RekeyContext): void;
     clear(): void;
 }
 //# sourceMappingURL=TouchedStore.d.ts.map

package/dist/store/TouchedStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TouchedStore.d.ts","sourceRoot":"","sources":["../../src/store/TouchedStore.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,qBAAa,YAAY;IACxB,uDAAuD;IACvD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAE3D,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIpC;;;OAGG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;IAOvD;;OAEG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAQvC;;OAEG;IACH,KAAK,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI;IAavD,KAAK,IAAI,IAAI;CAGb"}
+{"version":3,"file":"TouchedStore.d.ts","sourceRoot":"","sources":["../../src/store/TouchedStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAErE;;;;;;;GAOG;AACH,qBAAa,YAAa,YAAW,SAAS;IAC7C,uDAAuD;IACvD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAE3D,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIpC;;;OAGG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;IAOvD;;OAEG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAQvC;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI;IAc9B,KAAK,IAAI,IAAI;CAGb"}

package/dist/store/relationKey.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Derives the parent composite key ("parentType:parentId") from a relation key
+ * ("parentType:parentId:fieldName") by dropping the trailing field segment.
+ * Entity ids and field names never contain ':', so the parent key is everything
+ * before the last separator.
+ */
+export declare function parentKeyFromRelationKey(relationKey: string): string;
+/**
+ * Derives the parent composite key ("parentType:parentId") from an owner key
+ * prefix ("parentType:parentId:") by dropping the trailing separator. Callers
+ * pass the owner prefix used for relation-key lookups; this maps it to the key
+ * the {@link RelationEdgeIndex} stores edges under.
+ */
+export declare function parentKeyFromOwnerPrefix(ownerPrefix: string): string;
+//# sourceMappingURL=relationKey.d.ts.map

package/dist/store/relationKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relationKey.d.ts","sourceRoot":"","sources":["../../src/store/relationKey.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAGpE;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAEpE"}

package/dist/undo/UndoJournal.d.ts

@@ -0,0 +1,133 @@
+import type { EntitySnapshot } from '../store/snapshots.js';
+import type { StoredRelationState, StoredHasManyState } from '../store/RelationStore.js';
+import type { RekeyContext } from '../store/RekeyOrchestrator.js';
+/**
+ * Write-journal for undo/redo.
+ *
+ * A gesture (one dispatch, or one handle operation) opens a transaction; every
+ * primary-store write made inside it records the EDITABLE-LAYER pre-image of the
+ * cell it touches (first-writer-wins per cell). On commit, the accumulated cells
+ * become one {@link JournalEntry} — exactly the keys the gesture actually wrote,
+ * each with the state to restore. Undo restores those pre-images through the
+ * store's write paths (so the edge index and reachability cache rebuild
+ * themselves); derived state is never journaled.
+ *
+ * The journal captures only the editable layer (and, for re-creates, the full
+ * snapshot). The server baseline (serverData / serverId / serverState / serverIds
+ * / existsOnServer) is spliced back from the LIVE state on restore, so undoing an
+ * already-persisted edit re-dirties it against the current server view instead of
+ * resurrecting a stale baseline.
+ *
+ * Entry-closure invariant: on commit each entry is closed over the created,
+ * currently-unreachable subgraph its relation/has-many pre-images detach, so undo
+ * works no matter what memory sweep reclaims that subgraph in between (see
+ * {@link JournalTarget.exportUnreachableCreatedSubgraph}).
+ */
+/** A captured cell, keyed by kind + composite store key. */
+export interface EntityCellImage {
+    readonly kind: 'entity';
+    readonly key: string;
+    /** Whether the entity existed at capture time. false ⇒ undo removes it (un-create). */
+    readonly present: boolean;
+    readonly snapshot?: EntitySnapshot;
+    readonly existsOnServer?: boolean;
+    readonly isScheduledForDeletion?: boolean;
+    readonly isRoot?: boolean;
+}
+export interface RelationCellImage {
+    readonly kind: 'relation';
+    readonly key: string;
+    readonly present: boolean;
+    readonly state?: StoredRelationState;
+}
+export interface HasManyCellImage {
+    readonly kind: 'hasMany';
+    readonly key: string;
+    readonly present: boolean;
+    readonly state?: StoredHasManyState;
+}
+export type JournalCellImage = EntityCellImage | RelationCellImage | HasManyCellImage;
+/** The kind axis shared by cell images, editable-write counters, and the guard. */
+export type JournalCellKind = JournalCellImage['kind'];
+/**
+ * Monotonic editable-layer write counters, one per journal kind. Provided by the
+ * store so the journal can prove — at transaction close — that every editable
+ * write was preceded by a record call (see {@link UndoJournal.commit}). Counters
+ * only ever increase, so a per-transaction delta is `now - base`.
+ */
+export interface EditableWriteCounters {
+    readonly entity: number;
+    readonly relation: number;
+    readonly hasMany: number;
+}
+/** One undoable unit: the editable-layer pre-images of every cell a gesture touched. */
+export interface JournalEntry {
+    readonly cells: JournalCellImage[];
+}
+/**
+ * The store side of the journal: produces editable-layer pre-images for a cell and
+ * applies a set of pre-images back (through the write paths). Implemented by
+ * SnapshotStore, which alone knows the sub-stores.
+ */
+export interface JournalTarget {
+    exportEntityCell(key: string): EntityCellImage;
+    exportRelationCell(key: string): RelationCellImage;
+    exportHasManyCell(key: string): HasManyCellImage;
+    /**
+     * Images of every created, currently-unreachable entity (and its owned relation
+     * cells) reachable from the seed ids — the subgraph a memory sweep may reclaim
+     * before an undo needs it. Backs the journal's entry-closure invariant.
+     */
+    exportUnreachableCreatedSubgraph(seedIds: ReadonlySet<string>): JournalCellImage[];
+    applyJournalImages(images: JournalCellImage[]): void;
+    /**
+     * Current editable-layer write counters across the sub-stores. Read once when a
+     * transaction opens and again when it closes to detect writes that skipped their
+     * record call. Must be O(1) — it is on the write hot path.
+     */
+    getEditableWriteCounters(): EditableWriteCounters;
+}
+declare function cellRefKey(image: JournalCellImage): string;
+export declare class UndoJournal {
+    private readonly target;
+    private readonly onCommit;
+    private readonly onRekey?;
+    private readonly onClear?;
+    private depth;
+    /** Cells recorded in the currently-open transaction, deduped first-writer-wins. */
+    private active;
+    /** Editable-write counters snapshotted when the outermost transaction opened. */
+    private baseCounters;
+    constructor(target: JournalTarget, onCommit: (entry: JournalEntry) => void, onRekey?: ((ctx: RekeyContext) => void) | undefined, onClear?: (() => void) | undefined);
+    get isRecording(): boolean;
+    begin(): void;
+    commit(): void;
+    /**
+     * Coarse per-kind invariant check at transaction close: for each journal kind
+     * whose editable-write counter advanced during the transaction, at least one
+     * cell of that kind must have been recorded. A positive delta with no recorded
+     * cell means a mutating method wrote without recording — undo would restore
+     * stale/partial state — so fail loudly naming the offending kind(s).
+     */
+    private assertAllWritesRecorded;
+    /**
+     * Folds the detached created subgraph into the entry (first-writer-wins) so undo
+     * survives a later sweep of that subgraph. Runs before onCommit so the manager's
+     * debounce/group merge already sees the enriched cells.
+     */
+    private closeOverUnreachableCreated;
+    /** Records the pre-image of an entity cell (snapshot + meta + root membership). */
+    recordEntity(key: string): void;
+    recordRelation(key: string): void;
+    recordHasMany(key: string): void;
+    private record;
+    /** Captures the CURRENT image of each given cell — used to build the inverse entry. */
+    captureCurrent(cells: JournalCellImage[]): JournalCellImage[];
+    apply(cells: JournalCellImage[]): void;
+    /** Forwarded from the store when a temp id is rekeyed; lets the owner rewrite stacks. */
+    rekey(ctx: RekeyContext): void;
+    /** Forwarded from the store on a full clear; drops all owner history and any open gesture. */
+    clear(): void;
+}
+export { cellRefKey };
+//# sourceMappingURL=UndoJournal.d.ts.map

package/dist/undo/UndoJournal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UndoJournal.d.ts","sourceRoot":"","sources":["../../src/undo/UndoJournal.ts"],"names":[],"mappings":"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"}

package/dist/undo/UndoManager.d.ts

@@ -3,117 +3,60 @@ import type { SnapshotStore } from '../store/SnapshotStore.js';
 import type { UndoManagerConfig, UndoState } from './types.js';
 type Subscriber = () => void;
 /**
- * UndoManager provides undo/redo functionality for the Bindx store.
+ * UndoManager — the policy layer over the {@link UndoJournal}.
  *
- * Features:
- * - Automatic debounced grouping of rapid changes
- * - Manual grouping via beginGroup/endGroup
- * - Configurable history size
- * - Block/unblock during persist operations
- * - React integration via subscribe/getState
+ * The journal records each gesture (one dispatch / one handle transaction) as a
+ * {@link JournalEntry} of editable-layer pre-images. UndoManager owns the undo /
+ * redo stacks and the grouping policy (debounced auto-grouping + manual
+ * begin/endGroup), blocks during persist, and keeps the stacks aligned across a
+ * temp→persisted rekey. Restore goes straight through the store's write paths, so
+ * the edge index and reachability cache rebuild themselves; the event/interceptor
+ * pipeline is NOT replayed.
  */
 export declare class UndoManager {
     private readonly store;
+    private readonly journal;
     private undoStack;
     private redoStack;
-    private pendingEntry;
+    /** Cells accumulated while a debounce window or manual group is open (first-writer-wins). */
+    private pending;
     private debounceTimer;
-    private isBlocked;
     private manualGroupId;
-    private manualGroupLabel;
+    private blockDepth;
     private subscribers;
     private cachedState;
     private readonly maxHistorySize;
     private readonly debounceMs;
     constructor(store: SnapshotStore, config?: UndoManagerConfig);
     /**
-     * Creates middleware for ActionDispatcher.
-     * Must be added to dispatcher to enable undo tracking.
+     * Wires the journal into the store so its write paths record gestures. The
+     * returned middleware is a backward-compatible pass-through (recording is native
+     * to the store transaction, not the middleware).
      */
     createMiddleware(): ActionMiddleware;
-    /**
-     * Handles an action, capturing state for undo if trackable.
-     */
-    private handleAction;
-    /**
-     * Handles action in manual group mode.
-     */
-    private handleManualGroupAction;
-    /**
-     * Handles action in debounced auto-group mode.
-     */
-    private handleDebouncedAction;
-    /**
-     * Gets keys that are in source but not in target.
-     */
-    private getNewKeys;
-    /**
-     * Checks if keys object is empty.
-     */
-    private isEmptyKeys;
-    /**
-     * Merges additional snapshot into target.
-     */
-    private mergeSnapshots;
-    /**
-     * Starts the debounce timer.
-     */
-    private startDebounceTimer;
-    /**
-     * Resets the debounce timer.
-     */
+    private onEntry;
+    private mergeIntoPending;
+    private flushPending;
+    private pushEntry;
     private resetDebounceTimer;
     /**
-     * Flushes pending entry to undo stack.
-     */
-    private flushPendingEntry;
-    /**
-     * Trims history to max size.
-     */
-    private trimHistory;
-    /**
-     * Starts a manual group. All actions until endGroup are grouped as one undo entry.
-     * Returns group ID that must be passed to endGroup.
-     */
-    beginGroup(label?: string): string;
-    /**
-     * Ends a manual group and pushes to undo stack.
+     * Starts a manual group: every gesture until {@link endGroup} folds into one
+     * undo entry. Returns a handle that must be passed back to endGroup.
      */
+    beginGroup(_label?: string): string;
     endGroup(groupId: string): void;
-    /**
-     * Undoes the last entry.
-     */
     undo(): void;
-    /**
-     * Redoes the last undone entry.
-     */
     redo(): void;
-    /**
-     * Blocks undo/redo operations.
-     * Use during persist to prevent inconsistent state.
-     */
     block(): void;
-    /**
-     * Unblocks undo/redo operations.
-     */
     unblock(): void;
     /**
-     * Clears all undo/redo history.
+     * Rewrites every stacked entry when a temp id is replaced by its persisted id,
+     * so stored cells keep valid keys / id references (and sealed creates drop out).
      */
+    private rekeyStacks;
     clear(): void;
-    /**
-     * Subscribes to state changes.
-     * Returns unsubscribe function.
-     */
     subscribe(callback: Subscriber): () => void;
-    /**
-     * Gets current state for React integration.
-     * Returns a cached object to satisfy useSyncExternalStore's referential equality requirement.
-     */
     getState(): UndoState;
-    /**
-     * Notifies all subscribers of state change.
-     */
     private notifySubscribers;
 }
 export {};

package/dist/undo/UndoManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UndoManager.d.ts","sourceRoot":"","sources":["../../src/undo/UndoManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AASnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAC9D,OAAO,KAAK,EAIX,iBAAiB,EACjB,SAAS,EACT,MAAM,YAAY,CAAA;AAEnB,KAAK,UAAU,GAAG,MAAM,IAAI,CAAA;AAS5B;;;;;;;;;GASG;AACH,qBAAa,WAAW;IAetB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAdvB,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,SAAS,CAAkB;IACnC,OAAO,CAAC,YAAY,CAAgC;IACpD,OAAO,CAAC,aAAa,CAA6C;IAClE,OAAO,CAAC,SAAS,CAAQ;IACzB,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,gBAAgB,CAAgC;IACxD,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,WAAW,CAAyB;IAE5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;gBAGjB,KAAK,EAAE,aAAa,EACrC,MAAM,GAAE,iBAAsB;IAM/B;;;OAGG;IACH,gBAAgB,IAAI,gBAAgB;IAQpC;;OAEG;IACH,OAAO,CAAC,YAAY;IAuBpB;;OAEG;IACH,OAAO,CAAC,uBAAuB;IAsB/B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAqC7B;;OAEG;IACH,OAAO,CAAC,UAAU;IAQlB;;OAEG;IACH,OAAO,CAAC,WAAW;IAInB;;OAEG;IACH,OAAO,CAAC,cAAc;IAuBtB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAM1B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAO1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAqBzB;;OAEG;IACH,OAAO,CAAC,WAAW;IAMnB;;;OAGG;IACH,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM;IAUlC;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAW/B;;OAEG;IACH,IAAI,IAAI,IAAI;IA4BZ;;OAEG;IACH,IAAI,IAAI,IAAI;IAyBZ;;;OAGG;IACH,KAAK,IAAI,IAAI;IAOb;;OAEG;IACH,OAAO,IAAI,IAAI;IAKf;;OAEG;IACH,KAAK,IAAI,IAAI;IAab;;;OAGG;IACH,SAAS,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAO3C;;;OAGG;IACH,QAAQ,IAAI,SAAS;IAarB;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAMzB"}
+{"version":3,"file":"UndoManager.d.ts","sourceRoot":"","sources":["../../src/undo/UndoManager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAI9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAE9D,KAAK,UAAU,GAAG,MAAM,IAAI,CAAA;AAS5B;;;;;;;;;;GAUG;AACH,qBAAa,WAAW;IAkBtB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAjBvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAa;IACrC,OAAO,CAAC,SAAS,CAAqB;IACtC,OAAO,CAAC,SAAS,CAAqB;IAEtC,6FAA6F;IAC7F,OAAO,CAAC,OAAO,CAA6C;IAC5D,OAAO,CAAC,aAAa,CAA6C;IAClE,OAAO,CAAC,aAAa,CAAsB;IAE3C,OAAO,CAAC,UAAU,CAAI;IACtB,OAAO,CAAC,WAAW,CAAwB;IAC3C,OAAO,CAAC,WAAW,CAAyB;IAE5C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAQ;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;gBAGjB,KAAK,EAAE,aAAa,EACrC,MAAM,GAAE,iBAAsB;IAY/B;;;;OAIG;IACH,gBAAgB,IAAI,gBAAgB;IAWpC,OAAO,CAAC,OAAO;IAwBf,OAAO,CAAC,gBAAgB;IAaxB,OAAO,CAAC,YAAY;IAYpB,OAAO,CAAC,SAAS;IAUjB,OAAO,CAAC,kBAAkB;IAS1B;;;OAGG;IACH,UAAU,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM;IAOnC,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAW/B,IAAI,IAAI,IAAI;IAcZ,IAAI,IAAI,IAAI;IAaZ,KAAK,IAAI,IAAI;IAUb,OAAO,IAAI,IAAI;IAUf;;;OAGG;IACH,OAAO,CAAC,WAAW;IAiCnB,KAAK,IAAI,IAAI;IAYb,SAAS,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,IAAI;IAO3C,QAAQ,IAAI,SAAS;IAcrB,OAAO,CAAC,iBAAiB;CAMzB"}

package/dist/undo/UnrecordedWriteError.d.ts

@@ -0,0 +1,16 @@
+import type { JournalCellKind } from './UndoJournal.js';
+/**
+ * Thrown when a journal transaction closes after an editable-layer store write
+ * that was NOT preceded by a matching `journal.record*` call — i.e. a mutating
+ * SnapshotStore method wrote primary state a gesture can no longer undo.
+ *
+ * This turns the "every mutating method must record before writing" convention
+ * into a checked invariant: the sub-store editable-write counters advanced for a
+ * kind the transaction never recorded. The named kinds pinpoint which record call
+ * is missing (recordEntity / recordRelation / recordHasMany).
+ */
+export declare class UnrecordedWriteError extends Error {
+    readonly kinds: ReadonlyArray<JournalCellKind>;
+    constructor(kinds: ReadonlyArray<JournalCellKind>);
+}
+//# sourceMappingURL=UnrecordedWriteError.d.ts.map

package/dist/undo/UnrecordedWriteError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UnrecordedWriteError.d.ts","sourceRoot":"","sources":["../../src/undo/UnrecordedWriteError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEvD;;;;;;;;;GASG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;aAClB,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC;gBAArC,KAAK,EAAE,aAAa,CAAC,eAAe,CAAC;CASjE"}

package/dist/undo/index.d.ts

@@ -1,3 +1,5 @@
 export { UndoManager } from './UndoManager.js';
-export type { PartialStoreSnapshot, PendingUndoEntry, UndoEntry, UndoManagerConfig, UndoState, StoreAffectedKeys, } from './types.js';
+export { UnrecordedWriteError } from './UnrecordedWriteError.js';
+export type { UndoManagerConfig, UndoState } from './types.js';
+export type { JournalEntry, JournalCellImage, EntityCellImage, RelationCellImage, HasManyCellImage, } from './UndoJournal.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/undo/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/undo/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,YAAY,EACX,oBAAoB,EACpB,gBAAgB,EAChB,SAAS,EACT,iBAAiB,EACjB,SAAS,EACT,iBAAiB,GACjB,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/undo/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAChE,YAAY,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAC9D,YAAY,EACX,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,gBAAgB,GAChB,MAAM,kBAAkB,CAAA"}

package/dist/undo/rekeyJournalEntry.d.ts

@@ -0,0 +1,20 @@
+import type { RekeyContext } from '../store/RekeyOrchestrator.js';
+import type { JournalEntry } from './UndoJournal.js';
+/**
+ * Rewrites a journal entry for a temp→persisted rekey so stored cells stay valid
+ * after persist:
+ *   - owner keys move from the temp prefix to the persisted prefix;
+ *   - embedded id references (snapshot ids, relation currentId/serverId, has-many
+ *     members) are remapped oldId→newId;
+ *   - the create is SEALED: an "absent" pre-image of the now-persisted entity (or
+ *     its owned relations) is dropped, so undo can no longer delete the
+ *     server-backed row — only later edits to it remain undoable.
+ */
+/**
+ * Looks up the live server-member ids of a has-many list by its key. Lets the
+ * rekey rebase a pre-image when the just-persisted create has become a permanent
+ * member of that list.
+ */
+export type LiveServerIdsLookup = (relationKey: string) => Set<string>;
+export declare function rekeyJournalEntry(entry: JournalEntry, ctx: RekeyContext, liveServerIds: LiveServerIdsLookup): JournalEntry;
+//# sourceMappingURL=rekeyJournalEntry.d.ts.map

package/dist/undo/rekeyJournalEntry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rekeyJournalEntry.d.ts","sourceRoot":"","sources":["../../src/undo/rekeyJournalEntry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAIjE,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,kBAAkB,CAAA;AAEtE;;;;;;;;;GASG;AACH;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,WAAW,EAAE,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,CAAA;AAEtE,wBAAgB,iBAAiB,CAChC,KAAK,EAAE,YAAY,EACnB,GAAG,EAAE,YAAY,EACjB,aAAa,EAAE,mBAAmB,GAChC,YAAY,CAOd"}

package/dist/undo/types.d.ts

@@ -1,50 +1,3 @@
-import type { StoreAffectedKeys } from '../core/actionClassification.js';
-import type { EntitySnapshot } from '../store/snapshots.js';
-import type { StoredRelationState, StoredHasManyState, EntityMeta } from '../store/SnapshotStore.js';
-/**
- * Partial snapshot of store state.
- * Contains only the data affected by an action or group of actions.
- */
-export interface PartialStoreSnapshot {
-    /** Entity snapshots (frozen, immutable) */
-    entitySnapshots: Map<string, EntitySnapshot>;
-    /** Has-one relation states */
-    relationStates: Map<string, StoredRelationState>;
-    /** Has-many list states */
-    hasManyStates: Map<string, StoredHasManyState>;
-    /** Entity metadata (existsOnServer, deletion flags) */
-    entityMetas: Map<string, EntityMeta>;
-}
-/**
- * A single undo/redo entry.
- * Contains the snapshot of state BEFORE the action(s) were applied.
- */
-export interface UndoEntry {
-    /** Unique identifier for this entry */
-    id: string;
-    /** Optional human-readable label */
-    label?: string;
-    /** Snapshot of state BEFORE the action(s) */
-    beforeSnapshot: PartialStoreSnapshot;
-    /** Keys that were affected (for redo snapshot capture) */
-    affectedKeys: StoreAffectedKeys;
-    /** When this entry was created */
-    timestamp: number;
-}
-/**
- * Pending entry during debounce window.
- * Accumulates affected keys while waiting for debounce to complete.
- */
-export interface PendingUndoEntry {
-    /** Snapshot captured before the first action in the group */
-    beforeSnapshot: PartialStoreSnapshot;
-    /** Accumulated affected keys */
-    affectedKeys: StoreAffectedKeys;
-    /** When the first action occurred */
-    timestamp: number;
-    /** Optional label for manual grouping */
-    label?: string;
-}
 /**
  * Configuration options for UndoManager.
  */
@@ -70,5 +23,4 @@ export interface UndoState {
     /** Number of entries in redo stack */
     redoCount: number;
 }
-export type { StoreAffectedKeys } from '../core/actionClassification.js';
 //# sourceMappingURL=types.d.ts.map

package/dist/undo/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/undo/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AACxE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAC3D,OAAO,KAAK,EACX,mBAAmB,EACnB,kBAAkB,EAClB,UAAU,EACV,MAAM,2BAA2B,CAAA;AAElC;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACpC,2CAA2C;IAC3C,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;IAC5C,8BAA8B;IAC9B,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAA;IAChD,2BAA2B;IAC3B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAA;IAC9C,uDAAuD;IACvD,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CACpC;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB,uCAAuC;IACvC,EAAE,EAAE,MAAM,CAAA;IACV,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,6CAA6C;IAC7C,cAAc,EAAE,oBAAoB,CAAA;IACpC,0DAA0D;IAC1D,YAAY,EAAE,iBAAiB,CAAA;IAC/B,kCAAkC;IAClC,SAAS,EAAE,MAAM,CAAA;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAChC,6DAA6D;IAC7D,cAAc,EAAE,oBAAoB,CAAA;IACpC,gCAAgC;IAChC,YAAY,EAAE,iBAAiB,CAAA;IAC/B,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAA;IACjB,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAA;CACd;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,4DAA4D;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,oEAAoE;IACpE,SAAS,EAAE,OAAO,CAAA;IAClB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAA;IACjB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAA;CACjB;AAGD,YAAY,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/undo/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,4DAA4D;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,oEAAoE;IACpE,SAAS,EAAE,OAAO,CAAA;IAClB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAA;IACjB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAA;CACjB"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@contember/bindx",
-	"version": "0.1.46",
+	"version": "0.1.48",
 	"description": "Type-safe data binding framework (core)",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -17,7 +17,7 @@
 	],
 	"license": "MIT",
 	"dependencies": {
-		"@contember/bindx-client": "0.1.46",
+		"@contember/bindx-client": "0.1.48",
 		"@contember/graphql-client": "^2.1.0-beta.1"
 	},
 	"repository": {