atom.io 0.33.1 → 0.33.3

package/src/internal/store/withdraw.ts

@@ -2,10 +2,18 @@ import type {
 	AtomFamilyToken,
 	AtomIOToken,
 	AtomToken,
+	HeldSelectorFamilyToken,
+	HeldSelectorToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
+	PureSelectorFamilyToken,
+	PureSelectorToken,
 	ReadableFamilyToken,
 	ReadableToken,
+	ReadonlyHeldSelectorFamilyToken,
+	ReadonlyHeldSelectorToken,
+	ReadonlyPureSelectorFamilyToken,
+	ReadonlyPureSelectorToken,
 	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
 	RegularAtomFamilyToken,
@@ -16,6 +24,10 @@ import type {
 	TimelineToken,
 	TransactionToken,
 	WritableFamilyToken,
+	WritableHeldSelectorFamilyToken,
+	WritableHeldSelectorToken,
+	WritablePureSelectorFamilyToken,
+	WritablePureSelectorToken,
 	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
@@ -27,10 +39,18 @@ import type {
 	AtomFamily,
 	AtomIOInternalResource,
 	Func,
+	HeldSelector,
+	HeldSelectorFamily,
 	MutableAtom,
 	MutableAtomFamily,
+	PureSelector,
+	PureSelectorFamily,
 	ReadableFamily,
 	ReadableState,
+	ReadonlyHeldSelector,
+	ReadonlyHeldSelectorFamily,
+	ReadonlyPureSelector,
+	ReadonlyPureSelectorFamily,
 	ReadonlySelector,
 	ReadonlySelectorFamily,
 	RegularAtom,
@@ -39,6 +59,10 @@ import type {
 	SelectorFamily,
 	Transceiver,
 	WritableFamily,
+	WritableHeldSelector,
+	WritableHeldSelectorFamily,
+	WritablePureSelector,
+	WritablePureSelectorFamily,
 	WritableSelector,
 	WritableSelectorFamily,
 	WritableState,
@@ -59,12 +83,36 @@ export function withdraw<T extends Transceiver<any>>(
 export function withdraw<T>(store: Store, token: AtomToken<T>): Atom<T>
 export function withdraw<T>(
 	store: Store,
-	token: WritableSelectorToken<T>,
-): WritableSelector<T>
+	token: WritableHeldSelectorToken<T>,
+): WritableHeldSelector<T>
+export function withdraw<T>(
+	store: Store,
+	token: ReadonlyHeldSelectorToken<T>,
+): ReadonlyHeldSelector<T>
+export function withdraw<T>(
+	store: Store,
+	token: WritablePureSelectorToken<T>,
+): WritablePureSelector<T>
+export function withdraw<T>(
+	store: Store,
+	token: ReadonlyPureSelectorToken<T>,
+): ReadonlyPureSelector<T>
 export function withdraw<T>(
 	store: Store,
 	token: ReadonlySelectorToken<T>,
 ): ReadonlySelector<T>
+export function withdraw<T>(
+	store: Store,
+	token: WritableSelectorToken<T>,
+): WritableSelector<T>
+export function withdraw<T>(
+	store: Store,
+	token: HeldSelectorToken<T>,
+): HeldSelector<T>
+export function withdraw<T>(
+	store: Store,
+	token: PureSelectorToken<T>,
+): PureSelector<T>
 export function withdraw<T>(store: Store, token: SelectorToken<T>): Selector<T>
 export function withdraw<T>(
 	store: Store,
@@ -91,6 +139,22 @@ export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: AtomFamilyToken<T>,
 ): AtomFamily<T, any>
+export function withdraw<T, K extends Canonical>(
+	store: Store,
+	token: ReadonlyHeldSelectorFamilyToken<T, K>,
+): ReadonlyHeldSelectorFamily<T, any>
+export function withdraw<T, K extends Canonical>(
+	store: Store,
+	token: WritableHeldSelectorFamilyToken<T, K>,
+): WritableHeldSelectorFamily<T, any>
+export function withdraw<T, K extends Canonical>(
+	store: Store,
+	token: ReadonlyPureSelectorFamilyToken<T, K>,
+): ReadonlyPureSelectorFamily<T, any>
+export function withdraw<T, K extends Canonical>(
+	store: Store,
+	token: WritablePureSelectorFamilyToken<T, K>,
+): WritablePureSelectorFamily<T, any>
 export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: ReadonlySelectorFamilyToken<T, K>,
@@ -99,6 +163,14 @@ export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: WritableSelectorFamilyToken<T, K>,
 ): WritableSelectorFamily<T, any>
+export function withdraw<T, K extends Canonical>(
+	store: Store,
+	token: HeldSelectorFamilyToken<T, K>,
+): HeldSelectorFamily<T, any>
+export function withdraw<T, K extends Canonical>(
+	store: Store,
+	token: PureSelectorFamilyToken<T, K>,
+): PureSelectorFamily<T, any>
 export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: SelectorFamilyToken<T, K>,
@@ -147,16 +219,20 @@ export function withdraw(
 			case `mutable_atom`:
 				withdrawn = target.atoms.get(token.key)
 				break
-			case `selector`:
-				withdrawn = target.selectors.get(token.key)
+			case `writable_pure_selector`:
+			case `writable_held_selector`:
+				withdrawn = target.writableSelectors.get(token.key)
 				break
-			case `readonly_selector`:
+			case `readonly_pure_selector`:
+			case `readonly_held_selector`:
 				withdrawn = target.readonlySelectors.get(token.key)
 				break
 			case `atom_family`:
 			case `mutable_atom_family`:
-			case `selector_family`:
-			case `readonly_selector_family`:
+			case `writable_pure_selector_family`:
+			case `readonly_pure_selector_family`:
+			case `writable_held_selector_family`:
+			case `readonly_held_selector_family`:
 				withdrawn = target.families.get(token.key)
 				break
 			case `timeline`:

package/src/internal/subscribe/subscribe-in-store.ts

@@ -51,8 +51,10 @@ export function subscribeInStore(
 	switch (token.type) {
 		case `atom`:
 		case `mutable_atom`:
-		case `readonly_selector`:
-		case `selector`:
+		case `readonly_pure_selector`:
+		case `readonly_held_selector`:
+		case `writable_pure_selector`:
+		case `writable_held_selector`:
 			return subscribeToState(store, token, key, handleUpdate)
 		case `transaction`:
 			return subscribeToTransaction(store, token, key, handleUpdate)

package/src/internal/subscribe/subscribe-to-state.ts

@@ -26,7 +26,8 @@ export function subscribeToState<T>(
 	const state = withdraw(store, token)
 	store.logger.info(`👀`, state.type, state.key, `Adding subscription "${key}"`)
 	const isSelector =
-		state.type === `selector` || state.type === `readonly_selector`
+		state.type === `writable_pure_selector` ||
+		state.type === `readonly_pure_selector`
 	let dependencyUnsubFunctions: (() => void)[] | null = null
 	let updateHandler: UpdateHandler<T> = safelyHandleUpdate
 	if (isSelector) {

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

@@ -188,11 +188,13 @@ function addAtomToTimeline(
 			function timelineCapturesAtomUpdate(update) {
 				const target = newest(store)
 				const currentSelectorKey =
-					store.operation.open && store.operation.token.type === `selector`
+					store.operation.open &&
+					store.operation.token.type === `writable_pure_selector`
 						? store.operation.token.key
 						: null
 				const currentSelectorTime =
-					store.operation.open && store.operation.token.type === `selector`
+					store.operation.open &&
+					store.operation.token.type === `writable_pure_selector`
 						? store.operation.time
 						: null
 

package/src/internal/transaction/build-transaction.ts

@@ -43,7 +43,7 @@ export const buildTransaction = (
 		selectorGraph: new Junction(parent.selectorGraph.toJSON(), {
 			makeContentKey: (...keys) => keys.sort().join(`:`),
 		}),
-		selectors: new LazyMap(parent.selectors),
+		writableSelectors: new LazyMap(parent.writableSelectors),
 		valueMap: new LazyMap(parent.valueMap),
 		defaults: parent.defaults,
 		disposalTraces: store.disposalTraces.copy(),

package/src/introspection/attach-atom-index.ts

@@ -1,4 +1,4 @@
-import type { AtomToken, ReadonlySelectorToken } from "atom.io"
+import type { AtomToken, ReadonlyPureSelectorToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	createRegularAtom,
@@ -13,7 +13,7 @@ export type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>
 
 export const attachAtomIndex = (
 	store: Store,
-): ReadonlySelectorToken<AtomTokenIndex> => {
+): ReadonlyPureSelectorToken<AtomTokenIndex> => {
 	const atomTokenIndexState__INTERNAL = createRegularAtom<AtomTokenIndex>(
 		store,
 		{

package/src/introspection/attach-introspection-states.ts

@@ -1,6 +1,6 @@
 import type {
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
+	ReadonlyPureSelectorFamilyToken,
+	ReadonlyPureSelectorToken,
 	TimelineToken,
 	TransactionToken,
 	TransactionUpdate,
@@ -17,16 +17,16 @@ import { attachTransactionLogs } from "./attach-transaction-logs"
 import { attachTypeSelectors } from "./attach-type-selectors"
 
 export type IntrospectionStates = {
-	atomIndex: ReadonlySelectorToken<AtomTokenIndex>
-	selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>
-	transactionIndex: ReadonlySelectorToken<TransactionToken<Func>[]>
-	transactionLogSelectors: ReadonlySelectorFamilyToken<
+	atomIndex: ReadonlyPureSelectorToken<AtomTokenIndex>
+	selectorIndex: ReadonlyPureSelectorToken<SelectorTokenIndex>
+	transactionIndex: ReadonlyPureSelectorToken<TransactionToken<Func>[]>
+	transactionLogSelectors: ReadonlyPureSelectorFamilyToken<
 		TransactionUpdate<Func>[],
 		string
 	>
-	timelineIndex: ReadonlySelectorToken<TimelineToken<any>[]>
-	timelineSelectors: ReadonlySelectorFamilyToken<Timeline<any>, string>
-	typeSelectors: ReadonlySelectorFamilyToken<string, string>
+	timelineIndex: ReadonlyPureSelectorToken<TimelineToken<any>[]>
+	timelineSelectors: ReadonlyPureSelectorFamilyToken<Timeline<any>, string>
+	typeSelectors: ReadonlyPureSelectorFamilyToken<string, string>
 }
 
 export const attachIntrospectionStates = (store: Store): IntrospectionStates => {

package/src/introspection/attach-selector-index.ts

@@ -1,4 +1,4 @@
-import type { ReadonlySelectorToken, SelectorToken } from "atom.io"
+import type { ReadonlyPureSelectorToken, SelectorToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	createRegularAtom,
@@ -13,7 +13,7 @@ export type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>
 
 export const attachSelectorIndex = (
 	store: Store,
-): ReadonlySelectorToken<SelectorTokenIndex> => {
+): ReadonlyPureSelectorToken<SelectorTokenIndex> => {
 	const readonlySelectorTokenIndexState__INTERNAL =
 		createRegularAtom<SelectorTokenIndex>(
 			store,
@@ -22,7 +22,7 @@ export const attachSelectorIndex = (
 				key: `🔍 Selector Token Index (Internal)`,
 				default: () => {
 					const base: SelectorTokenIndex = new Map()
-					for (const map of [store.readonlySelectors, store.selectors]) {
+					for (const map of [store.readonlySelectors, store.writableSelectors]) {
 						for (const [key, val] of map) {
 							if (isReservedIntrospectionKey(key)) {
 								continue

package/src/introspection/attach-timeline-family.ts

@@ -1,4 +1,4 @@
-import type { ReadonlySelectorFamilyToken } from "atom.io"
+import type { ReadonlyPureSelectorFamilyToken } from "atom.io"
 import type { Store, Timeline } from "atom.io/internal"
 import {
 	createRegularAtomFamily,
@@ -8,7 +8,7 @@ import {
 
 export const attachTimelineFamily = (
 	store: Store,
-): ReadonlySelectorFamilyToken<Timeline<any>, string> => {
+): ReadonlyPureSelectorFamilyToken<Timeline<any>, string> => {
 	const findTimelineLogState__INTERNAL = createRegularAtomFamily<
 		Timeline<any>,
 		string

package/src/introspection/attach-timeline-index.ts

@@ -1,10 +1,10 @@
-import type { ReadonlySelectorToken, TimelineToken } from "atom.io"
+import type { ReadonlyPureSelectorToken, TimelineToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import { createRegularAtom, createStandaloneSelector } from "atom.io/internal"
 
 export const attachTimelineIndex = (
 	store: Store,
-): ReadonlySelectorToken<TimelineToken<any>[]> => {
+): ReadonlyPureSelectorToken<TimelineToken<any>[]> => {
 	const timelineTokenIndexState__INTERNAL = createRegularAtom<
 		TimelineToken<any>[]
 	>(

package/src/introspection/attach-transaction-index.ts

@@ -1,10 +1,10 @@
-import type { ReadonlySelectorToken, TransactionToken } from "atom.io"
+import type { ReadonlyPureSelectorToken, TransactionToken } from "atom.io"
 import type { Func, Store } from "atom.io/internal"
 import { createRegularAtom, createStandaloneSelector } from "atom.io/internal"
 
 export const attachTransactionIndex = (
 	store: Store,
-): ReadonlySelectorToken<TransactionToken<Func>[]> => {
+): ReadonlyPureSelectorToken<TransactionToken<Func>[]> => {
 	const transactionTokenIndexState__INTERNAL = createRegularAtom<
 		TransactionToken<Func>[]
 	>(

package/src/introspection/attach-transaction-logs.ts

@@ -1,10 +1,10 @@
-import type { ReadonlySelectorFamilyToken, TransactionUpdate } from "atom.io"
+import type { ReadonlyPureSelectorFamilyToken, TransactionUpdate } from "atom.io"
 import type { Func, Store } from "atom.io/internal"
 import { createRegularAtomFamily, createSelectorFamily } from "atom.io/internal"
 
 export const attachTransactionLogs = (
 	store: Store,
-): ReadonlySelectorFamilyToken<TransactionUpdate<Func>[], string> => {
+): ReadonlyPureSelectorFamilyToken<TransactionUpdate<Func>[], string> => {
 	const transactionUpdateLogAtoms = createRegularAtomFamily<
 		TransactionUpdate<Func>[],
 		string

package/src/introspection/attach-type-selectors.ts

@@ -1,13 +1,13 @@
-import type { ReadonlySelectorFamilyToken } from "atom.io"
+import type { ReadonlyPureSelectorFamilyToken } from "atom.io"
 import type { Store } from "atom.io/internal"
-import { createReadonlySelectorFamily } from "atom.io/internal"
+import { createReadonlyPureSelectorFamily } from "atom.io/internal"
 
 import { discoverType } from "./refinery"
 
 export const attachTypeSelectors = (
 	store: Store,
-): ReadonlySelectorFamilyToken<string, string> => {
-	const typeSelectors = createReadonlySelectorFamily<string, string>(store, {
+): ReadonlyPureSelectorFamilyToken<string, string> => {
+	const typeSelectors = createReadonlyPureSelectorFamily<string, string>(store, {
 		key: `🔍 State Type`,
 		get:
 			(key) =>
@@ -16,7 +16,7 @@ export const attachTypeSelectors = (
 				try {
 					const token =
 						store.atoms.get(key) ??
-						store.selectors.get(key) ??
+						store.writableSelectors.get(key) ??
 						store.readonlySelectors.get(key)
 					if (token === undefined) {
 						throw new Error(`Could not find state with key "${key}"`)

package/src/introspection/auditor.ts

@@ -2,7 +2,7 @@ import {
 	type AtomToken,
 	getState,
 	type ReadableToken,
-	type ReadonlySelectorToken,
+	type ReadonlyPureSelectorToken,
 	type SelectorToken,
 } from "atom.io"
 import * as Internal from "atom.io/internal"
@@ -26,8 +26,8 @@ export class Auditor {
 	public readonly store: Internal.Store
 	public auditorCreatedAt: number = performance.now()
 	public statesCreatedAt: Map<string, number> = new Map()
-	public readonly atomIndex: ReadonlySelectorToken<AtomTokenIndex>
-	public readonly selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>
+	public readonly atomIndex: ReadonlyPureSelectorToken<AtomTokenIndex>
+	public readonly selectorIndex: ReadonlyPureSelectorToken<SelectorTokenIndex>
 	public disposed = false
 
 	private readonly unsubscribeFromAtomCreation: () => void

package/src/json/select-json-family.ts

@@ -1,6 +1,6 @@
 import type * as AtomIO from "atom.io"
 import type { Store, Transceiver } from "atom.io/internal"
-import { createWritableSelectorFamily } from "atom.io/internal"
+import { createWritablePureSelectorFamily } from "atom.io/internal"
 
 import type { Canonical, Json, JsonInterface } from "."
 
@@ -12,7 +12,7 @@ export function selectJsonFamily<
 	store: Store,
 	atomFamilyToken: AtomIO.MutableAtomFamilyToken<T, J, K>,
 	transform: JsonInterface<T, J>,
-): AtomIO.WritableSelectorFamilyToken<J, K>
+): AtomIO.WritablePureSelectorFamilyToken<J, K>
 export function selectJsonFamily<
 	T,
 	J extends Json.Serializable,
@@ -21,7 +21,7 @@ export function selectJsonFamily<
 	store: Store,
 	atomFamilyToken: AtomIO.RegularAtomFamilyToken<T, K>,
 	transform: JsonInterface<T, J>,
-): AtomIO.WritableSelectorFamilyToken<J, K>
+): AtomIO.WritablePureSelectorFamilyToken<J, K>
 export function selectJsonFamily<
 	T,
 	J extends Json.Serializable,
@@ -32,8 +32,8 @@ export function selectJsonFamily<
 		| AtomIO.MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, J, K>
 		| AtomIO.RegularAtomFamilyToken<T, K>,
 	transform: JsonInterface<T, J>,
-): AtomIO.WritableSelectorFamilyToken<J, K> {
-	const jsonFamily = createWritableSelectorFamily<J, K>(
+): AtomIO.WritablePureSelectorFamilyToken<J, K> {
+	const jsonFamily = createWritablePureSelectorFamily<J, K>(
 		store,
 		{
 			key: `${atomFamilyToken.key}:JSON`,

package/src/json/select-json.ts

@@ -8,7 +8,7 @@ export const selectJson = <T, J extends Json.Serializable>(
 	atom: AtomIO.AtomToken<T>,
 	transform: JsonInterface<T, J>,
 	store: Store = IMPLICIT.STORE,
-): AtomIO.WritableSelectorToken<J> => {
+): AtomIO.WritablePureSelectorToken<J> => {
 	return createStandaloneSelector(store, {
 		key: `${atom.key}:JSON`,
 		get: ({ get }) => transform.toJson(get(atom)),

package/src/main/find-state.ts

@@ -3,13 +3,13 @@ import type {
 	MutableAtomToken,
 	ReadableFamilyToken,
 	ReadableToken,
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
+	ReadonlyPureSelectorFamilyToken,
+	ReadonlyPureSelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
 	WritableFamilyToken,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
+	WritablePureSelectorFamilyToken,
+	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
 import type { Transceiver } from "atom.io/internal"
@@ -54,9 +54,9 @@ export function findState<T, K extends Canonical, Key extends K>(
  * @overload Writable Selector
  */
 export function findState<T, K extends Canonical, Key extends K>(
-	token: WritableSelectorFamilyToken<T, K>,
+	token: WritablePureSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T, K>
+): WritablePureSelectorToken<T, K>
 /**
  * @public
  * Finds a state in the store
@@ -67,9 +67,9 @@ export function findState<T, K extends Canonical, Key extends K>(
  * @overload Readonly Selector
  */
 export function findState<T, K extends Canonical, Key extends K>(
-	token: ReadonlySelectorFamilyToken<T, K>,
+	token: ReadonlyPureSelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T, K>
+): ReadonlyPureSelectorToken<T, K>
 /**
  * @public
  * Finds a state in the store

package/src/main/index.ts

@@ -82,31 +82,76 @@ export type AtomToken<T, K extends Canonical = any> =
 	| RegularAtomToken<T, K>
 
 /** @public */
-export type WritableSelectorToken<T, K extends Canonical = any> = {
+export type WritablePureSelectorToken<T, K extends Canonical = any> = {
 	/** The unique identifier of the selector. */
 	key: string
 	/** Discriminator. */
-	type: `selector`
+	type: `writable_pure_selector`
 	/** Present if the selector belongs to a family. */
 	family?: FamilyMetadata<K>
 	/** Never present. This is a marker that preserves the type of the selector's value. */
 	__T?: T
 }
 /** @public */
-export type ReadonlySelectorToken<T, K extends Canonical = any> = {
+export type WritableHeldSelectorToken<T, K extends Canonical = any> = {
 	/** The unique identifier of the selector. */
 	key: string
 	/** Discriminator. */
-	type: `readonly_selector`
+	type: `writable_held_selector`
 	/** Present if the selector belongs to a family. */
 	family?: FamilyMetadata<K>
 	/** Never present. This is a marker that preserves the type of the selector's value. */
 	__T?: T
 }
+/** @public */
+export type ReadonlyPureSelectorToken<T, K extends Canonical = any> = {
+	/** The unique identifier of the selector. */
+	key: string
+	/** Discriminator. */
+	type: `readonly_pure_selector`
+	/** Present if the selector belongs to a family. */
+	family?: FamilyMetadata<K>
+	/** Never present. This is a marker that preserves the type of the selector's value. */
+	__T?: T
+}
+/** @public */
+export type ReadonlyHeldSelectorToken<T, K extends Canonical = any> = {
+	/** The unique identifier of the selector. */
+	key: string
+	/** Discriminator. */
+	type: `readonly_held_selector`
+	/** Present if the selector belongs to a family. */
+	family?: FamilyMetadata<K>
+	/** Never present. This is a marker that preserves the type of the selector's value. */
+	__T?: T
+}
+
+/** @public */
+export type PureSelectorToken<T, K extends Canonical = any> =
+	| ReadonlyPureSelectorToken<T, K>
+	| WritablePureSelectorToken<T, K>
+
+/** @public */
+export type HeldSelectorToken<T, K extends Canonical = any> =
+	| ReadonlyHeldSelectorToken<T, K>
+	| WritableHeldSelectorToken<T, K>
+
+/** @public */
+export type ReadonlySelectorToken<T, K extends Canonical = any> =
+	| ReadonlyHeldSelectorToken<T, K>
+	| ReadonlyPureSelectorToken<T, K>
+
+/** @public */
+export type WritableSelectorToken<T, K extends Canonical = any> =
+	| WritableHeldSelectorToken<T, K>
+	| WritablePureSelectorToken<T, K>
+
 /** @public */
 export type SelectorToken<T, K extends Canonical = any> =
-	| ReadonlySelectorToken<T, K>
-	| WritableSelectorToken<T, K>
+	| ReadonlyHeldSelectorToken<T, K>
+	| ReadonlyPureSelectorToken<T, K>
+	| WritableHeldSelectorToken<T, K>
+	| WritablePureSelectorToken<T, K>
 
 /**
  * @public

package/src/main/join.ts

@@ -1,4 +1,4 @@
-import type { MutableAtomFamilyToken, ReadonlySelectorToken } from "atom.io"
+import type { MutableAtomFamilyToken, ReadonlyPureSelectorToken } from "atom.io"
 import type {
 	Junction,
 	JunctionEntriesBase,
@@ -105,23 +105,23 @@ export type JoinStates<
 > = Cardinality extends `1:1`
 	? (Content extends Json.Object
 			? {
-					readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+					readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
 						[AType, Content] | null,
 						BType
 					>
 				} & {
-					readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+					readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
 						[BType, Content] | null,
 						AType
 					>
 				}
 			: {}) & {
-			readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+			readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
 				AType | null,
 				BType
 			>
 		} & {
-			readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+			readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
 				BType | null,
 				AType
 			>
@@ -129,23 +129,23 @@ export type JoinStates<
 	: Cardinality extends `1:n`
 		? (Content extends Json.Object
 				? {
-						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
 							[AType, Content] | null,
 							BType
 						>
 					} & {
-						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
 							[BType, Content][],
 							AType
 						>
 					}
 				: {}) & {
-				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
 					AType | null,
 					BType
 				>
 			} & {
-				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
 					BType[],
 					AType
 				>
@@ -153,23 +153,23 @@ export type JoinStates<
 		: Cardinality extends `n:n`
 			? (Content extends Json.Object
 					? {
-							readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+							readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
 								[AType, Content][],
 								BType
 							>
 						} & {
-							readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+							readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
 								[BType, Content][],
 								AType
 							>
 						}
 					: {}) & {
-					readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+					readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
 						AType[],
 						BType
 					>
 				} & {
-					readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+					readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
 						BType[],
 						AType
 					>