atom.io 0.27.4 → 0.27.5

package/internal/src/families/create-readonly-selector-family.ts

@@ -1,5 +1,6 @@
 import type {
 	FamilyMetadata,
+	getState,
 	ReadonlySelectorFamilyOptions,
 	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
@@ -15,6 +16,7 @@ import {
 	findInStore,
 	getFromStore,
 	getJsonToken,
+	prettyPrintTokenType,
 	type ReadonlySelectorFamily,
 	seekInStore,
 } from ".."
@@ -22,11 +24,10 @@ import { newest } from "../lineage"
 import { createReadonlySelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
-import { throwInCaseOfConflictingFamily } from "./throw-in-case-of-conflicting-family"
 
 export function createReadonlySelectorFamily<T, K extends Canonical>(
-	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
+	options: ReadonlySelectorFamilyOptions<T, K>,
 	internalRoles?: string[],
 ): ReadonlySelectorFamilyToken<T, K> {
 	const familyToken = {
@@ -34,7 +35,17 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 		type: `readonly_selector_family`,
 	} as const satisfies ReadonlySelectorFamilyToken<T, K>
 
-	throwInCaseOfConflictingFamily(familyToken, store)
+	const existing = store.families.get(options.key)
+	if (existing) {
+		store.logger.error(
+			`❗`,
+			`readonly_selector_family`,
+			options.key,
+			`Overwriting an existing ${prettyPrintTokenType(
+				existing,
+			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+		)
+	}
 
 	const subject = new Subject<
 		| StateCreation<ReadonlySelectorToken<T>>
@@ -48,12 +59,12 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 		const target = newest(store)
 
 		const token = createReadonlySelector(
+			target,
 			{
 				key: fullKey,
 				get: options.get(key),
 			},
 			family,
-			target,
 		)
 
 		subject.next({ type: `state_creation`, token })
@@ -63,14 +74,14 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
 		internalRoles,
 		subject,
-		install: (s: Store) => createReadonlySelectorFamily(options, s),
+		install: (s: Store) => createReadonlySelectorFamily(s, options),
 		default: (key: K) => {
 			const getFn = options.get(key)
 			return getFn({
-				get: (token) => getFromStore(token, store),
-				find: ((token, k) => findInStore(token, k, store)) as typeof findState,
-				seek: ((token, k) => seekInStore(token, k, store)) as typeof seekState,
-				json: (token) => getJsonToken(token, store),
+				get: ((...ps: [any]) => getFromStore(store, ...ps)) as typeof getState,
+				find: ((token, k) => findInStore(store, token, k)) as typeof findState,
+				seek: ((token, k) => seekInStore(store, token, k)) as typeof seekState,
+				json: (token) => getJsonToken(store, token),
 			})
 		},
 	}) satisfies ReadonlySelectorFamily<T, K>

package/internal/src/families/create-regular-atom-family.ts

@@ -10,16 +10,15 @@ import type {
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { RegularAtomFamily } from ".."
+import { prettyPrintTokenType, type RegularAtomFamily } from ".."
 import { createRegularAtom } from "../atom"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { Subject } from "../subject"
-import { throwInCaseOfConflictingFamily } from "./throw-in-case-of-conflicting-family"
 
 export function createRegularAtomFamily<T, K extends Canonical>(
-	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
+	options: RegularAtomFamilyOptions<T, K>,
 	internalRoles?: string[],
 ): RegularAtomFamilyToken<T, K> {
 	const familyToken = {
@@ -27,7 +26,17 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 		type: `atom_family`,
 	} as const satisfies RegularAtomFamilyToken<T, K>
 
-	throwInCaseOfConflictingFamily(familyToken, store)
+	const existing = store.families.get(options.key)
+	if (existing) {
+		store.logger.error(
+			`❗`,
+			`atom_family`,
+			options.key,
+			`Overwriting an existing ${prettyPrintTokenType(
+				existing,
+			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+		)
+	}
 
 	const subject = new Subject<
 		StateCreation<RegularAtomToken<T>> | StateDisposal<RegularAtomToken<T>>
@@ -48,7 +57,7 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 			individualOptions.effects = options.effects(key)
 		}
 
-		const token = createRegularAtom(individualOptions, family, target)
+		const token = createRegularAtom(target, individualOptions, family)
 
 		subject.next({ type: `state_creation`, token })
 		return token
@@ -56,7 +65,7 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 
 	const atomFamily = Object.assign(familyFunction, familyToken, {
 		subject,
-		install: (s: Store) => createRegularAtomFamily(options, s),
+		install: (s: Store) => createRegularAtomFamily(s, options),
 		internalRoles,
 	}) satisfies RegularAtomFamily<T, K>
 

package/internal/src/families/create-selector-family.ts

@@ -12,23 +12,23 @@ import { createReadonlySelectorFamily } from "./create-readonly-selector-family"
 import { createWritableSelectorFamily } from "./create-writable-selector-family"
 
 export function createSelectorFamily<T, K extends Canonical>(
-	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
+	options: WritableSelectorFamilyOptions<T, K>,
 ): WritableSelectorFamilyToken<T, K>
 export function createSelectorFamily<T, K extends Canonical>(
-	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
+	options: ReadonlySelectorFamilyOptions<T, K>,
 ): ReadonlySelectorFamilyToken<T, K>
 export function createSelectorFamily<T, K extends Canonical>(
+	store: Store,
 	options:
 		| ReadonlySelectorFamilyOptions<T, K>
 		| WritableSelectorFamilyOptions<T, K>,
-	store: Store,
 ): SelectorFamilyToken<T, K> {
 	const isWritable = `set` in options
 
 	if (isWritable) {
-		return createWritableSelectorFamily(options, store)
+		return createWritableSelectorFamily(store, options)
 	}
-	return createReadonlySelectorFamily(options, store)
+	return createReadonlySelectorFamily(store, options)
 }

package/internal/src/families/create-writable-selector-family.ts

@@ -1,5 +1,6 @@
 import type {
 	FamilyMetadata,
+	getState,
 	StateCreation,
 	StateDisposal,
 	WritableSelectorFamilyOptions,
@@ -15,6 +16,7 @@ import {
 	findInStore,
 	getFromStore,
 	getJsonToken,
+	prettyPrintTokenType,
 	seekInStore,
 	type WritableSelectorFamily,
 } from ".."
@@ -22,11 +24,10 @@ import { newest } from "../lineage"
 import { createWritableSelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
-import { throwInCaseOfConflictingFamily } from "./throw-in-case-of-conflicting-family"
 
 export function createWritableSelectorFamily<T, K extends Canonical>(
-	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
+	options: WritableSelectorFamilyOptions<T, K>,
 	internalRoles?: string[],
 ): WritableSelectorFamilyToken<T, K> {
 	const familyToken = {
@@ -34,8 +35,17 @@ export function createWritableSelectorFamily<T, K extends Canonical>(
 		type: `selector_family`,
 	} as const satisfies WritableSelectorFamilyToken<T, K>
 
-	throwInCaseOfConflictingFamily(familyToken, store)
-
+	const existing = store.families.get(options.key)
+	if (existing) {
+		store.logger.error(
+			`❗`,
+			`selector_family`,
+			options.key,
+			`Overwriting an existing ${prettyPrintTokenType(
+				existing,
+			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+		)
+	}
 	const subject = new Subject<
 		| StateCreation<WritableSelectorToken<T>>
 		| StateDisposal<WritableSelectorToken<T>>
@@ -48,13 +58,13 @@ export function createWritableSelectorFamily<T, K extends Canonical>(
 		const target = newest(store)
 
 		const token = createWritableSelector(
+			target,
 			{
 				key: fullKey,
 				get: options.get(key),
 				set: options.set(key),
 			},
 			family,
-			target,
 		)
 
 		subject.next({ type: `state_creation`, token })
@@ -64,14 +74,14 @@ export function createWritableSelectorFamily<T, K extends Canonical>(
 	const selectorFamily = Object.assign(familyFunction, familyToken, {
 		internalRoles,
 		subject,
-		install: (s: Store) => createWritableSelectorFamily(options, s),
+		install: (s: Store) => createWritableSelectorFamily(s, options),
 		default: (key: K) => {
 			const getFn = options.get(key)
 			return getFn({
-				get: (...params: [any]) => getFromStore(...params, store), // TODO: make store zero-arg
-				find: ((token, k) => findInStore(token, k, store)) as typeof findState,
-				seek: ((token, k) => seekInStore(token, k, store)) as typeof seekState,
-				json: (token) => getJsonToken(token, store),
+				get: ((...ps: [any]) => getFromStore(store, ...ps)) as typeof getState,
+				find: ((token, k) => findInStore(store, token, k)) as typeof findState,
+				seek: ((token, k) => seekInStore(store, token, k)) as typeof seekState,
+				json: (token) => getJsonToken(store, token),
 			})
 		},
 	}) satisfies WritableSelectorFamily<T, K>

package/internal/src/families/dispose-from-store.ts

@@ -10,50 +10,47 @@ import { type Canonical, stringifyJson } from "atom.io/json"
 
 import { disposeAtom } from "../atom"
 import { disposeMolecule } from "../molecule/dispose-molecule"
-import { NotFoundError } from "../not-found-error"
 import { disposeSelector } from "../selector"
 import type { Store } from "../store"
 import { findInStore } from "./find-in-store"
 import { seekInStore } from "./seek-in-store"
 
 export function disposeFromStore(
-	token: MoleculeToken<any> | ReadableToken<any>,
 	store: Store,
+	token: MoleculeToken<any> | ReadableToken<any>,
 ): void
 
 export function disposeFromStore<K extends Canonical>(
+	store: Store,
 	token: ReadableFamilyToken<any, K>,
 	key: K,
-	store: Store,
 ): void
 
 export function disposeFromStore<M extends MoleculeConstructor>(
+	store: Store,
 	token: MoleculeFamilyToken<M>,
 	key: MoleculeKey<M>,
-	store: Store,
 ): void
 
 export function disposeFromStore(
+	store: Store,
 	...params:
-		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>, store: Store]
-		| [token: MoleculeToken<any> | ReadableToken<any>, store: Store]
-		| [token: ReadableFamilyToken<any, any>, key: Canonical, store: Store]
+		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>]
+		| [token: MoleculeToken<any> | ReadableToken<any>]
+		| [token: ReadableFamilyToken<any, any>, key: Canonical]
 ): void {
 	let token: MoleculeToken<any> | ReadableToken<any>
-	let store: Store
-	if (params.length === 2) {
+	if (params.length === 1) {
 		token = params[0]
-		store = params[1]
 	} else {
 		const family = params[0]
 		const key = params[1]
-		store = params[2]
 		const maybeToken =
 			family.type === `molecule_family`
-				? seekInStore(family, key, store)
+				? seekInStore(store, family, key)
 				: store.config.lifespan === `immortal`
-					? seekInStore(family, key, store)
-					: findInStore(family, key, store)
+					? seekInStore(store, family, key)
+					: findInStore(store, family, key)
 		if (!maybeToken) {
 			store.logger.error(
 				`❗`,

package/internal/src/families/find-in-store.ts

@@ -29,67 +29,67 @@ export function findInStore<
 	K extends Canonical,
 	Key extends K,
 >(
+	store: Store,
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
-	store: Store,
 ): MutableAtomToken<T, J>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): RegularAtomToken<T>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: AtomFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): AtomToken<T>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): WritableSelectorToken<T>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): ReadonlySelectorToken<T>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): SelectorToken<T>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): WritableToken<T>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): ReadableToken<T>
 
 export function findInStore(
+	store: Store,
 	token: ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
-	store: Store,
 ): ReadableToken<any> {
 	if (store.config.lifespan === `immortal`) {
 		throw new Error(
 			`Do not use \`find\` or \`findState\` in an immortal store. Prefer \`seek\` or \`seekState\`.`,
 		)
 	}
-	let state = seekInStore(token, key, store)
+	let state = seekInStore(store, token, key)
 	if (state) {
 		return state
 	}
-	state = initFamilyMemberInStore(token, key, store)
+	state = initFamilyMemberInStore(store, token, key)
 	return state
 }

package/internal/src/families/init-family-member.ts

@@ -30,57 +30,57 @@ export function initFamilyMemberInStore<
 	K extends Canonical,
 	Key extends K,
 >(
+	store: Store,
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
-	store: Store,
 ): MutableAtomToken<T, J>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): RegularAtomToken<T>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: AtomFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): AtomToken<T>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): WritableSelectorToken<T>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): ReadonlySelectorToken<T>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): SelectorToken<T>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): WritableToken<T>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): ReadableToken<T>
 
 export function initFamilyMemberInStore(
+	store: Store,
 	token: ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
-	store: Store,
 ): ReadableToken<any> {
 	const familyKey = token.key
 	const family = store.families.get(familyKey)

package/internal/src/families/seek-in-store.ts

@@ -34,63 +34,63 @@ export function seekInStore<
 	K extends Canonical,
 	Key extends K,
 >(
+	store: Store,
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
-	store: Store,
 ): MutableAtomToken<T, J> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): RegularAtomToken<T> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: AtomFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): AtomToken<T> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): WritableSelectorToken<T> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): ReadonlySelectorToken<T> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): SelectorToken<T> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): WritableToken<T> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-	store: Store,
 ): ReadableToken<T> | undefined
 
 export function seekInStore<M extends MoleculeConstructor>(
+	store: Store,
 	token: MoleculeFamilyToken<M>,
 	key: MoleculeKey<M>,
-	store: Store,
 ): MoleculeKey<M> | undefined
 
 export function seekInStore(
+	store: Store,
 	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
 	key: Canonical,
-	store: Store,
 ): MoleculeToken<any> | ReadableToken<any> | undefined {
 	const subKey = stringifyJson(key)
 	const fullKey = `${token.key}(${subKey})`

package/internal/src/get-state/get-from-store.ts

@@ -14,47 +14,61 @@ import type { Store } from "../store"
 import { withdraw } from "../store"
 import { readOrComputeValue } from "./read-or-compute-value"
 
-export function getFromStore<T>(token: ReadableToken<T>, store: Store): T
+export function getFromStore<T>(store: Store, token: ReadableToken<T>): T
 
 export function getFromStore<M extends MoleculeConstructor>(
-	token: MoleculeToken<M>,
 	store: Store,
-): InstanceType<M> | undefined
+	token: MoleculeToken<M>,
+): InstanceType<M>
 
 export function getFromStore<T, K extends Canonical>(
+	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: K,
-	store: Store,
 ): T
 
 export function getFromStore<M extends MoleculeConstructor>(
+	store: Store,
 	token: MoleculeFamilyToken<M>,
 	key: MoleculeKey<M>,
-	store: Store,
 ): InstanceType<M>
 
