atom.io 0.33.1 → 0.33.3

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

@@ -0,0 +1,81 @@
+import type {
+	FamilyMetadata,
+	ReadonlyHeldSelectorFamilyOptions,
+	ReadonlyHeldSelectorFamilyToken,
+	ReadonlyHeldSelectorToken,
+	StateCreation,
+	StateDisposal,
+} from "atom.io"
+import type { Canonical } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
+
+import type { ReadonlyHeldSelectorFamily } from ".."
+import { prettyPrintTokenType } from ".."
+import { newest } from "../lineage"
+import { createReadonlyHeldSelector } from "../selector"
+import type { Store } from "../store"
+import { Subject } from "../subject"
+
+export function createReadonlyHeldSelectorFamily<
+	T extends object,
+	K extends Canonical,
+>(
+	store: Store,
+	options: ReadonlyHeldSelectorFamilyOptions<T, K>,
+	internalRoles?: string[],
+): ReadonlyHeldSelectorFamilyToken<T, K> {
+	const familyKey = options.key
+	const type = `readonly_held_selector_family`
+
+	const familyToken = {
+		key: familyKey,
+		type,
+	} as const satisfies ReadonlyHeldSelectorFamilyToken<T, K>
+
+	const existing = store.families.get(familyKey)
+	if (existing) {
+		store.logger.error(
+			`❗`,
+			type,
+			familyKey,
+			`Overwriting an existing ${prettyPrintTokenType(
+				existing,
+			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+		)
+	}
+
+	const subject = new Subject<
+		| StateCreation<ReadonlyHeldSelectorToken<T>>
+		| StateDisposal<ReadonlyHeldSelectorToken<T>>
+	>()
+
+	const familyFunction = (key: K): ReadonlyHeldSelectorToken<T> => {
+		const subKey = stringifyJson(key)
+		const family: FamilyMetadata = { key: familyKey, subKey }
+		const fullKey = `${familyKey}(${subKey})`
+		const target = newest(store)
+
+		const token = createReadonlyHeldSelector(
+			target,
+			{
+				key: fullKey,
+				const: options.const(key),
+				get: options.get(key),
+			},
+			family,
+		)
+
+		subject.next({ type: `state_creation`, token })
+		return token
+	}
+
+	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+		internalRoles,
+		subject,
+		install: (s: Store) => createReadonlyHeldSelectorFamily(s, options),
+		default: options.const,
+	}) satisfies ReadonlyHeldSelectorFamily<T, K>
+
+	store.families.set(familyKey, readonlySelectorFamily)
+	return familyToken
+}

package/src/internal/families/{create-readonly-selector-family.ts → create-readonly-pure-selector-family.ts}

@@ -2,9 +2,9 @@ import type {
 	FamilyMetadata,
 	findState,
 	getState,
-	ReadonlySelectorFamilyOptions,
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
+	ReadonlyPureSelectorFamilyOptions,
+	ReadonlyPureSelectorFamilyToken,
+	ReadonlyPureSelectorToken,
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
@@ -16,29 +16,32 @@ import {
 	getFromStore,
 	getJsonToken,
 	prettyPrintTokenType,
-	type ReadonlySelectorFamily,
+	type ReadonlyPureSelectorFamily,
 } from ".."
 import { newest } from "../lineage"
-import { createReadonlySelector } from "../selector"
+import { createReadonlyPureSelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 
-export function createReadonlySelectorFamily<T, K extends Canonical>(
+export function createReadonlyPureSelectorFamily<T, K extends Canonical>(
 	store: Store,
-	options: ReadonlySelectorFamilyOptions<T, K>,
+	options: ReadonlyPureSelectorFamilyOptions<T, K>,
 	internalRoles?: string[],
-): ReadonlySelectorFamilyToken<T, K> {
+): ReadonlyPureSelectorFamilyToken<T, K> {
+	const familyKey = options.key
+	const type = `readonly_pure_selector_family`
+
 	const familyToken = {
-		key: options.key,
-		type: `readonly_selector_family`,
-	} as const satisfies ReadonlySelectorFamilyToken<T, K>
+		key: familyKey,
+		type,
+	} as const satisfies ReadonlyPureSelectorFamilyToken<T, K>
 
-	const existing = store.families.get(options.key)
+	const existing = store.families.get(familyKey)
 	if (existing) {
 		store.logger.error(
 			`❗`,
-			`readonly_selector_family`,
-			options.key,
+			type,
+			familyKey,
 			`Overwriting an existing ${prettyPrintTokenType(
 				existing,
 			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
@@ -46,17 +49,17 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 	}
 
 	const subject = new Subject<
-		| StateCreation<ReadonlySelectorToken<T>>
-		| StateDisposal<ReadonlySelectorToken<T>>
+		| StateCreation<ReadonlyPureSelectorToken<T>>
+		| StateDisposal<ReadonlyPureSelectorToken<T>>
 	>()
 
-	const familyFunction = (key: K): ReadonlySelectorToken<T> => {
+	const familyFunction = (key: K): ReadonlyPureSelectorToken<T> => {
 		const subKey = stringifyJson(key)
-		const family: FamilyMetadata = { key: options.key, subKey }
-		const fullKey = `${options.key}(${subKey})`
+		const family: FamilyMetadata = { key: familyKey, subKey }
+		const fullKey = `${familyKey}(${subKey})`
 		const target = newest(store)
 
-		const token = createReadonlySelector(
+		const token = createReadonlyPureSelector(
 			target,
 			{
 				key: fullKey,
@@ -72,7 +75,7 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
 		internalRoles,
 		subject,
-		install: (s: Store) => createReadonlySelectorFamily(s, options),
+		install: (s: Store) => createReadonlyPureSelectorFamily(s, options),
 		default: (key: K) => {
 			const getFn = options.get(key)
 			return getFn({
@@ -83,8 +86,8 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 				json: (token) => getJsonToken(store, token),
 			})
 		},
-	}) satisfies ReadonlySelectorFamily<T, K>
+	}) satisfies ReadonlyPureSelectorFamily<T, K>
 
-	store.families.set(options.key, readonlySelectorFamily)
+	store.families.set(familyKey, readonlySelectorFamily)
 	return familyToken
 }

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

@@ -1,34 +1,57 @@
 import type {
-	ReadonlySelectorFamilyOptions,
-	ReadonlySelectorFamilyToken,
+	ReadonlyHeldSelectorFamilyOptions,
+	ReadonlyHeldSelectorFamilyToken,
+	ReadonlyPureSelectorFamilyOptions,
+	ReadonlyPureSelectorFamilyToken,
 	SelectorFamilyToken,
-	WritableSelectorFamilyOptions,
-	WritableSelectorFamilyToken,
+	WritableHeldSelectorFamilyOptions,
+	WritableHeldSelectorFamilyToken,
+	WritablePureSelectorFamilyOptions,
+	WritablePureSelectorFamilyToken,
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
 import type { Store } from "../store"
-import { createReadonlySelectorFamily } from "./create-readonly-selector-family"
-import { createWritableSelectorFamily } from "./create-writable-selector-family"
+import { createReadonlyHeldSelectorFamily } from "./create-readonly-held-selector-family"
+import { createReadonlyPureSelectorFamily } from "./create-readonly-pure-selector-family"
+import { createWritableHeldSelectorFamily } from "./create-writable-held-selector-family"
+import { createWritablePureSelectorFamily } from "./create-writable-pure-selector-family"
 
-export function createSelectorFamily<T, K extends Canonical>(
+export function createSelectorFamily<T extends object, K extends Canonical>(
+	store: Store,
+	options: WritableHeldSelectorFamilyOptions<T, K>,
+): WritableHeldSelectorFamilyToken<T, K>
+export function createSelectorFamily<T extends object, K extends Canonical>(
 	store: Store,
-	options: WritableSelectorFamilyOptions<T, K>,
-): WritableSelectorFamilyToken<T, K>
+	options: ReadonlyHeldSelectorFamilyOptions<T, K>,
+): ReadonlyHeldSelectorFamilyToken<T, K>
 export function createSelectorFamily<T, K extends Canonical>(
 	store: Store,
-	options: ReadonlySelectorFamilyOptions<T, K>,
-): ReadonlySelectorFamilyToken<T, K>
+	options: WritablePureSelectorFamilyOptions<T, K>,
+): WritablePureSelectorFamilyToken<T, K>
 export function createSelectorFamily<T, K extends Canonical>(
+	store: Store,
+	options: ReadonlyPureSelectorFamilyOptions<T, K>,
+): ReadonlyPureSelectorFamilyToken<T, K>
+export function createSelectorFamily(
 	store: Store,
 	options:
-		| ReadonlySelectorFamilyOptions<T, K>
-		| WritableSelectorFamilyOptions<T, K>,
-): SelectorFamilyToken<T, K> {
+		| ReadonlyHeldSelectorFamilyOptions<any, any>
+		| ReadonlyPureSelectorFamilyOptions<any, any>
+		| WritableHeldSelectorFamilyOptions<any, any>
+		| WritablePureSelectorFamilyOptions<any, any>,
+): SelectorFamilyToken<any, any> {
 	const isWritable = `set` in options
+	const isHeld = `const` in options
 
+	if (isHeld && isWritable) {
+		return createWritableHeldSelectorFamily(store, options, undefined)
+	}
+	if (isHeld) {
+		return createReadonlyHeldSelectorFamily(store, options, undefined)
+	}
 	if (isWritable) {
-		return createWritableSelectorFamily(store, options)
+		return createWritablePureSelectorFamily(store, options)
 	}
-	return createReadonlySelectorFamily(store, options)
+	return createReadonlyPureSelectorFamily(store, options)
 }

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

@@ -0,0 +1,80 @@
+import type {
+	FamilyMetadata,
+	StateCreation,
+	StateDisposal,
+	WritableHeldSelectorFamilyOptions,
+	WritableHeldSelectorFamilyToken,
+	WritableHeldSelectorToken,
+} from "atom.io"
+import type { Canonical } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
+
+import { prettyPrintTokenType, type WritableHeldSelectorFamily } from ".."
+import { newest } from "../lineage"
+import { createWritableHeldSelector } from "../selector"
+import type { Store } from "../store"
+import { Subject } from "../subject"
+
+export function createWritableHeldSelectorFamily<
+	T extends object,
+	K extends Canonical,
+>(
+	store: Store,
+	options: WritableHeldSelectorFamilyOptions<T, K>,
+	internalRoles?: string[],
+): WritableHeldSelectorFamilyToken<T, K> {
+	const familyKey = options.key
+	const type = `writable_held_selector_family`
+
+	const familyToken = {
+		key: familyKey,
+		type,
+	} as const satisfies WritableHeldSelectorFamilyToken<T, K>
+
+	const existing = store.families.get(familyKey)
+	if (existing) {
+		store.logger.error(
+			`❗`,
+			type,
+			familyKey,
+			`Overwriting an existing ${prettyPrintTokenType(
+				existing,
+			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
+		)
+	}
+	const subject = new Subject<
+		| StateCreation<WritableHeldSelectorToken<T>>
+		| StateDisposal<WritableHeldSelectorToken<T>>
+	>()
+
+	const familyFunction = (key: K): WritableHeldSelectorToken<T> => {
+		const subKey = stringifyJson(key)
+		const family: FamilyMetadata = { key: familyKey, subKey }
+		const fullKey = `${familyKey}(${subKey})`
+		const target = newest(store)
+
+		const token = createWritableHeldSelector(
+			target,
+			{
+				key: fullKey,
+				const: options.const(key),
+				get: options.get(key),
+				set: options.set(key),
+			},
+			family,
+		)
+
+		subject.next({ type: `state_creation`, token })
+		return token
+	}
+
+	const selectorFamily = Object.assign(familyFunction, familyToken, {
+		internalRoles,
+		subject,
+		install: (s: Store) => createWritableHeldSelectorFamily(s, options),
+		default: options.const,
+	}) satisfies WritableHeldSelectorFamily<T, K>
+
+	store.families.set(familyKey, selectorFamily)
+	return familyToken
+}

package/src/internal/families/{create-writable-selector-family.ts → create-writable-pure-selector-family.ts}

@@ -4,9 +4,9 @@ import type {
 	getState,
 	StateCreation,
 	StateDisposal,
-	WritableSelectorFamilyOptions,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
+	WritablePureSelectorFamilyOptions,
+	WritablePureSelectorFamilyToken,
+	WritablePureSelectorToken,
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
@@ -16,46 +16,49 @@ import {
 	getFromStore,
 	getJsonToken,
 	prettyPrintTokenType,
-	type WritableSelectorFamily,
+	type WritablePureSelectorFamily,
 } from ".."
 import { newest } from "../lineage"
-import { createWritableSelector } from "../selector"
+import { createWritablePureSelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 
-export function createWritableSelectorFamily<T, K extends Canonical>(
+export function createWritablePureSelectorFamily<T, K extends Canonical>(
 	store: Store,
-	options: WritableSelectorFamilyOptions<T, K>,
+	options: WritablePureSelectorFamilyOptions<T, K>,
 	internalRoles?: string[],
-): WritableSelectorFamilyToken<T, K> {
+): WritablePureSelectorFamilyToken<T, K> {
+	const familyKey = options.key
+	const type = `writable_pure_selector_family`
+
 	const familyToken = {
-		key: options.key,
-		type: `selector_family`,
-	} as const satisfies WritableSelectorFamilyToken<T, K>
+		key: familyKey,
+		type,
+	} as const satisfies WritablePureSelectorFamilyToken<T, K>
 
-	const existing = store.families.get(options.key)
+	const existing = store.families.get(familyKey)
 	if (existing) {
 		store.logger.error(
 			`❗`,
-			`selector_family`,
-			options.key,
+			type,
+			familyKey,
 			`Overwriting an existing ${prettyPrintTokenType(
 				existing,
 			)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`,
 		)
 	}
 	const subject = new Subject<
-		| StateCreation<WritableSelectorToken<T>>
-		| StateDisposal<WritableSelectorToken<T>>
+		| StateCreation<WritablePureSelectorToken<T>>
+		| StateDisposal<WritablePureSelectorToken<T>>
 	>()
 
-	const familyFunction = (key: K): WritableSelectorToken<T> => {
+	const familyFunction = (key: K): WritablePureSelectorToken<T> => {
 		const subKey = stringifyJson(key)
-		const family: FamilyMetadata = { key: options.key, subKey }
-		const fullKey = `${options.key}(${subKey})`
+		const family: FamilyMetadata = { key: familyKey, subKey }
+		const fullKey = `${familyKey}(${subKey})`
 		const target = newest(store)
 
-		const token = createWritableSelector(
+		const token = createWritablePureSelector(
 			target,
 			{
 				key: fullKey,
@@ -72,7 +75,7 @@ export function createWritableSelectorFamily<T, K extends Canonical>(
 	const selectorFamily = Object.assign(familyFunction, familyToken, {
 		internalRoles,
 		subject,
-		install: (s: Store) => createWritableSelectorFamily(s, options),
+		install: (s: Store) => createWritablePureSelectorFamily(s, options),
 		default: (key: K) => {
 			const getFn = options.get(key)
 			return getFn({
@@ -83,8 +86,8 @@ export function createWritableSelectorFamily<T, K extends Canonical>(
 				json: (token) => getJsonToken(store, token),
 			})
 		},
-	}) satisfies WritableSelectorFamily<T, K>
+	}) satisfies WritablePureSelectorFamily<T, K>
 
-	store.families.set(options.key, selectorFamily)
+	store.families.set(familyKey, selectorFamily)
 	return familyToken
 }

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

@@ -45,8 +45,10 @@ export function disposeFromStore(
 		case `mutable_atom`:
 			disposeAtom(store, token)
 			break
-		case `selector`:
-		case `readonly_selector`:
+		case `writable_pure_selector`:
+		case `readonly_pure_selector`:
+		case `writable_held_selector`:
+		case `readonly_held_selector`:
 			disposeSelector(store, token)
 			break
 	}

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

@@ -5,15 +5,15 @@ import type {
 	MutableAtomToken,
 	ReadableFamilyToken,
 	ReadableToken,
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
+	ReadonlyPureSelectorFamilyToken,
+	ReadonlyPureSelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
 	SelectorFamilyToken,
 	SelectorToken,
 	WritableFamilyToken,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
+	WritablePureSelectorFamilyToken,
+	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
 import { type Canonical, type Json, stringifyJson } from "atom.io/json"
@@ -49,15 +49,15 @@ export function findInStore<T, K extends Canonical, Key extends K>(
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: WritableSelectorFamilyToken<T, K>,
+	token: WritablePureSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T, K>
+): WritablePureSelectorToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: ReadonlySelectorFamilyToken<T, K>,
+	token: ReadonlyPureSelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T, K>
+): ReadonlyPureSelectorToken<T, K>
 
 export function findInStore<T, K extends Canonical, Key extends K>(
 	store: Store,

package/src/internal/families/get-family-of-token.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 { Canonical, Json } from "atom.io/json"
@@ -33,13 +33,13 @@ export function getFamilyOfToken<T, K extends Canonical>(
 
 export function getFamilyOfToken<T, K extends Canonical>(
 	store: Store,
-	token: WritableSelectorToken<T, K>,
-): WritableSelectorFamilyToken<T, K> | undefined
+	token: WritablePureSelectorToken<T, K>,
+): WritablePureSelectorFamilyToken<T, K> | undefined
 
 export function getFamilyOfToken<T, K extends Canonical>(
 	store: Store,
-	token: ReadonlySelectorToken<T, K>,
-): ReadonlySelectorFamilyToken<T, K> | undefined
+	token: ReadonlyPureSelectorToken<T, K>,
+): ReadonlyPureSelectorFamilyToken<T, K> | undefined
 
 export function getFamilyOfToken<T, K extends Canonical>(
 	store: Store,

package/src/internal/families/index.ts

@@ -1,9 +1,9 @@
 export * from "./create-atom-family"
-export * from "./create-readonly-selector-family"
-export * from "./create-readonly-selector-family"
+export * from "./create-readonly-pure-selector-family"
+export * from "./create-readonly-pure-selector-family"
 export * from "./create-regular-atom-family"
 export * from "./create-selector-family"
-export * from "./create-writable-selector-family"
+export * from "./create-writable-pure-selector-family"
 export * from "./dispose-from-store"
 export * from "./find-in-store"
 export * from "./init-family-member"

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

@@ -5,15 +5,15 @@ import type {
 	MutableAtomToken,
 	ReadableFamilyToken,
 	ReadableToken,
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
+	ReadonlyPureSelectorFamilyToken,
+	ReadonlyPureSelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
 	SelectorFamilyToken,
 	SelectorToken,
 	WritableFamilyToken,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
+	WritablePureSelectorFamilyToken,
+	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
 import type { Canonical, Json } from "atom.io/json"
@@ -49,15 +49,15 @@ export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: WritableSelectorFamilyToken<T, K>,
+	token: WritablePureSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T, K>
+): WritablePureSelectorToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: ReadonlySelectorFamilyToken<T, K>,
+	token: ReadonlyPureSelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T, K>
+): ReadonlyPureSelectorToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
@@ -95,8 +95,10 @@ export function initFamilyMemberInStore(
 				case `mutable_atom`:
 					store.on.atomCreation.next(state)
 					break
-				case `selector`:
-				case `readonly_selector`:
+				case `writable_pure_selector`:
+				case `readonly_pure_selector`:
+				case `writable_held_selector`:
+				case `readonly_held_selector`:
 					store.on.selectorCreation.next(state)
 					break
 			}

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

@@ -5,15 +5,15 @@ import type {
 	MutableAtomToken,
 	ReadableFamilyToken,
 	ReadableToken,
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
+	ReadonlyPureSelectorFamilyToken,
+	ReadonlyPureSelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
 	SelectorFamilyToken,
 	SelectorToken,
 	WritableFamilyToken,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
+	WritablePureSelectorFamilyToken,
+	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
 import type { Canonical, Json } from "atom.io/json"
@@ -49,15 +49,15 @@ export function seekInStore<T, K extends Canonical, Key extends K>(
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: WritableSelectorFamilyToken<T, K>,
+	token: WritablePureSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T, K> | undefined
+): WritablePureSelectorToken<T, K> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
-	token: ReadonlySelectorFamilyToken<T, K>,
+	token: ReadonlyPureSelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T, K> | undefined
+): ReadonlyPureSelectorToken<T, K> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
@@ -91,10 +91,12 @@ export function seekInStore(
 		case `mutable_atom_family`:
 			state = target.atoms.get(fullKey)
 			break
-		case `selector_family`:
-			state = target.selectors.get(fullKey)
+		case `writable_held_selector_family`:
+		case `writable_pure_selector_family`:
+			state = target.writableSelectors.get(fullKey)
 			break
-		case `readonly_selector_family`:
+		case `readonly_held_selector_family`:
+		case `readonly_pure_selector_family`:
 			state = target.readonlySelectors.get(fullKey)
 			break
 	}

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

@@ -50,11 +50,14 @@ export function getFromStore(
 			case `atom_family`:
 			case `mutable_atom_family`:
 				return store.defaults.get(family.key)
-			case `selector_family`:
-			case `readonly_selector_family`: {
+			case `readonly_pure_selector_family`:
+			case `writable_pure_selector_family`:
+			case `readonly_held_selector_family`:
+			case `writable_held_selector_family`: {
 				if (store.defaults.has(family.key)) {
 					return store.defaults.get(token.family.key)
 				}
+				3
 				const defaultValue = withdraw(store, family).default(subKey)
 				store.defaults.set(family.key, defaultValue)
 				return defaultValue