atom.io 0.31.0 → 0.32.0

package/internal/dist/index.js

@@ -1,3 +1,2 @@
-export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-42UH5F5Q.js';
-import '../../dist/chunk-ICGFFQ3H.js';
+export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Join, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-GY2XQYZY.js';
 import '../../dist/chunk-XWL6SNVU.js';

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

@@ -59,8 +59,8 @@ export function createRegularAtom<T>(
 		initialValue = options.default()
 	}
 	target.atoms.set(newAtom.key, newAtom)
-	markAtomAsDefault(options.key, store)
-	cacheValue(options.key, initialValue, subject, target)
+	markAtomAsDefault(store, options.key)
+	cacheValue(target, options.key, initialValue, subject)
 	const token = deposit(newAtom)
 	if (options.effects) {
 		let effectIndex = 0
@@ -71,7 +71,7 @@ export function createRegularAtom<T>(
 					setIntoStore(store, token, next)
 				},
 				onSet: (handle: UpdateHandler<T>) =>
-					subscribeToState(token, handle, `effect[${effectIndex}]`, store),
+					subscribeToState(store, token, `effect[${effectIndex}]`, handle),
 			})
 			if (cleanup) {
 				cleanupFunctions.push(cleanup)

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

@@ -3,16 +3,16 @@ import type { AtomDisposal, AtomToken } from "atom.io"
 import type { Store } from ".."
 import { getUpdateToken, isChildStore, newest, withdraw } from ".."
 
-export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
+export function disposeAtom(store: Store, atomToken: AtomToken<unknown>): void {
 	const target = newest(store)
 	const { key, family } = atomToken
-	const atom = withdraw(atomToken, target)
+	const atom = withdraw(target, atomToken)
 	if (!family) {
 		store.logger.error(`❌`, `atom`, key, `Standalone atoms cannot be disposed.`)
 	} else {
 		atom.cleanup?.()
 		const lastValue = store.valueMap.get(atom.key)
-		const atomFamily = withdraw({ key: family.key, type: `atom_family` }, store)
+		const atomFamily = withdraw(store, { key: family.key, type: `atom_family` })
 
 		const disposal: AtomDisposal<AtomToken<unknown>> = {
 			type: `state_disposal`,
@@ -24,15 +24,6 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 		atomFamily.subject.next(disposal)
 
 		const isChild = isChildStore(target)
-		// let molecule = target.molecules.get(family.subKey)
-		// if (molecule && isChild) {
-		// 	const parentMolecule = target.parent.molecules.get(family.subKey)
-		// 	if (parentMolecule === molecule) {
-		// 		molecule = parentMolecule.copy()
-		// 		target.molecules.set(family.subKey, molecule)
-		// 	}
-		// }
-		// molecule?.tokens.delete(family.key)
 
 		target.atoms.delete(key)
 		target.valueMap.delete(key)
@@ -42,7 +33,7 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 
 		if (atomToken.type === `mutable_atom`) {
 			const updateToken = getUpdateToken(atomToken)
-			disposeAtom(updateToken, store)
+			disposeAtom(store, updateToken)
 			store.trackers.delete(key)
 		}
 		store.logger.info(`🔥`, `atom`, key, `deleted`)

package/internal/src/atom/is-default.ts

@@ -1,17 +1,17 @@
 import { newest } from "../lineage"
 import type { Store } from "../store"
 
-export const isAtomDefault = (key: string, store: Store): boolean => {
+export const isAtomDefault = (store: Store, key: string): boolean => {
 	const core = newest(store)
 	return core.atomsThatAreDefault.has(key)
 }
 
-export const markAtomAsDefault = (key: string, store: Store): void => {
+export const markAtomAsDefault = (store: Store, key: string): void => {
 	const core = newest(store)
 	core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key)
 }
 
-export const markAtomAsNotDefault = (key: string, store: Store): void => {
+export const markAtomAsNotDefault = (store: Store, key: string): void => {
 	const core = newest(store)
 	core.atomsThatAreDefault = new Set(newest(store).atomsThatAreDefault)
 	core.atomsThatAreDefault.delete(key)

package/internal/src/caching.ts

@@ -8,22 +8,22 @@ import type { Store } from "./store"
 import type { Subject } from "./subject"
 
 export function cacheValue<T>(
+	store: Store,
 	key: string,
 	value: T,
 	subject: Subject<StateUpdate<unknown>>,
-	store: Store,
 ): T
 export function cacheValue<T extends Promise<any>>(
+	store: Store,
 	key: string,
 	value: T,
 	subject: Subject<StateUpdate<unknown>>,
-	store: Store,
 ): Future<T>
 export function cacheValue<T>(
+	target: Store,
 	key: string,
 	value: T,
 	subject: Subject<StateUpdate<unknown>>,
-	target: Store,
 ): Future<T> | T {
 	const currentValue = target.valueMap.get(key)
 	if (currentValue instanceof Future) {
@@ -35,7 +35,7 @@ export function cacheValue<T>(
 		target.valueMap.set(key, future)
 		future
 			.then((resolved) => {
-				cacheValue(key, resolved, subject, target)
+				cacheValue(target, key, resolved, subject)
 				subject.next({ newValue: resolved, oldValue: future })
 			})
 			.catch((thrown) => {
@@ -54,7 +54,7 @@ export const readCachedValue = <T>(
 	let value = target.valueMap.get(token.key) as T
 	if (token.type === `mutable_atom` && isChildStore(target)) {
 		const { parent } = target
-		const copiedValue = copyMutableIfNeeded(token, parent, target)
+		const copiedValue = copyMutableIfNeeded(target, token, parent)
 		value = copiedValue
 	}
 	return value

package/internal/src/capitalize.ts

@@ -0,0 +1,3 @@
+export function capitalize<S extends string>(string: S): Capitalize<S> {
+	return (string[0].toUpperCase() + string.slice(1)) as Capitalize<S>
+}

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

@@ -1,5 +1,6 @@
 import type {
 	FamilyMetadata,
+	findState,
 	getState,
 	ReadonlySelectorFamilyOptions,
 	ReadonlySelectorFamilyToken,
@@ -7,8 +8,6 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
-import type { findState } from "atom.io/ephemeral"
-import type { seekState } from "atom.io/immortal"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
@@ -18,7 +17,6 @@ import {
 	getJsonToken,
 	prettyPrintTokenType,
 	type ReadonlySelectorFamily,
-	seekInStore,
 } from ".."
 import { newest } from "../lineage"
 import { createReadonlySelector } from "../selector"
@@ -78,9 +76,10 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 		default: (key: K) => {
 			const getFn = options.get(key)
 			return getFn({
-				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,
+				get: ((...args: Parameters<typeof getState>) =>
+					getFromStore(store, ...args)) as typeof getState,
+				find: ((...args: Parameters<typeof findState>) =>
+					findInStore(store, ...args)) as typeof findState,
 				json: (token) => getJsonToken(store, token),
 			})
 		},

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

@@ -1,5 +1,6 @@
 import type {
 	FamilyMetadata,
+	findState,
 	getState,
 	StateCreation,
 	StateDisposal,
@@ -7,8 +8,6 @@ import type {
 	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 } from "atom.io"
-import type { findState } from "atom.io/ephemeral"
-import type { seekState } from "atom.io/immortal"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
@@ -17,7 +16,6 @@ import {
 	getFromStore,
 	getJsonToken,
 	prettyPrintTokenType,
-	seekInStore,
 	type WritableSelectorFamily,
 } from ".."
 import { newest } from "../lineage"
@@ -80,7 +78,6 @@ export function createWritableSelectorFamily<T, K extends Canonical>(
 			return getFn({
 				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),
 			})
 		},

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

@@ -2,7 +2,6 @@ import type { ReadableFamilyToken, ReadableToken } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
 import { disposeAtom } from "../atom"
-import { getTrace } from "../get-trace"
 import { disposeSelector } from "../selector"
 import { type Store, withdraw } from "../store"
 import { findInStore } from "./find-in-store"
@@ -31,33 +30,24 @@ export function disposeFromStore(
 		token = maybeToken
 	}
 	try {
-		withdraw(token, store)
+		withdraw(store, token)
 	} catch (thrown) {
-		// const disposal = store.disposalTraces.buffer.find(
-		// 	(item) => item?.key === token.key,
-		// )
 		store.logger.error(
 			`❌`,
 			token.type,
 			token.key,
 			`could not be disposed because it was not found in the store "${store.config.name}".`,
-			// disposal
-			// 	? `\n   This state was most recently disposed\n${disposal.trace}`
-			// 	: `No previous disposal trace was found.`,
 		)
 		return
 	}
 	switch (token.type) {
 		case `atom`:
 		case `mutable_atom`:
-			disposeAtom(token, store)
+			disposeAtom(store, token)
 			break
 		case `selector`:
 		case `readonly_selector`:
-			disposeSelector(token, store)
+			disposeSelector(store, token)
 			break
 	}
-
-	// const trace = getTrace(new Error())
-	// store.disposalTraces.add({ key: token.key, trace })
 }

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

@@ -16,12 +16,7 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import {
-	type Canonical,
-	type Json,
-	stringified,
-	stringifyJson,
-} from "atom.io/json"
+import { type Canonical, type Json, stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"

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

@@ -55,12 +55,12 @@ export function getFromStore(
 				if (store.defaults.has(family.key)) {
 					return store.defaults.get(token.family.key)
 				}
-				const defaultValue = withdraw(family, store).default(subKey)
+				const defaultValue = withdraw(store, family).default(subKey)
 				store.defaults.set(family.key, defaultValue)
 				return defaultValue
 			}
 		}
 	}
 
-	return readOrComputeValue(withdraw(token, store), store)
+	return readOrComputeValue(store, withdraw(store, token))
 }

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

@@ -3,8 +3,8 @@ import { readCachedValue } from "../caching"
 import type { Store } from "../store"
 
 export const readOrComputeValue = <T>(
-	state: ReadableState<T>,
 	target: Store,
+	state: ReadableState<T>,
 ): T => {
 	if (target.valueMap.has(state.key)) {
 		target.logger.info(`📖`, state.type, state.key, `reading cached value`)

package/internal/src/index.ts

@@ -17,21 +17,25 @@ import type { Canonical, Json, JsonInterface } from "atom.io/json"
 import type { Transceiver } from "./mutable"
 import type { Store } from "./store"
 import type { Subject } from "./subject"
+import type { Timeline } from "./timeline"
+import type { Transaction } from "./transaction"
 
 export * from "./arbitrary"
 export * from "./atom"
 export * from "./caching"
+export * from "./capitalize"
 export * from "./families"
 export * from "./future"
 export * from "./get-environment-data"
 export * from "./get-state"
 export * from "./get-trace"
 export * from "./ingest-updates"
+export * from "./join"
 export * from "./junction"
 export * from "./keys"
 export * from "./lazy-map"
 export * from "./lineage"
-export type * from "./molecule"
+export * from "./molecule"
 export * from "./mutable"
 export * from "./not-found-error"
 export * from "./operation"
@@ -100,14 +104,14 @@ T extends Transceiver<any>,
 J extends Json.Serializable,
 K extends Canonical,
 > = 
-& JsonInterface<T, J>
-& MutableAtomFamilyToken<T, J, K>
-& {
-		(key: K): MutableAtomToken<T, J>
-		subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>
-		install: (store: Store) => void
-		internalRoles: string[] | undefined
-	}
+	& JsonInterface<T, J>
+	& MutableAtomFamilyToken<T, J, K>
+	& {
+			(key: K): MutableAtomToken<T, J>
+			subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>
+			install: (store: Store) => void
+			internalRoles: string[] | undefined
+		}
 
 export type AtomFamily<T, K extends Canonical = Canonical> =
 	| MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K>
@@ -145,3 +149,9 @@ export type WritableFamily<T, K extends Canonical> =
 export type ReadableFamily<T, K extends Canonical> =
 	| AtomFamily<T, K>
 	| SelectorFamily<T, K>
+
+export type AtomIOInternalResource =
+	| ReadableFamily<any, any>
+	| ReadableState<any>
+	| Timeline<any>
+	| Transaction<any>

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

@@ -8,13 +8,12 @@ import type {
 } from "atom.io"
 import { parseJson, stringifyJson } from "atom.io/json"
 
+import { disposeFromStore, findInStore } from "../families"
 import {
 	allocateIntoStore,
 	claimWithinStore,
 	deallocateFromStore,
-} from "~/packages/atom.io/src/allocate"
-
-import { disposeFromStore, findInStore } from "../families"
+} from "../molecule"
 import type { Store } from "../store"
 
 export function ingestCreationEvent(

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

@@ -0,0 +1,48 @@
+import type { AtomIOToken } from "atom.io"
+
+import { newest } from "./lineage"
+import { type Store, withdraw } from "./store"
+import { isChildStore } from "./transaction"
+
+/**
+ * @public
+ * Install the given tokens into the target store
+ * @param tokens - States, families, transactions, and timelines to install into the target store
+ * @param target - The store to install the tokens into
+ * @param source - The store to install the tokens from
+ *
+ */
+export function installIntoStore(
+	tokens: AtomIOToken[],
+	target: Store,
+	source: Store,
+): void {
+	const sourceNewest = newest(source)
+	if (isChildStore(sourceNewest)) {
+		source.logger.error(
+			`❌`,
+			`transaction`,
+			sourceNewest.transactionMeta.update.key,
+			`could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
+			tokens,
+			`${sourceNewest.config.name} is undergoing a transaction.`,
+		)
+		return
+	}
+	const targetNewest = newest(target)
+	if (isChildStore(targetNewest)) {
+		target.logger.error(
+			`❌`,
+			`transaction`,
+			targetNewest.transactionMeta.update.key,
+			`could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
+			tokens,
+			`${targetNewest.config.name} is undergoing a transaction.`,
+		)
+		return
+	}
+	for (const token of tokens) {
+		const resource = withdraw(source, token)
+		resource.install(target)
+	}
+}

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

@@ -0,0 +1,32 @@
+import type { JoinToken } from "atom.io"
+import type { Json } from "atom.io/json"
+
+import type { Junction } from "../junction"
+import { newest } from "../lineage"
+import type { Store } from "../store"
+import { isChildStore } from "../transaction"
+import { getJoin } from "./get-join"
+
+export function editRelationsInStore<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null,
+>(
+	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
+	change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void,
+	store: Store,
+): void {
+	const myJoin = getJoin(token, store)
+	const target = newest(store)
+	if (isChildStore(target)) {
+		const { toolkit } = target.transactionMeta
+		myJoin.transact(toolkit, ({ relations }) => {
+			change(relations)
+		})
+	} else {
+		change(myJoin.relations)
+	}
+}

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

@@ -0,0 +1,124 @@
+import type { JoinStates, JoinToken } from "atom.io"
+import type { Json } from "atom.io/json"
+
+import { capitalize } from "../capitalize"
+import { findInStore } from "../families"
+import type { Store } from "../store"
+import { getJoin } from "./get-join"
+
+export function findRelationsInStore<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null,
+>(
+	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
+	key: AType | BType,
+	store: Store,
+): JoinStates<ASide, AType, BSide, BType, Cardinality, Content> {
+	const myJoin = getJoin(token, store)
+	let relations: JoinStates<ASide, AType, BSide, BType, Cardinality, Content>
+	switch (token.cardinality satisfies `1:1` | `1:n` | `n:n`) {
+		case `1:1`: {
+			const keyAB = `${token.a}KeyOf${capitalize(token.b)}`
+			const keyBA = `${token.b}KeyOf${capitalize(token.a)}`
+			relations = {
+				get [keyAB]() {
+					const familyAB = myJoin.states[keyAB as any]
+					const state = findInStore(store, familyAB, key)
+					return state
+				},
+				get [keyBA]() {
+					const familyBA = myJoin.states[keyBA as any]
+					const state = findInStore(store, familyBA, key)
+					return state
+				},
+			} as JoinStates<ASide, AType, BSide, BType, Cardinality, Content>
+			const entryAB = `${token.a}EntryOf${capitalize(token.b)}`
+			if (entryAB in myJoin.states) {
+				const entryBA = `${token.b}EntryOf${capitalize(token.a)}`
+				Object.assign(relations, {
+					get [entryAB]() {
+						const familyAB = myJoin.states[entryAB as any]
+						const state = findInStore(store, familyAB, key)
+						return state
+					},
+					get [entryBA]() {
+						const familyBA = myJoin.states[entryBA as any]
+						const state = findInStore(store, familyBA, key)
+						return state
+					},
+				})
+			}
+			break
+		}
+		case `1:n`: {
+			const keyAB = `${token.a}KeyOf${capitalize(token.b)}`
+			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`
+			relations = {
+				get [keyAB]() {
+					const familyAB = myJoin.states[keyAB as any]
+					const state = findInStore(store, familyAB, key)
+					return state
+				},
+				get [keysBA]() {
+					const familyBA = myJoin.states[keysBA as any]
+					const state = findInStore(store, familyBA, key)
+					return state
+				},
+			} as JoinStates<ASide, AType, BSide, BType, Cardinality, Content>
+			const entryAB = `${token.a}EntryOf${capitalize(token.b)}`
+			if (entryAB in myJoin.states) {
+				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`
+				Object.assign(relations, {
+					get [entryAB]() {
+						const familyAB = myJoin.states[entryAB as any]
+						const state = findInStore(store, familyAB, key)
+						return state
+					},
+					get [entriesBA]() {
+						const familyBA = myJoin.states[entriesBA as any]
+						const state = findInStore(store, familyBA, key)
+						return state
+					},
+				})
+			}
+			break
+		}
+		case `n:n`: {
+			const keysAB = `${token.a}KeysOf${capitalize(token.b)}`
+			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`
+			relations = {
+				get [keysAB]() {
+					const familyAB = myJoin.states[keysAB as any]
+					const state = findInStore(store, familyAB, key)
+					return state
+				},
+				get [keysBA]() {
+					const familyBA = myJoin.states[keysBA as any]
+					const state = findInStore(store, familyBA, key)
+					return state
+				},
+			} as JoinStates<ASide, AType, BSide, BType, Cardinality, Content>
+			const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`
+			if (entriesAB in myJoin.states) {
+				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`
+				Object.assign(relations, {
+					get [entriesAB]() {
+						const familyAB = myJoin.states[entriesAB as any]
+						const state = findInStore(store, familyAB, key)
+						return state
+					},
+					get [entriesBA]() {
+						const familyBA = myJoin.states[entriesBA as any]
+						const state = findInStore(store, familyBA, key)
+						return state
+					},
+				})
+			}
+		}
+	}
+	return relations
+}

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

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

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

@@ -0,0 +1,31 @@
+import type { JoinToken } from "atom.io"
+import type { Json } from "atom.io/json"
+
+import { IMPLICIT, type Store } from "../store"
+import { Join } from "./join-internal"
+
+export function getJoin<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null,
+>(
+	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
+	store: Store,
+): Join<ASide, AType, BSide, BType, Cardinality, Content> {
+	let myJoin = store.joins.get(token.key)
+	if (myJoin === undefined) {
+		const rootJoinMap = IMPLICIT.STORE.joins
+		const rootJoin = rootJoinMap.get(token.key)
+		if (rootJoin === undefined) {
+			throw new Error(
+				`Join "${token.key}" not found in store "${store.config.name}"`,
+			)
+		}
+		myJoin = new Join(rootJoin.options, rootJoin.defaultContent, store)
+		store.joins.set(token.key, myJoin)
+	}
+	return myJoin
+}

package/internal/src/join/index.ts

@@ -0,0 +1,5 @@
+export * from "./edit-relations-in-store"
+export * from "./find-relations-in-store"
+export * from "./get-internal-relations-from-store"
+export * from "./get-join"
+export * from "./join-internal"