atom.io 0.36.0 → 0.36.2

package/src/internal/mutable/transceiver.ts

@@ -1,6 +1,7 @@
 import type { Json } from "atom.io/json"
 
 export interface Transceiver<
+	V,
 	S extends Json.Serializable,
 	J extends Json.Serializable,
 > {
@@ -9,20 +10,21 @@ export interface Transceiver<
 	subscribe: (key: string, fn: (update: S) => void) => () => void
 	cacheUpdateNumber: number
 	getUpdateNumber: (update: S) => number
+	view: () => V
 	toJSON: () => J
 }
 
 // biome-ignore format: intersection
 export type TransceiverConstructor<
   J extends Json.Serializable,
-  T extends Transceiver<any, J>
+  T extends Transceiver<any, any, J>
 > =
 	& ( new () => T )
 	& { fromJSON: (json: J) => T }
 
 export function isTransceiver(
 	value: unknown,
-): value is Transceiver<Json.Serializable, Json.Serializable> {
+): value is Transceiver<any, Json.Serializable, Json.Serializable> {
 	return (
 		typeof value === `object` &&
 		value !== null &&
@@ -34,21 +36,20 @@ export function isTransceiver(
 
 export type TransceiverMode = `playback` | `record` | `transaction`
 
-export type SignalFrom<T extends Transceiver<any, any>> = T extends Transceiver<
-	infer S,
-	any
->
-	? S
-	: never
+export type ViewOf<T> = T extends Transceiver<infer V, any, any> ? V : T
 
-export type AsJSON<T extends Transceiver<any, any>> = T extends Transceiver<
+export type SignalFrom<T extends Transceiver<any, any, any>> =
+	T extends Transceiver<any, infer S, any> ? S : never
+
+export type AsJSON<T extends Transceiver<any, any, any>> = T extends Transceiver<
+	any,
 	any,
 	infer J
 >
 	? J
 	: never
 
-export type ConstructorOf<T extends Transceiver<any, any>> =
+export type ConstructorOf<T extends Transceiver<any, any, any>> =
 	TransceiverConstructor<AsJSON<T>, T>
 
 /*

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

@@ -5,7 +5,7 @@ import type {
 } from "atom.io"
 
 import type { ReadonlyHeldSelector } from ".."
-import { cacheValue } from "../caching"
+import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { Subject } from "../subject"
@@ -34,7 +34,7 @@ export const createReadonlyHeldSelector = <T extends object>(
 		}
 		innerTarget.selectorAtoms.delete(key)
 		options.get({ get, find, json }, constant)
-		cacheValue(newest(store), key, constant, subject)
+		writeToCache(newest(store), readonlySelector, constant)
 		covered.clear()
 		return constant
 	}

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

@@ -5,7 +5,7 @@ import type {
 } from "atom.io"
 
 import type { ReadonlyPureSelector } from ".."
-import { cacheValue } from "../caching"
+import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { Subject } from "../subject"
@@ -34,7 +34,7 @@ export const createReadonlyPureSelector = <T>(
 		}
 		innerTarget.selectorAtoms.delete(key)
 		const value = options.get({ get, find, json })
-		const cached = cacheValue(innerTarget, key, value, subject)
+		const cached = writeToCache(innerTarget, readonlySelector, value)
 		store.logger.info(`✨`, type, key, `=`, cached)
 		covered.clear()
 		return cached

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

@@ -5,7 +5,7 @@ import type {
 } from "atom.io"
 
 import type { WritableHeldSelector } from ".."
-import { cacheValue } from "../caching"
+import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import { markDone } from "../operation"
 import { become } from "../set-state"
@@ -39,7 +39,7 @@ export const createWritableHeldSelector = <T extends object>(
 		}
 		innerTarget.selectorAtoms.delete(key)
 		getFn(getterToolkit, constant)
-		cacheValue(innerTarget, key, constant, subject)
+		writeToCache(innerTarget, mySelector, constant)
 		store.logger.info(`✨`, type, key, `=`, constant)
 		covered.clear()
 		return constant
@@ -50,7 +50,7 @@ export const createWritableHeldSelector = <T extends object>(
 		const oldValue = getSelf(options.get, innerTarget)
 		const newValue = become(next)(oldValue)
 		store.logger.info(`📝`, type, key, `set (`, oldValue, `->`, newValue, `)`)
-		cacheValue(innerTarget, key, newValue, subject)
+		writeToCache(innerTarget, mySelector, newValue)
 		markDone(innerTarget, key)
 		if (isRootStore(innerTarget)) {
 			subject.next({ newValue, oldValue })
@@ -67,7 +67,6 @@ export const createWritableHeldSelector = <T extends object>(
 		...(family && { family }),
 	}
 	target.writableSelectors.set(key, mySelector)
-	// const initialValue = getSelf()
 
 	const token: WritableHeldSelectorToken<T> = { key, type }
 	if (family) {

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

@@ -5,7 +5,7 @@ import type {
 } from "atom.io"
 
 import type { WritablePureSelector } from ".."
-import { cacheValue } from "../caching"
+import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import { markDone } from "../operation"
 import { become } from "../set-state"
@@ -39,7 +39,7 @@ export const createWritablePureSelector = <T>(
 		}
 		innerTarget.selectorAtoms.delete(key)
 		const value = getFn(getterToolkit)
-		const cached = cacheValue(innerTarget, key, value, subject)
+		const cached = writeToCache(innerTarget, mySelector, value)
 		store.logger.info(`✨`, type, key, `=`, cached)
 		covered.clear()
 		return value
@@ -50,7 +50,7 @@ export const createWritablePureSelector = <T>(
 		const oldValue = getSelf(options.get, innerTarget)
 		const newValue = become(next)(oldValue)
 		store.logger.info(`📝`, type, key, `set (`, oldValue, `->`, newValue, `)`)
-		cacheValue(innerTarget, options.key, newValue, subject)
+		writeToCache(innerTarget, mySelector, newValue)
 		markDone(innerTarget, options.key)
 		if (isRootStore(innerTarget)) {
 			subject.next({ newValue, oldValue })

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

@@ -1,16 +1,17 @@
-import type { Atom, Selector } from ".."
+import type { Atom } from ".."
 import { evictCachedValue } from "../caching"
 import { newest } from "../lineage"
 import { isDone, markDone } from "../operation"
 import type { Store } from "../store"
 
-export function evictDownStream(store: Store, atom: Atom<any>): void {
+export function evictDownstreamFromAtom(store: Store, atom: Atom<any>): void {
 	const target = newest(store)
-	const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key)
+	const { key, type } = atom
+	const downstreamKeys = target.selectorAtoms.getRelatedKeys(key)
 	target.logger.info(
 		`🧹`,
-		atom.type,
-		atom.key,
+		type,
+		key,
 		downstreamKeys
 			? `evicting ${downstreamKeys.size} states downstream:`
 			: `no downstream states`,
@@ -20,36 +21,37 @@ export function evictDownStream(store: Store, atom: Atom<any>): void {
 		if (target.operation.open) {
 			target.logger.info(
 				`🧹`,
-				atom.type,
-				atom.key,
+				type,
+				key,
 				`[ ${[...target.operation.done].join(`, `)} ] already done`,
 			)
 		}
-		for (const key of downstreamKeys) {
-			if (isDone(target, key)) {
+		for (const downstreamKey of downstreamKeys) {
+			if (isDone(target, downstreamKey)) {
 				continue
 			}
-			evictCachedValue(target, key)
-			markDone(target, key)
+			evictCachedValue(target, downstreamKey)
+			markDone(target, downstreamKey)
 		}
 	}
 }
 
-export function evictDownStreamFromSelector(
+export function evictDownstreamFromSelector(
 	store: Store,
-	selector: Selector<any>,
+	selectorKey: string,
 ): void {
 	const target = newest(store)
 	const relationEntries = target.selectorGraph
 		.getRelationEntries({
-			upstreamSelectorKey: selector.key,
+			upstreamSelectorKey: selectorKey,
 		})
-		.filter(([_, { source }]) => source === selector.key)
+		.filter(([_, { source }]) => source === selectorKey)
 	for (const [downstreamSelectorKey] of relationEntries) {
 		if (isDone(target, downstreamSelectorKey)) {
 			continue
 		}
 		evictCachedValue(target, downstreamSelectorKey)
 		markDone(target, downstreamSelectorKey)
+		evictDownstreamFromSelector(store, downstreamSelectorKey)
 	}
 }

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

@@ -1,4 +1,5 @@
 export * from "./become"
+export * from "./evict-downstream"
 export * from "./reset-atom-or-selector"
 export * from "./reset-in-store"
 export * from "./set-atom-or-selector"

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

@@ -1,12 +1,10 @@
 import type { WritableFamilyToken, WritableToken } from "atom.io"
-import { type Canonical, parseJson } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
-import { findInStore } from "../families"
-import { getFamilyOfToken } from "../families/get-family-of-token"
-import { closeOperation, openOperation } from "../operation"
 import type { Store } from "../store"
-import { withdraw } from "../store"
-import { resetAtomOrSelector } from "./reset-atom-or-selector"
+import { setIntoStore } from "./set-into-store"
+
+export const RESET_STATE: unique symbol = Symbol(`RESET`)
 
 export function resetInStore(store: Store, token: WritableToken<any>): void
 
@@ -27,52 +25,10 @@ export function resetInStore<T>(
 	let key: Canonical | null
 	if (params.length === 1) {
 		token = params[0]
-		family = getFamilyOfToken(store, token) ?? null
-		if (family) {
-			key = token.family ? parseJson(token.family.subKey) : null
-			token = findInStore(store, family, key)
-		}
+		setIntoStore(store, token, RESET_STATE)
 	} else {
 		family = params[0]
 		key = params[1]
-		token = findInStore(store, family, key)
-	}
-
-	if (`counterfeit` in token && `family` in token) {
-		const subKey = token.family.subKey
-		const disposal = store.disposalTraces.buffer.find(
-			(item) => item?.key === subKey,
-		)
-		store.logger.error(
-			`❌`,
-			token.type,
-			token.key,
-			`could not be reset because it was not found in the store "${store.config.name}".`,
-			disposal
-				? `This state was previously disposed:\n${disposal.trace}`
-				: `No previous disposal trace was found.`,
-		)
-		return
-	}
-
-	const rejectionTime = openOperation(store, token)
-	if (rejectionTime) {
-		const unsubscribe = store.on.operationClose.subscribe(
-			`waiting to reset "${token.key}" at T-${rejectionTime}`,
-			() => {
-				unsubscribe()
-				store.logger.info(
-					`🟢`,
-					token.type,
-					token.key,
-					`resuming deferred resetState from T-${rejectionTime}`,
-				)
-				resetInStore(store, token)
-			},
-		)
-		return
+		setIntoStore(store, family, key, RESET_STATE)
 	}
-	const state = withdraw(store, token)
-	resetAtomOrSelector(store, state)
-	closeOperation(store)
 }

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

@@ -1,33 +1,27 @@
 import type { KeyedStateUpdate } from "atom.io"
 
-import type { Atom, Store } from ".."
-import { cacheValue } from "../caching"
+import type { Atom, MutableAtom, Store } from ".."
+import { hasRole } from "../atom/has-role"
+import { writeToCache } from "../caching"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { isTransceiver, type Transceiver } from "../mutable"
 import { markDone } from "../operation"
 import { isChildStore } from "../transaction/is-root-store"
 import { become } from "./become"
-import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
 import { emitUpdate } from "./emit-update"
-import { evictDownStream } from "./evict-downstream"
+import { evictDownstreamFromAtom } from "./evict-downstream"
 
 export const setAtom = <T>(
 	target: Store,
 	atom: Atom<T>,
 	next: T | ((oldValue: T) => T),
 ): void => {
-	const oldValue = readOrComputeValue(target, atom)
-	let newValue = oldValue
-	if (atom.type === `mutable_atom` && isChildStore(target)) {
-		const { parent } = target
-		const copiedValue = copyMutableIfNeeded(target, atom, parent)
-		newValue = copiedValue
-	}
-	newValue = become(next)(newValue)
+	const oldValue = readOrComputeValue(target, atom, `mut`)
+	let newValue = become(next)(oldValue)
 	target.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
-	newValue = cacheValue(target, atom.key, newValue, atom.subject)
+	newValue = writeToCache(target, atom, newValue)
 	markDone(target, atom.key)
-	evictDownStream(target, atom)
+	evictDownstreamFromAtom(target, atom)
 	const update = { oldValue, newValue }
 	if (!isChildStore(target)) {
 		emitUpdate(target, atom, update)
@@ -57,16 +51,15 @@ export const setAtom = <T>(
 			update.newValue,
 			`)`,
 		)
-	} else if (atom.key.startsWith(`*`)) {
-		const mutableKey = atom.key.slice(1)
-		const mutableAtom = target.atoms.get(mutableKey) as Atom<any>
-		let transceiver: Transceiver<any, any> = target.valueMap.get(mutableKey)
-		if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
-			const { parent } = target
-			const copiedValue = copyMutableIfNeeded(target, mutableAtom, parent)
-			transceiver = copiedValue
-		}
+	} else if (hasRole(atom, `tracker:signal`)) {
+		const key = atom.key.slice(1)
+		const mutable = target.atoms.get(key) as MutableAtom<
+			Transceiver<unknown, any, any>
+		>
+		const transceiver = readOrComputeValue(target, mutable, `mut`)
 		const accepted = transceiver.do(update.newValue) === null
-		if (accepted) evictDownStream(target, mutableAtom)
+		if (accepted === true) {
+			evictDownstreamFromAtom(target, mutable)
+		}
 	}
 }

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

@@ -6,19 +6,21 @@ import { getFamilyOfToken } from "../families/get-family-of-token"
 import { closeOperation, openOperation } from "../operation"
 import type { Store } from "../store"
 import { withdraw } from "../store"
+import { resetAtomOrSelector } from "./reset-atom-or-selector"
+import { RESET_STATE } from "./reset-in-store"
 import { setAtomOrSelector } from "./set-atom-or-selector"
 
 export function setIntoStore<T, New extends T>(
 	store: Store,
 	token: WritableToken<T>,
-	value: New | ((oldValue: T) => New),
+	value: New | typeof RESET_STATE | ((oldValue: T) => New),
 ): void
 
 export function setIntoStore<T, K extends Canonical, New extends T>(
 	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: K,
-	value: New | ((oldValue: T) => New),
+	value: New | typeof RESET_STATE | ((oldValue: T) => New),
 ): void
 
 export function setIntoStore<T, New extends T>(
@@ -27,20 +29,24 @@ export function setIntoStore<T, New extends T>(
 		| [
 				token: WritableFamilyToken<T, Canonical>,
 				key: Canonical,
-				value: New | ((oldValue: T) => New),
+				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+		  ]
+		| [
+				token: WritableToken<T>,
+				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
-		| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
 ): void {
 	let token: WritableToken<T>
 	let family: WritableFamilyToken<T, Canonical> | null
 	let key: Canonical | null
-	let value: New | ((oldValue: T) => New)
+	let value: New | typeof RESET_STATE | ((oldValue: T) => New)
 	if (params.length === 2) {
 		token = params[0]
 		value = params[1]
-		family = getFamilyOfToken(store, token) ?? null
-		if (family) {
-			key = token.family ? parseJson(token.family.subKey) : null
+		if (token.family) {
+			// biome-ignore lint/style/noNonNullAssertion: this token belongs to a family
+			family = getFamilyOfToken(store, token)!
+			key = parseJson(token.family.subKey)
 			token = findInStore(store, family, key)
 		}
 	} else {
@@ -50,6 +56,8 @@ export function setIntoStore<T, New extends T>(
 		token = findInStore(store, family, key)
 	}
 
+	const action = value === RESET_STATE ? `reset` : `set`
+
 	if (`counterfeit` in token && `family` in token) {
 		const subKey = token.family.subKey
 		const disposal = store.disposalTraces.buffer.find(
@@ -59,7 +67,9 @@ export function setIntoStore<T, New extends T>(
 			`❌`,
 			token.type,
 			token.key,
-			`could not be set because it was not found in the store "${store.config.name}".`,
+			`could not be`,
+			action,
+			`because it was not found in the store "${store.config.name}".`,
 			disposal
 				? `This state was previously disposed:\n${disposal.trace}`
 				: `No previous disposal trace was found.`,
@@ -70,14 +80,16 @@ export function setIntoStore<T, New extends T>(
 	const rejectionTime = openOperation(store, token)
 	if (rejectionTime) {
 		const unsubscribe = store.on.operationClose.subscribe(
-			`waiting to set "${token.key}" at T-${rejectionTime}`,
-			() => {
+			`waiting to ${action} "${token.key}" at T-${rejectionTime}`,
+			function waitUntilOperationCloseToSetState() {
 				unsubscribe()
 				store.logger.info(
 					`🟢`,
 					token.type,
 					token.key,
-					`resuming deferred setState from T-${rejectionTime}`,
+					`resuming deferred`,
+					action,
+					`from T-${rejectionTime}`,
 				)
 				setIntoStore(store, token, value)
 			},
@@ -85,6 +97,10 @@ export function setIntoStore<T, New extends T>(
 		return
 	}
 	const state = withdraw(store, token)
-	setAtomOrSelector(store, state, value)
+	if (value === RESET_STATE) {
+		resetAtomOrSelector(store, state)
+	} else {
+		setAtomOrSelector(store, state, value)
+	}
 	closeOperation(store)
 }

package/src/internal/store/counterfeit.ts

@@ -32,7 +32,7 @@ export const FAMILY_MEMBER_TOKEN_TYPES = {
 } as const
 
 export function counterfeit<
-	T extends Transceiver<any, any>,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 	Key extends K,
 >(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T>

package/src/internal/store/deposit.ts

@@ -26,7 +26,7 @@ import type {
 	Atom,
 	AtomFamily,
 	AtomIOInternalResource,
-	Func,
+	Fn,
 	MutableAtom,
 	MutableAtomFamily,
 	ReadableFamily,
@@ -47,7 +47,7 @@ import type {
 import type { Transaction } from "../transaction"
 
 export function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>
-export function deposit<T extends Transceiver<any, any>>(
+export function deposit<T extends Transceiver<any, any, any>>(
 	state: MutableAtom<T>,
 ): MutableAtomToken<T>
 export function deposit<T>(state: Atom<T>): AtomToken<T>
@@ -64,9 +64,10 @@ export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
 export function deposit<T, K extends Canonical>(
 	state: RegularAtomFamily<T, K>,
 ): RegularAtomFamilyToken<T, K>
-export function deposit<T extends Transceiver<any, any>, K extends Canonical>(
-	state: MutableAtomFamily<T, K>,
-): MutableAtomFamilyToken<T, K>
+export function deposit<
+	T extends Transceiver<any, any, any>,
+	K extends Canonical,
+>(state: MutableAtomFamily<T, K>): MutableAtomFamilyToken<T, K>
 export function deposit<T>(state: AtomFamily<T, any>): AtomFamilyToken<T, any>
 export function deposit<T>(
 	state: WritablePureSelectorFamily<T, any>,
@@ -84,9 +85,7 @@ export function deposit<T>(
 	state: ReadableFamily<T, any>,
 ): ReadableFamilyToken<T, any>
 
-export function deposit<T extends Func>(
-	state: Transaction<T>,
-): TransactionToken<T>
+export function deposit<T extends Fn>(state: Transaction<T>): TransactionToken<T>
 export function deposit<M extends TimelineManageable>(
 	state: Timeline<M>,
 ): TimelineToken<M>

package/src/internal/store/store.ts

@@ -35,7 +35,7 @@ import type {
 	TransactionProgress,
 } from "../transaction"
 import { isRootStore } from "../transaction"
-import type { Func } from "../utility-types"
+import type { Fn } from "../utility-types"
 import { CircularBuffer } from "./circular-buffer"
 
 export class Store implements Lineage {
@@ -70,7 +70,7 @@ export class Store implements Lineage {
 			makeContentKey: (...keys) => keys.sort().join(`:`),
 		},
 	)
-	public trackers: Map<string, Tracker<Transceiver<any, any>>> = new Map()
+	public trackers: Map<string, Tracker<Transceiver<any, any, any>>> = new Map()
 	public families: Map<
 		string,
 		| HeldSelectorFamily<any, any>
@@ -80,8 +80,8 @@ export class Store implements Lineage {
 	> = new Map()
 	public joins: Map<string, Join<any, any, any, any, any, any>> = new Map()
 
-	public transactions: Map<string, Transaction<Func>> = new Map()
-	public transactionMeta: TransactionEpoch | TransactionProgress<Func> = {
+	public transactions: Map<string, Transaction<Fn>> = new Map()
+	public transactionMeta: TransactionEpoch | TransactionProgress<Fn> = {
 		epoch: new Map<string, number>(),
 		actionContinuities: new Junction({
 			between: [`continuity`, `action`],
@@ -250,8 +250,8 @@ export type StoreEventCarrier = {
 	selectorCreation: Subject<SelectorToken<unknown>>
 	selectorDisposal: Subject<SelectorToken<unknown>>
 	timelineCreation: Subject<TimelineToken<unknown>>
-	transactionCreation: Subject<TransactionToken<Func>>
-	transactionApplying: StatefulSubject<TransactionProgress<Func> | null>
+	transactionCreation: Subject<TransactionToken<Fn>>
+	transactionApplying: StatefulSubject<TransactionProgress<Fn> | null>
 	operationClose: Subject<OperationProgress>
 	moleculeCreation: Subject<MoleculeCreation>
 	moleculeDisposal: Subject<MoleculeDisposal>

package/src/internal/store/withdraw.ts

@@ -38,7 +38,7 @@ import type {
 	Atom,
 	AtomFamily,
 	AtomIOInternalResource,
-	Func,
+	Fn,
 	HeldSelector,
 	HeldSelectorFamily,
 	MutableAtom,
@@ -76,7 +76,7 @@ export function withdraw<T>(
 	store: Store,
 	token: RegularAtomToken<T>,
 ): RegularAtom<T>
-export function withdraw<T extends Transceiver<any, any>>(
+export function withdraw<T extends Transceiver<any, any, any>>(
 	store: Store,
 	token: MutableAtomToken<T, any>,
 ): MutableAtom<T>
@@ -127,10 +127,10 @@ export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 ): RegularAtomFamily<T, K>
-export function withdraw<T extends Transceiver<any, any>, K extends Canonical>(
-	store: Store,
-	token: MutableAtomFamilyToken<T, K>,
-): MutableAtomFamily<T, K>
+export function withdraw<
+	T extends Transceiver<any, any, any>,
+	K extends Canonical,
+>(store: Store, token: MutableAtomFamilyToken<T, K>): MutableAtomFamily<T, K>
 export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: AtomFamilyToken<T, K>,
@@ -180,10 +180,10 @@ export function withdraw<T, K extends Canonical>(
 	token: WritableFamilyToken<T, K>,
 ): WritableFamily<T, K>
 
-export function withdraw<T extends Func>(
+export function withdraw<T extends Fn>(
 	store: Store,
 	token: TransactionToken<T>,
-): Transaction<T extends Func ? T : never>
+): Transaction<T extends Fn ? T : never>
 export function withdraw<T>(
 	store: Store,
 	token: TimelineToken<T>,

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

@@ -7,13 +7,13 @@ import type {
 	TransactionUpdateHandler,
 	UpdateHandler,
 } from "atom.io"
-import type { Func, Store } from "atom.io/internal"
-import {
-	arbitrary,
-	subscribeToState,
-	subscribeToTimeline,
-	subscribeToTransaction,
-} from "atom.io/internal"
+
+import { arbitrary } from "../arbitrary"
+import type { Store } from "../store"
+import type { Fn } from "../utility-types"
+import { subscribeToState } from "./subscribe-to-state"
+import { subscribeToTimeline } from "./subscribe-to-timeline"
+import { subscribeToTransaction } from "./subscribe-to-transaction"
 
 export function subscribeInStore<T>(
 	store: Store,
@@ -21,7 +21,7 @@ export function subscribeInStore<T>(
 	handleUpdate: UpdateHandler<T>,
 	key?: string,
 ): () => void
-export function subscribeInStore<F extends Func>(
+export function subscribeInStore<F extends Fn>(
 	store: Store,
 	token: TransactionToken<F>,
 	handleUpdate: TransactionUpdateHandler<F>,

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

@@ -1,7 +1,7 @@
 import type { TimelineManageable, TimelineToken, TimelineUpdate } from "atom.io"
 
-import type { Store } from ".."
-import { withdraw } from ".."
+import type { Store } from "../store/store"
+import { withdraw } from "../store/withdraw"
 
 export const subscribeToTimeline = <ManagedAtom extends TimelineManageable>(
 	store: Store,