atom.io 0.35.0 → 0.36.1

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/json/index.ts

@@ -1,6 +1,4 @@
 export * from "./entries"
-export * from "./select-json"
-export * from "./select-json-family"
 
 export type primitive = boolean | number | string | null
 

package/src/main/atom.ts

@@ -1,4 +1,4 @@
-import type { Transceiver } from "atom.io/internal"
+import type { ConstructorOf, Transceiver } from "atom.io/internal"
 import {
 	createMutableAtom,
 	createMutableAtomFamily,
@@ -6,7 +6,7 @@ import {
 	createRegularAtomFamily,
 	IMPLICIT,
 } from "atom.io/internal"
-import type { Canonical, Json, JsonInterface } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type { Setter } from "./set-state"
 import type {
@@ -34,20 +34,14 @@ export function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T> {
 	return createRegularAtom(IMPLICIT.STORE, options, undefined)
 }
 
-// biome-ignore format: intersection
-export type MutableAtomOptions<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-> =
-	& JsonInterface<T, J>
-	& {
-		/** The unique identifier of the atom */
-		key: string
-		/** A function to create an initial value for the atom */
-		default: () => T
-		/** Hooks used to run side effects when the atom is set */
-		effects?: AtomEffect<T>[]
-	}
+export type MutableAtomOptions<T extends Transceiver<any, any, any>> = {
+	/** The unique identifier of the atom */
+	key: string
+	/** A constructor for the atom's value */
+	class: ConstructorOf<T>
+	/** Hooks used to run side effects when the atom is set */
+	effects?: AtomEffect<T>[]
+}
 /**
  * Create a mutable atom, a global reactive variable in the implicit store
  *
@@ -57,10 +51,9 @@ export type MutableAtomOptions<
  * @returns
  * A reference to the atom created: a {@link MutableAtomToken}
  */
-export function mutableAtom<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(options: MutableAtomOptions<T, J>): MutableAtomToken<T, J> {
+export function mutableAtom<T extends Transceiver<any, any, any>>(
+	options: MutableAtomOptions<T>,
+): MutableAtomToken<T> {
 	return createMutableAtom(IMPLICIT.STORE, options, undefined)
 }
 
@@ -105,21 +98,17 @@ export function atomFamily<T, K extends Canonical>(
 	return createRegularAtomFamily(IMPLICIT.STORE, options)
 }
 
-// biome-ignore format: intersection
 export type MutableAtomFamilyOptions<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
-> =
-	& JsonInterface<T, J>
-	& {
-		/** The unique identifier of the atom family */
-		key: string
-		/** A function to create an initial value for each atom in the family */
-		default: (key: K) => T
-		/** Hooks used to run side effects when an atom in the family is set  */
-		effects?: (key: K) => AtomEffect<T>[]
-	}
+> = {
+	/** The unique identifier of the atom family */
+	key: string
+	/** The class of the transceiver to be created */
+	class: ConstructorOf<T>
+	/** Hooks used to run side effects when an atom in the family is set  */
+	effects?: (key: K) => AtomEffect<T>[]
+}
 /**
  * Create a family of mutable atoms, allowing for the dynamic creation and disposal of atoms.
  *
@@ -130,9 +119,8 @@ export type MutableAtomFamilyOptions<
  * A reference to the atom family created: a {@link MutableAtomFamilyToken}
  */
 export function mutableAtomFamily<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
->(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K> {
+>(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,19 +19,20 @@ 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>,
 	key: K,
 ): void
 export function disposeState(
-	...[token, key]:
+	...params:
 		| [token: ReadableFamilyToken<any, any>, key: Canonical]
 		| [token: ReadableToken<any>]
 ): void {
-	if (key) {
-		Internal.disposeFromStore(Internal.IMPLICIT.STORE, token as any, key)
+	if (params.length === 2) {
+		disposeFromStore(IMPLICIT.STORE, ...params)
 	} else {
-		Internal.disposeFromStore(Internal.IMPLICIT.STORE, token as any)
+		disposeFromStore(IMPLICIT.STORE, ...params)
 	}
 }

package/src/main/find-state.ts

@@ -12,7 +12,7 @@ import type {
 } from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import { findInStore, IMPLICIT } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type { MutableAtomFamilyToken, RegularAtomFamilyToken } from "./tokens"
 
@@ -30,11 +30,10 @@ import type { MutableAtomFamilyToken, RegularAtomFamilyToken } from "./tokens"
  * @overload Mutable Atom
  */
 export function findState<
-	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, K>
+>(token: MutableAtomFamilyToken<T, K>, key: Key): MutableAtomToken<T, K>
 /**
  * Finds a {@link RegularAtomToken} in the store, without accessing its value.
  *

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/join.ts

@@ -14,7 +14,7 @@ import {
 	IMPLICIT,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import type { SetRTX, SetRTXJson } from "atom.io/transceivers/set-rtx"
+import type { SetRTX } from "atom.io/transceivers/set-rtx"
 
 // biome-ignore format: intersection
 export type JoinOptions<
@@ -262,6 +262,6 @@ export function getInternalRelations<
 	Content extends Json.Object | null,
 >(
 	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
-): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string> {
+): MutableAtomFamilyToken<SetRTX<string>, string> {
 	return getInternalRelationsFromStore(token, IMPLICIT.STORE)
 }

package/src/main/logger.ts

@@ -105,7 +105,7 @@ export const simpleLogger: Logger = {
 
 export class AtomIOLogger implements Logger {
 	public logLevel: `error` | `info` | `warn` | null
-	private readonly filter: LogFilter | undefined
+	public filter: LogFilter | undefined
 	private readonly logger: Logger
 
 	public constructor(
@@ -119,31 +119,31 @@ export class AtomIOLogger implements Logger {
 	}
 
 	public error: LogFn = (...args) => {
-		const filterResult = this.filter?.(...args) ?? true
 		if (this.logLevel !== null) {
+			const filterResult = this.filter?.(...args) ?? true
 			if (filterResult === true) {
 				this.logger.error(...args)
-			} else if (filterResult !== false) {
+			} else if (filterResult) {
 				this.logger.error(...filterResult)
 			}
 		}
 	}
 	public info: LogFn = (...args) => {
-		const filterResult = this.filter?.(...args) ?? true
 		if (this.logLevel === `info`) {
+			const filterResult = this.filter?.(...args) ?? true
 			if (filterResult === true) {
 				this.logger.info(...args)
-			} else if (filterResult !== false) {
+			} else if (filterResult) {
 				this.logger.info(...filterResult)
 			}
 		}
 	}
 	public warn: LogFn = (...args) => {
-		const filterResult = this.filter?.(...args) ?? true
 		if (this.logLevel !== `error` && this.logLevel !== null) {
+			const filterResult = this.filter?.(...args) ?? true
 			if (filterResult === true) {
 				this.logger.warn(...args)
-			} else if (filterResult !== false) {
+			} else if (filterResult) {
 				this.logger.warn(...filterResult)
 			}
 		}

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,5 +1,5 @@
-import type { Func, Transceiver } from "atom.io/internal"
-import type { Canonical, Json, stringified } from "atom.io/json"
+import type { AsJSON, Fn, Transceiver } from "atom.io/internal"
+import type { Canonical, stringified } from "atom.io/json"
 
 /**
  * A token is an object that uniquely identifies a particular state, family, timeline, or transaction.
@@ -53,7 +53,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 +63,7 @@ export type TransactionToken<F extends Func> = {
 }
 
 export type AtomToken<T, K extends Canonical = any> =
-	| MutableAtomToken<T extends Transceiver<any> ? T : never, any, 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,8 +76,7 @@ export type RegularAtomToken<T, K extends Canonical = any> = {
 	__T?: T
 }
 export type MutableAtomToken<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical = any,
 > = {
 	/** The unique identifier of the atom. */
@@ -87,9 +86,7 @@ export type MutableAtomToken<
 	/** Present if the atom belongs to a family. */
 	family?: FamilyMetadata<K>
 	/** Never present. This is a marker that preserves the JSON form of the atom's transceiver value. */
-	__J?: J
-	/** Never present. This is a marker that preserves the type of the atom's transceiver value. */
-	__U?: T extends Transceiver<infer Update> ? Update : never
+	__J?: AsJSON<T>
 }
 
 export type SelectorToken<T, K extends Canonical = any> =
@@ -160,7 +157,7 @@ export type FamilyMetadata<K extends Canonical = any> = {
 }
 
 export type AtomFamilyToken<T, K extends Canonical = Canonical> =
-	| MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, 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 */
@@ -173,8 +170,7 @@ export type RegularAtomFamilyToken<T, K extends Canonical> = {
 	__K?: K
 }
 export type MutableAtomFamilyToken<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 > = {
 	/** The unique identifier of the atom family */
@@ -183,8 +179,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?: J
 	/** 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,11 +1,11 @@
-import type { EnvironmentData, Func, Transceiver } from "atom.io/internal"
+import type { AsJSON, EnvironmentData, Fn, Transceiver } from "atom.io/internal"
 import {
 	actUponStore,
 	arbitrary,
 	createTransaction,
 	IMPLICIT,
 } from "atom.io/internal"
-import type { Canonical, Json, stringified } from "atom.io/json"
+import type { Canonical, stringified } from "atom.io/json"
 
 import type { disposeState } from "./dispose-state"
 import type { findState } from "./find-state"
@@ -28,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`
@@ -55,6 +58,7 @@ export type MoleculeDisposal = {
 export type MoleculeTransfer = {
 	type: `molecule_transfer`
 	key: Canonical
+	exclusive: boolean
 	from: Canonical[]
 	to: Canonical[]
 }
@@ -66,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
@@ -85,29 +89,29 @@ export type ActorToolkit = Readonly<{
 	set: typeof setState
 	reset: typeof resetState
 	find: typeof findState
-	json: <T extends Transceiver<any>, J extends Json.Serializable>(
-		state: MutableAtomToken<T, J>,
-	) => WritablePureSelectorToken<J>
+	json: <T extends Transceiver<any, any, any>>(
+		state: MutableAtomToken<T>,
+	) => WritablePureSelectorToken<AsJSON<T>>
 	dispose: typeof disposeState
 	run: typeof runTransaction
 	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 */
@@ -119,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)
@@ -131,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> {