atom.io 0.39.1 → 0.40.1

package/src/internal/install-into-store.ts

@@ -2,6 +2,7 @@ import type { AtomIOToken } from "atom.io"
 
 import { newest } from "./lineage"
 import { type Store, withdraw } from "./store"
+import type { RootStore } from "./transaction"
 import { isChildStore } from "./transaction"
 
 /**
@@ -14,7 +15,7 @@ import { isChildStore } from "./transaction"
  */
 export function installIntoStore(
 	tokens: AtomIOToken[],
-	target: Store,
+	target: RootStore,
 	source: Store,
 ): void {
 	const sourceNewest = newest(source)

package/src/internal/join/create-join.ts

@@ -1,7 +1,7 @@
 import type { JoinOptions, JoinToken } from "atom.io"
 import type { Json } from "atom.io/json"
 
-import type { Store } from "../store"
+import type { RootStore } from "../transaction"
 import { Join } from "./join-internal"
 
 export function createJoin<
@@ -12,7 +12,7 @@ export function createJoin<
 	Cardinality extends `1:1` | `1:n` | `n:n`,
 	Content extends Json.Object,
 >(
-	store: Store,
+	store: RootStore,
 	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>,
 	defaultContent: Content | undefined,
 ): JoinToken<ASide, AType, BSide, BType, Cardinality, Content> {

package/src/internal/join/find-relations-in-store.ts

@@ -3,7 +3,7 @@ import type { Json } from "atom.io/json"
 
 import { capitalize } from "../capitalize"
 import { findInStore } from "../families"
-import type { Store } from "../store"
+import type { RootStore } from "../transaction"
 import { getJoin } from "./get-join"
 
 export function findRelationsInStore<
@@ -16,7 +16,7 @@ export function findRelationsInStore<
 >(
 	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
 	key: AType | BType,
-	store: Store,
+	store: RootStore,
 ): JoinStates<ASide, AType, BSide, BType, Cardinality, Content> {
 	const myJoin = getJoin(token, store)
 	let relations: JoinStates<ASide, AType, BSide, BType, Cardinality, Content>

package/src/internal/join/get-internal-relations-from-store.ts

@@ -1,12 +1,12 @@
 import type { JoinToken, MutableAtomFamilyToken } from "atom.io"
 import type { SetRTX } from "atom.io/transceivers/set-rtx"
 
-import type { Store } from "../store"
+import type { RootStore } from "../transaction"
 import { getJoin } from "./get-join"
 
 export function getInternalRelationsFromStore(
 	token: JoinToken<any, any, any, any, any, any>,
-	store: Store,
+	store: RootStore,
 ): MutableAtomFamilyToken<SetRTX<string>, string> {
 	const myJoin = getJoin(token, store)
 	const family = myJoin.core.relatedKeysAtoms

package/src/internal/join/get-join.ts

@@ -1,7 +1,9 @@
 import type { JoinToken } from "atom.io"
 import type { Json } from "atom.io/json"
 
-import { IMPLICIT, type Store } from "../store"
+import { eldest } from "../lineage"
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
 import { Join } from "./join-internal"
 
 export function getJoin<
@@ -24,7 +26,8 @@ export function getJoin<
 				`Join "${token.key}" not found in store "${store.config.name}"`,
 			)
 		}
-		myJoin = new Join(rootJoin.options, rootJoin.defaultContent, store)
+		const root = eldest(store)
+		myJoin = new Join(rootJoin.options, rootJoin.defaultContent, root)
 		store.joins.set(token.key, myJoin)
 	}
 	return myJoin

package/src/internal/join/join-internal.ts

@@ -13,7 +13,7 @@ import type {
 	WriterToolkit,
 } from "atom.io"
 import { Anarchy } from "atom.io"
-import type { Canonical, Json, stringified } from "atom.io/json"
+import type { Json } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
@@ -29,11 +29,11 @@ import type {
 	ExternalStoreConfiguration,
 } from "../junction"
 import { Junction } from "../junction"
-import type { Molecule } from "../molecule"
 import { createMutableAtomFamily, getJsonFamily, getJsonToken } from "../mutable"
 import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
 import { IMPLICIT } from "../store"
+import type { RootStore } from "../transaction"
 
 export type JoinStateFamilies<
 	ASide extends string,
@@ -132,7 +132,6 @@ export class Join<
 	private toolkit: WriterToolkit
 	public options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>
 	public defaultContent: Content | undefined
-	public molecules: Map<string, Molecule<any>> = new Map()
 	public relations: Junction<ASide, AType, BSide, BType, Content>
 	public states: JoinStateFamilies<
 		ASide,
@@ -163,7 +162,7 @@ export class Join<
 	public constructor(
 		options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>,
 		defaultContent: Content | undefined,
-		store: Store = IMPLICIT.STORE,
+		store: RootStore = IMPLICIT.STORE,
 	) {
 		type AnyKey = AType & BType
 
@@ -225,6 +224,9 @@ export class Join<
 				bKeys.delete(a)
 				return bKeys
 			})
