atom.io 0.40.0 → 0.40.2

package/src/internal/lineage.ts

@@ -4,9 +4,20 @@ export interface Lineage {
 	child: typeof this | null
 }
 
-export function newest<T extends Lineage>(scion: T): T {
+export function newest<T extends Lineage>(
+	scion: T,
+): Exclude<T[`child`], null> | T {
 	while (scion.child !== null) {
 		scion = scion.child
 	}
 	return scion
 }
+
+export function eldest<T extends Lineage>(
+	scion: T,
+): Exclude<T[`parent`], T[`child`] | null> {
+	while (scion.parent !== null) {
+		scion = scion.parent
+	}
+	return scion as Exclude<T[`parent`], T[`child`] | null>
+}

package/src/internal/molecule.ts

@@ -8,18 +8,20 @@ import type {
 	MoleculeDisposalEvent,
 	MoleculeTransferEvent,
 	SingularTypedKey,
+	TransactionToken,
 	Vassal,
 } from "atom.io"
 import type { Canonical, stringified } from "atom.io/json"
 import { parseJson, stringifyJson } from "atom.io/json"
 
-import { disposeFromStore, findInStore } from "./families"
+import { disposeFromStore } from "./families"
 import { getFromStore } from "./get-state"
 import { getTrace } from "./get-trace"
 import { newest } from "./lineage"
 import type { Store } from "./store"
 import { IMPLICIT } from "./store"
-import { isChildStore } from "./transaction"
+import type { RootStore } from "./transaction"
+import { createTransaction, isChildStore } from "./transaction"
 
 export type Molecule<K extends Canonical> = {
 	readonly key: K
@@ -135,23 +137,35 @@ export function fuseWithinStore<
 	return compoundKey
 }
 
+export function createDeallocateTX<
+	H extends Hierarchy,
+	V extends Exclude<Vassal<H>, CompoundTypedKey>,
+>(store: RootStore): TransactionToken<(claim: Claim<V>) => void> {
+	return createTransaction(store, {
+		key: `[Internal] deallocate`,
+		do: (_, claim: Claim<V>): void => {
+			deallocateFromStore<H, V>(newest(store), claim)
+		},
+	})
+}
+
 export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
-	store: Store,
+	target: Store,
 	claim: Claim<V>,
 ): void {
 	const stringKey = stringifyJson(claim)
 
-	const molecule = store.molecules.get(stringKey)
+	const molecule = target.molecules.get(stringKey)
 	if (!molecule) {
-		const disposal = store.disposalTraces.buffer.find(
+		const disposal = target.disposalTraces.buffer.find(
 			(item) => item?.key === stringKey,
 		)
-		store.logger.error(
+		target.logger.error(
 			`❌`,
 			`key`,
 			claim,
 			`deallocation failed:`,
-			`Could not find allocation for ${stringKey} in store "${store.config.name}".`,
+			`Could not find allocation for ${stringKey} in store "${target.config.name}".`,
 			disposal
 				? `\n   This state was most recently deallocated\n${disposal.trace}`
 				: `No previous disposal trace for ${stringKey} was found.`,
@@ -159,45 +173,29 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 		return
 	}
 
-	const joinKeys = store.moleculeJoins.getRelatedKeys(
-		molecule.key as string /* 💥 RECONCILE */,
-	)
+	const joinKeys = target.moleculeJoins.getRelatedKeys(stringKey)
 	if (joinKeys) {
 		for (const joinKey of joinKeys) {
-			const join = store.joins.get(joinKey)
+			const join = target.joins.get(joinKey)
 			if (join) {
-				join.relations.delete(molecule.key)
-				join.molecules.delete(molecule.stringKey) // get rid of
+				join.relations.delete(claim)
 			}
 		}
 	}
-	store.moleculeJoins.delete(molecule.stringKey)
+	target.moleculeJoins.delete(stringKey)
 
 	const provenance: stringified<Canonical>[] = []
 
 	const values: [string, any][] = []
-	const disposalEvent: MoleculeDisposalEvent = {
-		type: `molecule_disposal`,
-		key: molecule.key,
-		values,
-		provenance,
-		timestamp: Date.now(),
-	}
-	const target = newest(store)
-	target.molecules.delete(stringKey)
-	const isTransaction =
-		isChildStore(target) && target.transactionMeta.phase === `building`
-	if (isTransaction) {
-		target.transactionMeta.update.subEvents.push(disposalEvent)
-	}
-	const relatedMolecules = store.moleculeGraph.getRelationEntries({
-		downstreamMoleculeKey: molecule.stringKey,
+
+	const relatedMolecules = target.moleculeGraph.getRelationEntries({
+		downstreamMoleculeKey: stringKey,
 	})
 	if (relatedMolecules) {
 		for (const [relatedStringKey, { source }] of relatedMolecules) {
-			if (source === molecule.stringKey) {
+			if (source === stringKey) {
 				const relatedKey = parseJson(relatedStringKey)
-				deallocateFromStore<any, any>(store, relatedKey)
+				deallocateFromStore<any, any>(target, relatedKey)
 			} else {
 				provenance.push(source)
 			}
@@ -208,12 +206,24 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 		for (const familyKey of familyKeys) {
 			// biome-ignore lint/style/noNonNullAssertion: tokens of molecules must have a family
 			const family = target.families.get(familyKey)!
-			const token = findInStore(store, family, molecule.key)
-			const value = getFromStore(store, token)
+			const value = getFromStore(target, family, claim)
 			values.push([family.key, value])
-			disposeFromStore(store, token)
+			disposeFromStore(target, family, claim)
 		}
 	}
+	const disposalEvent: MoleculeDisposalEvent = {
+		type: `molecule_disposal`,
+		key: molecule.key,
+		values,
+		provenance,
+		timestamp: Date.now(),
+	}
+	target.molecules.delete(stringKey)
+	const isTransaction =
+		isChildStore(target) && target.transactionMeta.phase === `building`
+	if (isTransaction) {
+		target.transactionMeta.update.subEvents.push(disposalEvent)
+	}
 
 	target.moleculeGraph.delete(molecule.stringKey)
 	target.moleculeJoins.delete(molecule.stringKey)
@@ -225,8 +235,26 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 	target.molecules.delete(molecule.stringKey)
 
 	const trace = getTrace(new Error())
-	store.disposalTraces.add({ key: stringKey, trace })
+	target.disposalTraces.add({ key: stringKey, trace })
+}
+
+export function createClaimTX<
+	H extends Hierarchy,
+	V extends Exclude<Vassal<H>, CompoundTypedKey>,
+	A extends Above<V, H>,
+>(
+	store: RootStore,
+): TransactionToken<
+	(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`) => void
+> {
+	return createTransaction(store, {
+		key: `[Internal] claim`,
+		do: (_, newProvenance, claim, exclusive) => {
+			claimWithinStore<H, V, A>(store, newProvenance, claim, exclusive)
+		},
+	})
 }
+
 export function claimWithinStore<
 	H extends Hierarchy,
 	V extends Exclude<Vassal<H>, CompoundTypedKey>,

package/src/internal/mutable/create-mutable-atom-family.ts

@@ -10,10 +10,10 @@ import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import { createWritablePureSelectorFamily, type MutableAtomFamily } from ".."
+import type { MutableAtomFamily, RootStore } from ".."
+import { createWritablePureSelectorFamily } from ".."
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
-import type { Store } from "../store"
 import { Subject } from "../subject"
 import { FamilyTracker } from "./tracker-family"
 import type { AsJSON, Transceiver } from "./transceiver"
@@ -22,7 +22,7 @@ export function createMutableAtomFamily<
 	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 >(
-	store: Store,
+	store: RootStore,
 	options: MutableAtomFamilyOptions<T, K>,
 	internalRoles?: string[],
 ): MutableAtomFamilyToken<T, K> {
@@ -67,13 +67,13 @@ export function createMutableAtomFamily<
 	const atomFamily = Object.assign(familyFunction, familyToken, {
 		class: options.class,
 		subject,
-		install: (s: Store) => createMutableAtomFamily(s, options),
+		install: (s: RootStore) => createMutableAtomFamily(s, options),
 		internalRoles,
 	}) satisfies MutableAtomFamily<T, K>
 
 	store.families.set(options.key, atomFamily)
 
-	createWritablePureSelectorFamily<AsJSON<T>, K>(
+	createWritablePureSelectorFamily<AsJSON<T>, K, never>(
 		store,
 		{
 			key: `${options.key}:JSON`,

package/src/internal/mutable/create-mutable-atom.ts

@@ -5,7 +5,7 @@ import type {
 	UpdateHandler,
 } from "atom.io"
 
-import type { MutableAtom } from ".."
+import type { MutableAtom, RootStore } from ".."
 import { createStandaloneSelector, resetInStore, setIntoStore } from ".."
 import { newest } from "../lineage"
 import { deposit, type Store } from "../store"
@@ -45,7 +45,7 @@ export function createMutableAtom<T extends Transceiver<any, any, any>>(
 	const newAtom: MutableAtom<T> = {
 		...options,
 		type,
-		install: (s: Store) => {
+		install: (s: RootStore) => {
 			s.logger.info(`🛠️`, `atom`, key, `installing in store "${s.config.name}"`)
 			return createMutableAtom(s, options, family)
 		},

package/src/internal/mutable/get-json-family.ts

@@ -12,12 +12,13 @@ export const getJsonFamily = <
 >(
 	mutableAtomFamily: MutableAtomFamilyToken<Core, Key>,
 	store: Store,
-): WritablePureSelectorFamily<ReturnType<Core[`toJSON`]>, Key> => {
+): WritablePureSelectorFamily<ReturnType<Core[`toJSON`]>, Key, never> => {
 	const target = newest(store)
 	const key = `${mutableAtomFamily.key}:JSON`
 	const jsonFamily = target.families.get(key) as WritablePureSelectorFamily<
 		ReturnType<Core[`toJSON`]>,
-		Key
+		Key,
+		never
 	>
 	return jsonFamily
 }

package/src/internal/mutable/get-update-family.ts

@@ -1,7 +1,7 @@
 import type { MutableAtomFamilyToken } from "atom.io"
 import type { Json } from "atom.io/json"
 
-import type { AtomFamily } from ".."
+import type { RegularAtomFamily } from ".."
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import type { SignalFrom, Transceiver } from "./transceiver"
@@ -12,11 +12,13 @@ export const getUpdateFamily = <
 >(
 	mutableAtomFamily: MutableAtomFamilyToken<T, K>,
 	store: Store,
-): AtomFamily<SignalFrom<T>, K> => {
+): RegularAtomFamily<SignalFrom<T>, K, never> => {
 	const target = newest(store)
 	const key = `*${mutableAtomFamily.key}`
-	const updateFamily: AtomFamily<SignalFrom<T>, K> = target.families.get(
-		key,
-	) as AtomFamily<SignalFrom<T>, K>
+	const updateFamily = target.families.get(key) as RegularAtomFamily<
+		SignalFrom<T>,
+		K,
+		never
+	>
 	return updateFamily
 }

package/src/internal/mutable/tracker-family.ts

@@ -2,9 +2,9 @@ import type { MutableAtomToken, StateLifecycleEvent } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
-import type { MutableAtomFamily, RegularAtomFamily } from ".."
+import type { MutableAtomFamily, RegularAtomFamily, RootStore } from ".."
 import { createRegularAtomFamily } from "../families"
-import { type Store, withdraw } from "../store"
+import { withdraw } from "../store"
 import { Tracker } from "./tracker"
 import type { SignalFrom, Transceiver } from "./transceiver"
 
@@ -17,8 +17,12 @@ export class FamilyTracker<
 	public readonly latestSignalAtoms: RegularAtomFamily<SignalFrom<T> | null, K>
 	public readonly mutableAtoms: MutableAtomFamily<T, K>
 
-	public constructor(mutableAtoms: MutableAtomFamily<T, K>, store: Store) {
-		const latestSignalAtoms = createRegularAtomFamily<SignalFrom<T> | null, K>(
+	public constructor(mutableAtoms: MutableAtomFamily<T, K>, store: RootStore) {
+		const latestSignalAtoms = createRegularAtomFamily<
+			SignalFrom<T> | null,
+			K,
+			never
+		>(
 			store,
 			{
 				key: `*${mutableAtoms.key}`,

package/src/internal/mutable/tracker.ts

@@ -31,7 +31,11 @@ export class Tracker<T extends Transceiver<any, any, any>> {
 					subKey: mutableState.family.subKey,
 				}
 			: undefined
-		const latestSignalState = createRegularAtom<SignalFrom<T> | null>(
+		const latestSignalState = createRegularAtom<
+			SignalFrom<T> | null,
+			any,
+			never
+		>(
 			store,
 			{
 				key: latestSignalStateKey,

package/src/internal/operation.ts

@@ -8,7 +8,9 @@ export type OperationProgress =
 	| {
 			open: false
 	  }
-export type OpenOperation<R extends ReadableToken<any> = ReadableToken<any>> = {
+export type OpenOperation<
+	R extends ReadableToken<any, any> = ReadableToken<any, any>,
+> = {
 	open: true
 	token: R
 	done: Set<string>
@@ -19,7 +21,7 @@ export type OpenOperation<R extends ReadableToken<any> = ReadableToken<any>> = {
 
 export function openOperation(
 	store: Store,
-	token: ReadableToken<any>,
+	token: ReadableToken<any, any, any>,
 ): number | (Store & { operation: OpenOperation }) {
 	if (store.operation.open) {
 		const rejectionTime = performance.now()

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

@@ -4,7 +4,7 @@ import type {
 	ReadonlyHeldSelectorToken,
 } from "atom.io"
 
-import type { ReadonlyHeldSelector } from ".."
+import type { ReadonlyHeldSelector, RootStore } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -47,7 +47,7 @@ export function createReadonlyHeldSelector<T extends object>(
 		type,
 		subject,
 		getFrom,
-		install: (s: Store) => createReadonlyHeldSelector(s, options, family),
+		install: (s: RootStore) => createReadonlyHeldSelector(s, options, family),
 	}
 	if (family) readonlySelector.family = family
 

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

@@ -2,22 +2,24 @@ import type {
 	FamilyMetadata,
 	ReadonlyPureSelectorOptions,
 	ReadonlyPureSelectorToken,
+	StateUpdate,
 } from "atom.io"
+import type { Canonical } from "atom.io/json"
 
-import type { ReadonlyPureSelector } from ".."
+import type { ReadonlyPureSelector, RootStore } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 import { registerSelector } from "./register-selector"
 
-export function createReadonlyPureSelector<T>(
+export function createReadonlyPureSelector<T, K extends Canonical, E>(
 	store: Store,
-	options: ReadonlyPureSelectorOptions<T>,
-	family: FamilyMetadata | undefined,
-): ReadonlyPureSelectorToken<T> {
+	options: ReadonlyPureSelectorOptions<T, E>,
+	family: FamilyMetadata<K> | undefined,
+): ReadonlyPureSelectorToken<T, K, E> {
 	const target = newest(store)
-	const subject = new Subject<{ newValue: T; oldValue: T }>()
+	const subject = new Subject<StateUpdate<E | T>>()
 	const covered = new Set<string>()
 	const key = options.key
 	const type = `readonly_pure_selector` as const
@@ -43,12 +45,12 @@ export function createReadonlyPureSelector<T>(
 		return cached
 	}
 
-	const readonlySelector: ReadonlyPureSelector<T> = {
+	const readonlySelector: ReadonlyPureSelector<T, E> = {
 		...options,
 		type,
 		subject,
 		getFrom,
-		install: (s: Store) => createReadonlyPureSelector(s, options, family),
+		install: (s: RootStore) => createReadonlyPureSelector(s, options, family),
 	}
 	if (family) readonlySelector.family = family
 

package/src/internal/selector/create-standalone-selector.ts

@@ -23,26 +23,26 @@ export function createStandaloneSelector<T extends object>(
 	store: Store,
 	options: ReadonlyHeldSelectorOptions<T>,
 ): ReadonlyHeldSelectorToken<T>
-export function createStandaloneSelector<T>(
+export function createStandaloneSelector<T, E>(
 	store: Store,
-	options: WritablePureSelectorOptions<T>,
-): WritablePureSelectorToken<T>
-export function createStandaloneSelector<T>(
+	options: WritablePureSelectorOptions<T, E>,
+): WritablePureSelectorToken<T, any, E>
+export function createStandaloneSelector<T, E>(
 	store: Store,
-	options: ReadonlyPureSelectorOptions<T>,
-): ReadonlyPureSelectorToken<T>
+	options: ReadonlyPureSelectorOptions<T, E>,
+): ReadonlyPureSelectorToken<T, any, E>
 export function createStandaloneSelector(
 	store: Store,
 	options:
 		| ReadonlyHeldSelectorOptions<any>
-		| ReadonlyPureSelectorOptions<any>
+		| ReadonlyPureSelectorOptions<any, any>
 		| WritableHeldSelectorOptions<any>
-		| WritablePureSelectorOptions<any>,
+		| WritablePureSelectorOptions<any, any>,
 ):
 	| ReadonlyHeldSelectorToken<any>
-	| ReadonlyPureSelectorToken<any>
+	| ReadonlyPureSelectorToken<any, any, any>
 	| WritableHeldSelectorToken<any>
-	| WritablePureSelectorToken<any> {
+	| WritablePureSelectorToken<any, any, any> {
 	const isWritable = `set` in options
 	const isHeld = `const` in options
 

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

@@ -4,7 +4,7 @@ import type {
 	WritableHeldSelectorToken,
 } from "atom.io"
 
-import type { WritableHeldSelector } from ".."
+import type { RootStore, WritableHeldSelector } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -54,7 +54,7 @@ export function createWritableHeldSelector<T extends object>(
 		subject,
 		getFrom,
 		setSelf,
-		install: (s: Store) => createWritableHeldSelector(s, options, family),
+		install: (s: RootStore) => createWritableHeldSelector(s, options, family),
 	}
 	if (family) mySelector.family = family
 

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

@@ -1,23 +1,25 @@
 import type {
 	FamilyMetadata,
+	StateUpdate,
 	WritablePureSelectorOptions,
 	WritablePureSelectorToken,
 } from "atom.io"
+import type { Canonical } from "atom.io/json"
 
-import type { WritablePureSelector } from ".."
+import type { RootStore, WritablePureSelector } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 import { registerSelector } from "./register-selector"
 
-export function createWritablePureSelector<T>(
+export function createWritablePureSelector<T, K extends Canonical, E>(
 	store: Store,
-	options: WritablePureSelectorOptions<T>,
-	family: FamilyMetadata | undefined,
-): WritablePureSelectorToken<T> {
+	options: WritablePureSelectorOptions<T, E>,
+	family: FamilyMetadata<K> | undefined,
+): WritablePureSelectorToken<T, K, E> {
 	const target = newest(store)
-	const subject = new Subject<{ newValue: T; oldValue: T }>()
+	const subject = new Subject<StateUpdate<E | T>>()
 	const covered = new Set<string>()
 	const key = options.key
 	const type = `writable_pure_selector` as const
@@ -27,7 +29,7 @@ export function createWritablePureSelector<T>(
 	const { find, get, json } = setterToolkit
 	const getterToolkit = { find, get, json }
 
-	const getFrom = (innerTarget: Store): T => {
+	const getFrom = (innerTarget: Store): E | T => {
 		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({
 			downstreamSelectorKey: key,
 		})
@@ -48,13 +50,13 @@ export function createWritablePureSelector<T>(
 		options.set(setterToolkit, newValue)
 	}
 
-	const mySelector: WritablePureSelector<T> = {
+	const mySelector: WritablePureSelector<T, E> = {
 		...options,
 		type,
 		subject,
 		getFrom,
 		setSelf,
-		install: (s: Store) => createWritablePureSelector(s, options, family),
+		install: (s: RootStore) => createWritablePureSelector(s, options, family),
 	}
 	if (family) mySelector.family = family
 

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

@@ -5,7 +5,7 @@ import { isChildStore, newest, withdraw } from ".."
 
 export function disposeSelector(
 	store: Store,
-	selectorToken: SelectorToken<unknown>,
+	selectorToken: SelectorToken<unknown, any, any>,
 ): void {
 	const target = newest(store)
 	const { key, type, family: familyMeta } = selectorToken
@@ -21,7 +21,7 @@ export function disposeSelector(
 		if (molecule) {
 			target.moleculeData.delete(familyMeta.subKey, familyMeta.key)
 		}
-		let familyToken: SelectorFamilyToken<any, any>
+		let familyToken: SelectorFamilyToken<any, any, any>
 		switch (selectorToken.type) {
 			case `writable_held_selector`:
 				{

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

@@ -33,8 +33,8 @@ export function registerSelector(
 	return {
 		get: (
 			...params:
-				| [ReadableFamilyToken<any, any>, Canonical]
-				| [ReadableToken<any>]
+				| [ReadableFamilyToken<any, any, any>, Canonical]
+				| [ReadableToken<any, any, any>]
 		) => {
 			const target = newest(store)
 			const { token, family, subKey } = reduceReference(store, ...params)

package/src/internal/selector/trace-selector-atoms.ts

@@ -6,10 +6,10 @@ export function traceRootSelectorAtoms(
 	store: Store,
 	selectorKey: string,
 	covered: Set<string> = new Set<string>(),
-): Map<string, Atom<unknown>> {
+): Map<string, Atom<any, any>> {
 	const dependencies = getSelectorDependencyKeys(store, selectorKey)
 
-	const roots = new Map<string, Atom<unknown>>()
+	const roots = new Map<string, Atom<unknown, unknown>>()
 
 	while (dependencies.length > 0) {
 		// biome-ignore lint/style/noNonNullAssertion: just checked length ^^^
@@ -19,7 +19,7 @@ export function traceRootSelectorAtoms(
 		}
 		covered.add(dependencyKey)
 		if (isAtomKey(store, dependencyKey)) {
-			const atom = store.atoms.get(dependencyKey) as Atom<unknown>
+			const atom = store.atoms.get(dependencyKey) as Atom<unknown, unknown>
 			roots.set(atom.key, atom)
 		} else {
 			dependencies.push(...getSelectorDependencyKeys(store, dependencyKey))

package/src/internal/selector/update-selector-atoms.ts

@@ -12,7 +12,7 @@ export function updateSelectorAtoms(
 		| `writable_held_selector`
 		| `writable_pure_selector`,
 	selectorKey: string,
-	dependency: ReadableToken<unknown>,
+	dependency: ReadableToken<unknown, any, unknown>,
 	covered: Set<string>,
 ): void {
 	const target = newest(store)

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

@@ -1,9 +1,7 @@
 import { isFn } from "../is-fn"
 
-export type Modify<T> = (thing: T) => T
-
 export function become<T>(
-	nextVersionOfThing: Modify<T> | T,
+	nextVersionOfThing: T | ((prev: T) => T),
 	originalThing: T,
 ): T {
 	if (isFn(nextVersionOfThing)) {

package/src/internal/set-state/dispatch-state-update.ts

@@ -17,18 +17,18 @@ import { isChildStore, isRootStore } from "../transaction"
 import { evictDownstreamFromAtom } from "./evict-downstream"
 import type { ProtoUpdate } from "./operate-on-store"
 
-export function dispatchOrDeferStateUpdate<T>(
+export function dispatchOrDeferStateUpdate<T, E>(
 	target: Store & { operation: OpenOperation<any> },
-	state: WritableState<T>,
-	{ oldValue, newValue }: ProtoUpdate<T>,
+	state: WritableState<T, E>,
+	{ oldValue, newValue }: ProtoUpdate<E | T>,
 	stateIsNewlyCreated: boolean,
-	family?: WritableFamily<T, any>,
+	family?: WritableFamily<T, any, E>,
 ): void {
 	const token = deposit(state)
 	if (stateIsNewlyCreated && family) {
 		state.subject.next({ newValue })
 		const stateCreationEvent: StateCreationEvent<any> & TimelineEvent<any> = {
-			write: true,
+			checkpoint: true,
 			type: `state_creation`,
 			subType: `writable`,
 			token,
@@ -128,7 +128,11 @@ export function dispatchOrDeferStateUpdate<T>(
 			const mutable = target.atoms.get(keyOfMutable) as MutableAtom<
 				Transceiver<unknown, any, any>
 			>
-			const transceiver = readOrComputeValue(target, mutable, `mut`)
+			const transceiver = readOrComputeValue<Transceiver<any, any, any>, never>(
+				target,
+				mutable,
+				`mut`,
+			)
 			const accepted = transceiver.do(update.newValue) === null
 			if (accepted === true) {
 				evictDownstreamFromAtom(target, mutable)

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

@@ -4,7 +4,10 @@ import { newest } from "../lineage"
 import { isDone, markDone } from "../operation"
 import type { Store } from "../store"
 
-export function evictDownstreamFromAtom(store: Store, atom: Atom<any>): void {
+export function evictDownstreamFromAtom(
+	store: Store,
+	atom: Atom<any, any>,
+): void {
 	const target = newest(store)
 	const { key, type } = atom
 	const downstreamKeys = target.selectorAtoms.getRelatedKeys(key)