@contember/bindx 0.1.46 → 0.1.48

package/dist/store/HasManyStore.d.ts

@@ -0,0 +1,214 @@
+type ReconciliationResult = 'applied' | 'conflict';
+/**
+ * Removal type for has-many items
+ */
+export type HasManyRemovalType = 'disconnect' | 'delete';
+/**
+ * Kind of a planned has-many addition:
+ *   - 'created': a newly created entity (via add())
+ *   - 'connected': an existing persisted entity being connected (via connect())
+ */
+export type HasManyAdditionKind = 'created' | 'connected';
+export interface SentHasManyAddition {
+    itemId: string;
+    kind: HasManyAdditionKind;
+}
+export interface SentHasManyRemoval {
+    itemId: string;
+    type: HasManyRemovalType;
+}
+export interface SentHasManyDelta {
+    additions: readonly SentHasManyAddition[];
+    removals: readonly SentHasManyRemoval[];
+}
+/**
+ * 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 + plannedAdditions) */
+    orderedIds: string[] | null;
+    /** Planned removals (disconnect or delete) keyed by entity ID */
+    plannedRemovals: Map<string, HasManyRemovalType>;
+    /**
+     * Planned additions (IDs to add to the list) keyed by entity ID, with the
+     * value distinguishing newly CREATED entities (add()) from existing PERSISTED
+     * entities being CONNECTED (connect()). The keys are exactly the connections;
+     * the keys whose value is 'created' are exactly the created entities, so the
+     * "created ⊆ connections" invariant is structural.
+     */
+    plannedAdditions: Map<string, HasManyAdditionKind>;
+    version: number;
+}
+/**
+ * Computes the default ordered IDs for a has-many relation.
+ * Order is: serverIds (minus removals) + plannedAdditions
+ */
+export declare function computeDefaultOrderedIds(state: StoredHasManyState): string[];
+/**
+ * Owns has-many list state ("parentType:parentId:fieldName" → {@link StoredHasManyState}).
+ *
+ * Has its own monotonic {@link mutationVersion} bumped on every actual write
+ * (funnelled through {@link writeHasMany} plus the delete/clear paths); the
+ * facade sums this with the has-one counter for {@link ReachabilityAnalyzer}.
+ */
+export declare class HasManyStore {
+    /** Has-many list states keyed by "parentType:parentId:fieldName" */
+    private readonly hasManyStates;
+    /**
+     * Bidirectional live-edge index, maintained by {@link writeHasMany} /
+     * {@link deleteHasMany} so the parent↔child queries are O(degree) and the two
+     * directions stay consistent by construction.
+     */
+    private readonly edges;
+    private mutationVersion;
+    /**
+     * Monotonic counter bumped on EDITABLE-layer has-many writes (plan add/remove,
+     * add, connectExisting, remove, move, reset) — the writes an undo gesture must
+     * first record. Server- id ingestion (setHasManyServerIds), materialization
+     * (getOrCreateHasMany), post-persist commit, import, replaceEntityId, rekey and
+     * delete deliberately do NOT bump it. Read by the undo write-guard (see UndoJournal).
+     */
+    private editableWriteVersion;
+    getMutationVersion(): number;
+    getEditableWriteVersion(): number;
+    /**
+     * The single write chokepoint. Reconciles the edge index by diffing the live
+     * members of the previous state against the next, so every state-changing path
+     * (server ids / planned add/remove / move / import / replaceEntityId / ...)
+     * keeps the index correct without tracking the reverse direction itself.
+     */
+    private writeHasMany;
+    /**
+     * The single delete chokepoint — removes an entry and its live edges. Used by
+     * the bulk remove and rekey-owner paths so they don't leak edges.
+     */
+    private deleteHasMany;
+    /**
+     * 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;
+    /**
+     * Advances the server baseline by the confirmed sent delta and rebases local
+     * edits made after the request started onto that new baseline.
+     */
+    reconcileSentDelta(key: string, delta: SentHasManyDelta): ReconciliationResult;
+    /**
+     * Resets has-many state to server state (clears planned operations).
+     */
+    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, records the addition as 'connected' (not 'created') —
+     * 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;
+    /**
+     * Moves an item within a has-many relation from one index to another.
+     */
+    moveInHasMany(key: string, fromIndex: number, toIndex: number): void;
+    /**
+     * Gets the ordered list of item IDs for a has-many relation.
+     */
+    getHasManyOrderedIds(key: string): string[];
+    /**
+     * Collects the ids of child entities reachable through LIVE has-many edges
+     * (key prefix "parentType:parentId:") — an O(degree) read of the edge index.
+     */
+    collectLiveChildIds(keyPrefix: string, ids: Set<string>): void;
+    /**
+     * Adds the composite parent keys of every LIVE has-many edge containing
+     * {@link childId} — an O(degree) read of the edge index, the exact reverse of
+     * {@link collectLiveChildIds}.
+     */
+    collectParentKeysForChild(childId: string, parents: Set<string>): void;
+    /**
+     * Collects the keys of every has-many list owned by an entity (keys under the
+     * given owner prefix). Mirrors {@link removeOwnedRelations} but only enumerates.
+     */
+    collectOwnedKeys(keyPrefix: string, keys: string[]): void;
+    /**
+     * Removes a single has-many list state (and its live edges). Used by undo
+     * restore to drop a list that did not exist before the gesture.
+     */
+    removeHasMany(key: string): void;
+    /**
+     * Removes all has-many state owned by an entity (keys under the given owner
+     * prefix), dropping each entry's edges through {@link deleteHasMany}.
+     */
+    removeOwnedRelations(keyPrefix: string): void;
+    /**
+     * Commits all has-many relations for an entity.
+     *
+     * `pendingItems` (by relation key) names planned additions/removals that were NOT
+     * sent — they stay planned instead of being folded into the server baseline.
+     */
+    commitAllRelations(keyPrefix: string, pendingItems?: ReadonlyMap<string, ReadonlySet<string>>): void;
+    /**
+     * Resets all has-many relations for an entity to server state.
+     */
+    resetAllRelations(keyPrefix: string): void;
+    /**
+     * Collects the field names of dirty has-many relations for an entity.
+     */
+    collectDirtyRelations(keyPrefix: string, dirtyRelations: string[]): void;
+    /**
+     * Exports has-many states for given keys.
+     */
+    exportHasManyStates(keys: string[]): Map<string, StoredHasManyState>;
+    /**
+     * 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 has-many states
+     * (serverIds, orderedIds, plannedAdditions, plannedRemovals).
+     */
+    replaceEntityId(oldId: string, newId: string): void;
+    /**
+     * Rekeys has-many entries owned by an entity (changes the parent ID in the key).
+     * Routing through {@link deleteHasMany} + {@link writeHasMany} migrates the edge
+     * index from the old parent key to the new one for free.
+     */
+    rekeyOwner(oldKeyPrefix: string, newKeyPrefix: string): void;
+    /**
+     * Clears all has-many relation data.
+     */
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=HasManyStore.d.ts.map

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

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

package/dist/store/HasOneStore.d.ts

@@ -0,0 +1,159 @@
+import type { HasOneRelationState } from '../handles/types.js';
+import type { EntitySnapshot } from './snapshots.js';
+/**
+ * Relation state stored in SnapshotStore
+ */
+export interface StoredRelationState {
+    currentId: string | null;
+    serverId: string | null;
+    state: HasOneRelationState;
+    serverState: HasOneRelationState;
+    placeholderData: Record<string, unknown>;
+    version: number;
+}
+type ReconciliationResult = 'applied' | 'conflict';
+export type SentHasOneTransition = {
+    operation: 'connect';
+    targetId: string;
+} | {
+    operation: 'create';
+    targetId: string;
+} | {
+    operation: 'disconnect';
+    targetId: string;
+} | {
+    operation: 'delete';
+    targetId: string;
+};
+/**
+ * Owns has-one relation state ("parentType:parentId:fieldName" → {@link StoredRelationState}).
+ *
+ * Has its own monotonic {@link mutationVersion} bumped on every actual write
+ * (funnelled through {@link writeRelation} plus the delete/clear paths); the
+ * facade sums this with the has-many counter for {@link ReachabilityAnalyzer}.
+ */
+export declare class HasOneStore {
+    /** Relation states keyed by "parentType:parentId:fieldName" */
+    private readonly relationStates;
+    /**
+     * Bidirectional live-edge index, maintained by {@link writeRelation} /
+     * {@link deleteRelation} so the parent↔child queries are O(degree) and the two
+     * directions stay consistent by construction.
+     */
+    private readonly edges;
+    private mutationVersion;
+    /**
+     * Monotonic counter bumped on EDITABLE-layer has-one writes (setRelation /
+     * resetRelation) — the writes an undo gesture must first record. Materialization
+     * (getOrCreateRelation), post-persist commit, import, replaceEntityId, rekey and
+     * delete deliberately do NOT bump it. Read by the undo write-guard (see UndoJournal).
+     */
+    private editableWriteVersion;
+    getMutationVersion(): number;
+    getEditableWriteVersion(): number;
+    /**
+     * The single write chokepoint. Reconciles the edge index by diffing the live
+     * child of the previous state against the next, so every state-changing path
+     * (set/commit/reset/import/replaceEntityId/...) keeps the index correct without
+     * tracking the reverse direction itself.
+     */
+    private writeRelation;
+    /**
+     * The single delete chokepoint — removes an entry and its live edge. Used by
+     * the bulk remove and rekey-owner paths so they don't leak edges.
+     */
+    private deleteRelation;
+    /**
+     * Gets or creates relation state.
+     */
+    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;
+    /**
+     * Advances the server baseline by one confirmed sent transition while keeping
+     * edits made after the request started as pending local state.
+     */
+    reconcileSentTransition(key: string, transition: SentHasOneTransition): ReconciliationResult;
+    /**
+     * Resets relation to server state.
+     */
+    resetRelation(key: string): void;
+    /**
+     * Collects the ids of child entities reachable through LIVE has-one edges
+     * (key prefix "parentType:parentId:") — an O(degree) read of the edge index.
+     */
+    collectLiveChildIds(keyPrefix: string, ids: Set<string>): void;
+    /**
+     * Adds the composite parent keys of every LIVE has-one edge pointing at
+     * {@link childId} — an O(degree) read of the edge index, the exact reverse of
+     * {@link collectLiveChildIds}.
+     */
+    collectParentKeysForChild(childId: string, parents: Set<string>): void;
+    /**
+     * Collects the keys of every has-one relation owned by an entity (keys under the
+     * given owner prefix). Mirrors {@link removeOwnedRelations} but only enumerates.
+     */
+    collectOwnedKeys(keyPrefix: string, keys: string[]): void;
+    /**
+     * Removes a single has-one relation state (and its live edge). Used by undo
+     * restore to drop a relation that did not exist before the gesture.
+     */
+    removeRelation(key: string): void;
+    /**
+     * Removes all has-one state owned by an entity (keys under the given owner
+     * prefix), dropping each entry's edge through {@link deleteRelation}.
+     */
+    removeOwnedRelations(keyPrefix: string): void;
+    /**
+     * Commits all has-one relations for an entity.
+     *
+     * A relation whose planned op targets an item in `pendingItems` (by relation key)
+     * was not sent and is left uncommitted, so the op is retried on the next persist.
+     */
+    commitAllRelations(keyPrefix: string, pendingItems?: ReadonlyMap<string, ReadonlySet<string>>): void;
+    /**
+     * Resets all has-one relations for an entity to server state.
+     */
+    resetAllRelations(keyPrefix: string): void;
+    /**
+     * Collects the field names of dirty has-one relations for an entity.
+     */
+    collectDirtyRelations(keyPrefix: string, dirtyRelations: string[]): void;
+    /**
+     * Exports relation states for given keys.
+     */
+    exportRelationStates(keys: string[]): Map<string, StoredRelationState>;
+    /**
+     * Imports relation states from a snapshot.
+     * Returns the keys that were imported for notification.
+     */
+    importRelationStates(states: Map<string, StoredRelationState>): string[];
+    /**
+     * Replaces all occurrences of oldId with newId across has-one relation states
+     * (currentId, serverId).
+     */
+    replaceEntityId(oldId: string, newId: string): void;
+    /**
+     * Rekeys has-one entries owned by an entity (changes the parent ID in the key).
+     * Routing through {@link deleteRelation} + {@link writeRelation} migrates the
+     * edge index from the old parent key to the new one for free.
+     */
+    rekeyOwner(oldKeyPrefix: string, newKeyPrefix: string): void;
+    /**
+     * Clears all has-one relation data.
+     */
+    clear(): void;
+}
+export {};
+//# sourceMappingURL=HasOneStore.d.ts.map

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

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

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"}