-export function getFromStore<T>(
+export function getFromStore(
+	store: Store,
+	token: MoleculeToken<any> | ReadableToken<any>,
+): any
+
+export function getFromStore(
+	store: Store,
+	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
+	key: Canonical,
+): any
+
+export function getFromStore(
+	store: Store,
 	...params:
-		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>, store: Store]
-		| [token: MoleculeToken<any>, store: Store]
-		| [token: ReadableFamilyToken<T, any>, key: Canonical, store: Store]
-		| [token: ReadableToken<T>, store: Store]
+		| [
+				token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
+				key: Canonical,
+		  ]
+		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>]
+		| [token: MoleculeToken<any> | ReadableToken<any>]
+		| [token: MoleculeToken<any>]
+		| [token: ReadableFamilyToken<any, any>, key: Canonical]
+		| [token: ReadableToken<any>]
 ): any {
-	let token: MoleculeToken<any> | ReadableToken<T>
-	let store: Store
-	if (params.length === 2) {
+	let token: MoleculeToken<any> | ReadableToken<any>
+	if (params.length === 1) {
 		token = params[0]
-		store = params[1]
 	} else {
 		const family = params[0]
 		const key = params[1]
-		store = params[2]
 		const maybeToken =
 			family.type === `molecule_family`
-				? seekInStore(family, key, store)
+				? seekInStore(store, family, key)
 				: store.config.lifespan === `immortal`
-					? seekInStore(family, key, store)
-					: findInStore(family, key, store)
+					? seekInStore(store, family, key)
+					: findInStore(store, family, key)
 		if (!maybeToken) {
 			store.logger.error(
 				`❗`,

package/internal/src/ingest-updates/ingest-atom-update.ts

@@ -14,5 +14,5 @@ export function ingestAtomUpdate(
 	if (atomUpdate.family) {
 		Object.assign(token, { family: atomUpdate.family })
 	}
-	setIntoStore(token, value, store)
+	setIntoStore(store, token, value)
 }

package/internal/src/ingest-updates/ingest-creation-disposal.ts

@@ -22,7 +22,7 @@ export function ingestCreationEvent(
 			break
 		}
 		case `oldValue`: {
-			disposeFromStore(update.token, store)
+			disposeFromStore(store, update.token)
 			break
 		}
 	}
@@ -35,7 +35,7 @@ export function ingestDisposalEvent(
 ): void {
 	switch (applying) {
 		case `newValue`: {
-			disposeFromStore(update.token, store)
+			disposeFromStore(store, update.token)
 			break
 		}
 		case `oldValue`: {
@@ -58,7 +58,7 @@ function createInStore(token: ReadableToken<any>, store: Store): void {
 			if (store.config.lifespan === `immortal`) {
 				throw new Error(`No molecule found for key "${token.family.subKey}"`)
 			}
-			initFamilyMemberInStore(family, parseJson(token.family.subKey), store)
+			initFamilyMemberInStore(store, family, parseJson(token.family.subKey))
 		}
 	}
 }
@@ -79,7 +79,7 @@ export function ingestMoleculeCreationEvent(
 			)
 			break
 		case `oldValue`:
-			disposeFromStore(update.token, store)
+			disposeFromStore(store, update.token)
 			break
 	}
 }
@@ -90,7 +90,7 @@ export function ingestMoleculeDisposalEvent(
 ): void {
 	switch (applying) {
 		case `newValue`:
-			disposeFromStore(update.token, store)
+			disposeFromStore(store, update.token)
 			break
 		case `oldValue`:
 			{

package/internal/src/molecule/create-molecule-family.ts

@@ -10,8 +10,8 @@ import type { Store } from "../store"
 import { Subject } from "../subject"
 
 export function createMoleculeFamily<M extends MoleculeConstructor>(
-	options: MoleculeFamilyOptions<M>,
 	store: Store,
+	options: MoleculeFamilyOptions<M>,
 ): MoleculeFamilyToken<M> {
 	const subject = new Subject<MoleculeCreation<M>>()
 

package/internal/src/molecule/dispose-molecule.ts

@@ -55,7 +55,7 @@ export function disposeMolecule<M extends MoleculeConstructor>(
 			disposalEvent.family = token.family
 		}
 		for (const state of molecule.tokens.values()) {
-			disposeFromStore(state, store)
+			disposeFromStore(store, state)
 		}
 		for (const child of molecule.below.values()) {
 			if (child.family?.dependsOn === `all`) {