atom.io 0.40.0 → 0.40.2

package/src/internal/get-state/read-or-compute-value.ts

@@ -5,21 +5,21 @@ import { readFromCache, writeToCache } from "../caching"
 import { isFn } from "../is-fn"
 import type { Store } from "../store"
 
-export function readOrComputeValue<T>(
+export function readOrComputeValue<T, E>(
 	target: Store,
-	state: ReadableState<T>,
+	state: ReadableState<T, E>,
 	mut?: undefined,
-): ViewOf<T>
-export function readOrComputeValue<T>(
+): ViewOf<E | T>
+export function readOrComputeValue<T, E>(
 	target: Store,
-	state: ReadableState<T>,
+	state: ReadableState<T, E>,
 	mut: `mut`,
-): T
-export function readOrComputeValue<T>(
+): E | T
+export function readOrComputeValue<T, E>(
 	target: Store,
-	state: ReadableState<T>,
+	state: ReadableState<T, E>,
 	mut: `mut` | undefined,
-): T {
+): E | T {
 	if (target.valueMap.has(state.key)) {
 		return readFromCache(target, state, mut)
 	}
@@ -27,16 +27,80 @@ export function readOrComputeValue<T>(
 	const { key } = state
 	switch (state.type) {
 		case `readonly_held_selector`:
-		case `readonly_pure_selector`:
 		case `writable_held_selector`:
-		case `writable_pure_selector`:
 			target.logger.info(`🧮`, state.type, key, `computing value`)
 			return state.getFrom(target)
+		case `readonly_pure_selector`:
+		case `writable_pure_selector`: {
+			let val: E | T
+			target.logger.info(`🧮`, state.type, key, `computing value`)
+			try {
+				val = state.getFrom(target)
+				if (val instanceof Promise) {
+					return (val as Promise<E & T>).catch((e) => {
+						target.logger.error(`💥`, state.type, key, `rejected:`, e)
+						if (state.catch) {
+							for (const Class of state.catch) {
+								if (e instanceof Class) {
+									return writeToCache(target, state, e)
+								}
+							}
+						}
+						throw e
+					}) as E | T
+				}
+			} catch (e) {
+				target.logger.error(`💥`, state.type, key, `rejected:`, e)
+				if (state.catch) {
+					for (const Class of state.catch) {
+						if (e instanceof Class) {
+							return writeToCache(target, state, e)
+						}
+					}
+				}
+				throw e
+			}
+			const cachedValue = writeToCache(target, state, val)
+			return cachedValue
+		}
 		case `atom`: {
-			let def: T
+			let def: E | T
 			if (isFn(state.default)) {
-				def = state.default()
-				target.logger.info(`✨`, state.type, key, `computed default`, def)
+				try {
+					def = state.default()
+					if (def instanceof Promise) {
+						def = (def as Promise<T> & T).catch<E | T>((e) => {
+							target.logger.error(`💥`, state.type, key, `rejected:`, e)
+							if (state.catch) {
+								for (const Class of state.catch) {
+									if (e instanceof Class) {
+										def = writeToCache(target, state, e)
+										return def
+									}
+								}
+							}
+							throw e
+						}) as E | T
+					}
+				} catch (e) {
+					target.logger.error(`💥`, state.type, key, `rejected:`, e)
+					if (state.catch) {
+						for (const Class of state.catch) {
+							if (e instanceof Class) {
+								def = writeToCache(target, state, e)
+								target.logger.info(
+									`✨`,
+									state.type,
+									key,
+									`computed default`,
+									def,
+								)
+								return def
+							}
+						}
+					}
+					throw e
+				}
 			} else {
 				def = state.default
 				target.logger.info(`✨`, state.type, key, `using static default`, def)

package/src/internal/get-state/reduce-reference.ts

@@ -13,27 +13,27 @@ import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 
-export function reduceReference<T, K extends Canonical>(
+export function reduceReference<T, K extends Canonical, E>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<T, K>, key: K]
-		| [token: ReadableToken<T>]
+		| [token: ReadableFamilyToken<T, K, E>, key: K]
+		| [token: ReadableToken<T, K, E>]
 ): {
-	token: ReadableToken<T, K>
-	family: ReadableFamily<T, K> | undefined
+	token: ReadableToken<T, K, E>
+	family: ReadableFamily<T, K, E> | undefined
 	subKey: K | undefined
 	isNew: boolean
 } {
-	let existingToken: ReadableToken<T> | undefined
-	let brandNewToken: ReadableToken<T> | undefined
-	let family: ReadableFamily<T, K> | undefined
+	let existingToken: ReadableToken<T, K, E> | undefined
+	let brandNewToken: ReadableToken<T, K, E> | undefined
+	let family: ReadableFamily<T, K, E> | undefined
 	let subKey: K | undefined
-	let token: ReadableToken<T, K>
+	let token: ReadableToken<T, K, E>
 	if (params.length === 1) {
 		token = params[0]
 		if (`family` in token) {
 			const familyToken = getFamilyOfToken(store, token)
-			family = withdraw(store, familyToken) as ReadableFamily<T, K>
+			family = withdraw(store, familyToken) as ReadableFamily<T, K, E>
 			subKey = parseJson(token.family.subKey)
 			existingToken = seekInStore(store, familyToken, subKey)
 			if (`counterfeit` in token) {

package/src/internal/index.ts

@@ -22,7 +22,7 @@ import type { ConstructorOf, Transceiver } from "./mutable"
 import type { Store } from "./store"
 import type { Subject } from "./subject"
 import type { Timeline } from "./timeline"
-import type { Transaction } from "./transaction"
+import type { RootStore, Transaction } from "./transaction"
 import type { Flat } from "./utility-types"
 
 export * from "./arbitrary"
@@ -58,15 +58,16 @@ export type * from "./utility-types"
 export type AtomIOState = {
 	key: string
 	family?: FamilyMetadata
-	install: (store: Store) => void
+	install: (store: RootStore) => void
 	subject: Subject<StateUpdate<any>>
 }
-export type RegularAtom<T> = Flat<
+export type RegularAtom<T, E> = Flat<
 	AtomIOState & {
 		type: `atom`
 		default: T | (() => T)
 		cleanup?: () => void
 		internalRoles?: internalRole[]
+		catch?: readonly (new () => E)[]
 	}
 >
 export type MutableAtom<T extends Transceiver<any, any, any>> = Flat<
@@ -76,8 +77,8 @@ export type MutableAtom<T extends Transceiver<any, any, any>> = Flat<
 		cleanup?: () => void
 	}
 >
-export type Atom<T> =
-	| RegularAtom<T>
+export type Atom<T, E> =
+	| RegularAtom<T, E>
 	| (T extends Transceiver<any, any, any> ? MutableAtom<T> : never)
 
 export type WritableHeldSelector<T> = Flat<
@@ -95,48 +96,52 @@ export type ReadonlyHeldSelector<T> = Flat<
 		getFrom: (target: Store) => T
 	}
 >
-export type WritablePureSelector<T> = Flat<
+export type WritablePureSelector<T, E> = Flat<
 	AtomIOState & {
 		type: `writable_pure_selector`
-		getFrom: (target: Store) => T
+		getFrom: (target: Store) => E | T
 		setSelf: (newValue: T) => void
+		catch?: readonly (new () => E)[]
 	}
 >
-export type ReadonlyPureSelector<T> = Flat<
+export type ReadonlyPureSelector<T, E> = Flat<
 	AtomIOState & {
 		type: `readonly_pure_selector`
-		getFrom: (target: Store) => T
+		getFrom: (target: Store) => E | T
+		catch?: readonly (new () => E)[]
 	}
 >
-export type ReadonlySelector<T> =
+export type ReadonlySelector<T, E> =
 	| ReadonlyHeldSelector<T>
-	| ReadonlyPureSelector<T>
-export type WritableSelector<T> =
+	| ReadonlyPureSelector<T, E>
+export type WritableSelector<T, E> =
 	| WritableHeldSelector<T>
-	| WritablePureSelector<T>
+	| WritablePureSelector<T, E>
 export type HeldSelector<T> = ReadonlyHeldSelector<T> | WritableHeldSelector<T>
-export type PureSelector<T> = ReadonlyPureSelector<T> | WritablePureSelector<T>
-export type Selector<T> =
+export type PureSelector<T, E> =
+	| ReadonlyPureSelector<T, E>
+	| WritablePureSelector<T, E>
+export type Selector<T, E> =
 	| ReadonlyHeldSelector<T>
-	| ReadonlyPureSelector<T>
+	| ReadonlyPureSelector<T, E>
 	| WritableHeldSelector<T>
-	| WritablePureSelector<T>
+	| WritablePureSelector<T, E>
 
-export type WritableState<T> = Atom<T> | WritableSelector<T>
-export type ReadableState<T> = Atom<T> | Selector<T>
+export type WritableState<T, E> = Atom<T, E> | WritableSelector<T, E>
+export type ReadableState<T, E> = Atom<T, E> | Selector<T, E>
 
 // biome-ignore format: intersection
-export type RegularAtomFamily<T, K extends Canonical> =
+export type RegularAtomFamily<T, K extends Canonical, E = never> =
 	& Flat<
-		& RegularAtomFamilyToken<T, K>
+		& RegularAtomFamilyToken<T, K, E>
 		& {
 			default: T | ((key: K) => T)
-			install: (store: Store) => void
+			install: (store: RootStore) => void
 			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<RegularAtomToken<T>>>
+			subject: Subject<StateLifecycleEvent<RegularAtomToken<T, K, E>>>
 		}
 	>
-	& ((key: K) => RegularAtomToken<T>)
+	& (<Key extends K>(key: Key) => RegularAtomToken<T, Key, E>)
 
 // biome-ignore format: intersection
 export type MutableAtomFamily<
@@ -147,29 +152,29 @@ export type MutableAtomFamily<
 		& MutableAtomFamilyToken<T, K>
 		& {
 				class: ConstructorOf<T>
-				install: (store: Store) => void
+				install: (store: RootStore) => void
 				internalRoles: string[] | undefined
 				subject: Subject<StateLifecycleEvent<MutableAtomToken<T>>>
 			}
 	>
-	& ((key: K) => MutableAtomToken<T>)
+	& (<Key extends K>(key: Key) => MutableAtomToken<T, Key>)
 
-export type AtomFamily<T, K extends Canonical = Canonical> =
+export type AtomFamily<T, K extends Canonical, E> =
 	| MutableAtomFamily<T extends Transceiver<any, any, any> ? T : never, K>
-	| RegularAtomFamily<T, K>
+	| RegularAtomFamily<T, K, E>
 
 // biome-ignore format: intersection
-export type WritablePureSelectorFamily<T, K extends Canonical> =
+export type WritablePureSelectorFamily<T, K extends Canonical, E> =
 	& Flat<
-		& WritablePureSelectorFamilyToken<T, K>
+		& WritablePureSelectorFamilyToken<T, K, E>
 		& {
 			default: (key: K) => T,
-			install: (store: Store) => void
+			install: (store: RootStore) => void
 			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<WritablePureSelectorToken<T>>>
+			subject: Subject<StateLifecycleEvent<WritablePureSelectorToken<T, K, E>>>
 		}
 	>
-	& ((key: K) => WritablePureSelectorToken<T>)
+	& (<Key extends K>(key: Key) => WritablePureSelectorToken<T, Key, E>)
 
 // biome-ignore format: intersection
 export type WritableHeldSelectorFamily<T , K extends Canonical> =
@@ -177,25 +182,25 @@ export type WritableHeldSelectorFamily<T , K extends Canonical> =
 		& WritableHeldSelectorFamilyToken<T, K>
 		& {
 			default: (key: K) => T,
-			install: (store: Store) => void
+			install: (store: RootStore) => void
 			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<WritableHeldSelectorToken<T>>>
+			subject: Subject<StateLifecycleEvent<WritableHeldSelectorToken<T, K>>>
 		}
 	>
-	& ((key: K) => WritableHeldSelectorToken<T>)
+	& (<Key extends K>(key: Key) => WritableHeldSelectorToken<T, Key>)
 
 // biome-ignore format: intersection
-export type ReadonlyPureSelectorFamily<T, K extends Canonical> =
+export type ReadonlyPureSelectorFamily<T, K extends Canonical, E> =
 	& Flat<
-		& ReadonlyPureSelectorFamilyToken<T, K>
+		& ReadonlyPureSelectorFamilyToken<T, K, E>
 		& {
 			default: (key: K) => T,
-			install: (store: Store) => void
+			install: (store: RootStore) => void
 			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<ReadonlyPureSelectorToken<T>>>
+			subject: Subject<StateLifecycleEvent<ReadonlyPureSelectorToken<T, K, E>>>
 		}
 	>
-	& ((key: K) => ReadonlyPureSelectorToken<T>)
+	& (<Key extends K>(key: Key) => ReadonlyPureSelectorToken<T, Key, E>)
 
 // biome-ignore format: intersection
 export type ReadonlyHeldSelectorFamily<T , K extends Canonical> =
@@ -203,42 +208,42 @@ export type ReadonlyHeldSelectorFamily<T , K extends Canonical> =
 		& ReadonlyHeldSelectorFamilyToken<T, K>
 		& {
 			default: (key: K) => T,
-			install: (store: Store) => void
+			install: (store: RootStore) => void
 			internalRoles: string[] | undefined
 			subject: Subject<StateLifecycleEvent<ReadonlyHeldSelectorToken<T>>>
 		}
 	>
-	& ((key: K) => ReadonlyHeldSelectorToken<T>)
+	& (<Key extends K>(key: Key) => ReadonlyHeldSelectorToken<T, Key>)
 
-export type PureSelectorFamily<T, K extends Canonical> =
-	| ReadonlyPureSelectorFamily<T, K>
-	| WritablePureSelectorFamily<T, K>
+export type PureSelectorFamily<T, K extends Canonical, E> =
+	| ReadonlyPureSelectorFamily<T, K, E>
+	| WritablePureSelectorFamily<T, K, E>
 
 export type HeldSelectorFamily<T, K extends Canonical> =
 	| ReadonlyHeldSelectorFamily<T, K>
 	| WritableHeldSelectorFamily<T, K>
 
-export type ReadonlySelectorFamily<T, K extends Canonical> =
+export type ReadonlySelectorFamily<T, K extends Canonical, E> =
 	| ReadonlyHeldSelectorFamily<T, K>
-	| ReadonlyPureSelectorFamily<T, K>
+	| ReadonlyPureSelectorFamily<T, K, E>
 
-export type WritableSelectorFamily<T, K extends Canonical> =
+export type WritableSelectorFamily<T, K extends Canonical, E> =
 	| WritableHeldSelectorFamily<T, K>
-	| WritablePureSelectorFamily<T, K>
+	| WritablePureSelectorFamily<T, K, E>
 
-export type SelectorFamily<T, K extends Canonical> =
+export type SelectorFamily<T, K extends Canonical, E> =
 	| HeldSelectorFamily<T, K>
-	| PureSelectorFamily<T, K>
+	| PureSelectorFamily<T, K, E>
 
-export type WritableFamily<T, K extends Canonical> =
-	| AtomFamily<T, K>
-	| WritablePureSelectorFamily<T, K>
-export type ReadableFamily<T, K extends Canonical> =
-	| AtomFamily<T, K>
-	| SelectorFamily<T, K>
+export type WritableFamily<T, K extends Canonical, E> =
+	| AtomFamily<T, K, E>
+	| WritableSelectorFamily<T, K, E>
+export type ReadableFamily<T, K extends Canonical, E> =
+	| AtomFamily<T, K, E>
+	| SelectorFamily<T, K, E>
 
 export type AtomIOInternalResource =
-	| ReadableFamily<any, any>
-	| ReadableState<any>
+	| ReadableFamily<any, any, any>
+	| ReadableState<any, any>
 	| Timeline<any>
 	| Transaction<any>

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
 
@@ -200,7 +199,8 @@ export class Join<
 		this.core = { relatedKeysAtoms }
 		const getRelatedKeys: Read<
 			(key: string) => SetRTX<AType> | SetRTX<BType>
-		> = ({ get }, key) => get(relatedKeysAtoms, key) as any
+		> = ({ get }, key) =>
+			get(relatedKeysAtoms, key) as SetRTX<AType> | SetRTX<BType>
 		const addRelation: Write<(a: string, b: string) => void> = (
 			{ set },
 			a,
@@ -225,6 +225,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 +270,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 +313,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) => {
@@ -335,7 +332,7 @@ export class Join<
 		let contentAtoms: RegularAtomFamilyToken<Content, string>
 
 		if (defaultContent) {
-			contentAtoms = createRegularAtomFamily<Content, ContentKey>(
+			contentAtoms = createRegularAtomFamily<Content, ContentKey, never>(
 				store,
 				{
 					key: `${options.key}/content`,
@@ -364,9 +361,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 +379,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 +389,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)
@@ -403,7 +399,7 @@ export class Join<
 		)
 
 		const createSingleKeySelectorFamily = () =>
-			createReadonlyPureSelectorFamily<string | null, string>(
+			createReadonlyPureSelectorFamily<string | null, string, never>(
 				store,
 				{
 					key: `${options.key}/singleRelatedKey`,
@@ -420,7 +416,7 @@ export class Join<
 				[`join`, `keys`],
 			)
 		const getMultipleKeySelectorFamily = () => {
-			return createReadonlyPureSelectorFamily<string[], string>(
+			return createReadonlyPureSelectorFamily<string[], string, never>(
 				store,
 				{
 					key: `${options.key}/multipleRelatedKeys`,
@@ -436,7 +432,11 @@ export class Join<
 			)
 		}
 		const createSingleEntrySelectorFamily = () =>
-			createReadonlyPureSelectorFamily<[string, ViewOf<Content>] | null, string>(
+			createReadonlyPureSelectorFamily<
+				[string, ViewOf<Content>] | null,
+				string,
+				never
+			>(
 				store,
 				{
 					key: `${options.key}/singleRelatedEntry`,
@@ -459,7 +459,11 @@ export class Join<
 				[`join`, `entries`],
 			)
 		const getMultipleEntrySelectorFamily = () =>
-			createReadonlyPureSelectorFamily<[string, ViewOf<Content>][], string>(
+			createReadonlyPureSelectorFamily<
+				[string, ViewOf<Content>][],
+				string,
+				never
+			>(
 				store,
 				{
 					key: `${options.key}/multipleRelatedEntries`,