atom.io 0.40.6 → 0.40.8

package/src/internal/get-state/get-fallback.ts

@@ -1,14 +1,14 @@
 import type { ReadableToken, ViewOf } from "atom.io"
 import { type Canonical, stringifyJson } from "atom.io/json"
 
-import type { ReadableFamily } from ".."
+import type { ReadableFamily } from "../state-types"
 import type { Store } from "../store"
 
 export function getFallback<T, K extends Canonical, E>(
 	store: Store,
 	token: ReadableToken<T, K, E>,
 	family: ReadableFamily<T, K, E>,
-	subKey: K,
+	subKey: NoInfer<K>,
 ): ViewOf<E | T> {
 	const disposal = store.disposalTraces.buffer.find(
 		(item) => item?.key === stringifyJson(subKey),

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

@@ -16,20 +16,20 @@ export function getFromStore<T, E>(
 export function getFromStore<T, K extends Canonical, E>(
 	store: Store,
 	token: ReadableFamilyToken<T, K, E>,
-	key: K,
+	key: NoInfer<K>,
 ): ViewOf<E | T>
 
-export function getFromStore<T, K extends Canonical, Key extends K, E>(
+export function getFromStore<T, K extends Canonical, E>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<T, K, E>, key: Key]
+		| [token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>]
 		| [token: ReadableToken<T, any, E>]
 ): ViewOf<E | T>
 
-export function getFromStore<T, K extends Canonical, Key extends K, E>(
+export function getFromStore<T, K extends Canonical, E>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<T, K, E>, key: Key]
+		| [token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>]
 		| [token: ReadableToken<T, any, E>]
 ): ViewOf<E | T> {
 	const { token, family, subKey } = reduceReference(store, ...params)

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

@@ -1,8 +1,8 @@
 import type { ViewOf } from "atom.io"
 
-import type { ReadableState } from ".."
 import { readFromCache, writeToCache } from "../caching"
 import { safeCompute } from "../safe-compute"
+import type { ReadableState } from "../state-types"
 import type { Store } from "../store"
 
 export function readOrComputeValue<T, E>(

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

@@ -5,23 +5,25 @@ import type {
 } from "atom.io"
 import { type Canonical, parseJson } from "atom.io/json"
 
-import type { ReadableFamily, Subject } from ".."
-import { isChildStore, isRootStore, newest } from ".."
 import { seekInStore } from "../families"
 import { getFamilyOfToken } from "../families/get-family-of-token"
 import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
+import { newest } from "../lineage"
+import type { ReadableFamily } from "../state-types"
 import type { Store } from "../store"
 import { withdraw } from "../store"
+import type { Subject } from "../subject"
+import { isChildStore, isRootStore } from "../transaction"
 
 export function reduceReference<T, K extends Canonical, E>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<T, K, E>, key: K]
+		| [token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>]
 		| [token: ReadableToken<T, K, E>]
 ): {
 	token: ReadableToken<T, K, E>
 	family: ReadableFamily<T, K, E> | undefined
-	subKey: K | undefined
+	subKey: NoInfer<K> | undefined
 	isNew: boolean
 } {
 	let existingToken: ReadableToken<T, K, E> | undefined
@@ -45,7 +47,7 @@ export function reduceReference<T, K extends Canonical, E>(
 				}
 			}
 			if (!existingToken) {
-				brandNewToken = mintInStore(store, familyToken, subKey, MUST_CREATE)
+				brandNewToken = mintInStore(MUST_CREATE, store, familyToken, subKey)
 				token = brandNewToken
 			} else {
 				token = existingToken
@@ -56,7 +58,7 @@ export function reduceReference<T, K extends Canonical, E>(
 		subKey = params[1]
 		existingToken = seekInStore(store, family, subKey)
 		if (!existingToken) {
-			brandNewToken = mintInStore(store, family, subKey, MUST_CREATE)
+			brandNewToken = mintInStore(MUST_CREATE, store, family, subKey)
 			token = brandNewToken
 		} else {
 			token = existingToken

package/src/internal/index.ts

@@ -1,30 +1,3 @@
-import type {
-	FamilyMetadata,
-	MutableAtomFamilyToken,
-	MutableAtomToken,
-	ReadonlyHeldSelectorFamilyToken,
-	ReadonlyHeldSelectorToken,
-	ReadonlyPureSelectorFamilyToken,
-	ReadonlyPureSelectorToken,
-	RegularAtomFamilyToken,
-	RegularAtomToken,
-	StateLifecycleEvent,
-	StateUpdate,
-	WritableHeldSelectorFamilyToken,
-	WritableHeldSelectorToken,
-	WritablePureSelectorFamilyToken,
-	WritablePureSelectorToken,
-} from "atom.io"
-import type { Canonical } from "atom.io/json"
-
-import type { internalRole } from "./atom/has-role"
-import type { ConstructorOf, Transceiver } from "./mutable"
-import type { Store } from "./store"
-import type { Subject } from "./subject"
-import type { Timeline } from "./timeline"
-import type { RootStore, Transaction } from "./transaction"
-import type { Ctor, Flat } from "./utility-types"
-
 export * from "./arbitrary"
 export * from "./atom"
 export * from "./caching"
@@ -36,6 +9,7 @@ export * from "./get-environment-data"
 export * from "./get-state"
 export * from "./get-trace"
 export * from "./install-into-store"
+export * from "./is-fn"
 export * from "./join"
 export * from "./junction"
 export * from "./keys"
@@ -48,202 +22,10 @@ export * from "./overlays"
 export * from "./reserved-keys"
 export * from "./selector"
 export * from "./set-state"
+export type * from "./state-types"
 export * from "./store"
 export * from "./subject"
 export * from "./subscribe"
 export * from "./timeline"
 export * from "./transaction"
 export type * from "./utility-types"
-
-export type AtomIOState = {
-	key: string
-	family?: FamilyMetadata
-	install: (store: RootStore) => void
-	subject: Subject<StateUpdate<any>>
-}
-export type RegularAtom<T, E> = Flat<
-	AtomIOState & {
-		type: `atom`
-		default: T | (() => T)
-		cleanup?: () => void
-		internalRoles?: internalRole[]
-		catch?: readonly Ctor<E>[]
-	}
->
-export type MutableAtom<T extends Transceiver<any, any, any>> = Flat<
-	AtomIOState & {
-		type: `mutable_atom`
-		class: ConstructorOf<T>
-		cleanup?: () => void
-	}
->
-export type Atom<T, E> =
-	| RegularAtom<T, E>
-	| (T extends Transceiver<any, any, any> ? MutableAtom<T> : never)
-
-export type WritableHeldSelector<T> = Flat<
-	AtomIOState & {
-		type: `writable_held_selector`
-		const: T
-		getFrom: (target: Store) => T
-		setSelf: (newValue: T) => void
-	}
->
-export type ReadonlyHeldSelector<T> = Flat<
-	AtomIOState & {
-		type: `readonly_held_selector`
-		const: T
-		getFrom: (target: Store) => T
-	}
->
-export type WritablePureSelector<T, E> = Flat<
-	AtomIOState & {
-		type: `writable_pure_selector`
-		getFrom: (target: Store) => E | T
-		setSelf: (newValue: T) => void
-		catch?: readonly Ctor<E>[]
-	}
->
-export type ReadonlyPureSelector<T, E> = Flat<
-	AtomIOState & {
-		type: `readonly_pure_selector`
-		getFrom: (target: Store) => E | T
-		catch?: readonly Ctor<E>[]
-	}
->
-export type ReadonlySelector<T, E> =
-	| ReadonlyHeldSelector<T>
-	| ReadonlyPureSelector<T, E>
-export type WritableSelector<T, E> =
-	| WritableHeldSelector<T>
-	| WritablePureSelector<T, E>
-export type HeldSelector<T> = ReadonlyHeldSelector<T> | WritableHeldSelector<T>
-export type PureSelector<T, E> =
-	| ReadonlyPureSelector<T, E>
-	| WritablePureSelector<T, E>
-export type Selector<T, E> =
-	| ReadonlyHeldSelector<T>
-	| ReadonlyPureSelector<T, E>
-	| WritableHeldSelector<T>
-	| WritablePureSelector<T, E>
-
-export type WritableState<T, E> = Atom<T, E> | WritableSelector<T, E>
-export type ReadableState<T, E> = Atom<T, E> | Selector<T, E>
-
-// biome-ignore format: intersection
-export type RegularAtomFamily<T, K extends Canonical, E = never> =
-	& Flat<
-		& RegularAtomFamilyToken<T, K, E>
-		& {
-			create: <Key extends K>(key: Key) => RegularAtomToken<T, Key, E>
-			default: T | ((key: K) => T)
-			install: (store: RootStore) => void
-			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<RegularAtomToken<T, K, E>>>
-		}
-	>
-
-// biome-ignore format: intersection
-export type MutableAtomFamily<
-	T extends Transceiver<any, any, any>,
-	K extends Canonical,
-> =
-	& Flat<
-		& MutableAtomFamilyToken<T, K>
-		& {
-				create: <Key extends K>(key: Key) => MutableAtomToken<T, Key>
-				class: ConstructorOf<T>
-				install: (store: RootStore) => void
-				internalRoles: string[] | undefined
-				subject: Subject<StateLifecycleEvent<MutableAtomToken<T>>>
-			}
-	>
-
-export type AtomFamily<T, K extends Canonical, E> =
-	| MutableAtomFamily<T extends Transceiver<any, any, any> ? T : never, K>
-	| RegularAtomFamily<T, K, E>
-
-// biome-ignore format: intersection
-export type WritablePureSelectorFamily<T, K extends Canonical, E> =
-	& Flat<
-		& WritablePureSelectorFamilyToken<T, K, E>
-		& {
-			create: <Key extends K>(key: Key) => WritablePureSelectorToken<T, Key, E>
-			default: (key: K) => T,
-			install: (store: RootStore) => void
-			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<WritablePureSelectorToken<T, K, E>>>
-		}
-	>
-
-// biome-ignore format: intersection
-export type WritableHeldSelectorFamily<T , K extends Canonical> =
-	& Flat<
-		& WritableHeldSelectorFamilyToken<T, K>
-		& {
-			create: <Key extends K>(key: Key) => WritableHeldSelectorToken<T, Key>
-			default: (key: K) => T,
-			install: (store: RootStore) => void
-			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<WritableHeldSelectorToken<T, K>>>
-		}
-	>
-
-// biome-ignore format: intersection
-export type ReadonlyPureSelectorFamily<T, K extends Canonical, E> =
-	& Flat<
-		& ReadonlyPureSelectorFamilyToken<T, K, E>
-		& {
-			create: <Key extends K>(key: Key) => ReadonlyPureSelectorToken<T, Key, E>
-			default: (key: K) => T,
-			install: (store: RootStore) => void
-			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<ReadonlyPureSelectorToken<T, K, E>>>
-		}
-	>
-
-// biome-ignore format: intersection
-export type ReadonlyHeldSelectorFamily<T , K extends Canonical> =
-	& Flat<
-		& ReadonlyHeldSelectorFamilyToken<T, K>
-		& {
-			create: <Key extends K>(key: Key) => ReadonlyHeldSelectorToken<T, Key>
-			default: (key: K) => T,
-			install: (store: RootStore) => void
-			internalRoles: string[] | undefined
-			subject: Subject<StateLifecycleEvent<ReadonlyHeldSelectorToken<T>>>
-		}
-	>
-
-export type PureSelectorFamily<T, K extends Canonical, E> =
-	| ReadonlyPureSelectorFamily<T, K, E>
-	| WritablePureSelectorFamily<T, K, E>
-
-export type HeldSelectorFamily<T, K extends Canonical> =
-	| ReadonlyHeldSelectorFamily<T, K>
-	| WritableHeldSelectorFamily<T, K>
-
-export type ReadonlySelectorFamily<T, K extends Canonical, E> =
-	| ReadonlyHeldSelectorFamily<T, K>
-	| ReadonlyPureSelectorFamily<T, K, E>
-
-export type WritableSelectorFamily<T, K extends Canonical, E> =
-	| WritableHeldSelectorFamily<T, K>
-	| WritablePureSelectorFamily<T, K, E>
-
-export type SelectorFamily<T, K extends Canonical, E> =
-	| HeldSelectorFamily<T, K>
-	| PureSelectorFamily<T, K, E>
-
-export type WritableFamily<T, K extends Canonical, E> =
-	| AtomFamily<T, K, E>
-	| WritableSelectorFamily<T, K, E>
-export type ReadableFamily<T, K extends Canonical, E> =
-	| AtomFamily<T, K, E>
-	| SelectorFamily<T, K, E>
-
-export type AtomIOInternalResource =
-	| ReadableFamily<any, any, any>
-	| ReadableState<any, any>
-	| Timeline<any>
-	| Transaction<any>

package/src/internal/molecule.ts

@@ -19,7 +19,6 @@ import { getFromStore } from "./get-state"
 import { getTrace } from "./get-trace"
 import { newest } from "./lineage"
 import type { Store } from "./store"
-import { IMPLICIT } from "./store"
 import type { RootStore } from "./transaction"
 import { createTransaction, isChildStore } from "./transaction"
 
@@ -30,8 +29,8 @@ export type Molecule<K extends Canonical> = {
 }
 
 export function makeRootMoleculeInStore<S extends string>(
+	store: Store,
 	key: S,
-	store: Store = IMPLICIT.STORE,
 ): S {
 	const molecule = {
 		key,

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

@@ -10,11 +10,12 @@ import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { MutableAtomFamily, RootStore } from ".."
-import { createWritablePureSelectorFamily } from ".."
+import { createWritablePureSelectorFamily } from "../families"
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
+import type { MutableAtomFamily } from "../state-types"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 import { FamilyTracker } from "./tracker-family"
 import type { AsJSON, Transceiver } from "./transceiver"
 

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

@@ -5,12 +5,14 @@ import type {
 	UpdateHandler,
 } from "atom.io"
 
-import type { MutableAtom, RootStore } from ".."
-import { createStandaloneSelector, resetInStore, setIntoStore } from ".."
 import { newest } from "../lineage"
+import { createStandaloneSelector } from "../selector"
+import { resetInStore, setIntoStore } from "../set-state"
+import type { MutableAtom } from "../state-types"
 import { deposit, type Store } from "../store"
 import { Subject } from "../subject"
 import { subscribeToState } from "../subscribe"
+import type { RootStore } from "../transaction"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
 

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

@@ -1,8 +1,8 @@
 import type { MutableAtomFamilyToken } from "atom.io"
 import type { Canonical, Json } from "atom.io/json"
 
-import type { WritablePureSelectorFamily } from ".."
 import { newest } from "../lineage"
+import type { WritablePureSelectorFamily } from "../state-types"
 import type { Store } from "../store"
 import type { Transceiver } from "./transceiver"
 

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

@@ -1,8 +1,8 @@
 import type { MutableAtomFamilyToken } from "atom.io"
 import type { Json } from "atom.io/json"
 
-import type { RegularAtomFamily } from ".."
 import { newest } from "../lineage"
+import type { RegularAtomFamily } from "../state-types"
 import type { Store } from "../store"
 import type { SignalFrom, Transceiver } from "./transceiver"
 

package/src/internal/mutable/tracker-family.ts

@@ -2,9 +2,10 @@ import type { MutableAtomToken, StateLifecycleEvent } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
-import type { MutableAtomFamily, RegularAtomFamily, RootStore } from ".."
 import { createRegularAtomFamily } from "../families"
+import type { MutableAtomFamily, RegularAtomFamily } from "../state-types"
 import { withdraw } from "../store"
+import type { RootStore } from "../transaction"
 import { Tracker } from "./tracker"
 import type { SignalFrom, Transceiver } from "./transceiver"
 

package/src/internal/mutable/tracker.ts

@@ -1,14 +1,17 @@
-import type { FamilyMetadata, MutableAtomToken, RegularAtomToken } from "atom.io"
+import type {
+	FamilyMetadata,
+	MutableAtomToken,
+	RegularAtomToken,
+	StateUpdate,
+} from "atom.io"
 
-import type { Store } from ".."
-import {
-	getFromStore,
-	newest,
-	setIntoStore,
-	subscribeToState,
-	subscribeToTimeline,
-} from ".."
 import { createRegularAtom } from "../atom"
+import { getFromStore } from "../get-state"
+import { newest } from "../lineage"
+import { setIntoStore } from "../set-state"
+import { JOIN_OP, operateOnStore } from "../set-state/operate-on-store"
+import type { Store } from "../store"
+import { subscribeToState, subscribeToTimeline } from "../subscribe"
 import { isChildStore } from "../transaction/is-root-store"
 import type { SignalFrom, Transceiver } from "./transceiver"
 
@@ -64,9 +67,9 @@ export class Tracker<T extends Transceiver<any, any, any>> {
 		const storeStatus = isChildStore(target)
 			? target.transactionMeta.update.token.key
 			: `main`
-		const subscriptionKey = `tracker:${storeName}:${storeStatus}:${stateKey}`
+		const subscriptionKey = `tracker-from-core:${storeName}:${storeStatus}:${stateKey}`
 		const trackerCapturesOutboundSignal = (update: SignalFrom<T>) => {
-			setIntoStore(target, latestSignalState, update)
+			operateOnStore(JOIN_OP, target, latestSignalState, update)
 		}
 		const originalInnerValue = getFromStore(target, mutableState)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
@@ -94,60 +97,69 @@ export class Tracker<T extends Transceiver<any, any, any>> {
 		latestSignalState: RegularAtomToken<SignalFrom<T> | null>,
 		target: Store,
 	): void {
-		const subscriptionKey = `tracker:${target.config.name}:${
-			isChildStore(target) ? target.transactionMeta.update.token.key : `main`
-		}:${mutableState.key}`
+		const stateKey = mutableState.key
+		const storeName = target.config.name
+		const storeStatus = isChildStore(target)
+			? target.transactionMeta.update.token.key
+			: `main`
+		const subscriptionKey = `tracker-to-core:${storeName}:${storeStatus}:${stateKey}`
 		subscribeToState(
 			target,
 			latestSignalState,
 			subscriptionKey,
-			function trackerCapturesInboundSignal({ newValue, oldValue }) {
-				const timelineId = target.timelineTopics.getRelatedKey(
-					latestSignalState.key,
-				)
-
-				if (timelineId && target.timelines.get(timelineId)?.timeTraveling) {
-					const unsubscribe = subscribeToTimeline(
-						target,
-						{ key: timelineId, type: `timeline` },
-						subscriptionKey,
-						function trackerWaitsForTimeTravelToFinish(update) {
-							unsubscribe()
-							setIntoStore(target, mutableState, (transceiver) => {
-								if (update === `redo` && newValue) {
-									transceiver.do(newValue)
-								} else if (update === `undo` && oldValue) {
-									transceiver.undo(oldValue)
-								}
-								return transceiver
-							})
-						},
+			Object.assign(
+				function trackerCapturesInboundSignal({
+					newValue,
+					oldValue,
+				}: StateUpdate<SignalFrom<T> | null>) {
+					const timelineId = target.timelineTopics.getRelatedKey(
+						latestSignalState.key,
 					)
-					return
-				}
 
-				const mutable = getFromStore(target, mutableState)
-				const updateNumber = mutable.getUpdateNumber(newValue)
-				const eventOffset = updateNumber - mutable.cacheUpdateNumber
-				if (newValue && eventOffset === 1) {
-					setIntoStore(
-						target,
-						mutableState,
-						(transceiver) => (transceiver.do(newValue), transceiver),
-					)
-				} else {
-					const expected = mutable.cacheUpdateNumber + 1
-					target.logger.info(
-						`❌`,
-						`mutable_atom`,
-						mutableState.key,
-						`could not be updated. Expected update number`,
-						expected,
-						`but got`,
-						updateNumber,
-					)
-				}
-			},
+					if (timelineId && target.timelines.get(timelineId)?.timeTraveling) {
+						const unsubscribe = subscribeToTimeline(
+							target,
+							{ key: timelineId, type: `timeline` },
+							subscriptionKey,
+							function trackerWaitsForTimeTravelToFinish(update) {
+								unsubscribe()
+								setIntoStore(target, mutableState, (transceiver) => {
+									if (update === `redo` && newValue) {
+										transceiver.do(newValue)
+									} else if (update === `undo` && oldValue) {
+										transceiver.undo(oldValue)
+									}
+									return transceiver
+								})
+							},
+						)
+						return
+					}
+
+					const mutable = getFromStore(target, mutableState)
+					const updateNumber = mutable.getUpdateNumber(newValue)
+					const eventOffset = updateNumber - mutable.cacheUpdateNumber
+					if (newValue && eventOffset === 1) {
+						setIntoStore(
+							target,
+							mutableState,
+							(transceiver) => (transceiver.do(newValue), transceiver),
+						)
+					} else {
+						const expected = mutable.cacheUpdateNumber + 1
+						target.logger.info(
+							`❌`,
+							`mutable_atom`,
+							mutableState.key,
+							`could not be updated. Expected update number`,
+							expected,
+							`but got`,
+							updateNumber,
+						)
+					}
+				},
+				{ inboundTracker: true },
+			),
 		)
 	}
 

package/src/internal/safe-compute.ts

@@ -1,6 +1,6 @@
-import type { PureSelector, RegularAtom } from "."
 import { writeToCache } from "./caching"
 import { isFn } from "./is-fn"
+import type { PureSelector, RegularAtom } from "./state-types"
 import type { Store } from "./store"
 
 export function safeCompute<T, E>(

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

@@ -4,11 +4,12 @@ import type {
 	ReadonlyHeldSelectorToken,
 } from "atom.io"
 
-import type { ReadonlyHeldSelector, RootStore } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
+import type { ReadonlyHeldSelector } from "../state-types"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
 export function createReadonlyHeldSelector<T extends object>(

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

@@ -6,11 +6,12 @@ import type {
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
-import type { ReadonlyPureSelector, RootStore } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
+import type { ReadonlyPureSelector } from "../state-types"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
 export function createReadonlyPureSelector<T, K extends Canonical, E>(

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

@@ -4,11 +4,12 @@ import type {
 	WritableHeldSelectorToken,
 } from "atom.io"
 
-import type { RootStore, WritableHeldSelector } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
+import type { WritableHeldSelector } from "../state-types"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
 export function createWritableHeldSelector<T extends object>(

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

@@ -6,11 +6,12 @@ import type {
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
-import type { RootStore, WritablePureSelector } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
+import type { WritablePureSelector } from "../state-types"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
 export function createWritablePureSelector<T, K extends Canonical, E>(

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

@@ -1,7 +1,8 @@
 import type { SelectorFamilyToken, SelectorToken } from "atom.io"
 
-import type { Store } from ".."
-import { isChildStore, newest, withdraw } from ".."
+import { newest } from "../lineage"
+import { type Store, withdraw } from "../store"
+import { isChildStore } from "../transaction"
 
 export function disposeSelector(
 	store: Store,