atom.io 0.35.0 → 0.36.0

package/src/internal/families/seek-in-store.ts

@@ -16,7 +16,7 @@ import type {
 	WritablePureSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import type { Molecule, ReadableState } from ".."
@@ -25,15 +25,14 @@ import type { Transceiver } from "../mutable"
 import { deposit, type Store } from "../store"
 
 export function seekInStore<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 	Key extends K,
 >(
 	store: Store,
-	token: MutableAtomFamilyToken<T, J, K>,
+	token: MutableAtomFamilyToken<T, K>,
 	key: Key,
-): MutableAtomToken<T, J, K> | undefined
+): MutableAtomToken<T, K> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
 	store: Store,

package/src/internal/get-state/read-or-compute-value.ts

@@ -16,8 +16,7 @@ export const readOrComputeValue = <T>(
 		case `writable_pure_selector`:
 			target.logger.info(`🧮`, state.type, state.key, `computing value`)
 			return state.get()
-		case `atom`:
-		case `mutable_atom`: {
+		case `atom`: {
 			const def = state.default
 			let defaultValue: T
 			if (def instanceof Function) {
@@ -40,5 +39,18 @@ export const readOrComputeValue = <T>(
 			)
 			return cachedValue
 		}
+		case `mutable_atom`: {
+			const Ctor = state.class
+			const instance = new Ctor()
+			const cachedValue = cacheValue(target, state.key, instance, state.subject)
+			target.logger.info(
+				`💁`,
+				`mutable_atom`,
+				state.key,
+				`could not find cached value; using default`,
+				instance,
+			)
+			return cachedValue
+		}
 	}
 }

package/src/internal/index.ts

@@ -16,9 +16,9 @@ import type {
 	WritablePureSelectorFamilyToken,
 	WritablePureSelectorToken,
 } from "atom.io"
-import type { Canonical, Json, JsonInterface } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
-import type { Transceiver } from "./mutable"
+import type { ConstructorOf, Transceiver } from "./mutable"
 import type { Store } from "./store"
 import type { Subject } from "./subject"
 import type { Timeline } from "./timeline"
@@ -69,20 +69,16 @@ export type RegularAtom<T> = Flat<
 		cleanup?: () => void
 	}
 >
-export type MutableAtom<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-> = Flat<
-	AtomIOState &
-		JsonInterface<T, J> & {
-			type: `mutable_atom`
-			default: () => T
-			cleanup?: () => void
-		}
+export type MutableAtom<T extends Transceiver<any, any>> = Flat<
+	AtomIOState & {
+		type: `mutable_atom`
+		class: ConstructorOf<T>
+		cleanup?: () => void
+	}
 >
 export type Atom<T> =
 	| RegularAtom<T>
