atom.io 0.33.2 → 0.33.4

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

@@ -11,8 +11,10 @@ export const readOrComputeValue = <T>(
 		return readCachedValue(state, target)
 	}
 	switch (state.type) {
-		case `selector`:
-		case `readonly_selector`:
+		case `readonly_held_selector`:
+		case `readonly_pure_selector`:
+		case `writable_held_selector`:
+		case `writable_pure_selector`:
 			target.logger.info(`🧮`, state.type, state.key, `computing value`)
 			return state.get()
 		case `atom`:

package/src/internal/index.ts

@@ -3,14 +3,18 @@ import type {
 	FamilyMetadata,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
+	ReadonlyHeldSelectorFamilyToken,
+	ReadonlyHeldSelectorToken,
+	ReadonlyPureSelectorFamilyToken,
+	ReadonlyPureSelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
 	StateCreation,
 	StateDisposal,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
+	WritableHeldSelectorFamilyToken,
+	WritableHeldSelectorToken,
+	WritablePureSelectorFamilyToken,
+	WritablePureSelectorToken,
 } from "atom.io"
 import type { Canonical, Json, JsonInterface } from "atom.io/json"
 
@@ -76,16 +80,39 @@ export type Atom<T> =
 	| RegularAtom<T>
 	| (T extends Transceiver<any> ? MutableAtom<T, any> : never)
 
-export type WritableSelector<T> = AtomIOState & {
-	type: `selector`
+export type WritableHeldSelector<T> = AtomIOState & {
+	type: `writable_held_selector`
+	const: T
 	get: () => T
 	set: (newValue: T | ((oldValue: T) => T)) => void
 }
-export type ReadonlySelector<T> = AtomIOState & {
-	type: `readonly_selector`
+export type ReadonlyHeldSelector<T> = AtomIOState & {
+	type: `readonly_held_selector`
+	const: T
 	get: () => T
 }
-export type Selector<T> = ReadonlySelector<T> | WritableSelector<T>
+export type WritablePureSelector<T> = AtomIOState & {
+	type: `writable_pure_selector`
+	get: () => T
+	set: (newValue: T | ((oldValue: T) => T)) => void
+}
+export type ReadonlyPureSelector<T> = AtomIOState & {
+	type: `readonly_pure_selector`
+	get: () => T
+}
+export type ReadonlySelector<T> =
+	| ReadonlyHeldSelector<T>
+	| ReadonlyPureSelector<T>
+export type WritableSelector<T> =
+	| WritableHeldSelector<T>
+	| WritablePureSelector<T>
+export type HeldSelector<T> = ReadonlyHeldSelector<T> | WritableHeldSelector<T>
+export type PureSelector<T> = ReadonlyPureSelector<T> | WritablePureSelector<T>
+export type Selector<T> =
+	| ReadonlyHeldSelector<T>
+	| ReadonlyPureSelector<T>
+	| WritableHeldSelector<T>
+	| WritablePureSelector<T>
 
 export type WritableState<T> = Atom<T> | WritableSelector<T>
 export type ReadableState<T> = Atom<T> | Selector<T>
@@ -120,34 +147,84 @@ export type AtomFamily<T, K extends Canonical = Canonical> =
 	| RegularAtomFamily<T, K>
 
 // biome-ignore format: intersection
-export type WritableSelectorFamily<T, K extends Canonical> = 
-	& WritableSelectorFamilyToken<T, K> 
-	& ((key: K) => WritableSelectorToken<T>)
+export type WritablePureSelectorFamily<T, K extends Canonical> = 
+	& WritablePureSelectorFamilyToken<T, K> 
+	& ((key: K) => WritablePureSelectorToken<T>)
+	& {
+		default: (key: K) => T,
+		subject: Subject<
+			| StateCreation<WritablePureSelectorToken<T>>
+			| StateDisposal<WritablePureSelectorToken<T>>
+		>
+		install: (store: Store) => void
+		internalRoles : string[] | undefined
+	}
+
+// biome-ignore format: intersection
+export type WritableHeldSelectorFamily<T , K extends Canonical> = 
+	& WritableHeldSelectorFamilyToken<T, K> 
+	& ((key: K) => WritableHeldSelectorToken<T>)
 	& {
 		default: (key: K) => T,
-		subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>
+		subject: Subject<
+			| StateCreation<WritableHeldSelectorToken<T>>
+			| StateDisposal<WritableHeldSelectorToken<T>>
+		>
 		install: (store: Store) => void
 		internalRoles : string[] | undefined
 	}
 
 // biome-ignore format: intersection
-export type ReadonlySelectorFamily<T, K extends Canonical> = 
-	& ReadonlySelectorFamilyToken<T, K>
-	& ((key: K) => ReadonlySelectorToken<T>)
+export type ReadonlyPureSelectorFamily<T, K extends Canonical> = 
+	& ReadonlyPureSelectorFamilyToken<T, K>
+	& ((key: K) => ReadonlyPureSelectorToken<T>)
 	& {
 		default: (key: K) => T,
-		subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>
+		subject: Subject<
+			| StateCreation<ReadonlyPureSelectorToken<T>>
+			| StateDisposal<ReadonlyPureSelectorToken<T>>
+		>
 		install: (store: Store) => void
 		internalRoles : string[] | undefined
 	}
 
+// biome-ignore format: intersection
+export type ReadonlyHeldSelectorFamily<T , K extends Canonical> = 
+	& ReadonlyHeldSelectorFamilyToken<T, K>
+	& ((key: K) => ReadonlyHeldSelectorToken<T>)
+	& {
+		default: (key: K) => T,
+		subject: Subject<
+			| StateCreation<ReadonlyHeldSelectorToken<T>> 
+			| StateDisposal<ReadonlyHeldSelectorToken<T>>
+		>
+		install: (store: Store) => void
+		internalRoles : string[] | undefined
+	}
+
+export type PureSelectorFamily<T, K extends Canonical> =
+	| ReadonlyPureSelectorFamily<T, K>
+	| WritablePureSelectorFamily<T, K>
+
+export type HeldSelectorFamily<T, K extends Canonical> =
+	| ReadonlyHeldSelectorFamily<T, K>
+	| WritableHeldSelectorFamily<T, K>
+
+export type ReadonlySelectorFamily<T, K extends Canonical> =
+	| ReadonlyHeldSelectorFamily<T, K>
+	| ReadonlyPureSelectorFamily<T, K>
+
+export type WritableSelectorFamily<T, K extends Canonical> =
+	| WritableHeldSelectorFamily<T, K>
+	| WritablePureSelectorFamily<T, K>
+
 export type SelectorFamily<T, K extends Canonical> =
-	| ReadonlySelectorFamily<T, K>
-	| WritableSelectorFamily<T, K>
+	| HeldSelectorFamily<T, K>
+	| PureSelectorFamily<T, K>
 
 export type WritableFamily<T, K extends Canonical> =
 	| AtomFamily<T, K>
-	| WritableSelectorFamily<T, K>
+	| WritablePureSelectorFamily<T, K>
 export type ReadableFamily<T, K extends Canonical> =
 	| AtomFamily<T, K>
 	| SelectorFamily<T, K>

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

@@ -5,7 +5,7 @@ import type {
 	JoinOptions,
 	MutableAtomFamilyToken,
 	Read,
-	ReadonlySelectorFamilyToken,
+	ReadonlyPureSelectorFamilyToken,
 	RegularAtomFamilyToken,
 	setState,
 	SetterToolkit,
@@ -19,7 +19,7 @@ import { SetRTX } from "atom.io/transceivers/set-rtx"
 
 import { capitalize } from "../capitalize"
 import {
-	createReadonlySelectorFamily,
+	createReadonlyPureSelectorFamily,
 	createRegularAtomFamily,
 	findInStore,
 } from "../families"
@@ -45,23 +45,23 @@ export type JoinStateFamilies<
 > = Cardinality extends `1:1`
 	? (Content extends Json.Object
 			? {
-					readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<
+					readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorFamilyToken<
 						[AType, Content] | null,
 						BType
 					>
 				} & {
-					readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<
+					readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlyPureSelectorFamilyToken<
 						[BType, Content] | null,
 						AType
 					>
 				}
 			: {}) & {
-			readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<
+			readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorFamilyToken<
 				AType | null,
 				BType
 			>
 		} & {
-			readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<
+			readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlyPureSelectorFamilyToken<
 				BType | null,
 				AType
 			>
@@ -69,23 +69,23 @@ export type JoinStateFamilies<
 	: Cardinality extends `1:n`
 		? (Content extends Json.Object
 				? {
-						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<
+						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorFamilyToken<
 							[AType, Content] | null,
 							BType
 						>
 					} & {
-						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<
+						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorFamilyToken<
 							[BType, Content][],
 							AType
 						>
 					}
 				: {}) & {
-				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<
+				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorFamilyToken<
 					AType | null,
 					BType
 				>
 			} & {
-				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<
+				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorFamilyToken<
 					BType[],
 					AType
 				>
@@ -93,23 +93,23 @@ export type JoinStateFamilies<
 		: Cardinality extends `n:n`
 			? (Content extends Json.Object
 					? {
-							readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<
+							readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlyPureSelectorFamilyToken<
 								[AType, Content][],
 								BType
 							>
 						} & {
-							readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<
+							readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorFamilyToken<
 								[BType, Content][],
 								AType
 							>
 						}
 					: {}) & {
-					readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<
+					readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlyPureSelectorFamilyToken<
 						AType[],
 						BType
 					>
 				} & {
-					readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<
+					readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorFamilyToken<
 						BType[],
 						AType
 					>
@@ -412,7 +412,7 @@ export class Join<
 		)
 
 		const createSingleKeySelectorFamily = () =>
-			createReadonlySelectorFamily<string | null, string>(
+			createReadonlyPureSelectorFamily<string | null, string>(
 				store,
 				{
 					key: `${options.key}/singleRelatedKey`,
@@ -429,7 +429,7 @@ export class Join<
 				[`join`, `keys`],
 			)
 		const getMultipleKeySelectorFamily = () => {
-			return createReadonlySelectorFamily<string[], string>(
+			return createReadonlyPureSelectorFamily<string[], string>(
 				store,
 				{
 					key: `${options.key}/multipleRelatedKeys`,
@@ -445,7 +445,7 @@ export class Join<
 			)
 		}
 		const createSingleEntrySelectorFamily = () =>
-			createReadonlySelectorFamily<[string, Content] | null, string>(
+			createReadonlyPureSelectorFamily<[string, Content] | null, string>(
 				store,
 				{
 					key: `${options.key}/singleRelatedEntry`,
@@ -468,7 +468,7 @@ export class Join<
 				[`join`, `entries`],
 			)
 		const getMultipleEntrySelectorFamily = () =>
-			createReadonlySelectorFamily<[string, Content][], string>(
+			createReadonlyPureSelectorFamily<[string, Content][], string>(
 				store,
 				{
 					key: `${options.key}/multipleRelatedEntries`,

package/src/internal/keys.ts

@@ -13,7 +13,7 @@ export const isAtomKey = (store: Store, key: string): key is AtomKey<unknown> =>
 export const isSelectorKey = (
 	store: Store,
 	key: string,
-): key is SelectorKey<unknown> => newest(store).selectors.has(key)
+): key is SelectorKey<unknown> => newest(store).writableSelectors.has(key)
 export const isReadonlySelectorKey = (
 	store: Store,
 	key: string,

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

@@ -7,7 +7,12 @@ import type {
 import type { Json } from "atom.io/json"
 import { selectJson } from "atom.io/json"
 
-import { cacheValue, type MutableAtom, setIntoStore } from ".."
+import {
+	cacheValue,
+	type MutableAtom,
+	prettyPrintTokenType,
+	setIntoStore,
+} from ".."
 import { markAtomAsDefault } from "../atom"
 import { newest } from "../lineage"
 import { deposit, type Store } from "../store"
@@ -31,12 +36,14 @@ export function createMutableAtom<
 		`creating in store "${store.config.name}"`,
 	)
 	const target = newest(store)
-	const existing = target.atoms.get(options.key)
-	if (existing && existing.type === `mutable_atom`) {
+	const { key, default: def } = options
+	const existing = target.atoms.get(key)
+	const type = `mutable_atom`
+	if (existing && existing.type === type) {
 		store.logger.error(
 			`❌`,
-			`atom`,
-			options.key,
+			type,
+			key,
 			`Tried to create atom, but it already exists in the store.`,
 		)
 		return deposit(existing)
@@ -44,14 +51,9 @@ export function createMutableAtom<
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const newAtom: MutableAtom<T, J> = {
 		...options,
-		type: `mutable_atom`,
+		type,
 		install: (s: Store) => {
-			s.logger.info(
-				`🛠️`,
-				`atom`,
-				options.key,
-				`installing in store "${s.config.name}"`,
-			)
+			s.logger.info(`🛠️`, `atom`, key, `installing in store "${s.config.name}"`)
 			return createMutableAtom(s, options, family)
 		},
 		subject,
@@ -59,10 +61,10 @@ export function createMutableAtom<
 	if (family) {
 		newAtom.family = family
 	}
-	const initialValue = options.default()
+	const initialValue = def()
 	target.atoms.set(newAtom.key, newAtom)
-	markAtomAsDefault(store, options.key)
-	cacheValue(target, options.key, initialValue, subject)
+	markAtomAsDefault(store, key)
+	cacheValue(target, key, initialValue, subject)
 	const token = deposit(newAtom)
 	if (options.effects) {
 		let effectIndex = 0

package/src/internal/mutable/get-json-family.ts

@@ -1,7 +1,7 @@
 import type { MutableAtomFamilyToken } from "atom.io"
 import type { Canonical, Json } from "atom.io/json"
 
-import type { WritableSelectorFamily } from ".."
+import type { WritablePureSelectorFamily } from ".."
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import type { Transceiver } from "./transceiver"
@@ -13,10 +13,10 @@ export const getJsonFamily = <
 >(
 	mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>,
 	store: Store,
-): WritableSelectorFamily<SerializableCore, Key> => {
+): WritablePureSelectorFamily<SerializableCore, Key> => {
 	const target = newest(store)
 	const key = `${mutableAtomFamily.key}:JSON`
-	const jsonFamily: WritableSelectorFamily<SerializableCore, Key> =
-		target.families.get(key) as WritableSelectorFamily<SerializableCore, Key>
+	const jsonFamily: WritablePureSelectorFamily<SerializableCore, Key> =
+		target.families.get(key) as WritablePureSelectorFamily<SerializableCore, Key>
 	return jsonFamily
 }

package/src/internal/mutable/get-json-token.ts

@@ -1,7 +1,7 @@
 import type {
 	MutableAtomToken,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
+	WritablePureSelectorFamilyToken,
+	WritablePureSelectorToken,
 } from "atom.io"
 import type { Json } from "atom.io/json"
 
@@ -16,24 +16,24 @@ export const getJsonToken = <
 >(
 	store: Store,
 	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
-): WritableSelectorToken<SerializableCore> => {
+): WritablePureSelectorToken<SerializableCore> => {
 	if (mutableAtomToken.family) {
 		const target = newest(store)
 		const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`
-		const jsonFamilyToken: WritableSelectorFamilyToken<
+		const jsonFamilyToken: WritablePureSelectorFamilyToken<
 			SerializableCore,
 			string
 		> = {
 			key: jsonFamilyKey,
-			type: `selector_family`,
+			type: `writable_pure_selector_family`,
 		}
 		const family = withdraw(target, jsonFamilyToken)
 		const subKey = JSON.parse(mutableAtomToken.family.subKey)
 		const jsonToken = findInStore(store, family, subKey)
 		return jsonToken
 	}
-	const token: WritableSelectorToken<SerializableCore> = {
-		type: `selector`,
+	const token: WritablePureSelectorToken<SerializableCore> = {
+		type: `writable_pure_selector`,
 		key: `${mutableAtomToken.key}:JSON`,
 	}
 	return token

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

@@ -0,0 +1,50 @@
+import type {
+	FamilyMetadata,
+	ReadonlyHeldSelectorOptions,
+	ReadonlyHeldSelectorToken,
+} from "atom.io"
+
+import type { ReadonlyHeldSelector } from ".."
+import { cacheValue } from "../caching"
+import { newest } from "../lineage"
+import type { Store } from "../store"
+import { Subject } from "../subject"
+import { registerSelector } from "./register-selector"
+
+export const createReadonlyHeldSelector = <T extends object>(
+	store: Store,
+	options: ReadonlyHeldSelectorOptions<T>,
+	family: FamilyMetadata | undefined,
+): ReadonlyHeldSelectorToken<T> => {
+	const target = newest(store)
+	const subject = new Subject<{ newValue: T; oldValue: T }>()
+	const covered = new Set<string>()
+	const { key, const: constant } = options
+	const type = `readonly_held_selector` as const
+	const { get, find, json } = registerSelector(target, type, key, covered)
+	const getSelf = () => {
+		options.get({ get, find, json }, constant)
+		cacheValue(newest(store), key, constant, subject)
+		covered.clear()
+		return constant
+	}
+
+	const readonlySelector: ReadonlyHeldSelector<T> = {
+		...options,
+		type,
+		subject,
+		install: (s: Store) => createReadonlyHeldSelector(s, options, family),
+		get: getSelf,
+		...(family && { family }),
+	}
+	target.readonlySelectors.set(key, readonlySelector)
+	store.logger.info(`✨`, type, key, `=`, constant)
+	const token: ReadonlyHeldSelectorToken<T> = {
+		key,
+		type,
+	}
+	if (family) {
+		token.family = family
+	}
+	return token
+}

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

@@ -0,0 +1,51 @@
+import type {
+	FamilyMetadata,
+	ReadonlyPureSelectorOptions,
+	ReadonlyPureSelectorToken,
+} from "atom.io"
+
+import type { ReadonlyPureSelector } from ".."
+import { cacheValue } from "../caching"
+import { newest } from "../lineage"
+import type { Store } from "../store"
+import { Subject } from "../subject"
+import { registerSelector } from "./register-selector"
+
+export const createReadonlyPureSelector = <T>(
+	store: Store,
+	options: ReadonlyPureSelectorOptions<T>,
+	family: FamilyMetadata | undefined,
+): ReadonlyPureSelectorToken<T> => {
+	const target = newest(store)
+	const subject = new Subject<{ newValue: T; oldValue: T }>()
+	const covered = new Set<string>()
+	const key = options.key
+	const type = `readonly_pure_selector` as const
+	const { get, find, json } = registerSelector(target, type, key, covered)
+	const getSelf = () => {
+		const value = options.get({ get, find, json })
+		cacheValue(newest(store), key, value, subject)
+		covered.clear()
+		return value
+	}
+
+	const readonlySelector: ReadonlyPureSelector<T> = {
+		...options,
+		type,
+		subject,
+		install: (s: Store) => createReadonlyPureSelector(s, options, family),
+		get: getSelf,
+		...(family && { family }),
+	}
+	target.readonlySelectors.set(key, readonlySelector)
+	const initialValue = getSelf()
+	store.logger.info(`✨`, type, key, `=`, initialValue)
+	const token: ReadonlyPureSelectorToken<T> = {
+		key,
+		type,
+	}
+	if (family) {
+		token.family = family
+	}
+	return token
+}

package/src/internal/selector/create-standalone-selector.ts

@@ -1,34 +1,67 @@
 import type {
-	ReadonlySelectorOptions,
-	ReadonlySelectorToken,
-	WritableSelectorOptions,
-	WritableSelectorToken,
+	ReadonlyHeldSelectorOptions,
+	ReadonlyHeldSelectorToken,
+	ReadonlyPureSelectorOptions,
+	ReadonlyPureSelectorToken,
+	WritableHeldSelectorOptions,
+	WritableHeldSelectorToken,
+	WritablePureSelectorOptions,
+	WritablePureSelectorToken,
 } from "atom.io"
 
 import type { Store } from "../store"
-import { createReadonlySelector } from "./create-readonly-selector"
-import { createWritableSelector } from "./create-writable-selector"
+import { createReadonlyHeldSelector } from "./create-readonly-held-selector"
+import { createReadonlyPureSelector } from "./create-readonly-pure-selector"
+import { createWritableHeldSelector } from "./create-writable-held-selector"
+import { createWritablePureSelector } from "./create-writable-pure-selector"
 
-export function createStandaloneSelector<T>(
+export function createStandaloneSelector<T extends object>(
+	store: Store,
+	options: WritableHeldSelectorOptions<T>,
+): WritableHeldSelectorToken<T>
+export function createStandaloneSelector<T extends object>(
 	store: Store,
-	options: WritableSelectorOptions<T>,
-): WritableSelectorToken<T>
+	options: ReadonlyHeldSelectorOptions<T>,
+): ReadonlyHeldSelectorToken<T>
 export function createStandaloneSelector<T>(
 	store: Store,
-	options: ReadonlySelectorOptions<T>,
-): ReadonlySelectorToken<T>
+	options: WritablePureSelectorOptions<T>,
+): WritablePureSelectorToken<T>
 export function createStandaloneSelector<T>(
 	store: Store,
-	options: ReadonlySelectorOptions<T> | WritableSelectorOptions<T>,
-): ReadonlySelectorToken<T> | WritableSelectorToken<T> {
+	options: ReadonlyPureSelectorOptions<T>,
+): ReadonlyPureSelectorToken<T>
+export function createStandaloneSelector(
+	store: Store,
+	options:
+		| ReadonlyHeldSelectorOptions<any>
+		| ReadonlyPureSelectorOptions<any>
+		| WritableHeldSelectorOptions<any>
+		| WritablePureSelectorOptions<any>,
+):
+	| ReadonlyHeldSelectorToken<any>
+	| ReadonlyPureSelectorToken<any>
+	| WritableHeldSelectorToken<any>
+	| WritablePureSelectorToken<any> {
 	const isWritable = `set` in options
+	const isHeld = `const` in options
 
+	if (isHeld && isWritable) {
+		const state = createWritableHeldSelector(store, options, undefined)
+		store.on.selectorCreation.next(state)
+		return state
+	}
+	if (isHeld) {
+		const state = createReadonlyHeldSelector(store, options, undefined)
+		store.on.selectorCreation.next(state)
+		return state
+	}
 	if (isWritable) {
-		const state = createWritableSelector(store, options, undefined)
+		const state = createWritablePureSelector(store, options, undefined)
 		store.on.selectorCreation.next(state)
 		return state
 	}
-	const state = createReadonlySelector(store, options, undefined)
+	const state = createReadonlyPureSelector(store, options, undefined)
 	store.on.selectorCreation.next(state)
 	return state
 }