atom.io 0.40.6 → 0.40.8

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

@@ -67,17 +67,20 @@ export function registerSelector(
 			updateSelectorAtoms(store, selectorType, selectorKey, token, covered)
 			return dependencyValue
 		},
-		set: (<T, K extends Canonical, New extends T, Key extends K>(
+		set: (<T, K extends Canonical>(
 			...params:
 				| [
 						token: WritableFamilyToken<T, K>,
-						key: Key,
-						value: New | ((oldValue: any) => New),
+						key: NoInfer<K>,
+						value: NoInfer<T> | ((oldValue: T) => NoInfer<T>),
+				  ]
+				| [
+						token: WritableToken<T>,
+						value: NoInfer<T> | ((oldValue: T) => NoInfer<T>),
 				  ]
-				| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
 		) => {
 			const target = newest(store)
-			operateOnStore(target, JOIN_OP, ...params)
+			operateOnStore(JOIN_OP, target, ...params)
 		}) as typeof setState,
 		find: ((...args: Parameters<typeof findState>) =>
 			findInStore(store, ...args)) as typeof findState,

package/src/internal/selector/trace-selector-atoms.ts

@@ -1,5 +1,6 @@
-import type { Atom, Store } from ".."
 import { isAtomKey } from "../keys"
+import type { Atom } from "../state-types"
+import type { Store } from "../store"
 import { getSelectorDependencyKeys } from "./get-selector-dependency-keys"
 
 export function traceRootSelectorAtoms(

package/src/internal/set-state/dispatch-state-update.ts

@@ -5,14 +5,15 @@ import type {
 	TimelineEvent,
 } from "atom.io"
 
-import type { MutableAtom, Subject, WritableFamily, WritableState } from ".."
-import { newest } from ".."
 import { hasRole } from "../atom"
 import { readOrComputeValue } from "../get-state"
+import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
 import { isTransceiver } from "../mutable"
 import type { OpenOperation } from "../operation"
+import type { MutableAtom, WritableFamily, WritableState } from "../state-types"
 import { deposit, type Store } from "../store"
+import type { Subject } from "../subject"
 import { isChildStore, isRootStore } from "../transaction"
 import { evictDownstreamFromAtom } from "./evict-downstream"
 import type { ProtoUpdate } from "./operate-on-store"

package/src/internal/set-state/evict-downstream.ts

@@ -1,7 +1,7 @@
-import type { Atom } from ".."
 import { evictCachedValue } from "../caching"
 import { newest } from "../lineage"
 import { isDone, markDone } from "../operation"
+import type { Atom } from "../state-types"
 import type { Store } from "../store"
 
 export function evictDownstreamFromAtom(

package/src/internal/set-state/operate-on-store.ts

@@ -1,12 +1,12 @@
-import type { WritableFamilyToken, WritableToken } from "atom.io"
+import type { Setter, WritableFamilyToken, WritableToken } from "atom.io"
 import { type Canonical, parseJson } from "atom.io/json"
 
-import type { WritableFamily } from ".."
 import { seekInStore } from "../families"
 import { getFamilyOfToken } from "../families/get-family-of-token"
 import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
 import type { OpenOperation } from "../operation"
 import { closeOperation, openOperation } from "../operation"
+import type { WritableFamily } from "../state-types"
 import { type Store, withdraw } from "../store"
 import { dispatchOrDeferStateUpdate } from "./dispatch-state-update"
 import { resetAtomOrSelector } from "./reset-atom-or-selector"
@@ -18,32 +18,26 @@ export type ProtoUpdate<T> = { oldValue: T; newValue: T }
 export const OWN_OP: unique symbol = Symbol(`OWN_OP`)
 export const JOIN_OP: unique symbol = Symbol(`JOIN_OP`)
 
-export function operateOnStore<
-	T,
-	K extends Canonical,
-	New extends T,
-	Key extends K,
-	E,
->(
-	store: Store,
+export function operateOnStore<T, TT extends T, K extends Canonical, E>(
 	opMode: typeof JOIN_OP | typeof OWN_OP,
+	store: Store,
 	...params:
 		| [
 				token: WritableFamilyToken<T, K, E>,
-				key: Key,
-				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+				key: NoInfer<K>,
+				value: Setter<TT> | TT | typeof RESET_STATE,
 		  ]
 		| [
-				token: WritableToken<T, Key, E>,
-				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+				token: WritableToken<T, any, E>,
+				value: Setter<TT> | TT | typeof RESET_STATE,
 		  ]
 ): void {
-	let existingToken: WritableToken<T, Key, E> | undefined
-	let brandNewToken: WritableToken<T, Key, E> | undefined
-	let token: WritableToken<T, Key, E>
+	let existingToken: WritableToken<T, K, E> | undefined
+	let brandNewToken: WritableToken<T, K, E> | undefined
+	let token: WritableToken<T, K, E>
 	let family: WritableFamily<T, K, E> | undefined
-	let key: Key | null
-	let value: New | typeof RESET_STATE | ((oldValue: T) => New)
+	let key: K | null
+	let value: Setter<TT> | TT | typeof RESET_STATE
 	if (params.length === 2) {
 		token = params[0]
 		value = params[1]
@@ -52,7 +46,7 @@ export function operateOnStore<
 			key = parseJson(token.family.subKey)
 			existingToken = seekInStore(store, family, key)
 			if (!existingToken) {
-				token = brandNewToken = mintInStore(store, family, key, MUST_CREATE)
+				token = brandNewToken = mintInStore(MUST_CREATE, store, family, key)
 			} else {
 				token = existingToken
 			}
@@ -63,7 +57,7 @@ export function operateOnStore<
 		value = params[2]
 		existingToken = seekInStore(store, family, key)
 		if (!existingToken) {
-			token = brandNewToken = mintInStore(store, family, key, MUST_CREATE)
+			token = brandNewToken = mintInStore(MUST_CREATE, store, family, key)
 		} else {
 			token = existingToken
 		}
@@ -90,7 +84,7 @@ export function operateOnStore<
 						action,
 						`from T-${rejectionTime}`,
 					)
-					operateOnStore(store, opMode, token, value)
+					operateOnStore(opMode, store, token, value)
 				},
 			)
 			return

package/src/internal/set-state/reset-atom-or-selector.ts

@@ -1,7 +1,9 @@
-import type { Atom, OpenOperation, Store, WritableState } from ".."
-import { traceRootSelectorAtoms } from ".."
 import { isFn } from "../is-fn"
+import type { OpenOperation } from "../operation"
 import { safeCompute } from "../safe-compute"
+import { traceRootSelectorAtoms } from "../selector"
+import type { Atom, WritableState } from "../state-types"
+import type { Store } from "../store"
 import { dispatchOrDeferStateUpdate } from "./dispatch-state-update"
 import type { ProtoUpdate } from "./operate-on-store"
 import { setAtom } from "./set-atom"
@@ -17,7 +19,7 @@ function resetAtom<T, E>(
 			let def: E | T
 			if (isFn(atom.default)) def = safeCompute(target, atom)
 			else def = atom.default
-			return setAtom(target, atom, def)
+			return setAtom<E | T>(target, atom, def)
 		}
 	}
 }

package/src/internal/set-state/reset-in-store.ts

@@ -14,20 +14,20 @@ export function resetInStore(
 export function resetInStore<K extends Canonical>(
 	store: Store,
 	token: WritableFamilyToken<any, K, any>,
-	key: K,
+	key: NoInfer<K>,
 ): void
 
-export function resetInStore<T, K extends Canonical, Key extends K>(
+export function resetInStore<T, K extends Canonical>(
 	store: Store,
 	...params:
-		| [token: WritableFamilyToken<T, K, any>, key: Key]
+		| [token: WritableFamilyToken<T, K, any>, key: NoInfer<K>]
 		| [token: WritableToken<T, any, any>]
 ): void
 
-export function resetInStore<T, K extends Canonical, Key extends K>(
+export function resetInStore<T, K extends Canonical>(
 	store: Store,
 	...params:
-		| [token: WritableFamilyToken<T, K, any>, key: Key]
+		| [token: WritableFamilyToken<T, K, any>, key: NoInfer<K>]
 		| [token: WritableToken<T, any, any>]
 ): void {
 	const subParams = [...params, RESET_STATE] as const

package/src/internal/set-state/set-atom-or-selector.ts

@@ -1,5 +1,5 @@
-import type { WritableState } from ".."
 import type { OpenOperation } from "../operation"
+import type { WritableState } from "../state-types"
 import type { Store } from "../store"
 import type { ProtoUpdate } from "./operate-on-store"
 import { setAtom } from "./set-atom"
@@ -8,7 +8,7 @@ import { setSelector } from "./set-selector"
 export const setAtomOrSelector = <T>(
 	target: Store & { operation: OpenOperation },
 	state: WritableState<T, any>,
-	value: T | ((oldValue: T) => T),
+	value: NoInfer<T> | ((oldValue: T) => NoInfer<T>),
 ): ProtoUpdate<T> => {
 	let protoUpdate: ProtoUpdate<T>
 	switch (state.type) {

package/src/internal/set-state/set-atom.ts

@@ -1,7 +1,9 @@
-import type { Atom, OpenOperation, Store } from ".."
 import { writeToCache } from "../caching"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
+import type { OpenOperation } from "../operation"
 import { markDone } from "../operation"
+import type { Atom } from "../state-types"
+import type { Store } from "../store"
 import { become } from "./become"
 import { evictDownstreamFromAtom } from "./evict-downstream"
 import type { ProtoUpdate } from "./operate-on-store"
@@ -9,7 +11,7 @@ import type { ProtoUpdate } from "./operate-on-store"
 export const setAtom = <T>(
 	target: Store & { operation: OpenOperation<any> },
 	atom: Atom<T, any>,
-	next: T | ((oldValue: T) => T),
+	next: NoInfer<T> | ((oldValue: T) => NoInfer<T>),
 ): ProtoUpdate<T> => {
 	const oldValue = readOrComputeValue(target, atom, `mut`)
 	let newValue = become(next, oldValue)

package/src/internal/set-state/set-into-store.ts

@@ -1,67 +1,49 @@
-import type { WritableFamilyToken, WritableToken } from "atom.io"
+import type { Setter, WritableFamilyToken, WritableToken } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
 import type { Store } from "../store"
 import { operateOnStore, OWN_OP } from "./operate-on-store"
 import type { RESET_STATE } from "./reset-in-store"
 
-export function setIntoStore<T, New extends T, E>(
+export function setIntoStore<T, TT extends T>(
 	store: Store,
-	token: WritableToken<T, any, E>,
-	value: New | typeof RESET_STATE | ((oldValue: T) => New),
+	token: WritableToken<T, any, any>,
+	value: Setter<TT> | TT | typeof RESET_STATE,
 ): void
 
-export function setIntoStore<
-	T,
-	K extends Canonical,
-	New extends T,
-	Key extends K,
-	E,
->(
+export function setIntoStore<T, TT extends T, K extends Canonical>(
 	store: Store,
-	token: WritableFamilyToken<T, K, E>,
-	key: Key,
-	value: New | typeof RESET_STATE | ((oldValue: T) => New),
+	token: WritableFamilyToken<T, K, any>,
+	key: NoInfer<K>,
+	value: Setter<TT> | TT | typeof RESET_STATE,
 ): void
 
-export function setIntoStore<
-	T,
-	K extends Canonical,
-	New extends T,
-	Key extends K,
-	E,
->(
+export function setIntoStore<T, TT extends T, K extends Canonical>(
 	store: Store,
 	...params:
 		| [
-				token: WritableFamilyToken<T, K, E>,
-				key: Key,
-				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+				token: WritableFamilyToken<T, K, any>,
+				key: NoInfer<K>,
+				value: Setter<TT> | TT | typeof RESET_STATE,
 		  ]
 		| [
-				token: WritableToken<T, any, E>,
-				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+				token: WritableToken<T, any, any>,
+				value: Setter<TT> | TT | typeof RESET_STATE,
 		  ]
 ): void
 
-export function setIntoStore<
-	T,
-	K extends Canonical,
-	New extends T,
-	Key extends K,
-	E,
->(
+export function setIntoStore<T, TT extends T, K extends Canonical>(
 	store: Store,
 	...params:
 		| [
-				token: WritableFamilyToken<T, K, E>,
-				key: Key,
-				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+				token: WritableFamilyToken<T, K, any>,
+				key: NoInfer<K>,
+				value: Setter<TT> | TT | typeof RESET_STATE,
 		  ]
 		| [
-				token: WritableToken<T, any, E>,
-				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+				token: WritableToken<T, any, any>,
+				value: Setter<TT> | TT | typeof RESET_STATE,
 		  ]
 ): void {
-	operateOnStore(store, OWN_OP, ...params)
+	operateOnStore(OWN_OP, store, ...params)
 }

package/src/internal/set-state/set-selector.ts

@@ -1,6 +1,7 @@
-import { readOrComputeValue, type WritableSelector } from ".."
 import { writeToCache } from "../caching"
+import { readOrComputeValue } from "../get-state"
 import { markDone, type OpenOperation } from "../operation"
+import type { WritableSelector } from "../state-types"
 import type { Store } from "../store"
 import { become } from "./become"
 import type { ProtoUpdate } from "./operate-on-store"
@@ -8,7 +9,7 @@ import type { ProtoUpdate } from "./operate-on-store"
 export function setSelector<T>(
 	target: Store & { operation: OpenOperation<any> },
 	selector: WritableSelector<T, any>,
-	next: T | ((oldValue: T) => T),
+	next: NoInfer<T> | ((oldValue: T) => NoInfer<T>),
 ): ProtoUpdate<T> {
 	let oldValue: T
 	let newValue: T

package/src/internal/state-types.ts

@@ -0,0 +1,228 @@
+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"
+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 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>[]
+		__T?: T
+		__E?: E
+	}
+>
+export type MutableAtom<T extends Transceiver<any, any, any>> = Flat<
+	AtomIOState & {
+		type: `mutable_atom`
+		class: ConstructorOf<T>
+		cleanup?: () => void
+		__T?: T
+	}
+>
+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
+		__T?: T
+	}
+>
+export type ReadonlyHeldSelector<T> = Flat<
+	AtomIOState & {
+		type: `readonly_held_selector`
+		const: T
+		getFrom: (target: Store) => T
+		__T?: 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>[]
+		__T?: T
+		__E?: E
+	}
+>
+export type ReadonlyPureSelector<T, E> = Flat<
+	AtomIOState & {
+		type: `readonly_pure_selector`
+		getFrom: (target: Store) => E | T
+		catch?: readonly Ctor<E>[]
+		__T?: T
+		__E?: 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/store/deposit.ts

@@ -22,11 +22,11 @@ import type {
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
+import type { Transceiver } from "../mutable"
 import type {
 	Atom,
 	AtomFamily,
 	AtomIOInternalResource,
-	Fn,
 	MutableAtom,
 	MutableAtomFamily,
 	ReadableFamily,
@@ -37,14 +37,14 @@ import type {
 	RegularAtomFamily,
 	Selector,
 	SelectorFamily,
-	Timeline,
-	Transceiver,
 	WritableFamily,
 	WritablePureSelector,
 	WritablePureSelectorFamily,
 	WritableState,
-} from ".."
+} from "../state-types"
+import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
+import type { Fn } from "../utility-types"
 
 export function deposit<T, E>(
 	state: RegularAtom<T, E>,

package/src/internal/store/index.ts

@@ -1,5 +1,4 @@
 export * from "./circular-buffer"
 export * from "./deposit"
-export * from "./mint-or-counterfeit"
 export * from "./store"
 export * from "./withdraw"

package/src/internal/store/store.ts

@@ -10,6 +10,14 @@ import type {
 import { AtomIOLogger } from "atom.io"
 import type { Canonical, stringified } from "atom.io/json"
 
+import type { Join } from "../join"
+import { Junction } from "../junction"
+import type { Lineage } from "../lineage"
+import type { Molecule } from "../molecule"
+import type { Tracker, Transceiver } from "../mutable"
+import { getJsonToken, getUpdateToken } from "../mutable"
+import type { OperationProgress } from "../operation"
+import { isReservedIntrospectionKey } from "../reserved-keys"
 import type {
 	Atom,
 	HeldSelectorFamily,
@@ -18,15 +26,7 @@ import type {
 	ReadonlySelector,
 	RegularAtomFamily,
 	WritableSelector,
-} from ".."
-import { isReservedIntrospectionKey } from ".."
-import type { Join } from "../join"
-import { Junction } from "../junction"
-import type { Lineage } from "../lineage"
-import type { Molecule } from "../molecule"
-import type { Tracker, Transceiver } from "../mutable"
-import { getJsonToken, getUpdateToken } from "../mutable"
-import type { OperationProgress } from "../operation"
+} from "../state-types"
 import { StatefulSubject, Subject } from "../subject"
 import type { Timeline } from "../timeline"
 import type {

package/src/internal/store/withdraw.ts

@@ -34,11 +34,12 @@ import type {
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
+import type { Transceiver } from "../mutable"
+import { NotFoundError } from "../not-found-error"
 import type {
 	Atom,
 	AtomFamily,
 	AtomIOInternalResource,
-	Fn,
 	HeldSelector,
 	HeldSelectorFamily,
 	MutableAtom,
@@ -57,7 +58,6 @@ import type {
 	RegularAtomFamily,
 	Selector,
 	SelectorFamily,
-	Transceiver,
 	WritableFamily,
 	WritableHeldSelector,
 	WritableHeldSelectorFamily,
@@ -66,10 +66,10 @@ import type {
 	WritableSelector,
 	WritableSelectorFamily,
 	WritableState,
-} from ".."
-import { NotFoundError } from ".."
+} from "../state-types"
 import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
+import type { Fn } from "../utility-types"
 import type { Store } from "./store"
 
 export function withdraw<T, E>(