atom.io 0.35.0 → 0.36.1

package/src/internal/mutable/transceiver.ts

@@ -1,16 +1,30 @@
 import type { Json } from "atom.io/json"
 
-export interface Transceiver<S extends Json.Serializable> {
+export interface Transceiver<
+	V,
+	S extends Json.Serializable,
+	J extends Json.Serializable,
+> {
 	do: (update: S) => number | `OUT_OF_RANGE` | null
 	undo: (update: S) => void
 	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, any, J>
+> =
+	& ( new () => T )
+	& { fromJSON: (json: J) => T }
+
 export function isTransceiver(
 	value: unknown,
-): value is Transceiver<Json.Serializable> {
+): value is Transceiver<any, Json.Serializable, Json.Serializable> {
 	return (
 		typeof value === `object` &&
 		value !== null &&
@@ -22,17 +36,27 @@ export function isTransceiver(
 
 export type TransceiverMode = `playback` | `record` | `transaction`
 
-export type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<
-	infer S
+export type ViewOf<T> = T extends Transceiver<infer V, any, any> ? V : T
+
+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
 >
-	? S
+	? J
 	: never
 
+export type ConstructorOf<T extends Transceiver<any, any, any>> =
+	TransceiverConstructor<AsJSON<T>, T>
+
 /*
 A transceiver may also keep a list of updates that have been applied to it.
 This is useful for undo/redo functionality, especially in the context of
-revising history. It is a good idea to accept a cache limit in your 
-constructor, and overwrite old updates. Here's an example of how we 
+revising history. It is a good idea to accept a cache limit in your
+constructor, and overwrite old updates. Here's an example of how we
 might set that up:
 
 myTransceiver = Transceiver {
@@ -48,7 +72,7 @@ myTransceiver = Transceiver {
 
 CONFIRM/NO-OP
 Update `27=del:"x"` is passed to myTransceiver.do:
-- [updateNumber = 27, update = `del:"x"`]	
+- [updateNumber = 27, update = `del:"x"`]
 - updateOffset = updateNumber - cacheUpdateNumber // 0
 - eventOffset < 1 // true (we're validating the past)
 - |eventOffset| < cacheLimit // true (we remember this update)
@@ -75,7 +99,7 @@ Update `29=del:"x"` is passed to myTransceiver.do:
 - eventOffset === 1 // false (we're NOT ready to apply this update)
 - updateIdx := cacheIdx + updateOffset // 3
 - updateIdx %= cacheLimit // 0
-- cache[updateIdx] = update // cache = <{ 0 => del:"x" }> 
+- cache[updateIdx] = update // cache = <{ 0 => del:"x" }>
 - expectedUpdateNumber = cacheUpdateNumber + 1 // 28
 - return expectedUpdateNumber // 🤨👂
 
@@ -110,3 +134,7 @@ Update `24=add:"z"` is passed to myTransceiver.do:
 - return `OUT_OF_RANGE` // 😵‍💫👂
 
 */
+
+// The function wants a constructor C
+// - that has a static fromJSON(json) returning an instance of C
+// - and whose instances have toJSON() whose return type matches fromJSON's param

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), key, constant, subject)
 		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, key, value, subject)
 		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, key, constant, subject)
 		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, key, newValue, subject)
 		markDone(innerTarget, key)
 		if (isRootStore(innerTarget)) {
 			subject.next({ newValue, oldValue })

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, key, value, subject)
 		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, options.key, newValue, subject)
 		markDone(innerTarget, options.key)
 		if (isRootStore(innerTarget)) {
 			subject.next({ newValue, oldValue })

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

@@ -8,9 +8,8 @@ export function disposeSelector(
 	selectorToken: SelectorToken<unknown>,
 ): void {
 	const target = newest(store)
-	const { key, type } = selectorToken
-	const selector = withdraw(target, selectorToken)
-	if (!selector.family) {
+	const { key, type, family: familyMeta } = selectorToken
+	if (!familyMeta) {
 		store.logger.error(
 			`❌`,
 			type,
@@ -18,9 +17,9 @@ export function disposeSelector(
 			`Standalone selectors cannot be disposed.`,
 		)
 	} else {
-		const molecule = target.molecules.get(selector.family.subKey)
+		const molecule = target.molecules.get(familyMeta.subKey)
 		if (molecule) {
-			target.moleculeData.delete(selector.family.subKey, selector.family.key)
+			target.moleculeData.delete(familyMeta.subKey, familyMeta.key)
 		}
 		let familyToken: SelectorFamilyToken<any, any>
 		switch (selectorToken.type) {
@@ -28,7 +27,7 @@ export function disposeSelector(
 				{
 					target.writableSelectors.delete(key)
 					familyToken = {
-						key: selector.family.key,
+						key: familyMeta.key,
 						type: `writable_held_selector_family`,
 					}
 					const family = withdraw(store, familyToken)
@@ -43,7 +42,7 @@ export function disposeSelector(
 				{
 					target.writableSelectors.delete(key)
 					familyToken = {
-						key: selector.family.key,
+						key: familyMeta.key,
 						type: `writable_pure_selector_family`,
 					}
 					const family = withdraw(store, familyToken)
@@ -58,7 +57,7 @@ export function disposeSelector(
 				{
 					target.readonlySelectors.delete(key)
 					familyToken = {
-						key: selector.family.key,
+						key: familyMeta.key,
 						type: `readonly_held_selector_family`,
 					}
 					const family = withdraw(store, familyToken)
@@ -73,7 +72,7 @@ export function disposeSelector(
 				{
 					target.readonlySelectors.delete(key)
 					familyToken = {
-						key: selector.family.key,
+						key: familyMeta.key,
 						type: `readonly_pure_selector_family`,
 					}
 					const family = withdraw(store, familyToken)
@@ -89,6 +88,7 @@ export function disposeSelector(
 		target.valueMap.delete(key)
 		target.selectorAtoms.delete(key)
 		target.selectorGraph.delete(key)
+		target.moleculeData.delete(familyMeta.key, familyMeta.subKey)
 		store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
 		if (isChildStore(target) && target.transactionMeta.phase === `building`) {
 			target.transactionMeta.update.updates.push({

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

@@ -4,11 +4,18 @@ import type { Store } from "../store"
 import { setAtom } from "./set-atom"
 
 function resetAtom(store: Store, state: Atom<any>) {
-	let def = state.default
-	if (def instanceof Function) {
-		def = def()
+	switch (state.type) {
+		case `mutable_atom`:
+			setAtom(store, state, new state.class())
+			return
+		case `atom`: {
+			let def = state.default
+			if (def instanceof Function) {
+				def = def()
+			}
+			setAtom(store, state, def)
+		}
 	}
-	setAtom(store, state, def)
 }
 
 export function resetAtomOrSelector(

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

@@ -1,13 +1,13 @@
 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"
 
@@ -16,16 +16,10 @@ export const setAtom = <T>(
 	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.key, newValue, atom.subject)
 	markDone(target, atom.key)
 	evictDownStream(target, atom)
 	const update = { oldValue, newValue }
@@ -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> = 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) {
+			evictDownStream(target, mutable)
+		}
 	}
 }

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

@@ -38,9 +38,10 @@ export function setIntoStore<T, New extends T>(
 	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 {
@@ -71,7 +72,7 @@ export function setIntoStore<T, New extends T>(
 	if (rejectionTime) {
 		const unsubscribe = store.on.operationClose.subscribe(
 			`waiting to set "${token.key}" at T-${rejectionTime}`,
-			() => {
+			function waitUntilOperationCloseToSetState() {
 				unsubscribe()
 				store.logger.info(
 					`🟢`,

package/src/internal/store/counterfeit.ts

@@ -16,7 +16,7 @@ import type {
 	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import type { Transceiver } from "../mutable"
@@ -32,11 +32,10 @@ export const FAMILY_MEMBER_TOKEN_TYPES = {
 } as const
 
 export function counterfeit<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 	Key extends K,
->(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>
+>(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T>
 
 export function counterfeit<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,

package/src/internal/store/deposit.ts

@@ -20,13 +20,13 @@ import type {
 	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type {
 	Atom,
 	AtomFamily,
 	AtomIOInternalResource,
-	Func,
+	Fn,
 	MutableAtom,
 	MutableAtomFamily,
 	ReadableFamily,
@@ -47,9 +47,9 @@ import type {
 import type { Transaction } from "../transaction"
 
 export function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>
-export function deposit<T extends Transceiver<any>>(
-	state: MutableAtom<T, any>,
-): MutableAtomToken<T, any>
+export function deposit<T extends Transceiver<any, any, any>>(
+	state: MutableAtom<T>,
+): MutableAtomToken<T>
 export function deposit<T>(state: Atom<T>): AtomToken<T>
 export function deposit<T>(
 	state: WritablePureSelector<T>,
@@ -65,10 +65,9 @@ export function deposit<T, K extends Canonical>(
 	state: RegularAtomFamily<T, K>,
 ): RegularAtomFamilyToken<T, K>
 export function deposit<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
->(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>
+>(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>,
@@ -86,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,18 +70,18 @@ export class Store implements Lineage {
 			makeContentKey: (...keys) => keys.sort().join(`:`),
 		},
 	)
-	public trackers: Map<string, Tracker<Transceiver<any>>> = new Map()
+	public trackers: Map<string, Tracker<Transceiver<any, any, any>>> = new Map()
 	public families: Map<
 		string,
 		| HeldSelectorFamily<any, any>
-		| MutableAtomFamily<any, any, any>
+		| MutableAtomFamily<any, any>
 		| PureSelectorFamily<any, any>
 		| RegularAtomFamily<any, any>
 	> = 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

@@ -32,13 +32,13 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type {
 	Atom,
 	AtomFamily,
 	AtomIOInternalResource,
-	Func,
+	Fn,
 	HeldSelector,
 	HeldSelectorFamily,
 	MutableAtom,
@@ -76,10 +76,10 @@ export function withdraw<T>(
 	store: Store,
 	token: RegularAtomToken<T>,
 ): RegularAtom<T>
-export function withdraw<T extends Transceiver<any>>(
+export function withdraw<T extends Transceiver<any, any, any>>(
 	store: Store,
 	token: MutableAtomToken<T, any>,
-): MutableAtom<T, any>
+): MutableAtom<T>
 export function withdraw<T>(store: Store, token: AtomToken<T>): Atom<T>
 export function withdraw<T>(
 	store: Store,
@@ -128,13 +128,9 @@ export function withdraw<T, K extends Canonical>(
 	token: RegularAtomFamilyToken<T, K>,
 ): RegularAtomFamily<T, K>
 export function withdraw<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
->(
-	store: Store,
-	token: MutableAtomFamilyToken<T, J, K>,
-): MutableAtomFamily<T, J, K>
+>(store: Store, token: MutableAtomFamilyToken<T, K>): MutableAtomFamily<T, K>
 export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: AtomFamilyToken<T, K>,
@@ -184,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,7 +7,7 @@ import type {
 	TransactionUpdateHandler,
 	UpdateHandler,
 } from "atom.io"
-import type { Func, Store } from "atom.io/internal"
+import type { Fn, Store } from "atom.io/internal"
 import {
 	arbitrary,
 	subscribeToState,
@@ -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-transaction.ts

@@ -1,9 +1,9 @@
 import type { TransactionToken, TransactionUpdateHandler } from "atom.io"
 
-import type { Func, Store } from ".."
+import type { Fn, Store } from ".."
 import { withdraw } from ".."
 
-export const subscribeToTransaction = <F extends Func>(
+export const subscribeToTransaction = <F extends Fn>(
 	store: Store,
 	token: TransactionToken<F>,
 	key: string,

package/src/internal/timeline/create-timeline.ts

@@ -23,7 +23,7 @@ import { getUpdateToken } from "../mutable"
 import { type Store, withdraw } from "../store"
 import { Subject } from "../subject"
 import { isChildStore } from "../transaction"
-import type { Flat, Func } from "../utility-types"
+import type { Flat, Fn } from "../utility-types"
 
 export type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = Flat<
 	StateUpdate<TokenType<ManagedAtom>> & {
@@ -40,7 +40,7 @@ export type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
 	atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[]
 }
 export type TimelineTransactionUpdate = Flat<
-	TransactionUpdate<Func> & {
+	TransactionUpdate<Fn> & {
 		key: string
 		type: `transaction_update`
 		timestamp: number
@@ -340,7 +340,7 @@ function addAtomFamilyToTimeline(
 function joinTransaction(
 	store: Store,
 	tl: Timeline<any>,
-	txUpdateInProgress: TransactionUpdate<Func>,
+	txUpdateInProgress: TransactionUpdate<Fn>,
 ) {
 	const currentTxKey = txUpdateInProgress.key
 	const currentTxInstanceId = txUpdateInProgress.id

package/src/internal/transaction/act-upon-store.ts

@@ -3,9 +3,9 @@ import type { TransactionToken } from "atom.io"
 import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
 import { withdraw } from "../store"
-import type { Func } from "../utility-types"
+import type { Fn } from "../utility-types"
 
-export function actUponStore<F extends Func>(
+export function actUponStore<F extends Fn>(
 	store: Store,
 	token: TransactionToken<F>,
 	id: string,

package/src/internal/transaction/apply-transaction.ts

@@ -2,11 +2,11 @@ import { ingestTransactionUpdate } from "../ingest-updates"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { withdraw } from "../store"
-import type { Func } from "../utility-types"
+import type { Fn } from "../utility-types"
 import { isChildStore, isRootStore } from "./is-root-store"
 import { setEpochNumberOfAction } from "./set-epoch-number"
 
-export const applyTransaction = <F extends Func>(
+export const applyTransaction = <F extends Fn>(
 	output: ReturnType<F>,
 	store: Store,
 ): void => {

package/src/internal/transaction/build-transaction.ts

@@ -16,7 +16,7 @@ import { newest } from "../lineage"
 import { getJsonToken } from "../mutable"
 import { resetInStore, setIntoStore } from "../set-state"
 import type { Store } from "../store"
-import type { Func } from "../utility-types"
+import type { Fn } from "../utility-types"
 import type { TransactionProgress } from "."
 import { actUponStore, getEpochNumberOfAction } from "."
 import type { ChildStore, RootStore } from "./is-root-store"
@@ -66,7 +66,7 @@ export const buildTransaction = (
 		miscResources: new LazyMap(parent.miscResources),
 	}
 	const epoch = getEpochNumberOfAction(store, key)
-	const transactionMeta: TransactionProgress<Func> = {
+	const transactionMeta: TransactionProgress<Fn> = {
 		phase: `building`,
 		update: {
 			type: `transaction_update`,