atom.io 0.36.0 → 0.36.1

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

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

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)
 	}
 }