atom.io 0.34.2 → 0.36.0

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

@@ -4,11 +4,9 @@ import type {
 	MutableAtomToken,
 	UpdateHandler,
 } from "atom.io"
-import type { Json } from "atom.io/json"
-import { selectJson } from "atom.io/json"
 
 import type { MutableAtom } from ".."
-import { resetInStore, setIntoStore } from ".."
+import { createStandaloneSelector, resetInStore, setIntoStore } from ".."
 import { newest } from "../lineage"
 import { deposit, type Store } from "../store"
 import { Subject } from "../subject"
@@ -16,14 +14,11 @@ import { subscribeToState } from "../subscribe"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
 
-export function createMutableAtom<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(
+export function createMutableAtom<T extends Transceiver<any, any>>(
 	store: Store,
-	options: MutableAtomOptions<T, J>,
+	options: MutableAtomOptions<T>,
 	family: FamilyMetadata | undefined,
-): MutableAtomToken<T, J> {
+): MutableAtomToken<T> {
 	store.logger.info(
 		`🔨`,
 		`atom`,
@@ -43,8 +38,11 @@ export function createMutableAtom<
 		)
 		return deposit(existing)
 	}
-	const subject = new Subject<{ newValue: T; oldValue: T }>()
-	const newAtom: MutableAtom<T, J> = {
+	const subject = new Subject<{
+		newValue: T
+		oldValue: T
+	}>()
+	const newAtom: MutableAtom<T> = {
 		...options,
 		type,
 		install: (s: Store) => {
@@ -86,8 +84,14 @@ export function createMutableAtom<
 
 	new Tracker(token, store)
 	if (!family) {
-		selectJson(token, options, store)
+		createStandaloneSelector(store, {
+			key: `${key}:JSON`,
+			get: ({ get }) => get(token).toJSON(),
+			set: ({ set }, newValue) => {
+				set(token, options.class.fromJSON(newValue))
+			},
+		})
 	}
-
+	store.on.atomCreation.next(token)
 	return token
 }

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

@@ -7,16 +7,17 @@ import type { Store } from "../store"
 import type { Transceiver } from "./transceiver"
 
 export const getJsonFamily = <
-	Core extends Transceiver<Json.Serializable>,
-	SerializableCore extends Json.Serializable,
+	Core extends Transceiver<Json.Serializable, Json.Serializable>,
 	Key extends Canonical,
 >(
-	mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>,
+	mutableAtomFamily: MutableAtomFamilyToken<Core, Key>,
 	store: Store,
-): WritablePureSelectorFamily<SerializableCore, Key> => {
+): WritablePureSelectorFamily<ReturnType<Core[`toJSON`]>, Key> => {
 	const target = newest(store)
 	const key = `${mutableAtomFamily.key}:JSON`
-	const jsonFamily: WritablePureSelectorFamily<SerializableCore, Key> =
-		target.families.get(key) as WritablePureSelectorFamily<SerializableCore, Key>
+	const jsonFamily = target.families.get(key) as WritablePureSelectorFamily<
+		ReturnType<Core[`toJSON`]>,
+		Key
+	>
 	return jsonFamily
 }

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

@@ -3,27 +3,20 @@ import type {
 	WritablePureSelectorFamilyToken,
 	WritablePureSelectorToken,
 } from "atom.io"
-import type { Json } from "atom.io/json"
 
 import { findInStore } from "../families"
 import { newest } from "../lineage"
 import { type Store, withdraw } from "../store"
-import type { Transceiver } from "./transceiver"
+import type { AsJSON, Transceiver } from "./transceiver"
 
-export const getJsonToken = <
-	Core extends Transceiver<any>,
-	SerializableCore extends Json.Serializable,
->(
+export const getJsonToken = <T extends Transceiver<any, any>>(
 	store: Store,
-	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
-): WritablePureSelectorToken<SerializableCore> => {
+	mutableAtomToken: MutableAtomToken<T>,
+): WritablePureSelectorToken<AsJSON<T>> => {
 	if (mutableAtomToken.family) {
 		const target = newest(store)
 		const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`
-		const jsonFamilyToken: WritablePureSelectorFamilyToken<
-			SerializableCore,
-			string
-		> = {
+		const jsonFamilyToken: WritablePureSelectorFamilyToken<AsJSON<T>, string> = {
 			key: jsonFamilyKey,
 			type: `writable_pure_selector_family`,
 		}
@@ -32,7 +25,7 @@ export const getJsonToken = <
 		const jsonToken = findInStore(store, family, subKey)
 		return jsonToken
 	}
-	const token: WritablePureSelectorToken<SerializableCore> = {
+	const token: WritablePureSelectorToken<AsJSON<T>> = {
 		type: `writable_pure_selector`,
 		key: `${mutableAtomToken.key}:JSON`,
 	}

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

@@ -4,20 +4,19 @@ import type { Json } from "atom.io/json"
 import type { AtomFamily } from ".."
 import { newest } from "../lineage"
 import type { Store } from "../store"
-import type { Signal, Transceiver } from "./transceiver"
+import type { SignalFrom, Transceiver } from "./transceiver"
 
 export const getUpdateFamily = <
-	Core extends Transceiver<Json.Serializable>,
-	SerializableCore extends Json.Serializable,
-	Key extends string,
+	T extends Transceiver<Json.Serializable, Json.Serializable>,
+	K extends string,
 >(
-	mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>,
+	mutableAtomFamily: MutableAtomFamilyToken<T, K>,
 	store: Store,
-): AtomFamily<Signal<Core>, Key> => {
+): AtomFamily<SignalFrom<T>, K> => {
 	const target = newest(store)
 	const key = `*${mutableAtomFamily.key}`
-	const updateFamily: AtomFamily<Signal<Core>, Key> = target.families.get(
+	const updateFamily: AtomFamily<SignalFrom<T>, K> = target.families.get(
 		key,
-	) as AtomFamily<Signal<Core>, Key>
+	) as AtomFamily<SignalFrom<T>, K>
 	return updateFamily
 }

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

@@ -1,16 +1,12 @@
 import type { MutableAtomToken, RegularAtomToken } from "atom.io"
-import type { Json } from "atom.io/json"
 
-import type { Signal, Transceiver } from "./transceiver"
+import type { SignalFrom, Transceiver } from "./transceiver"
 
-export const getUpdateToken = <
-	Core extends Transceiver<any>,
-	SerializableCore extends Json.Serializable,
->(
-	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
-): RegularAtomToken<Signal<Core>> => {
+export const getUpdateToken = <T extends Transceiver<any, any>>(
+	mutableAtomToken: MutableAtomToken<T>,
+): RegularAtomToken<SignalFrom<T>> => {
 	const key = `*${mutableAtomToken.key}`
-	const updateToken: RegularAtomToken<Signal<Core>> = { type: `atom`, key }
+	const updateToken: RegularAtomToken<SignalFrom<T>> = { type: `atom`, key }
 	if (mutableAtomToken.family) {
 		updateToken.family = {
 			key: `*${mutableAtomToken.family.key}`,

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

@@ -8,24 +8,21 @@ import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
 
 export class FamilyTracker<
-	Core extends Transceiver<any>,
-	FamilyMemberKey extends Canonical,
+	T extends Transceiver<any, any>,
+	K extends Canonical,
 > {
-	private trackers: Map<FamilyMemberKey, Tracker<Core>> = new Map()
+	private trackers: Map<K, Tracker<T>> = new Map()
 
 	public readonly latestUpdateAtoms: RegularAtomFamily<
-		(Core extends Transceiver<infer Signal> ? Signal : never) | null,
-		FamilyMemberKey
+		(T extends Transceiver<infer Signal, any> ? Signal : never) | null,
+		K
 	>
-	public readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>
+	public readonly mutableAtoms: MutableAtomFamily<T, K>
 
-	public constructor(
-		mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>,
-		store: Store,
-	) {
+	public constructor(mutableAtoms: MutableAtomFamily<T, K>, store: Store) {
 		const updateAtoms = createRegularAtomFamily<
-			(Core extends Transceiver<infer Signal> ? Signal : never) | null,
-			FamilyMemberKey
+			(T extends Transceiver<infer Signal, any> ? Signal : never) | null,
+			K
 		>(
 			store,
 			{
@@ -44,7 +41,7 @@ export class FamilyTracker<
 					const key = parseJson(token.family.subKey)
 					switch (type) {
 						case `state_creation`:
-							this.trackers.set(key, new Tracker<Core>(token, store))
+							this.trackers.set(key, new Tracker<T>(token, store))
 							break
 						case `state_disposal`:
 							{

package/src/internal/mutable/tracker.ts

@@ -1,5 +1,4 @@
 import type { FamilyMetadata, MutableAtomToken, RegularAtomToken } from "atom.io"
-import type { Json } from "atom.io/json"
 
 import type { Store } from ".."
 import {
@@ -11,20 +10,18 @@ import {
 } from ".."
 import { createRegularAtom } from "../atom"
 import { isChildStore } from "../transaction/is-root-store"
-import type { Transceiver } from "./transceiver"
+import type { SignalFrom, Transceiver } from "./transceiver"
 
 /**
  * @internal Give the tracker a transceiver state and a store, and it will
  * subscribe to the transceiver's inner value. When the inner value changes,
  * the tracker will update its own state to reflect the change.
  */
-export class Tracker<Mutable extends Transceiver<any>> {
+export class Tracker<T extends Transceiver<any, any>> {
 	private initializeState(
-		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
+		mutableState: MutableAtomToken<T>,
 		store: Store,
-	): RegularAtomToken<
-		(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-	> {
+	): RegularAtomToken<SignalFrom<T> | null> {
 		const latestUpdateStateKey = `*${mutableState.key}`
 		store.atoms.delete(latestUpdateStateKey)
 		store.valueMap.delete(latestUpdateStateKey)
@@ -34,9 +31,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					subKey: mutableState.family.subKey,
 				}
 			: undefined
-		const latestUpdateState = createRegularAtom<
-			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-		>(
+		const latestUpdateState = createRegularAtom<SignalFrom<T> | null>(
 			store,
 			{
 				key: latestUpdateStateKey,
@@ -54,46 +49,41 @@ export class Tracker<Mutable extends Transceiver<any>> {
 
 	private unsubscribeFromInnerValue!: () => void
 	private unsubscribeFromState!: () => void
-	private observeCore(
-		mutableState: MutableAtomToken<Mutable, any>,
-		latestUpdateState: RegularAtomToken<
-			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-		>,
+	private captureSignalsFromCore(
+		mutableState: MutableAtomToken<T, any>,
+		latestUpdateState: RegularAtomToken<SignalFrom<T> | null>,
 		target: Store,
 	): void {
 		const subscriptionKey = `tracker:${target.config.name}:${
 			isChildStore(target) ? target.transactionMeta.update.key : `main`
 		}:${mutableState.key}`
+		const trackerCapturesOutboundSignal = (update: SignalFrom<T>) => {
+			setIntoStore(target, latestUpdateState, update)
+		}
 		const originalInnerValue = getFromStore(target, mutableState)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
 			subscriptionKey,
-			(update) => {
-				setIntoStore(target, latestUpdateState, update)
-			},
+			trackerCapturesOutboundSignal,
 		)
 		this.unsubscribeFromState = subscribeToState(
 			target,
 			mutableState,
 			subscriptionKey,
-			(update) => {
+			function trackerLooksForNewReference(update: SignalFrom<T>) {
 				if (update.newValue !== update.oldValue) {
 					this.unsubscribeFromInnerValue()
 					this.unsubscribeFromInnerValue = update.newValue.subscribe(
 						subscriptionKey,
-						(transceiverUpdate) => {
-							setIntoStore(target, latestUpdateState, transceiverUpdate)
-						},
+						trackerCapturesOutboundSignal,
 					)
 				}
-			},
+			}.bind(this),
 		)
 	}
 
-	private updateCore<Core extends Transceiver<any>>(
-		mutableState: MutableAtomToken<Core, Json.Serializable>,
-		latestUpdateState: RegularAtomToken<
-			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-		>,
+	private supplySignalsToCore(
+		mutableState: MutableAtomToken<T>,
+		latestUpdateState: RegularAtomToken<SignalFrom<T> | null>,
 		target: Store,
 	): void {
 		const subscriptionKey = `tracker:${target.config.name}:${
@@ -103,85 +93,71 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			target,
 			latestUpdateState,
 			subscriptionKey,
-			({ newValue, oldValue }) => {
+			function trackerCapturesInboundSignal({ newValue, oldValue }) {
 				const timelineId = target.timelineTopics.getRelatedKey(
 					latestUpdateState.key,
 				)
 
-				if (timelineId) {
-					const timelineData = target.timelines.get(timelineId)
-					if (timelineData?.timeTraveling) {
-						const unsubscribe = subscribeToTimeline(
-							target,
-							{ key: timelineId, type: `timeline` },
-							subscriptionKey,
-							(update) => {
-								unsubscribe()
-								setIntoStore(target, mutableState, (transceiver) => {
-									if (update === `redo` && newValue) {
-										transceiver.do(newValue)
-									} else if (update === `undo` && oldValue) {
-										transceiver.undo(oldValue)
-									}
-									return transceiver
-								})
-							},
-						)
-						return
-					}
+				if (timelineId && target.timelines.get(timelineId)?.timeTraveling) {
+					const unsubscribe = subscribeToTimeline(
+						target,
+						{ key: timelineId, type: `timeline` },
+						subscriptionKey,
+						function trackerWaitsForTimeTravelToFinish(update) {
+							unsubscribe()
+							setIntoStore(target, mutableState, (transceiver) => {
+								if (update === `redo` && newValue) {
+									transceiver.do(newValue)
+								} else if (update === `undo` && oldValue) {
+									transceiver.undo(oldValue)
+								}
+								return transceiver
+							})
+						},
+					)
+					return
 				}
 
-				const unsubscribe = target.on.operationClose.subscribe(
-					subscriptionKey,
-					() => {
-						unsubscribe()
-						const mutable = getFromStore(target, mutableState)
-						const updateNumber =
-							newValue === null ? -1 : mutable.getUpdateNumber(newValue)
-						const eventOffset = updateNumber - mutable.cacheUpdateNumber
-						if (newValue && eventOffset === 1) {
-							setIntoStore(
-								target,
-								mutableState,
-								(transceiver) => (transceiver.do(newValue), transceiver),
-							)
-						} else {
-							target.logger.info(
-								`❌`,
-								`mutable_atom`,
-								mutableState.key,
-								`could not be updated. Expected update number ${
-									mutable.cacheUpdateNumber + 1
-								}, but got ${updateNumber}`,
-							)
-						}
-					},
-				)
+				const mutable = getFromStore(target, mutableState)
+				const updateNumber = mutable.getUpdateNumber(newValue)
+				const eventOffset = updateNumber - mutable.cacheUpdateNumber
+				if (newValue && eventOffset === 1) {
+					setIntoStore(
+						target,
+						mutableState,
+						(transceiver) => (transceiver.do(newValue), transceiver),
+					)
+				} else {
+					target.logger.info(
+						`❌`,
+						`mutable_atom`,
+						mutableState.key,
+						`could not be updated. Expected update number ${
+							mutable.cacheUpdateNumber + 1
+						}, but got ${updateNumber}`,
+					)
+				}
 			},
 		)
 	}
 
-	public mutableState: MutableAtomToken<Mutable, Json.Serializable>
-	public latestUpdateState: RegularAtomToken<
-		(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
-	>
+	public mutableAtomToken: MutableAtomToken<T>
+	public latestSignalToken: RegularAtomToken<SignalFrom<T> | null>
 
 	public [Symbol.dispose]!: () => void
 
-	public constructor(
-		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
-		store: Store,
-	) {
-		this.mutableState = mutableState
+	public constructor(mutableAtomToken: MutableAtomToken<T>, store: Store) {
 		const target = newest(store)
-		this.latestUpdateState = this.initializeState(mutableState, target)
-		this.observeCore(mutableState, this.latestUpdateState, target)
-		this.updateCore(mutableState, this.latestUpdateState, target)
-		target.trackers.set(mutableState.key, this)
+		const latestSignalToken = this.initializeState(mutableAtomToken, target)
+		this.mutableAtomToken = mutableAtomToken
+		this.latestSignalToken = latestSignalToken
+		this.captureSignalsFromCore(mutableAtomToken, latestSignalToken, target)
+		this.supplySignalsToCore(mutableAtomToken, latestSignalToken, target)
+		target.trackers.set(mutableAtomToken.key, this)
 		this[Symbol.dispose] = () => {
 			this.unsubscribeFromInnerValue()
 			this.unsubscribeFromState()
-			target.trackers.delete(mutableState.key)
+			target.trackers.delete(mutableAtomToken.key)
 		}
 	}
 }

package/src/internal/mutable/transceiver.ts

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

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

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

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

@@ -3,9 +3,9 @@ import type {
 	ReadableFamilyToken,
 	ReadableToken,
 	setState,
-	SetterToolkit,
 	WritableFamilyToken,
 	WritableToken,
+	WriterToolkit,
 } from "atom.io"
 import type { Json } from "atom.io/json"
 
@@ -27,7 +27,7 @@ export const registerSelector = (
 		| `writable_pure_selector`,
 	selectorKey: string,
 	covered: Set<string>,
-): SetterToolkit => ({
+): WriterToolkit => ({
 	get: (
 		...params:
 			| [ReadableFamilyToken<any, any>, Json.Serializable]

package/src/internal/set-state/copy-mutable-if-needed.ts

@@ -2,12 +2,14 @@ import type { MutableAtom, Transceiver } from ".."
 import { Tracker } from "../mutable"
 import type { Store } from "../store"
 
-export function copyMutableIfNeeded<T extends Transceiver<any>>(
+export function copyMutableIfNeeded<T extends Transceiver<any, any>>(
 	target: Store,
-	atom: MutableAtom<T, any>,
+	atom: MutableAtom<T>,
 	origin: Store,
 ): T {
-	const originValue = origin.valueMap.get(atom.key)
+	const originValue = origin.valueMap.get(atom.key) as
+		| Transceiver<any, any>
+		| undefined
 	const targetValue = target.valueMap.get(atom.key)
 
 	if (originValue !== targetValue) {
@@ -15,12 +17,12 @@ export function copyMutableIfNeeded<T extends Transceiver<any>>(
 	}
 
 	if (originValue === undefined) {
-		return atom.default()
+		return new atom.class()
 	}
 
 	origin.logger.info(`📃`, `atom`, atom.key, `copying`)
-	const jsonValue = atom.toJson(originValue)
-	const copiedValue = atom.fromJson(jsonValue)
+	const jsonValue = originValue.toJSON()
+	const copiedValue = atom.class.fromJSON(jsonValue)
 	target.valueMap.set(atom.key, copiedValue)
 	new Tracker(atom, origin)
 	return copiedValue