@contember/bindx 0.1.46 → 0.1.47

package/src/store/SubscriptionManager.ts

@@ -1,3 +1,5 @@
+import type { RekeyContext, Rekeyable } from './RekeyOrchestrator.js'
+
 type Subscriber = () => void
 
 /**
@@ -8,6 +10,16 @@ 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.
  *
@@ -15,10 +27,10 @@ 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 class SubscriptionManager {
+export class SubscriptionManager implements Rekeyable {
 	/** Subscribers per entity key */
 	private readonly entitySubscribers = new Map<string, Set<Subscriber>>()
 
@@ -28,15 +40,19 @@ export class SubscriptionManager {
 	/** Global subscribers (notified on any change) */
 	private readonly globalSubscribers = new Set<Subscriber>()
 
-	/** Parent-child relationships: childKey -> Set of parentKeys */
-	private readonly childToParents = new Map<string, Set<string>>()
-
 	/** Maps old keys → new keys after rekey, so unsubscribe closures can find migrated callbacks */
 	private readonly rekeyedKeys = new Map<string, string>()
 
 	/** Global version number for change detection */
 	private globalVersion = 0
 
+	/**
+	 * 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: ParentKeyLookup | undefined
+
 	/**
 	 * Resolves a key through the rekey redirect chain.
 	 * The rekey() method collapses chains (A→C instead of A→B→C), so this should
@@ -116,32 +132,54 @@ export class SubscriptionManager {
 		}
 	}
 
+	/**
+	 * 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.
+	 */
+	notifyAll(): void {
+		this.globalVersion++
+
+		// Iterate the live sets, as the per-key paths do: a subscriber that unsubscribes a
+		// not-yet-visited sibling removes it from the iteration, whereas a copied array would
+		// still invoke it after its unsubscribe() returned.
+		for (const subs of this.entitySubscribers.values()) {
+			for (const sub of subs) sub()
+		}
+		for (const subs of this.relationSubscribers.values()) {
+			for (const sub of subs) sub()
+		}
+		for (const sub of this.globalSubscribers) sub()
+	}
+
 	// ==================== Parent-Child Relationships ====================
 
 	/**
-	 * Registers a parent-child relationship for change propagation.
-	 * When the child entity changes, parent entity subscribers will be notified.
+	 * 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.
 	 */
-	registerParentChild(parentKey: string, childKey: string): void {
-		let parents = this.childToParents.get(childKey)
-		if (!parents) {
-			parents = new Set()
-			this.childToParents.set(childKey, parents)
-		}
-		parents.add(parentKey)
+	setParentKeyLookup(lookup: ParentKeyLookup): void {
+		this.parentKeyLookup = lookup
 	}
 
 	/**
-	 * Unregisters a parent-child relationship.
+	 * 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}).
 	 */
-	unregisterParentChild(parentKey: string, childKey: string): void {
-		const parents = this.childToParents.get(childKey)
-		if (parents) {
-			parents.delete(parentKey)
-			if (parents.size === 0) {
-				this.childToParents.delete(childKey)
-			}
-		}
+	private getParentKeys(childKey: string): Set<string> {
+		if (!this.parentKeyLookup) return new Set()
+		const separator = childKey.indexOf(':')
+		if (separator === -1) return new Set()
+		const childId = childKey.slice(separator + 1)
+		return this.parentKeyLookup.getParentKeysForChild(childId)
 	}
 
 	// ==================== Notification ====================
@@ -153,7 +191,25 @@ export class SubscriptionManager {
 	notifyEntitySubscribers(
 		key: string,
 		bumper: SnapshotVersionBumper,
-		notifiedKeys: Set<string> = new Set(),
+	): void {
+		this.globalVersion++
+		this.notifyEntityAndParentSubscribers(key, bumper, new Set())
+	}
+
+	/**
+	 * 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(
+		key: string,
+		bumper: SnapshotVersionBumper,
+		notifiedKeys: Set<string>,
 	): void {
 		// Prevent infinite recursion
 		if (notifiedKeys.has(key)) return
@@ -164,8 +220,6 @@ export class SubscriptionManager {
 		const isRoot = notifiedKeys.size === 0
 		notifiedKeys.add(key)
 
-		this.globalVersion++
-
 		// Notify entity-specific subscribers
 		const entitySubs = this.entitySubscribers.get(key)
 		if (entitySubs) {
@@ -174,14 +228,16 @@ export class SubscriptionManager {
 			}
 		}
 
-		// Notify parent entity subscribers (propagate change up the tree)
-		const parents = this.childToParents.get(key)
-		if (parents) {
-			for (const parentKey of parents) {
-				// Bump parent snapshot version so useSyncExternalStore detects a change
-				bumper.bumpEntitySnapshotVersion(parentKey)
-				this.notifyEntitySubscribers(parentKey, bumper, notifiedKeys)
-			}
+		// Notify parent entity subscribers (propagate change up the tree).
+		// Parents are derived from the relation store's LIVE edges, so a
+		// disconnected child no longer reaches its former parent.
+		const parents = this.getParentKeys(key)
+		for (const parentKey of parents) {
+			// An ancestor reachable through several edges is bumped and walked once.
+			if (notifiedKeys.has(parentKey)) continue
+			// Bump parent snapshot version so useSyncExternalStore detects a change
+			bumper.bumpEntitySnapshotVersion(parentKey)
+			this.notifyEntityAndParentSubscribers(parentKey, bumper, notifiedKeys)
 		}
 
 		// Notify global subscribers (only once, from the root invocation — not
@@ -194,8 +250,8 @@ export class SubscriptionManager {
 	}
 
 	/**
-	 * 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(
@@ -216,18 +272,7 @@ export class SubscriptionManager {
 		// Bump entity snapshot version so isEqual detects a change
 		bumper.bumpEntitySnapshotVersion(entityKey)
 
-		// Notify entity subscribers
-		const entitySubs = this.entitySubscribers.get(entityKey)
-		if (entitySubs) {
-			for (const sub of entitySubs) {
-				sub()
-			}
-		}
-
-		// Notify global subscribers
-		for (const sub of this.globalSubscribers) {
-			sub()
-		}
+		this.notifyEntityAndParentSubscribers(entityKey, bumper, new Set())
 	}
 
 	/**
@@ -267,11 +312,15 @@ export class SubscriptionManager {
 	}
 
 	/**
-	 * 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(oldKey: string, newKey: string, oldKeyPrefix: string, newKeyPrefix: string): void {
+	rekey(ctx: RekeyContext): void {
+		const { oldKey, newKey, oldKeyPrefix, newKeyPrefix } = ctx
 		// Register redirect for entity key (update existing chains first)
 		for (const [fromKey, toKey] of this.rekeyedKeys) {
 			if (toKey === oldKey) {
@@ -280,21 +329,17 @@ export class SubscriptionManager {
 		}
 		this.rekeyedKeys.set(oldKey, newKey)
 
-		// Move entity subscribers
-		const entitySubs = this.entitySubscribers.get(oldKey)
-		if (entitySubs) {
-			this.entitySubscribers.delete(oldKey)
-			this.entitySubscribers.set(newKey, entitySubs)
-		}
+		// Move entity subscribers, merging into anything already subscribed under the new key
+		this.moveSubscribers(this.entitySubscribers, oldKey, newKey)
 
 		// Move relation subscribers by prefix (e.g. "Entity:tempId:" → "Entity:persistedId:")
-		const toMoveRelations: [string, Set<Subscriber>][] = []
-		for (const [key, subs] of this.relationSubscribers) {
+		const toMoveRelations: string[] = []
+		for (const key of this.relationSubscribers.keys()) {
 			if (key.startsWith(oldKeyPrefix)) {
-				toMoveRelations.push([key, subs])
+				toMoveRelations.push(key)
 			}
 		}
-		for (const [oldRelKey, subs] of toMoveRelations) {
+		for (const oldRelKey of toMoveRelations) {
 			const newRelKey = newKeyPrefix + oldRelKey.slice(oldKeyPrefix.length)
 
 			// Register redirect for relation key (update existing chains first)
@@ -305,23 +350,25 @@ export class SubscriptionManager {
 			}
 			this.rekeyedKeys.set(oldRelKey, newRelKey)
 
-			this.relationSubscribers.delete(oldRelKey)
-			this.relationSubscribers.set(newRelKey, subs)
-		}
-
-		// Move parent-child: update child→parent mappings
-		const parents = this.childToParents.get(oldKey)
-		if (parents) {
-			this.childToParents.delete(oldKey)
-			this.childToParents.set(newKey, parents)
+			this.moveSubscribers(this.relationSubscribers, oldRelKey, newRelKey)
 		}
+	}
 
-		// Update parent-child: replace oldKey in any parent sets that reference it
-		for (const parentSet of this.childToParents.values()) {
-			if (parentSet.has(oldKey)) {
-				parentSet.delete(oldKey)
-				parentSet.add(newKey)
-			}
+	/**
+	 * 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.
+	 */
+	private moveSubscribers(map: Map<string, Set<Subscriber>>, oldKey: string, newKey: string): void {
+		const moved = map.get(oldKey)
+		if (!moved) return
+		map.delete(oldKey)
+
+		const existing = map.get(newKey)
+		if (!existing) {
+			map.set(newKey, moved)
+			return
 		}
+		for (const sub of moved) existing.add(sub)
 	}
 }

package/src/store/TouchedStore.ts

@@ -1,3 +1,5 @@
+import type { RekeyContext, Rekeyable } from './RekeyOrchestrator.js'
+
 /**
  * Manages touched state for entity fields.
  *
@@ -6,7 +8,7 @@
  *
  * Keys are pre-computed composite strings (e.g., "entityType:id:fieldName").
  */
-export class TouchedStore {
+export class TouchedStore implements Rekeyable {
 	/** Touched state keyed by "entityType:id:fieldName" */
 	private readonly touchedFields = new Map<string, boolean>()
 
@@ -39,7 +41,8 @@ export class TouchedStore {
 	/**
 	 * Rekeys all touched fields from oldKeyPrefix to newKeyPrefix.
 	 */
-	rekey(oldKeyPrefix: string, newKeyPrefix: string): void {
+	rekey(ctx: RekeyContext): void {
+		const { oldKeyPrefix, newKeyPrefix } = ctx
 		const toMove: [string, boolean][] = []
 		for (const [key, value] of this.touchedFields) {
 			if (key.startsWith(oldKeyPrefix)) {

package/src/store/relationKey.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 function parentKeyFromRelationKey(relationKey: string): string {
+	const lastSeparator = relationKey.lastIndexOf(':')
+	return relationKey.slice(0, lastSeparator)
+}
+
+/**
+ * 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 function parentKeyFromOwnerPrefix(ownerPrefix: string): string {
+	return ownerPrefix.endsWith(':') ? ownerPrefix.slice(0, -1) : ownerPrefix
+}

package/src/undo/UndoJournal.ts

@@ -0,0 +1,258 @@
+import type { EntitySnapshot } from '../store/snapshots.js'
+import type { StoredRelationState, StoredHasManyState } from '../store/RelationStore.js'
+import type { RekeyContext } from '../store/RekeyOrchestrator.js'
+import { UnrecordedWriteError } from './UnrecordedWriteError.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
+}
+
+function cellRefKey(image: JournalCellImage): string {
+	return `${image.kind}:${image.key}`
+}
+
+/**
+ * Ids referenced by an entry's relation/has-many PRE-images — the roots of any
+ * created subgraph the gesture may have detached (has-one currentId; has-many
+ * members / planned add/remove). The unreachable-created gate filters the rest.
+ */
+function collectDetachedSeedIds(active: Map<string, JournalCellImage>): Set<string> {
+	const ids = new Set<string>()
+	for (const image of active.values()) {
+		if (image.kind === 'relation') {
+			if (image.state?.currentId) ids.add(image.state.currentId)
+		} else if (image.kind === 'hasMany' && image.state) {
+			if (image.state.orderedIds) for (const id of image.state.orderedIds) ids.add(id)
+			for (const id of image.state.plannedAdditions.keys()) ids.add(id)
+			for (const id of image.state.plannedRemovals.keys()) ids.add(id)
+		}
+	}
+	return ids
+}
+
+export class UndoJournal {
+	private depth = 0
+	/** Cells recorded in the currently-open transaction, deduped first-writer-wins. */
+	private active: Map<string, JournalCellImage> | null = null
+	/** Editable-write counters snapshotted when the outermost transaction opened. */
+	private baseCounters: EditableWriteCounters | null = null
+
+	constructor(
+		private readonly target: JournalTarget,
+		private readonly onCommit: (entry: JournalEntry) => void,
+		private readonly onRekey?: (ctx: RekeyContext) => void,
+		private readonly onClear?: () => void,
+	) {}
+
+	get isRecording(): boolean {
+		return this.active !== null
+	}
+
+	begin(): void {
+		if (this.depth === 0) {
+			this.active = new Map()
+			this.baseCounters = this.target.getEditableWriteCounters()
+		}
+		this.depth++
+	}
+
+	commit(): void {
+		if (this.depth === 0) return
+		this.depth--
+		if (this.depth > 0) return
+		const active = this.active
+		this.active = null
+		// Guard runs even for an empty entry: a write that skipped its record call
+		// leaves zero cells yet still advanced the counters — that is the bug to catch.
+		this.assertAllWritesRecorded(active)
+		this.baseCounters = null
+		if (active && active.size > 0) {
+			this.closeOverUnreachableCreated(active)
+			this.onCommit({ cells: [...active.values()] })
+		}
+	}
+
+	/**
+	 * 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(active: Map<string, JournalCellImage> | null): void {
+		const base = this.baseCounters
+		if (base === null) return
+		const now = this.target.getEditableWriteCounters()
+
+		const recorded: Record<JournalCellKind, boolean> = { entity: false, relation: false, hasMany: false }
+		if (active) {
+			for (const image of active.values()) recorded[image.kind] = true
+		}
+
+		const unrecorded: JournalCellKind[] = []
+		if (now.entity > base.entity && !recorded.entity) unrecorded.push('entity')
+		if (now.relation > base.relation && !recorded.relation) unrecorded.push('relation')
+		if (now.hasMany > base.hasMany && !recorded.hasMany) unrecorded.push('hasMany')
+
+		if (unrecorded.length > 0) throw new UnrecordedWriteError(unrecorded)
+	}
+
+	/**
+	 * 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(active: Map<string, JournalCellImage>): void {
+		const seedIds = collectDetachedSeedIds(active)
+		if (seedIds.size === 0) return
+		for (const image of this.target.exportUnreachableCreatedSubgraph(seedIds)) {
+			const refKey = cellRefKey(image)
+			if (!active.has(refKey)) active.set(refKey, image)
+		}
+	}
+
+	/** Records the pre-image of an entity cell (snapshot + meta + root membership). */
+	recordEntity(key: string): void {
+		this.record(`entity:${key}`, () => this.target.exportEntityCell(key))
+	}
+
+	recordRelation(key: string): void {
+		this.record(`relation:${key}`, () => this.target.exportRelationCell(key))
+	}
+
+	recordHasMany(key: string): void {
+		this.record(`hasMany:${key}`, () => this.target.exportHasManyCell(key))
+	}
+
+	private record(refKey: string, make: () => JournalCellImage): void {
+		if (!this.active) return // no transaction open ⇒ not part of any gesture
+		if (this.active.has(refKey)) return // first-writer-wins: keep the pre-gesture state
+		this.active.set(refKey, make())
+	}
+
+	/** Captures the CURRENT image of each given cell — used to build the inverse entry. */
+	captureCurrent(cells: JournalCellImage[]): JournalCellImage[] {
+		return cells.map(cell => {
+			switch (cell.kind) {
+				case 'entity':
+					return this.target.exportEntityCell(cell.key)
+				case 'relation':
+					return this.target.exportRelationCell(cell.key)
+				case 'hasMany':
+					return this.target.exportHasManyCell(cell.key)
+			}
+		})
+	}
+
+	apply(cells: JournalCellImage[]): void {
+		this.target.applyJournalImages(cells)
+	}
+
+	/** Forwarded from the store when a temp id is rekeyed; lets the owner rewrite stacks. */
+	rekey(ctx: RekeyContext): void {
+		this.onRekey?.(ctx)
+	}
+
+	/** Forwarded from the store on a full clear; drops all owner history and any open gesture. */
+	clear(): void {
+		// A full store clear wipes the world these pre-images describe. Drop the open
+		// gesture's cells but keep `active` non-null so begin/commit depth stays paired.
+		// Null the baseline too: the wiped transaction can't be meaningfully guarded.
+		if (this.active !== null) this.active = new Map()
+		this.baseCounters = null
+		this.onClear?.()
+	}
+}
+
+export { cellRefKey }