@contember/bindx 0.1.45 → 0.1.47

package/dist/store/ReachabilityAnalyzer.d.ts

@@ -17,6 +17,14 @@ import type { RootRegistry } from './RootRegistry.js';
  * The graph is read from {@link RelationStore} (the source of truth for live
  * relation membership), never from the subscription parent-child registry,
  * which is append-mostly for notifications and does not reflect disconnects.
+ *
+ * The walk is O(E+R) and runs on every dirty check and post-persist sweep, so
+ * its result is memoized. Each sub-store the walk reads exposes a monotonic
+ * `getMutationVersion()` that bumps only when graph-relevant state changes
+ * (entity key set, `existsOnServer`/`isPersisting`, roots, relation edges).
+ * Their sum is a cache key: it is strictly increasing, so an unchanged sum
+ * proves nothing relevant changed and the cached set can be returned. Pure
+ * field edits do not bump any counter, keeping the cache warm on the hot path.
  */
 export declare class ReachabilityAnalyzer {
     private readonly entitySnapshots;
@@ -24,10 +32,21 @@ export declare class ReachabilityAnalyzer {
     private readonly relations;
     private readonly roots;
     constructor(entitySnapshots: EntitySnapshotStore, meta: EntityMetaStore, relations: RelationStore, roots: RootRegistry);
+    private cache;
     /**
      * Returns the set of entity keys ("entityType:id") for created
      * (never-persisted) entities reachable from a root through live relations.
+     *
+     * The returned set is the cached instance and is owned by the analyzer —
+     * callers must treat it as read-only (the current consumers only call
+     * `.has(...)` on it).
      */
     computeReachableCreated(): Set<string>;
+    /**
+     * Sum of the graph-relevant mutation counters across the sub-stores the walk
+     * reads. Monotonic, so an unchanged value means no relevant mutation happened.
+     */
+    private graphVersion;
+    private walk;
 }
 //# sourceMappingURL=ReachabilityAnalyzer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ReachabilityAnalyzer.d.ts","sourceRoot":"","sources":["../../src/store/ReachabilityAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,oBAAoB;IAE/B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAHL,eAAe,EAAE,mBAAmB,EACpC,IAAI,EAAE,eAAe,EACrB,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,YAAY;IAGrC;;;OAGG;IACH,uBAAuB,IAAI,GAAG,CAAC,MAAM,CAAC;CA0DtC"}
+{"version":3,"file":"ReachabilityAnalyzer.d.ts","sourceRoot":"","sources":["../../src/store/ReachabilityAnalyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AACnE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,oBAAoB;IAE/B,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,KAAK;gBAHL,eAAe,EAAE,mBAAmB,EACpC,IAAI,EAAE,eAAe,EACrB,SAAS,EAAE,aAAa,EACxB,KAAK,EAAE,YAAY;IAGrC,OAAO,CAAC,KAAK,CAAwD;IAErE;;;;;;;OAOG;IACH,uBAAuB,IAAI,GAAG,CAAC,MAAM,CAAC;IAYtC;;;OAGG;IACH,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,IAAI;CA0DZ"}

package/dist/store/RekeyOrchestrator.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Describes a single temp→persisted rekey in every shape the participating
+ * sub-stores need (full key, owner prefix, bare id).
+ */
+export interface RekeyContext {
+    /** Old composite key, "entityType:tempId". */
+    readonly oldKey: string;
+    /** New composite key, "entityType:persistedId". */
+    readonly newKey: string;
+    /** Old owner prefix, "entityType:tempId:". */
+    readonly oldKeyPrefix: string;
+    /** New owner prefix, "entityType:persistedId:". */
+    readonly newKeyPrefix: string;
+    /** The temp id being replaced. */
+    readonly oldId: string;
+    /** The server-assigned id. */
+    readonly newId: string;
+}
+/**
+ * A store that owns per-entity state keyed (directly or by prefix) on an entity
+ * id and can migrate it from a temp id to its persisted id.
+ */
+export interface Rekeyable {
+    rekey(ctx: RekeyContext): void;
+}
+/**
+ * Single source of temp→persisted identity, and the one place the rekey fan-out
+ * is sequenced.
+ *
+ * Owns the only id-redirect map: "entityType:tempId" → persistedId. Both key
+ * resolution ({@link resolveKey}/{@link resolveId}) and persisted-id queries
+ * ({@link getPersistedId}/{@link isNewEntity}) derive from it, so there is no
+ * second copy to keep in sync — the former `SnapshotStore.rekeyedEntities` and
+ * `EntityMetaStore.tempToPersistedId` are both gone. `SubscriptionManager` keeps
+ * its own closure-redirect chain, which tracks relation-key prefixes and stale
+ * unsubscribe closures rather than entity identity, so it stays internal there.
+ */
+export declare class RekeyOrchestrator {
+    /** "entityType:tempId" → persistedId. The single identity-redirect map. */
+    private readonly tempToPersisted;
+    private readonly participants;
+    private readonly participantSet;
+    /**
+     * @param participants the sub-stores to migrate, in the exact order
+     *   {@link rekey} must visit them (the order is load-bearing — see rekey()).
+     */
+    constructor(participants: readonly Rekeyable[]);
+    /** Adds a participant once, preserving registration order. */
+    registerParticipant(participant: Rekeyable): void;
+    /** Resolves an entity key, following a temp→persisted redirect if present. */
+    resolveKey(entityType: string, id: string): string;
+    /** Resolves an entity id to its persisted id if it has been rekeyed. */
+    resolveId(entityType: string, id: string): string;
+    /** The persisted id for an entity, or null if it has none yet. */
+    getPersistedId(entityType: string, id: string): string | null;
+    /** Whether an entity has never been persisted (no server-assigned id yet). */
+    isNewEntity(entityType: string, id: string): boolean;
+    /**
+     * Migrates an entity from its temp id to its server-assigned id across every
+     * participating store.
+     *
+     * Ordering contract (do not reorder — each step relies on the previous):
+     *   0. register the redirect, so any resolveKey/resolveId during the fan-out
+     *      already sees the persisted key;
+     *   1. roots — keep the root registry aligned;
+     *   2. entity snapshot — move data, rewrite the id field and id index;
+     *   3. meta — move metadata/load/persisting, then mark exists-on-server;
+     *   4. subscriptions — move entity + relation subscribers and parent links;
+     *   5. relations — rekey owned relation keys, then replace value references;
+     *   6. errors / touched / propagation — move the remaining per-entity state.
+     * The caller performs the final notification on the new key.
+     */
+    rekey(entityType: string, tempId: string, persistedId: string): void;
+    clear(): void;
+}
+//# sourceMappingURL=RekeyOrchestrator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RekeyOrchestrator.d.ts","sourceRoot":"","sources":["../../src/store/RekeyOrchestrator.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC5B,8CAA8C;IAC9C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,mDAAmD;IACnD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,8CAA8C;IAC9C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,mDAAmD;IACnD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,kCAAkC;IAClC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,8BAA8B;IAC9B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACtB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI,CAAA;CAC9B;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAiB;IAC7B,2EAA2E;IAC3E,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA4B;IAC5D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAkB;IAC/C,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAuB;IAEtD;;;OAGG;gBACS,YAAY,EAAE,SAAS,SAAS,EAAE;IAI9C,8DAA8D;IAC9D,mBAAmB,CAAC,WAAW,EAAE,SAAS,GAAG,IAAI;IAMjD,8EAA8E;IAC9E,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAKlD,wEAAwE;IACxE,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAIjD,kEAAkE;IAClE,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAM7D,8EAA8E;IAC9E,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO;IAMpD;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAiBpE,KAAK,IAAI,IAAI;CAGb"}

package/dist/store/RelationEdgeIndex.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Bidirectional index of LIVE relation edges between a parent entity
+ * ("parentType:parentId") and a child entity id (a bare id).
+ *
+ * Both directions are updated together by {@link addEdge}/{@link removeEdge}, so
+ * the forward query ({@link collectChildren}) and the reverse query
+ * ({@link collectParents}) can never disagree — that was the failure mode of the
+ * old append-only `childToParents` map, which was updated on connect but not on
+ * disconnect. Both queries are O(degree), not O(total edges).
+ *
+ * Edges are reference-counted: one parent entity may reach the same child through
+ * more than one relation field (e.g. `author` and `coauthor`, or two has-many
+ * fields), so an edge survives until the last field that contributes it drops it.
+ *
+ * The index stores only the LIVE edge set; turning relation state (server ids,
+ * planned additions/removals, has-one state) into that set is the owning
+ * sub-store's job, done once per write by diffing the previous against the next
+ * live set (see {@link HasOneStore}/{@link HasManyStore}). The index itself knows
+ * nothing about liveness rules.
+ */
+export declare class RelationEdgeIndex {
+    /** parentKey ("parentType:parentId") → childId → refcount */
+    private readonly forward;
+    /** childId → parentKey → refcount */
+    private readonly reverse;
+    addEdge(parentKey: string, childId: string): void;
+    removeEdge(parentKey: string, childId: string): void;
+    /** Adds the live child ids of {@link parentKey} to {@link out}. */
+    collectChildren(parentKey: string, out: Set<string>): void;
+    /** Adds the parent keys that hold a live edge to {@link childId} to {@link out}. */
+    collectParents(childId: string, out: Set<string>): void;
+    clear(): void;
+}
+//# sourceMappingURL=RelationEdgeIndex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RelationEdgeIndex.d.ts","sourceRoot":"","sources":["../../src/store/RelationEdgeIndex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,iBAAiB;IAC7B,6DAA6D;IAC7D,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyC;IACjE,qCAAqC;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyC;IAEjE,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAKjD,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAKpD,mEAAmE;IACnE,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI;IAO1D,oFAAoF;IACpF,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI;IAOvD,KAAK,IAAI,IAAI;CAIb"}

package/dist/store/RelationStore.d.ts

@@ -1,189 +1,131 @@
-import type { HasOneRelationState } from '../handles/types.js';
 import type { EntitySnapshot } from './snapshots.js';
-/**
- * Removal type for has-many items
- */
-export type HasManyRemovalType = 'disconnect' | 'delete';
-/**
- * Has-many list state stored in SnapshotStore
- */
-export interface StoredHasManyState {
-    /** IDs of items from server */
-    serverIds: Set<string>;
-    /** Explicit ordered list of item IDs, null means use default order (serverIds + plannedConnections) */
-    orderedIds: string[] | null;
-    /** Planned removals (disconnect or delete) keyed by entity ID */
-    plannedRemovals: Map<string, HasManyRemovalType>;
-    /** Planned connections (IDs to add to the list) */
-    plannedConnections: Set<string>;
-    /** Entity IDs created via add() - tracked for proper remove() semantics and mutation generation */
-    createdEntities: Set<string>;
-    version: number;
-}
-/**
- * Relation state stored in SnapshotStore
- */
-export interface StoredRelationState {
-    currentId: string | null;
-    serverId: string | null;
-    state: HasOneRelationState;
-    serverState: HasOneRelationState;
-    placeholderData: Record<string, unknown>;
-    version: number;
-}
+import type { RekeyContext, Rekeyable } from './RekeyOrchestrator.js';
+import { type SentHasOneTransition, type StoredRelationState } from './HasOneStore.js';
+import { type HasManyRemovalType, type SentHasManyDelta, type StoredHasManyState } from './HasManyStore.js';
+export type { StoredRelationState } from './HasOneStore.js';
+export type { SentHasOneTransition } from './HasOneStore.js';
+export type { HasManyAdditionKind, HasManyRemovalType, SentHasManyAddition, SentHasManyDelta, SentHasManyRemoval, StoredHasManyState, } from './HasManyStore.js';
+export { computeDefaultOrderedIds } from './HasManyStore.js';
+export type RelationReconciliationResult = 'applied' | 'conflict';
 /**
  * Manages has-one and has-many relation state.
  *
  * Relation keys use the format "parentType:parentId:fieldName".
  * Notification is handled by callers via callback returns.
+ *
+ * Thin facade composing a {@link HasOneStore} and a {@link HasManyStore}: each
+ * sub-store owns its own state map and write helper, and the facade merges the
+ * cross-cutting queries (mutation version sum; live-child/parent-key unions;
+ * dirty union) and fans out the cross-cutting mutations (rekey, removeOwned,
+ * clear) to both.
  */
-export declare class RelationStore {
-    /** Relation states keyed by "parentType:parentId:fieldName" */
-    private readonly relationStates;
-    /** Has-many list states keyed by "parentType:parentId:fieldName" */
-    private readonly hasManyStates;
-    /**
-     * Gets or creates relation state.
-     */
+export declare class RelationStore implements Rekeyable {
+    private readonly hasOne;
+    private readonly hasMany;
+    /**
+     * Increases whenever EITHER sub-store mutates. Used by {@link ReachabilityAnalyzer}
+     * to memoize its walk; only monotonic-increase-on-mutation matters, so the sum
+     * of the two per-store counters is sufficient.
+     */
+    getMutationVersion(): number;
+    /** Editable-layer has-one write counter — read by the undo write-guard. */
+    getEditableHasOneWriteVersion(): number;
+    /** Editable-layer has-many write counter — read by the undo write-guard. */
+    getEditableHasManyWriteVersion(): number;
     getOrCreateRelation(key: string, initial: Omit<StoredRelationState, 'version'>): StoredRelationState;
-    /**
-     * Gets relation state.
-     */
     getRelation(key: string): StoredRelationState | undefined;
-    /**
-     * Updates relation state.
-     * If the relation state doesn't exist, creates it using entity snapshot for server data.
-     */
     setRelation(key: string, updates: Partial<Omit<StoredRelationState, 'version'>>, entitySnapshot: EntitySnapshot | undefined, fieldName: string): void;
-    /**
-     * Commits relation state (server = current).
-     */
     commitRelation(key: string): void;
-    /**
-     * Resets relation to server state.
-     */
+    reconcileSentRelation(key: string, transition: SentHasOneTransition): RelationReconciliationResult;
     resetRelation(key: string): void;
-    /**
-     * Gets or creates has-many list state.
-     */
     getOrCreateHasMany(key: string, serverIds?: string[]): StoredHasManyState;
-    /**
-     * Gets has-many list state.
-     */
     getHasMany(key: string): StoredHasManyState | undefined;
-    /**
-     * Sets server IDs for a has-many relation.
-     */
     setHasManyServerIds(key: string, serverIds: string[]): void;
-    /**
-     * Plans a removal for a has-many item.
-     */
     planHasManyRemoval(key: string, itemId: string, type: HasManyRemovalType): void;
-    /**
-     * Plans a connection for a has-many item.
-     */
     planHasManyConnection(key: string, itemId: string): void;
-    /**
-     * Commits has-many state after successful persist.
-     */
     commitHasMany(key: string, newServerIds: string[]): void;
-    /**
-     * Resets has-many state to server state (clears planned operations).
-     */
+    reconcileSentHasMany(key: string, delta: SentHasManyDelta): RelationReconciliationResult;
     resetHasMany(key: string): void;
-    /**
-     * Adds a newly created entity to a has-many relation.
-     * Used by HasManyListHandle.add() for inline entity creation.
-     */
     addToHasMany(key: string, itemId: string): void;
-    /**
-     * Connects an existing (persisted) entity to a has-many relation.
-     * Unlike addToHasMany, does NOT add to createdEntities — used for
-     * materializing embedded connect references to existing entities.
-     */
     connectExistingToHasMany(key: string, itemId: string): void;
-    /**
-     * Removes an entity from a has-many relation.
-     * For newly created entities (via add()), cancels the connection.
-     * For existing server entities, plans the specified removal type.
-     * Returns true if the state changed (caller should notify), false if it was a no-op.
-     */
     removeFromHasMany(key: string, itemId: string, removalType: HasManyRemovalType): boolean;
+    moveInHasMany(key: string, fromIndex: number, toIndex: number): void;
+    getHasManyOrderedIds(key: string): string[];
     /**
      * Collects the ids of child entities currently reachable through an entity's
-     * LIVE relations (key prefix "parentType:parentId:"). Used by reachability-based
-     * create detection to walk the relation graph from roots.
-     *
-     * Live edges are:
-     *   - has-one: currentId, when the relation is not disconnected/deleted
-     *     (a disconnected relation has a null currentId; a 'deleted' relation is
-     *     removing its target, so the target is not anchored by it).
-     *   - has-many: effective members = (serverIds ∪ plannedConnections ∪
-     *     createdEntities) minus plannedRemovals.
+     * LIVE relations (key prefix "parentType:parentId:"). Unions the live has-one
+     * edges with the live has-many members.
      */
     getLiveChildIds(keyPrefix: string): string[];
     /**
-     * Removes all relation and has-many state owned by an entity (keys under the
-     * given owner prefix). Called by removeEntity so a removed entity leaves no
-     * stale relation state behind.
+     * Collects the composite keys ("parentType:parentId") of every entity that
+     * currently has a LIVE relation edge pointing at {@link childId} — the reverse
+     * of {@link getLiveChildIds}. Unions both sub-stores' results, scanning the
+     * same live edges the forward query reads so the two never disagree.
+     *
+     * {@link childId} is a BARE entity id (no type): relation state records child ids
+     * without their type, so the match is by id alone. This deliberately relies on
+     * the store-wide invariant that entity ids are globally unique across types
+     * (server UUIDs / minted temp ids — the same invariant behind
+     * EntitySnapshotStore's idIndex / keyForId), so a bare id resolves to exactly one
+     * entity. The forward reachability walk matches on the same bare ids, so making
+     * this type-aware in isolation would only diverge the two halves of one query.
      */
-    removeOwnedRelations(keyPrefix: string): void;
+    getParentKeysForChild(childId: string): Set<string>;
     /**
-     * Moves an item within a has-many relation from one index to another.
+     * Keys of every has-one relation owned by an entity (owner prefix
+     * "parentType:parentId:"). Used by the journal's entry-closure to enumerate a
+     * detached created entity's own relation cells.
      */
-    moveInHasMany(key: string, fromIndex: number, toIndex: number): void;
+    getOwnedRelationKeys(keyPrefix: string): string[];
     /**
-     * Gets the ordered list of item IDs for a has-many relation.
+     * Keys of every has-many list owned by an entity (owner prefix
+     * "parentType:parentId:"). Counterpart of {@link getOwnedRelationKeys}.
      */
-    getHasManyOrderedIds(key: string): string[];
+    getOwnedHasManyKeys(keyPrefix: string): string[];
     /**
-     * Restores a has-many state from a captured snapshot.
-     * Used in pessimistic mode after successful server confirmation.
+     * Removes a single has-one relation state by key (undo restore of an
+     * absent-before-the-gesture relation).
      */
-    restoreHasManyState(key: string, state: StoredHasManyState): void;
+    removeRelationState(key: string): void;
     /**
-     * Commits all relations (hasOne and hasMany) for an entity.
+     * Removes a single has-many list state by key (undo restore of an
+     * absent-before-the-gesture list).
      */
-    commitAllRelations(keyPrefix: string): void;
+    removeHasManyState(key: string): void;
     /**
-     * Resets all relations (hasOne and hasMany) for an entity to server state.
+     * Removes all relation and has-many state owned by an entity (keys under the
+     * given owner prefix). Called by removeEntity so a removed entity leaves no
+     * stale relation state behind.
      */
-    resetAllRelations(keyPrefix: string): void;
+    removeOwnedRelations(keyPrefix: string): void;
     /**
-     * Gets all relation states for an entity.
+     * Commits all relations (hasOne and hasMany) for an entity.
      */
-    getAllRelationsForEntity(keyPrefix: string): Map<string, StoredRelationState>;
+    commitAllRelations(keyPrefix: string, pendingItems?: ReadonlyMap<string, ReadonlySet<string>>): void;
     /**
-     * Gets all has-many states for an entity.
+     * Resets all relations (hasOne and hasMany) for an entity to server state.
      */
-    getAllHasManyForEntity(keyPrefix: string): Map<string, StoredHasManyState>;
+    resetAllRelations(keyPrefix: string): void;
     /**
-     * Gets the list of dirty relations for an entity.
+     * Gets the list of dirty relations (has-one and has-many) for an entity.
      */
     getDirtyRelations(keyPrefix: string): string[];
-    /**
-     * Exports relation states for given keys.
-     */
     exportRelationStates(keys: string[]): Map<string, StoredRelationState>;
-    /**
-     * Exports has-many states for given keys.
-     */
     exportHasManyStates(keys: string[]): Map<string, StoredHasManyState>;
-    /**
-     * Imports relation states from a snapshot.
-     * Returns the keys that were imported for notification.
-     */
     importRelationStates(states: Map<string, StoredRelationState>): string[];
-    /**
-     * Imports has-many states from a snapshot.
-     * Returns the keys that were imported for notification.
-     */
     importHasManyStates(states: Map<string, StoredHasManyState>): string[];
     /**
      * Replaces all occurrences of oldId with newId across relation and hasMany states.
      * Used after persist to rekey temp IDs to server-assigned IDs.
      */
     replaceEntityId(oldId: string, newId: string): void;
+    /**
+     * Migrates an entity's relation state for a temp→persisted rekey: first the
+     * relation/has-many keys it owns (the parent id in the key), then every value
+     * reference to its id from other entities' relations.
+     */
+    rekey(ctx: RekeyContext): void;
     /**
      * Rekeys relation/hasMany entries owned by an entity (changes the parent ID in the key).
      */
@@ -193,9 +135,4 @@ export declare class RelationStore {
      */
     clear(): void;
 }
-/**
- * Computes the default ordered IDs for a has-many relation.
- * Order is: serverIds (minus removals) + plannedConnections
- */
-export declare function computeDefaultOrderedIds(state: StoredHasManyState): string[];
 //# sourceMappingURL=RelationStore.d.ts.map

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

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

package/dist/store/RootRegistry.d.ts

@@ -13,16 +13,37 @@
  *
  * Keys use the same composite format as the rest of the store: "entityType:id".
  */
-export declare class RootRegistry {
+import type { RekeyContext, Rekeyable } from './RekeyOrchestrator.js';
+export declare class RootRegistry implements Rekeyable {
     private readonly roots;
+    /**
+     * Monotonic counter bumped whenever the root set actually changes. Used by
+     * {@link ReachabilityAnalyzer} to memoize the reachability walk. Bumps happen
+     * only on a real change so the per-render `registerParentChild` → `unregister`
+     * call (almost always a no-op for an already-anchored child) does not
+     * needlessly invalidate the cache.
+     */
+    private mutationVersion;
+    /**
+     * Monotonic counter bumped on EDITABLE-layer root changes — the create-root
+     * register/unregister that back an undoable gesture (createEntity,
+     * registerParentChild). The persist rekey and full clear deliberately do NOT
+     * bump it. Read by the undo write-guard (see UndoJournal). The unjournaled
+     * register/unregister callers (undo restore, memory sweep, unmount cleanup) all
+     * run outside a journal transaction, so counting them here is harmless.
+     */
+    private editableWriteVersion;
     register(key: string): void;
     unregister(key: string): void;
+    getEditableWriteVersion(): number;
     keys(): IterableIterator<string>;
+    has(key: string): boolean;
     /**
-     * Moves a root entry from oldKey to newKey (used after persist rekeys a temp
-     * id to a server-assigned id).
+     * Moves a root entry from the temp key to the persisted key (used after
+     * persist rekeys a temp id to a server-assigned id).
      */
-    rekey(oldKey: string, newKey: string): void;
+    rekey(ctx: RekeyContext): void;
     clear(): void;
+    getMutationVersion(): number;
 }
 //# sourceMappingURL=RootRegistry.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"RootRegistry.d.ts","sourceRoot":"","sources":["../../src/store/RootRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,qBAAa,YAAY;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAE1C,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI3B,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAI7B,IAAI,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAIhC;;;OAGG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAM3C,KAAK,IAAI,IAAI;CAGb"}
+{"version":3,"file":"RootRegistry.d.ts","sourceRoot":"","sources":["../../src/store/RootRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAA;AAErE,qBAAa,YAAa,YAAW,SAAS;IAC7C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAoB;IAE1C;;;;;;OAMG;IACH,OAAO,CAAC,eAAe,CAAI;IAE3B;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB,CAAI;IAEhC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAQ3B,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAO7B,uBAAuB,IAAI,MAAM;IAIjC,IAAI,IAAI,gBAAgB,CAAC,MAAM,CAAC;IAIhC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB;;;OAGG;IACH,KAAK,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI;IAO9B,KAAK,IAAI,IAAI;IAKb,kBAAkB,IAAI,MAAM;CAG5B"}