-	| (T extends Transceiver<any> ? MutableAtom<T, any> : never)
+	| (T extends Transceiver<any, any> ? MutableAtom<T> : never)
 
 export type WritableHeldSelector<T> = Flat<
 	AtomIOState & {
@@ -141,23 +137,25 @@ export type RegularAtomFamily<T, K extends Canonical> =
 
 // biome-ignore format: intersection
 export type MutableAtomFamily<
-T extends Transceiver<any>,
-J extends Json.Serializable,
-K extends Canonical,
+	// C extends TransceiverConstructor<any,any>,
+	T extends Transceiver<any,any>,
+	K extends Canonical,
 > =
 	& Flat<
-		& JsonInterface<T, J>
-		& MutableAtomFamilyToken<T, J, K>
+		& MutableAtomFamilyToken<T, K>
 		& {
 				install: (store: Store) => void
 				internalRoles: string[] | undefined
-				subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>
+				subject: Subject<
+					| StateCreation<MutableAtomToken<T>>
+					| StateDisposal<MutableAtomToken<T>>
+				>
 			}
 	>
-	& ((key: K) => MutableAtomToken<T, J>)
+	& ((key: K) => MutableAtomToken<T>)
 
 export type AtomFamily<T, K extends Canonical = Canonical> =
-	| MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K>
+	| MutableAtomFamily<T extends Transceiver<any, any> ? T : never, K>
 	| RegularAtomFamily<T, K>
 
 // biome-ignore format: intersection

package/src/internal/ingest-updates/ingest-creation-disposal.ts

@@ -115,25 +115,28 @@ export function ingestMoleculeTransferEvent(
 	switch (applying) {
 		case `newValue`:
 			{
-				const provenance = update.to.length === 1 ? update.to[0] : update.to
-				claimWithinStore<any, any, any>(
-					store,
-					provenance,
-					update.key,
-					`exclusive`,
-				)
+				for (const newOwner of update.to) {
+					claimWithinStore<any, any, any>(
+						store,
+						newOwner,
+						update.key,
+						update.exclusive ? `exclusive` : undefined,
+					)
+				}
 			}
 			break
 		case `oldValue`:
 			{
-				const provenance =
-					update.from.length === 1 ? update.from[0] : update.from
-				claimWithinStore<any, any, any>(
-					store,
-					provenance,
-					update.key,
-					`exclusive`,
-				)
+				let exclusivity: `exclusive` | undefined = `exclusive`
+				for (const previousOwner of update.from) {
+					claimWithinStore<any, any, any>(
+						store,
+						previousOwner,
+						update.key,
+						exclusivity,
+					)
+					exclusivity = undefined
+				}
 			}
 			break
 	}

package/src/internal/ingest-updates/ingest-selector-update.ts

@@ -1,5 +1,7 @@
+import type { TimelineManageable } from "atom.io"
+
 import type { Store } from "../store"
-import type { TimelineSelectorUpdate } from "../timeline"
+import type { TimelineAtomUpdate, TimelineSelectorUpdate } from "../timeline"
 import { ingestAtomUpdate } from "./ingest-atom-update"
 
 export function ingestSelectorUpdate(
@@ -7,10 +9,12 @@ export function ingestSelectorUpdate(
 	selectorUpdate: TimelineSelectorUpdate<any>,
 	store: Store,
 ): void {
-	const updates =
-		applying === `newValue`
-			? selectorUpdate.atomUpdates
-			: selectorUpdate.atomUpdates.toReversed()
+	let updates: Omit<TimelineAtomUpdate<TimelineManageable>, `timestamp`>[]
+	if (applying === `newValue`) {
+		updates = selectorUpdate.atomUpdates
+	} else {
+		updates = selectorUpdate.atomUpdates.toReversed()
+	}
 	for (const atomUpdate of updates) {
 		ingestAtomUpdate(applying, atomUpdate, store)
 	}

package/src/internal/join/get-internal-relations-from-store.ts

@@ -1,5 +1,5 @@
 import type { JoinToken, MutableAtomFamilyToken } from "atom.io"
-import type { SetRTX, SetRTXJson } from "atom.io/transceivers/set-rtx"
+import type { SetRTX } from "atom.io/transceivers/set-rtx"
 
 import type { Store } from "../store"
 import { getJoin } from "./get-join"
@@ -7,7 +7,7 @@ import { getJoin } from "./get-join"
 export function getInternalRelationsFromStore(
 	token: JoinToken<any, any, any, any, any, any>,
 	store: Store,
-): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string> {
+): MutableAtomFamilyToken<SetRTX<string>, string> {
 	const myJoin = getJoin(token, store)
 	const family = myJoin.core.relatedKeysAtoms
 	return family

package/src/internal/join/join-internal.ts

@@ -14,7 +14,6 @@ import type {
 import { Anarchy } from "atom.io"
 import type { Canonical, Json, stringified } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
-import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
 import { capitalize } from "../capitalize"
@@ -143,11 +142,7 @@ export class Join<
 		Content
 	>
 	public core: {
-		relatedKeysAtoms: MutableAtomFamilyToken<
-			SetRTX<string>,
-			SetRTXJson<string>,
-			string
-		>
+		relatedKeysAtoms: MutableAtomFamilyToken<SetRTX<string>, string>
 	}
 	public transact(
 		toolkit: WriterToolkit,
@@ -193,17 +188,11 @@ export class Join<
 
 		const aSide: ASide = options.between[0]
 		const bSide: BSide = options.between[1]
-		const relatedKeysAtoms = createMutableAtomFamily<
-			SetRTX<string>,
-			SetRTXJson<string>,
-			string
-		>(
+		const relatedKeysAtoms = createMutableAtomFamily<SetRTX<string>, string>(
 			store,
 			{
 				key: `${options.key}/relatedKeys`,
-				default: () => new SetRTX(),
-				fromJson: (json) => SetRTX.fromJSON(json),
-				toJson: (set) => set.toJSON(),
+				class: SetRTX,
 			},
 			[`join`, `relations`],
 		)

package/src/internal/molecule.ts

@@ -293,6 +293,7 @@ export function claimWithinStore<
 	const transferEvent: MoleculeTransfer = {
 		type: `molecule_transfer`,
 		key: molecule.key,
+		exclusive: Boolean(exclusive),
 		from: priorProvenance,
 		to: [newProvenanceMolecule.key],
 	}

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

@@ -7,30 +7,33 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
-import { selectJsonFamily, stringifyJson } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
 
-import { type MutableAtomFamily, prettyPrintTokenType } from ".."
+import {
+	createWritablePureSelectorFamily,
+	type MutableAtomFamily,
+	prettyPrintTokenType,
+} 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 { Transceiver } from "./transceiver"
+import type { AsJSON, Transceiver } from "./transceiver"
 
 export function createMutableAtomFamily<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any>,
 	K extends Canonical,
 >(
 	store: Store,
-	options: MutableAtomFamilyOptions<T, J, K>,
+	options: MutableAtomFamilyOptions<T, K>,
 	internalRoles?: string[],
-): MutableAtomFamilyToken<T, J, K> {
-	const familyToken = {
+): MutableAtomFamilyToken<T, K> {
+	const familyToken: MutableAtomFamilyToken<T & Transceiver<any, any>, K> = {
 		key: options.key,
 		type: `mutable_atom_family`,
-	} as const satisfies MutableAtomFamilyToken<T, J, K>
+	}
 
 	const existing = store.families.get(options.key)
 	if (existing) {
@@ -45,20 +48,18 @@ export function createMutableAtomFamily<
 	}
 
 	const subject = new Subject<
-		StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>
+		StateCreation<MutableAtomToken<T>> | StateDisposal<MutableAtomToken<T>>
 	>()
 
-	const familyFunction = (key: K): MutableAtomToken<T, J> => {
+	const familyFunction = (key: K): MutableAtomToken<T> => {
 		const subKey = stringifyJson(key)
 		const family: FamilyMetadata = { key: options.key, subKey }
 		const fullKey = `${options.key}(${subKey})`
 		const target = newest(store)
 
-		const individualOptions: MutableAtomOptions<T, J> = {
+		const individualOptions: MutableAtomOptions<T> = {
 			key: fullKey,
-			default: () => options.default(key),
-			toJson: options.toJson,
-			fromJson: options.fromJson,
+			class: options.class,
 		}
 		if (options.effects) {
 			individualOptions.effects = options.effects(key)
@@ -73,13 +74,29 @@ export function createMutableAtomFamily<
 	const atomFamily = Object.assign(familyFunction, familyToken, {
 		subject,
 		install: (s: Store) => createMutableAtomFamily(s, options),
-		toJson: options.toJson,
-		fromJson: options.fromJson,
 		internalRoles,
-	}) satisfies MutableAtomFamily<T, J, K>
+	}) satisfies MutableAtomFamily<T, K>
 
 	store.families.set(options.key, atomFamily)
-	selectJsonFamily(store, atomFamily, options)
+
+	createWritablePureSelectorFamily<AsJSON<T>, K>(
+		store,
+		{
+			key: `${options.key}:JSON`,
+			get:
+				(key) =>
+				({ get }) =>
+					get(familyToken, key).toJSON(),
+			set:
+				(key) =>
+				({ set }, newValue) => {
+					set(familyToken, key, options.class.fromJSON(newValue))
+				},
+		},
+		[`mutable`, `json`],
+	)
+
 	new FamilyTracker(atomFamily, store)
+
 	return familyToken
 }

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,7 +84,13 @@ 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`:
 							{