+			const [x, y] = [a, b].sort()
+			const compositeKey = `${x}:${y}`
+			this.store.moleculeJoins.delete(compositeKey)
 		}
 		const replaceRelationsSafely: Write<
 			(a: string, newRelationsOfA: string[]) => void
@@ -267,9 +269,9 @@ export class Join<
 								relationsOfB.clear()
 							}
 							for (const previousOwner of previousOwnersToDispose) {
-								const sorted = [newRelationB, previousOwner].sort()
-								const compositeKey = `"${sorted[0]}:${sorted[1]}"`
-								this.molecules.delete(compositeKey)
+								const [x, y] = [newRelationB, previousOwner].sort()
+								const compositeKey = `${x}:${y}`
+								store.moleculeJoins.delete(compositeKey)
 							}
 						}
 						if (!newRelationBIsAlreadyRelated) {
@@ -310,14 +312,8 @@ export class Join<
 		const baseExternalStoreConfiguration: BaseExternalStoreConfiguration = {
 			getRelatedKeys: (key) => getRelatedKeys(this.toolkit, key),
 			addRelation: (a, b) => {
-				this.store.moleculeJoins.set(
-					a as stringified<Canonical> /* 💥 RECONCILE */,
-					options.key,
-				)
-				this.store.moleculeJoins.set(
-					b as stringified<Canonical> /* 💥 RECONCILE */,
-					options.key,
-				)
+				this.store.moleculeJoins.set(`"${a}"`, options.key)
+				this.store.moleculeJoins.set(`"${b}"`, options.key)
 				addRelation(this.toolkit, a, b)
 			},
 			deleteRelation: (a, b) => {
@@ -364,9 +360,7 @@ export class Join<
 				setContent: (contentKey: ContentKey, content: Content) => {
 					setContent(this.toolkit, contentKey, content)
 				},
-				deleteContent: (contentKey: ContentKey) => {
-					this.realm.deallocate(contentKey)
-				},
+				deleteContent: (_: ContentKey) => {},
 			}
 			externalStore = Object.assign(
 				baseExternalStoreConfiguration,
@@ -384,8 +378,8 @@ export class Join<
 				isBType: options.isBType,
 				makeContentKey: (...args) => {
 					const [a, b] = args
-					const sorted = args.sort()
-					const compositeKey = `${sorted[0]}:${sorted[1]}`
+					const [x, y] = args.sort()
+					const compositeKey = `${x}:${y}`
 					const aMolecule = store.molecules.get(stringifyJson(a))
 					const bMolecule = store.molecules.get(stringifyJson(b))
 					if (!aMolecule) {
@@ -394,6 +388,7 @@ export class Join<
 					if (!bMolecule) {
 						this.realm.allocate(options.key, b)
 					}
+
 					this.realm.allocate(a, compositeKey, `all`)
 					this.realm.claim(b, compositeKey)
 					this.store.moleculeJoins.set(compositeKey, options.key)

package/src/internal/lineage.ts

@@ -4,9 +4,20 @@ export interface Lineage {
 	child: typeof this | null
 }
 
-export function newest<T extends Lineage>(scion: T): T {
+export function newest<T extends Lineage>(
+	scion: T,
+): Exclude<T[`child`], null> | T {
 	while (scion.child !== null) {
 		scion = scion.child
 	}
 	return scion
 }
+
+export function eldest<T extends Lineage>(
+	scion: T,
+): Exclude<T[`parent`], T[`child`] | null> {
+	while (scion.parent !== null) {
+		scion = scion.parent
+	}
+	return scion as Exclude<T[`parent`], T[`child`] | null>
+}

package/src/internal/molecule.ts

@@ -8,18 +8,20 @@ import type {
 	MoleculeDisposalEvent,
 	MoleculeTransferEvent,
 	SingularTypedKey,
+	TransactionToken,
 	Vassal,
 } from "atom.io"
 import type { Canonical, stringified } from "atom.io/json"
 import { parseJson, stringifyJson } from "atom.io/json"
 
-import { disposeFromStore, findInStore } from "./families"
+import { disposeFromStore } from "./families"
 import { getFromStore } from "./get-state"
 import { getTrace } from "./get-trace"
 import { newest } from "./lineage"
 import type { Store } from "./store"
 import { IMPLICIT } from "./store"
-import { isChildStore } from "./transaction"
+import type { RootStore } from "./transaction"
+import { createTransaction, isChildStore } from "./transaction"
 
 export type Molecule<K extends Canonical> = {
 	readonly key: K
@@ -135,23 +137,35 @@ export function fuseWithinStore<
 	return compoundKey
 }
 
+export function createDeallocateTX<
+	H extends Hierarchy,
+	V extends Exclude<Vassal<H>, CompoundTypedKey>,
+>(store: RootStore): TransactionToken<(claim: Claim<V>) => void> {
+	return createTransaction(store, {
+		key: `[Internal] deallocate`,
+		do: (_, claim: Claim<V>): void => {
+			deallocateFromStore<H, V>(newest(store), claim)
+		},
+	})
+}
+
 export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
-	store: Store,
+	target: Store,
 	claim: Claim<V>,
 ): void {
 	const stringKey = stringifyJson(claim)
 
-	const molecule = store.molecules.get(stringKey)
+	const molecule = target.molecules.get(stringKey)
 	if (!molecule) {
-		const disposal = store.disposalTraces.buffer.find(
+		const disposal = target.disposalTraces.buffer.find(
 			(item) => item?.key === stringKey,
 		)
-		store.logger.error(
+		target.logger.error(
 			`❌`,
 			`key`,
 			claim,
 			`deallocation failed:`,
-			`Could not find allocation for ${stringKey} in store "${store.config.name}".`,
+			`Could not find allocation for ${stringKey} in store "${target.config.name}".`,
 			disposal
 				? `\n   This state was most recently deallocated\n${disposal.trace}`
 				: `No previous disposal trace for ${stringKey} was found.`,
@@ -159,45 +173,29 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 		return
 	}
 
-	const joinKeys = store.moleculeJoins.getRelatedKeys(
-		molecule.key as string /* 💥 RECONCILE */,
-	)
+	const joinKeys = target.moleculeJoins.getRelatedKeys(stringKey)
 	if (joinKeys) {
 		for (const joinKey of joinKeys) {
-			const join = store.joins.get(joinKey)
+			const join = target.joins.get(joinKey)
 			if (join) {
-				join.relations.delete(molecule.key)
-				join.molecules.delete(molecule.stringKey) // get rid of
+				join.relations.delete(claim)
 			}
 		}
 	}
-	store.moleculeJoins.delete(molecule.stringKey)
+	target.moleculeJoins.delete(stringKey)
 
 	const provenance: stringified<Canonical>[] = []
 
 	const values: [string, any][] = []
-	const disposalEvent: MoleculeDisposalEvent = {
-		type: `molecule_disposal`,
-		key: molecule.key,
-		values,
-		provenance,
-		timestamp: Date.now(),
-	}
-	const target = newest(store)
-	target.molecules.delete(stringKey)
-	const isTransaction =
-		isChildStore(target) && target.transactionMeta.phase === `building`
-	if (isTransaction) {
-		target.transactionMeta.update.subEvents.push(disposalEvent)
-	}
-	const relatedMolecules = store.moleculeGraph.getRelationEntries({
-		downstreamMoleculeKey: molecule.stringKey,
+
+	const relatedMolecules = target.moleculeGraph.getRelationEntries({
+		downstreamMoleculeKey: stringKey,
 	})
 	if (relatedMolecules) {
 		for (const [relatedStringKey, { source }] of relatedMolecules) {
-			if (source === molecule.stringKey) {
+			if (source === stringKey) {
 				const relatedKey = parseJson(relatedStringKey)
-				deallocateFromStore<any, any>(store, relatedKey)
+				deallocateFromStore<any, any>(target, relatedKey)
 			} else {
 				provenance.push(source)
 			}
@@ -208,12 +206,24 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 		for (const familyKey of familyKeys) {
 			// biome-ignore lint/style/noNonNullAssertion: tokens of molecules must have a family
 			const family = target.families.get(familyKey)!
-			const token = findInStore(store, family, molecule.key)
-			const value = getFromStore(store, token)
+			const value = getFromStore(target, family, claim)
 			values.push([family.key, value])
-			disposeFromStore(store, token)
+			disposeFromStore(target, family, claim)
 		}
 	}
+	const disposalEvent: MoleculeDisposalEvent = {
+		type: `molecule_disposal`,
+		key: molecule.key,
+		values,
+		provenance,
+		timestamp: Date.now(),
+	}
+	target.molecules.delete(stringKey)
+	const isTransaction =
+		isChildStore(target) && target.transactionMeta.phase === `building`
+	if (isTransaction) {
+		target.transactionMeta.update.subEvents.push(disposalEvent)
+	}
 
 	target.moleculeGraph.delete(molecule.stringKey)
 	target.moleculeJoins.delete(molecule.stringKey)
@@ -225,8 +235,26 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 	target.molecules.delete(molecule.stringKey)
 
 	const trace = getTrace(new Error())
-	store.disposalTraces.add({ key: stringKey, trace })
+	target.disposalTraces.add({ key: stringKey, trace })
+}
+
+export function createClaimTX<
+	H extends Hierarchy,
+	V extends Exclude<Vassal<H>, CompoundTypedKey>,
+	A extends Above<V, H>,
+>(
+	store: RootStore,
+): TransactionToken<
+	(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`) => void
+> {
+	return createTransaction(store, {
+		key: `[Internal] claim`,
+		do: (_, newProvenance, claim, exclusive) => {
+			claimWithinStore<H, V, A>(store, newProvenance, claim, exclusive)
+		},
+	})
 }
+
 export function claimWithinStore<
 	H extends Hierarchy,
 	V extends Exclude<Vassal<H>, CompoundTypedKey>,

package/src/internal/mutable/create-mutable-atom-family.ts

@@ -10,10 +10,10 @@ import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import { createWritablePureSelectorFamily, type MutableAtomFamily } from ".."
+import type { MutableAtomFamily, RootStore } from ".."
+import { createWritablePureSelectorFamily } from ".."
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
-import type { Store } from "../store"
 import { Subject } from "../subject"
 import { FamilyTracker } from "./tracker-family"
 import type { AsJSON, Transceiver } from "./transceiver"
@@ -22,7 +22,7 @@ export function createMutableAtomFamily<
 	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 >(
-	store: Store,
+	store: RootStore,
 	options: MutableAtomFamilyOptions<T, K>,
 	internalRoles?: string[],
 ): MutableAtomFamilyToken<T, K> {
@@ -67,7 +67,7 @@ export function createMutableAtomFamily<
 	const atomFamily = Object.assign(familyFunction, familyToken, {
 		class: options.class,
 		subject,
-		install: (s: Store) => createMutableAtomFamily(s, options),
+		install: (s: RootStore) => createMutableAtomFamily(s, options),
 		internalRoles,
 	}) satisfies MutableAtomFamily<T, K>
 

package/src/internal/mutable/create-mutable-atom.ts

@@ -5,7 +5,7 @@ import type {
 	UpdateHandler,
 } from "atom.io"
 
-import type { MutableAtom } from ".."
+import type { MutableAtom, RootStore } from ".."
 import { createStandaloneSelector, resetInStore, setIntoStore } from ".."
 import { newest } from "../lineage"
 import { deposit, type Store } from "../store"
@@ -45,7 +45,7 @@ export function createMutableAtom<T extends Transceiver<any, any, any>>(
 	const newAtom: MutableAtom<T> = {
 		...options,
 		type,
-		install: (s: Store) => {
+		install: (s: RootStore) => {
 			s.logger.info(`🛠️`, `atom`, key, `installing in store "${s.config.name}"`)
 			return createMutableAtom(s, options, family)
 		},

package/src/internal/mutable/tracker-family.ts

@@ -2,9 +2,9 @@ import type { MutableAtomToken, StateLifecycleEvent } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
-import type { MutableAtomFamily, RegularAtomFamily } from ".."
+import type { MutableAtomFamily, RegularAtomFamily, RootStore } from ".."
 import { createRegularAtomFamily } from "../families"
-import { type Store, withdraw } from "../store"
+import { withdraw } from "../store"
 import { Tracker } from "./tracker"
 import type { SignalFrom, Transceiver } from "./transceiver"
 
@@ -17,7 +17,7 @@ export class FamilyTracker<
 	public readonly latestSignalAtoms: RegularAtomFamily<SignalFrom<T> | null, K>
 	public readonly mutableAtoms: MutableAtomFamily<T, K>
 
-	public constructor(mutableAtoms: MutableAtomFamily<T, K>, store: Store) {
+	public constructor(mutableAtoms: MutableAtomFamily<T, K>, store: RootStore) {
 		const latestSignalAtoms = createRegularAtomFamily<SignalFrom<T> | null, K>(
 			store,
 			{

package/src/internal/operation.ts

@@ -1,4 +1,4 @@
-import type { ReadableToken } from "atom.io"
+import type { AtomUpdateEvent, ReadableToken, StateCreationEvent } from "atom.io"
 
 import type { Store } from "./store"
 import { isChildStore } from "./transaction/is-root-store"
@@ -14,6 +14,7 @@ export type OpenOperation<R extends ReadableToken<any> = ReadableToken<any>> = {
 	done: Set<string>
 	prev: Map<string, any>
 	timestamp: number
+	subEvents: (AtomUpdateEvent<any> | StateCreationEvent<any>)[]
 }
 
 export function openOperation(
@@ -36,6 +37,7 @@ export function openOperation(
 		prev: new Map(),
 		timestamp: Date.now(),
 		token,
+		subEvents: [],
 	}
 	store.logger.info(
 		`⭕`,

package/src/internal/selector/create-readonly-held-selector.ts

@@ -4,7 +4,7 @@ import type {
 	ReadonlyHeldSelectorToken,
 } from "atom.io"
 
-import type { ReadonlyHeldSelector } from ".."
+import type { ReadonlyHeldSelector, RootStore } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -47,7 +47,7 @@ export function createReadonlyHeldSelector<T extends object>(
 		type,
 		subject,
 		getFrom,
-		install: (s: Store) => createReadonlyHeldSelector(s, options, family),
+		install: (s: RootStore) => createReadonlyHeldSelector(s, options, family),
 	}
 	if (family) readonlySelector.family = family
 

package/src/internal/selector/create-readonly-pure-selector.ts

@@ -4,7 +4,7 @@ import type {
 	ReadonlyPureSelectorToken,
 } from "atom.io"
 
-import type { ReadonlyPureSelector } from ".."
+import type { ReadonlyPureSelector, RootStore } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -48,7 +48,7 @@ export function createReadonlyPureSelector<T>(
 		type,
 		subject,
 		getFrom,
-		install: (s: Store) => createReadonlyPureSelector(s, options, family),
+		install: (s: RootStore) => createReadonlyPureSelector(s, options, family),
 	}
 	if (family) readonlySelector.family = family
 

package/src/internal/selector/create-writable-held-selector.ts

@@ -4,7 +4,7 @@ import type {
 	WritableHeldSelectorToken,
 } from "atom.io"
 
-import type { WritableHeldSelector } from ".."
+import type { RootStore, WritableHeldSelector } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -54,7 +54,7 @@ export function createWritableHeldSelector<T extends object>(
 		subject,
 		getFrom,
 		setSelf,
-		install: (s: Store) => createWritableHeldSelector(s, options, family),
+		install: (s: RootStore) => createWritableHeldSelector(s, options, family),
 	}
 	if (family) mySelector.family = family
 

package/src/internal/selector/create-writable-pure-selector.ts

@@ -4,7 +4,7 @@ import type {
 	WritablePureSelectorToken,
 } from "atom.io"
 
-import type { WritablePureSelector } from ".."
+import type { RootStore, WritablePureSelector } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -54,7 +54,7 @@ export function createWritablePureSelector<T>(
 		subject,
 		getFrom,
 		setSelf,
-		install: (s: Store) => createWritablePureSelector(s, options, family),
+		install: (s: RootStore) => createWritablePureSelector(s, options, family),
 	}
 	if (family) mySelector.family = family
 

package/src/internal/set-state/become.ts

@@ -1,9 +1,7 @@
 import { isFn } from "../is-fn"
 
-export type Modify<T> = (thing: T) => T
-
 export function become<T>(
-	nextVersionOfThing: Modify<T> | T,
+	nextVersionOfThing: T | ((prev: T) => T),
 	originalThing: T,
 ): T {
 	if (isFn(nextVersionOfThing)) {

package/src/internal/set-state/dispatch-state-update.ts

@@ -1,12 +1,12 @@
-import type { AtomUpdateEvent, StateCreationEvent, StateUpdate } from "atom.io"
+import type {
+	AtomUpdateEvent,
+	StateCreationEvent,
+	StateUpdate,
+	TimelineEvent,
+} from "atom.io"
 
-import {
-	type MutableAtom,
-	newest,
-	type Subject,
-	type WritableFamily,
-	type WritableState,
-} from ".."
+import type { MutableAtom, Subject, WritableFamily, WritableState } from ".."
+import { newest } from ".."
 import { hasRole } from "../atom"
 import { readOrComputeValue } from "../get-state"
 import type { Transceiver } from "../mutable"
@@ -27,13 +27,15 @@ export function dispatchOrDeferStateUpdate<T>(
 	const token = deposit(state)
 	if (stateIsNewlyCreated && family) {
 		state.subject.next({ newValue })
-		const stateCreationEvent: StateCreationEvent<any> = {
+		const stateCreationEvent: StateCreationEvent<any> & TimelineEvent<any> = {
+			checkpoint: true,
 			type: `state_creation`,
 			subType: `writable`,
 			token,
 			timestamp: Date.now(),
 			value: newValue,
 		}
+		target.operation.subEvents.push(stateCreationEvent)
 		const familySubject = family.subject as Subject<StateCreationEvent<any>>
 		familySubject.next(stateCreationEvent)
 		const innerTarget = newest(target)
@@ -75,7 +77,7 @@ export function dispatchOrDeferStateUpdate<T>(
 					`is now (`,
 					newValue,
 					`) subscribers:`,
-					subject.subscribers,
+					subject.subscribers.keys(),
 				)
 				break
 			case `atom`:
@@ -90,7 +92,7 @@ export function dispatchOrDeferStateUpdate<T>(
 					`->`,
 					newValue,
 					`) subscribers:`,
-					subject.subscribers,
+					subject.subscribers.keys(),
 				)
 		}
 		subject.next(update)

package/src/internal/set-state/reset-in-store.ts

@@ -14,21 +14,19 @@ export function resetInStore<K extends Canonical>(
 	key: K,
 ): void
 
-export function resetInStore<T>(
+export function resetInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	...params:
-		| [token: WritableFamilyToken<T, Canonical>, key: Canonical]
+		| [token: WritableFamilyToken<T, K>, key: Key]
+		| [token: WritableToken<T>]
+): void
+
+export function resetInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
+	...params:
+		| [token: WritableFamilyToken<T, K>, key: Key]
 		| [token: WritableToken<T>]
 ): void {
-	let token: WritableToken<T>
-	let family: WritableFamilyToken<T, Canonical> | null
-	let key: Canonical | null
-	if (params.length === 1) {
-		token = params[0]
-		setIntoStore(store, token, RESET_STATE)
-	} else {
-		family = params[0]
-		key = params[1]
-		setIntoStore(store, family, key, RESET_STATE)
-	}
+	const subParams = [...params, RESET_STATE] as const
+	setIntoStore(store, ...subParams)
 }