atom.io 0.36.0 → 0.36.2

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`,

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

@@ -8,12 +8,12 @@ import { newest } from "../lineage"
 import type { Store } from "../store"
 import { deposit } from "../store"
 import { Subject } from "../subject"
-import type { Func } from "../utility-types"
+import type { Fn } from "../utility-types"
 import { abortTransaction } from "./abort-transaction"
 import { applyTransaction } from "./apply-transaction"
 import { buildTransaction } from "./build-transaction"
 
-export type Transaction<F extends Func> = {
+export type Transaction<F extends Fn> = {
 	key: string
 	type: `transaction`
 	install: (store: Store) => void
@@ -21,7 +21,7 @@ export type Transaction<F extends Func> = {
 	run: (parameters: Parameters<F>, id?: string) => ReturnType<F>
 }
 
-export function createTransaction<F extends Func>(
+export function createTransaction<F extends Fn>(
 	store: Store,
 	options: TransactionOptions<F>,
 ): TransactionToken<F> {

package/src/internal/transaction/index.ts

@@ -1,7 +1,7 @@
 import type { ActorToolkit, TransactionUpdate } from "atom.io"
 
 import type { Junction } from "../junction"
-import type { Func } from "../utility-types"
+import type { Fn } from "../utility-types"
 
 export * from "./abort-transaction"
 export * from "./act-upon-store"
@@ -16,7 +16,7 @@ export * from "./set-epoch-number"
 export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
 export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
 
-export type TransactionProgress<F extends Func> = {
+export type TransactionProgress<F extends Fn> = {
 	phase: `applying` | `building`
 	update: TransactionUpdate<F>
 	toolkit: ActorToolkit

package/src/internal/transaction/is-root-store.ts

@@ -1,5 +1,6 @@
+import type { LazyMap } from "../lazy-map"
 import type { Store } from "../store"
-import type { Func } from "../utility-types"
+import type { Fn } from "../utility-types"
 import type { TransactionEpoch, TransactionProgress } from "."
 
 export interface RootStore extends Store {
@@ -8,9 +9,10 @@ export interface RootStore extends Store {
 	child: ChildStore | null
 }
 export interface ChildStore extends Store {
-	transactionMeta: TransactionProgress<Func>
+	transactionMeta: TransactionProgress<Fn>
 	parent: ChildStore | RootStore
 	child: ChildStore | null
+	valueMap: LazyMap<string, any>
 }
 
 export function isRootStore(store: Store): store is RootStore {

package/src/internal/utility-types.ts

@@ -1,4 +1,4 @@
-export type Func = (...parameters: any[]) => any
+export type Fn = (...parameters: any[]) => any
 
 export type Flat<R extends { [K in PropertyKey]: any }> = {
 	[K in keyof R]: R[K]

package/src/introspection/attach-introspection-states.ts

@@ -6,7 +6,7 @@ import type {
 	TransactionToken,
 	TransactionUpdate,
 } from "atom.io"
-import type { Func, Store, Timeline } from "atom.io/internal"
+import type { Fn, Store, Timeline } from "atom.io/internal"
 
 import { type AtomTokenIndex, attachAtomIndex } from "./attach-atom-index"
 import type { SelectorTokenIndex } from "./attach-selector-index"
@@ -20,9 +20,9 @@ import { attachTypeSelectors } from "./attach-type-selectors"
 export type IntrospectionStates = {
 	atomIndex: AtomToken<AtomTokenIndex>
 	selectorIndex: AtomToken<SelectorTokenIndex>
-	transactionIndex: AtomToken<TransactionToken<Func>[]>
+	transactionIndex: AtomToken<TransactionToken<Fn>[]>
 	transactionLogSelectors: ReadonlyPureSelectorFamilyToken<
-		TransactionUpdate<Func>[],
+		TransactionUpdate<Fn>[],
 		string
 	>
 	timelineIndex: AtomToken<TimelineToken<any>[]>

package/src/introspection/attach-transaction-index.ts

@@ -1,16 +1,16 @@
 import type { AtomToken, TransactionToken } from "atom.io"
-import type { Func, Store } from "atom.io/internal"
+import type { Fn, Store } from "atom.io/internal"
 import { createRegularAtom, isReservedIntrospectionKey } from "atom.io/internal"
 
 export const attachTransactionIndex = (
 	store: Store,
-): AtomToken<TransactionToken<Func>[]> => {
-	return createRegularAtom<TransactionToken<Func>[]>(
+): AtomToken<TransactionToken<Fn>[]> => {
+	return createRegularAtom<TransactionToken<Fn>[]>(
 		store,
 		{
 			key: `🔍 Transaction Token Index`,
 			default: () => {
-				const tokens: TransactionToken<Func>[] = []
+				const tokens: TransactionToken<Fn>[] = []
 				for (const [key] of store.transactions) {
 					if (isReservedIntrospectionKey(key)) {
 						continue

package/src/introspection/attach-transaction-logs.ts

@@ -1,12 +1,12 @@
 import type { ReadonlyPureSelectorFamilyToken, TransactionUpdate } from "atom.io"
-import type { Func, Store } from "atom.io/internal"
+import type { Fn, Store } from "atom.io/internal"
 import { createRegularAtomFamily, createSelectorFamily } from "atom.io/internal"
 
 export const attachTransactionLogs = (
 	store: Store,
-): ReadonlyPureSelectorFamilyToken<TransactionUpdate<Func>[], string> => {
+): ReadonlyPureSelectorFamilyToken<TransactionUpdate<Fn>[], string> => {
 	const transactionUpdateLogAtoms = createRegularAtomFamily<
-		TransactionUpdate<Func>[],
+		TransactionUpdate<Fn>[],
 		string
 	>(store, {
 		key: `🔍 Transaction Update Log (Internal)`,
@@ -23,7 +23,7 @@ export const attachTransactionLogs = (
 		],
 	})
 	const findTransactionUpdateLogState = createSelectorFamily<
-		TransactionUpdate<Func>[],
+		TransactionUpdate<Fn>[],
 		string
 	>(store, {
 		key: `🔍 Transaction Update Log`,

package/src/introspection/auditor.ts

@@ -4,7 +4,7 @@ import {
 	type ReadableToken,
 	type SelectorToken,
 } from "atom.io"
-import * as Internal from "atom.io/internal"
+import { IMPLICIT, type Store } from "atom.io/internal"
 
 import type { FamilyNode } from "."
 import type { AtomTokenIndex } from "./attach-atom-index"
@@ -22,7 +22,7 @@ export type ListResourcesParam = {
  * @experimental
  */
 export class Auditor {
-	public readonly store: Internal.Store
+	public readonly store: Store
 	public auditorCreatedAt: number = performance.now()
 	public statesCreatedAt: Map<string, number> = new Map()
 	public readonly atomIndex: AtomToken<AtomTokenIndex>
@@ -37,7 +37,7 @@ export class Auditor {
 	/**
 	 * @param {Store} store - The store to audit.
 	 */
-	public constructor(store: Internal.Store = Internal.IMPLICIT.STORE) {
+	public constructor(store: Store = IMPLICIT.STORE) {
 		this.store = store
 		this.atomIndex = attachAtomIndex(this.store)
 		this.selectorIndex = attachSelectorIndex(this.store)

package/src/main/atom.ts

@@ -34,7 +34,7 @@ export function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T> {
 	return createRegularAtom(IMPLICIT.STORE, options, undefined)
 }
 
-export type MutableAtomOptions<T extends Transceiver<any, any>> = {
+export type MutableAtomOptions<T extends Transceiver<any, any, any>> = {
 	/** The unique identifier of the atom */
 	key: string
 	/** A constructor for the atom's value */
@@ -51,7 +51,7 @@ export type MutableAtomOptions<T extends Transceiver<any, any>> = {
  * @returns
  * A reference to the atom created: a {@link MutableAtomToken}
  */
-export function mutableAtom<T extends Transceiver<any, any>>(
+export function mutableAtom<T extends Transceiver<any, any, any>>(
 	options: MutableAtomOptions<T>,
 ): MutableAtomToken<T> {
 	return createMutableAtom(IMPLICIT.STORE, options, undefined)
@@ -99,7 +99,7 @@ export function atomFamily<T, K extends Canonical>(
 }
 
 export type MutableAtomFamilyOptions<
-	T extends Transceiver<any, any>,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 > = {
 	/** The unique identifier of the atom family */
@@ -119,7 +119,7 @@ export type MutableAtomFamilyOptions<
  * A reference to the atom family created: a {@link MutableAtomFamilyToken}
  */
 export function mutableAtomFamily<
-	T extends Transceiver<any, any>,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 >(options: MutableAtomFamilyOptions<T, K>): MutableAtomFamilyToken<T, K> {
 	return createMutableAtomFamily(IMPLICIT.STORE, options)

package/src/main/dispose-state.ts

@@ -1,4 +1,4 @@
-import * as Internal from "atom.io/internal"
+import { disposeFromStore, IMPLICIT } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
 
 import type { ReadableFamilyToken, ReadableToken } from "."
@@ -19,6 +19,7 @@ export function disposeState(token: ReadableToken<any>): void
  *
  * @param token - The token of the state family to dispose
  * @param key - The unique key of the state to dispose
+ * @overload Streamlined
  */
 export function disposeState<K extends Canonical>(
 	token: ReadableFamilyToken<any, K>,
@@ -30,8 +31,8 @@ export function disposeState(
 		| [token: ReadableToken<any>]
 ): void {
 	if (params.length === 2) {
-		Internal.disposeFromStore(Internal.IMPLICIT.STORE, ...params)
+		disposeFromStore(IMPLICIT.STORE, ...params)
 	} else {
-		Internal.disposeFromStore(Internal.IMPLICIT.STORE, ...params)
+		disposeFromStore(IMPLICIT.STORE, ...params)
 	}
 }

package/src/main/find-state.ts

@@ -30,7 +30,7 @@ import type { MutableAtomFamilyToken, RegularAtomFamilyToken } from "./tokens"
  * @overload Mutable Atom
  */
 export function findState<
-	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, K>

package/src/main/get-state.ts

@@ -1,4 +1,5 @@
-import * as Internal from "atom.io/internal"
+import type { ViewOf } from "atom.io/internal"
+import { getFromStore, IMPLICIT } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
 
 import type { ReadableFamilyToken, ReadableToken } from "."
@@ -10,7 +11,7 @@ import type { ReadableFamilyToken, ReadableToken } from "."
  * @overload Default
  * @default
  */
-export function getState<T>(token: ReadableToken<T>): T
+export function getState<T>(token: ReadableToken<T>): ViewOf<T>
 
 /**
  * Read or compute the current value of a state
@@ -22,7 +23,7 @@ export function getState<T>(token: ReadableToken<T>): T
 export function getState<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-): T
+): ViewOf<T>
 
 export function getState(
 	...params:
@@ -30,7 +31,7 @@ export function getState(
 		| [token: ReadableToken<any>]
 ): any {
 	if (params.length === 2) {
-		return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params)
+		return getFromStore(IMPLICIT.STORE, ...params)
 	}
-	return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params)
+	return getFromStore(IMPLICIT.STORE, ...params)
 }

package/src/main/reset-state.ts

@@ -1,4 +1,4 @@
-import * as Internal from "atom.io/internal"
+import { IMPLICIT, resetInStore } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
 
 import type { WritableFamilyToken, WritableToken } from "."
@@ -26,8 +26,8 @@ export function resetState(
 		| [token: WritableToken<any>]
 ): void {
 	if (params.length === 2) {
-		Internal.resetInStore(Internal.IMPLICIT.STORE, ...params)
+		resetInStore(IMPLICIT.STORE, ...params)
 	} else {
-		Internal.resetInStore(Internal.IMPLICIT.STORE, ...params)
+		resetInStore(IMPLICIT.STORE, ...params)
 	}
 }

package/src/main/set-state.ts

@@ -1,4 +1,4 @@
-import * as Internal from "atom.io/internal"
+import { IMPLICIT, setIntoStore } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
 
 import type { WritableFamilyToken, WritableToken } from "./tokens"
@@ -45,8 +45,8 @@ export function setState<T, New extends T>(
 		| [token: WritableToken<T>, value: New | Setter<T, New>]
 ): void {
 	if (params.length === 2) {
-		Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params)
+		setIntoStore(IMPLICIT.STORE, ...params)
 	} else {
-		Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params)
+		setIntoStore(IMPLICIT.STORE, ...params)
 	}
 }

package/src/main/subscribe.ts

@@ -1,4 +1,4 @@
-import type { Flat, Func } from "atom.io/internal"
+import type { Flat, Fn } from "atom.io/internal"
 import { arbitrary, IMPLICIT, subscribeInStore } from "atom.io/internal"
 
 import type {
@@ -20,7 +20,7 @@ export type KeyedStateUpdate<T> = Flat<
 	}
 >
 export type UpdateHandler<T> = (update: StateUpdate<T>) => void
-export type TransactionUpdateHandler<F extends Func> = (
+export type TransactionUpdateHandler<F extends Fn> = (
 	data: TransactionUpdate<F>,
 ) => void
 
@@ -45,7 +45,7 @@ export function subscribe<T>(
  * @returns A function that can be called to unsubscribe from the transaction
  * @overload Transaction
  */
-export function subscribe<F extends Func>(
+export function subscribe<F extends Fn>(
 	token: TransactionToken<F>,
 	handleUpdate: TransactionUpdateHandler<F>,
 	key?: string,

package/src/main/tokens.ts

@@ -1,4 +1,4 @@
-import type { AsJSON, Func, Transceiver } from "atom.io/internal"
+import type { AsJSON, Fn, Transceiver } from "atom.io/internal"
 import type { Canonical, stringified } from "atom.io/json"
 
 /**
@@ -18,27 +18,22 @@ export type AtomIOToken =
 	| TimelineToken<any>
 	| TransactionToken<any>
 
-/**
- * These states cannot be set.
- */
 export type ReadableToken<T, K extends Canonical = any> =
 	| AtomToken<T, K>
 	| SelectorToken<T, K>
-/**
- * These states can be set.
- */
+
 export type WritableToken<T, K extends Canonical = any> =
 	| AtomToken<T, K>
 	| WritableSelectorToken<T, K>
 
 /**
- * States belonging to this family can be gotten from the store.
+ * States belonging to this family can be read from the store.
  */
 export type ReadableFamilyToken<T, K extends Canonical> =
 	| AtomFamilyToken<T, K>
 	| SelectorFamilyToken<T, K>
 /**
- * States belonging to this family can be set.
+ * States belonging to this family can be written directly.
  */
 export type WritableFamilyToken<T, K extends Canonical> =
 	| AtomFamilyToken<T, K>
@@ -53,7 +48,7 @@ export type TimelineToken<M> = {
 	__M?: M
 }
 
-export type TransactionToken<F extends Func> = {
+export type TransactionToken<F extends Fn> = {
 	/** The unique identifier of the transaction */
 	key: string
 	/** Discriminator */
@@ -63,7 +58,7 @@ export type TransactionToken<F extends Func> = {
 }
 
 export type AtomToken<T, K extends Canonical = any> =
-	| MutableAtomToken<T extends Transceiver<any, any> ? T : never, K>
+	| MutableAtomToken<T extends Transceiver<any, any, any> ? T : never, K>
 	| RegularAtomToken<T, K>
 export type RegularAtomToken<T, K extends Canonical = any> = {
 	/** The unique identifier of the atom. */
@@ -76,7 +71,7 @@ export type RegularAtomToken<T, K extends Canonical = any> = {
 	__T?: T
 }
 export type MutableAtomToken<
-	T extends Transceiver<any, any>,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical = any,
 > = {
 	/** The unique identifier of the atom. */
@@ -87,8 +82,6 @@ export type MutableAtomToken<
 	family?: FamilyMetadata<K>
 	/** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
 	__J?: AsJSON<T>
-	/** Never present. This is a marker that preserves the type of the atom's transceiver value. */
-	__U?: T extends Transceiver<infer Update, any> ? Update : never
 }
 
 export type SelectorToken<T, K extends Canonical = any> =
@@ -159,7 +152,7 @@ export type FamilyMetadata<K extends Canonical = any> = {
 }
 
 export type AtomFamilyToken<T, K extends Canonical = Canonical> =
-	| MutableAtomFamilyToken<T extends Transceiver<any, any> ? T : never, K>
+	| MutableAtomFamilyToken<T extends Transceiver<any, any, any> ? T : never, K>
 	| RegularAtomFamilyToken<T, K>
 export type RegularAtomFamilyToken<T, K extends Canonical> = {
 	/** The unique identifier of the atom family */
@@ -172,7 +165,7 @@ export type RegularAtomFamilyToken<T, K extends Canonical> = {
 	__K?: K
 }
 export type MutableAtomFamilyToken<
-	T extends Transceiver<any, any>,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 > = {
 	/** The unique identifier of the atom family */
@@ -181,8 +174,6 @@ export type MutableAtomFamilyToken<
 	type: `mutable_atom_family`
 	/** Never present. This is a marker that preserves the type of atoms in this family */
 	__T?: T
-	/** Never present. This is a marker that preserves the type of the JSON form of atoms in this family */
-	__J?: AsJSON<T>
 	/** Never present. This is a marker that preserves the type of keys used for atoms in this family */
 	__K?: K
 }

package/src/main/transaction.ts

@@ -1,9 +1,4 @@
-import type {
-	AsJSON,
-	EnvironmentData,
-	Func,
-	Transceiver,
-} from "atom.io/internal"
+import type { AsJSON, EnvironmentData, Fn, Transceiver } from "atom.io/internal"
 import {
 	actUponStore,
 	arbitrary,
@@ -33,6 +28,9 @@ export type StateCreation<Token extends ReadableToken<any>> = {
 export type StateDisposal<Token extends ReadableToken<any>> =
 	| AtomDisposal<Token>
 	| SelectorDisposal<Token>
+export type StateLifecycleEvent<Token extends ReadableToken<any>> =
+	| StateCreation<Token>
+	| StateDisposal<Token>
 
 export type AtomDisposal<Token extends ReadableToken<any>> = {
 	type: `state_disposal`
@@ -72,9 +70,9 @@ export type TransactionUpdateContent =
 	| MoleculeTransfer
 	| StateCreation<ReadableToken<unknown>>
 	| StateDisposal<ReadableToken<unknown>>
-	| TransactionUpdate<Func>
+	| TransactionUpdate<Fn>
 
-export type TransactionUpdate<F extends Func> = {
+export type TransactionUpdate<F extends Fn> = {
 	type: `transaction_update`
 	key: string
 	id: string
@@ -91,7 +89,7 @@ export type ActorToolkit = Readonly<{
 	set: typeof setState
 	reset: typeof resetState
 	find: typeof findState
-	json: <T extends Transceiver<any, any>>(
+	json: <T extends Transceiver<any, any, any>>(
 		state: MutableAtomToken<T>,
 	) => WritablePureSelectorToken<AsJSON<T>>
 	dispose: typeof disposeState
@@ -99,21 +97,21 @@ export type ActorToolkit = Readonly<{
 	env: () => EnvironmentData
 }>
 
-export type Read<F extends Func> = (
+export type Read<F extends Fn> = (
 	toolkit: ReaderToolkit,
 	...parameters: Parameters<F>
 ) => ReturnType<F>
-export type Write<F extends Func> = (
+export type Write<F extends Fn> = (
 	toolkit: WriterToolkit,
 	...parameters: Parameters<F>
 ) => ReturnType<F>
-export type Transact<F extends Func> = (
+export type Transact<F extends Fn> = (
 	toolkit: ActorToolkit,
 	...parameters: Parameters<F>
 ) => ReturnType<F>
 export type TransactionIO<Token extends TransactionToken<any>> =
 	Token extends TransactionToken<infer F> ? F : never
-export type TransactionOptions<F extends Func> = {
+export type TransactionOptions<F extends Fn> = {
 	/** The unique identifier of the transaction */
 	key: string
 	/** The operation to perform */
@@ -125,7 +123,7 @@ export type TransactionOptions<F extends Func> = {
  * @param options - {@link TransactionOptions}
  * @returns A reference to the transaction created: a {@link TransactionToken}
  */
-export function transaction<F extends Func>(
+export function transaction<F extends Fn>(
 	options: TransactionOptions<F>,
 ): TransactionToken<F> {
 	return createTransaction(IMPLICIT.STORE, options)
@@ -137,7 +135,7 @@ export function transaction<F extends Func>(
  * @param id - A unique identifier for the transaction. If not provided, a random identifier will be generated
  * @returns A function that can be called to run the transaction with its {@link TransactionIO} parameters
  */
-export function runTransaction<F extends Func>(
+export function runTransaction<F extends Fn>(
 	token: TransactionToken<F>,
 	id: string = arbitrary(),
 ): (...parameters: Parameters<F>) => ReturnType<F> {

package/src/react/use-json.ts

@@ -7,14 +7,14 @@ import * as React from "react"
 import { StoreContext } from "./store-context"
 import { useO } from "./use-o"
 
-export function useJSON<T extends Transceiver<any, any>>(
+export function useJSON<T extends Transceiver<any, any, any>>(
 	token: MutableAtomToken<T>,
 ): AsJSON<T>
 
-export function useJSON<T extends Transceiver<any, any>, K extends Canonical>(
-	token: MutableAtomFamilyToken<T, K>,
-	key: K,
-): AsJSON<T>
+export function useJSON<
+	T extends Transceiver<any, any, any>,
+	K extends Canonical,
+>(token: MutableAtomFamilyToken<T, K>, key: K): AsJSON<T>
 
 export function useJSON(
 	token: MutableAtomFamilyToken<any, any> | MutableAtomToken<any>,

package/src/react-devtools/TransactionIndex.tsx

@@ -4,7 +4,7 @@ import type {
 	TransactionToken,
 	TransactionUpdate,
 } from "atom.io"
-import { findInStore, type Func } from "atom.io/internal"
+import { findInStore, type Fn } from "atom.io/internal"
 import { useI, useO } from "atom.io/react"
 import { type FC, useContext } from "react"
 
@@ -13,9 +13,9 @@ import { DevtoolsContext } from "./store"
 import { article } from "./Updates"
 
 export const TransactionLog: FC<{
-	token: TransactionToken<Func>
+	token: TransactionToken<Fn>
 	isOpenState: RegularAtomToken<boolean>
-	logState: ReadonlyPureSelectorToken<TransactionUpdate<Func>[]>
+	logState: ReadonlyPureSelectorToken<TransactionUpdate<Fn>[]>
 }> = ({ token, isOpenState, logState }) => {
 	const log = useO(logState)
 	const isOpen = useO(isOpenState)