atom.io 0.15.5 → 0.16.0

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

@@ -1,50 +1,95 @@
+import type { UpdateHandler } from "atom.io"
 import type {
 	FamilyMetadata,
 	MutableAtomOptions,
 	MutableAtomToken,
 } from "atom.io"
+import { setState } from "atom.io"
 import type { Json } from "atom.io/json"
 import { selectJson } from "atom.io/json"
 
-import { createRegularAtom } from "../atom"
+import { type MutableAtom, cacheValue } from ".."
+import { createRegularAtom, markAtomAsDefault } from "../atom"
 import { newest } from "../lineage"
-import type { Store } from "../store"
+import { type Store, deposit } from "../store"
+import { Subject } from "../subject"
 import { subscribeToState } from "../subscribe"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
 
 export function createMutableAtom<
-	Core extends Transceiver<any>,
-	SerializableCore extends Json.Serializable,
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
 >(
-	options: MutableAtomOptions<Core, SerializableCore>,
+	options: MutableAtomOptions<T, J>,
 	family: FamilyMetadata | undefined,
 	store: Store,
-): MutableAtomToken<Core, SerializableCore> {
+): MutableAtomToken<T, J> {
 	store.logger.info(
-		`🔧`,
+		`🔨`,
 		`atom`,
 		options.key,
 		`creating in store "${store.config.name}"`,
 	)
-	const coreState = createRegularAtom<Core>(options, family, store)
-	new Tracker(coreState, store)
-	const jsonState = selectJson(coreState, options, store)
 	const target = newest(store)
-	subscribeToState(
-		jsonState,
-		() => {
-			const trackerHasBeenInitialized = newest(store).trackers.has(coreState.key)
-			if (!trackerHasBeenInitialized) {
-				new Tracker(coreState, store)
-			}
+	const existing = target.atoms.get(options.key)
+	if (existing && existing.type === `mutable_atom`) {
+		store.logger.error(
+			`❌`,
+			`atom`,
+			options.key,
+			`Tried to create atom, but it already exists in the store.`,
+		)
+		return deposit(existing)
+	}
+	const subject = new Subject<{ newValue: T; oldValue: T }>()
+	const newAtom: MutableAtom<T, J> = {
+		...options,
+		type: `mutable_atom`,
+		install: (store: Store) => {
+			store.logger.info(
+				`🛠️`,
+				`atom`,
+				options.key,
+				`installing in store "${store.config.name}"`,
+			)
+			return createMutableAtom(options, family, store)
 		},
-		`tracker-initializer:${store?.config.name}:${
-			target.transactionMeta === null
-				? `main`
-				: `${target.transactionMeta.update.key}`
-		}`,
-		store,
-	)
-	return coreState as MutableAtomToken<Core, SerializableCore>
+		subject,
+	} as const
+	if (family) {
+		newAtom.family = family
+	}
+	const initialValue = options.default()
+	target.atoms.set(newAtom.key, newAtom)
+	markAtomAsDefault(options.key, store)
+	cacheValue(options.key, initialValue, subject, target)
+	const token = deposit(newAtom)
+	if (options.effects) {
+		let effectIndex = 0
+		const cleanupFunctions: (() => void)[] = []
+		for (const effect of options.effects) {
+			const cleanup = effect({
+				setSelf: (next) => setState(token, next, store),
+				onSet: (handle: UpdateHandler<T>) =>
+					subscribeToState(token, handle, `effect[${effectIndex}]`, store),
+			})
+			if (cleanup) {
+				cleanupFunctions.push(cleanup)
+			}
+			++effectIndex
+		}
+		newAtom.cleanup = () => {
+			for (const cleanup of cleanupFunctions) {
+				cleanup()
+			}
+		}
+	}
+
+	new Tracker(token, store)
+	selectJson(token, options, store)
+
+	store.on.atomCreation.next(token)
+
+	return token
 }

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

@@ -1,4 +1,4 @@
-import type { MutableAtomFamily, SelectorFamily } from "atom.io"
+import type { MutableAtomFamily, WritableSelectorFamily } from "atom.io"
 import type { Json } from "atom.io/json"
 
 import { newest } from "../lineage"
@@ -12,11 +12,10 @@ export const getJsonFamily = <
 >(
 	mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>,
 	store: Store,
-): SelectorFamily<SerializableCore, Key> => {
+): WritableSelectorFamily<SerializableCore, Key> => {
 	const target = newest(store)
 	const key = `${mutableAtomFamily.key}:JSON`
-	const jsonFamily: SelectorFamily<SerializableCore, Key> = target.families.get(
-		key,
-	) as SelectorFamily<SerializableCore, Key>
+	const jsonFamily: WritableSelectorFamily<SerializableCore, Key> =
+		target.families.get(key) as WritableSelectorFamily<SerializableCore, Key>
 	return jsonFamily
 }

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

@@ -1,4 +1,4 @@
-import type { MutableAtomToken, SelectorToken } from "atom.io"
+import type { MutableAtomToken, WritableSelectorToken } from "atom.io"
 import type { Json } from "atom.io/json"
 
 import type { Transceiver } from "./transceiver"
@@ -8,11 +8,14 @@ export const getJsonToken = <
 	SerializableCore extends Json.Serializable,
 >(
 	mutableAtomToken: MutableAtomToken<Core, SerializableCore>,
-): SelectorToken<SerializableCore> => {
+): WritableSelectorToken<SerializableCore> => {
 	const key = mutableAtomToken.family
 		? `${mutableAtomToken.family.key}:JSON(${mutableAtomToken.family.subKey})`
 		: `${mutableAtomToken.key}:JSON`
-	const jsonToken: SelectorToken<SerializableCore> = { type: `selector`, key }
+	const jsonToken: WritableSelectorToken<SerializableCore> = {
+		type: `selector`,
+		key,
+	}
 	if (mutableAtomToken.family) {
 		jsonToken.family = {
 			key: `${mutableAtomToken.family.key}:JSON`,

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

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

package/internal/src/mutable/index.ts

@@ -1,15 +1,9 @@
-import type { Atom } from "../atom"
-
 export * from "./create-mutable-atom"
 export * from "./create-mutable-atom-family"
 export * from "./get-json-family"
 export * from "./get-json-token"
 export * from "./get-update-token"
-export * from "./get-update-family"
+export * from "./is-mutable"
 export * from "./tracker"
 export * from "./tracker-family"
 export * from "./transceiver"
-
-export interface MutableAtom<T> extends Atom<T> {
-	mutable: true
-}

package/internal/src/mutable/is-mutable.ts

@@ -1,17 +1,16 @@
 import type { AtomFamily, MutableAtomFamily } from "atom.io"
 
-import type { MutableAtom } from "."
-import type { Atom } from "../atom"
+import type { Atom, MutableAtom } from ".."
 
-export function isMutable(atom: Atom<any>): atom is MutableAtom<any>
+export function isMutable(atom: Atom<any>): atom is MutableAtom<any, any>
 export function isMutable(
 	family: AtomFamily<any, any>,
 ): family is MutableAtomFamily<any, any, any>
 export function isMutable(
 	atomOrTokenOrFamily: Atom<any> | AtomFamily<any, any>,
 ): boolean {
-	if (`mutable` in atomOrTokenOrFamily) {
-		return atomOrTokenOrFamily.mutable
-	}
-	return false
+	return (
+		atomOrTokenOrFamily.type === `mutable_atom` ||
+		atomOrTokenOrFamily.type === `mutable_atom_family`
+	)
 }

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

@@ -1,4 +1,4 @@
-import type { AtomFamily } from "atom.io"
+import type { MutableAtomFamily, RegularAtomFamily } from "atom.io"
 import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
@@ -15,14 +15,14 @@ export class FamilyTracker<
 		? Signal
 		: never
 
-	public readonly findLatestUpdateState: AtomFamily<
+	public readonly findLatestUpdateState: RegularAtomFamily<
 		typeof this.Update | null,
 		FamilyMemberKey
 	>
-	public readonly findMutableState: AtomFamily<Core, FamilyMemberKey>
+	public readonly findMutableState: MutableAtomFamily<Core, any, FamilyMemberKey>
 
 	public constructor(
-		findMutableState: AtomFamily<Core, FamilyMemberKey>,
+		findMutableState: MutableAtomFamily<Core, any, FamilyMemberKey>,
 		store: Store,
 	) {
 		this.findLatestUpdateState = createRegularAtomFamily<

package/internal/src/mutable/tracker.ts

@@ -1,4 +1,4 @@
-import type { AtomToken, FamilyMetadata, MutableAtomToken } from "atom.io"
+import type { FamilyMetadata, MutableAtomToken, RegularAtomToken } from "atom.io"
 import { getState, setState } from "atom.io"
 import type { Json } from "atom.io/json"
 
@@ -18,7 +18,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 	private initializeState(
 		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
 		store: Store,
-	): AtomToken<typeof this.Update | null> {
+	): RegularAtomToken<typeof this.Update | null> {
 		const latestUpdateStateKey = `*${mutableState.key}`
 		store.atoms.delete(latestUpdateStateKey)
 		store.valueMap.delete(latestUpdateStateKey)
@@ -49,8 +49,8 @@ export class Tracker<Mutable extends Transceiver<any>> {
 	private unsubscribeFromInnerValue: () => void
 	private unsubscribeFromState: () => void
 	private observeCore(
-		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
-		latestUpdateState: AtomToken<typeof this.Update | null>,
+		mutableState: MutableAtomToken<Mutable, any>,
+		latestUpdateState: RegularAtomToken<typeof this.Update | null>,
 		store: Store,
 	): void {
 		const originalInnerValue = getState(mutableState, store)
@@ -112,7 +112,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 
 	private updateCore<Core extends Transceiver<any>>(
 		mutableState: MutableAtomToken<Core, Json.Serializable>,
-		latestUpdateState: AtomToken<typeof this.Update | null>,
+		latestUpdateState: RegularAtomToken<typeof this.Update | null>,
 		store: Store,
 	): void {
 		subscribeToState(
@@ -174,7 +174,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 	}
 
 	public mutableState: MutableAtomToken<Mutable, Json.Serializable>
-	public latestUpdateState: AtomToken<typeof this.Update | null>
+	public latestUpdateState: RegularAtomToken<typeof this.Update | null>
 
 	public dispose: () => void
 

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

@@ -1,13 +1,16 @@
-import type { StateNode } from "."
+import type { ReadableState } from "."
 import { readCachedValue } from "./caching"
 import type { Store } from "./store"
 
-export const readOrComputeValue = <T>(state: StateNode<T>, target: Store): T => {
+export const readOrComputeValue = <T>(
+	state: ReadableState<T>,
+	target: Store,
+): T => {
 	if (target.valueMap.has(state.key)) {
 		target.logger.info(`📖`, state.type, state.key, `reading cached value`)
 		return readCachedValue(state, target)
 	}
-	if (state.type !== `atom`) {
+	if (state.type !== `atom` && state.type !== `mutable_atom`) {
 		target.logger.info(`🧮`, state.type, state.key, `computing value`)
 		return state.get()
 	}

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

@@ -4,12 +4,11 @@ import type {
 	ReadonlySelectorToken,
 } from "atom.io"
 
+import type { ReadonlySelector } from ".."
 import { cacheValue } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { Subject } from "../subject"
-import type { ReadonlySelector } from "./create-selector"
-import { createSelector } from "./create-selector"
 import { registerSelector } from "./register-selector"
 
 export const createReadonlySelector = <T>(
@@ -30,7 +29,7 @@ export const createReadonlySelector = <T>(
 	const readonlySelector: ReadonlySelector<T> = {
 		...options,
 		subject,
-		install: (s: Store) => createSelector(options, family, s),
+		install: (s: Store) => createReadonlySelector(options, family, s),
 		get: getSelf,
 		type: `readonly_selector`,
 		...(family && { family }),

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

@@ -0,0 +1,32 @@
+import type {
+	FamilyMetadata,
+	ReadonlySelectorOptions,
+	ReadonlySelectorToken,
+	WritableSelectorOptions,
+	WritableSelectorToken,
+} from "atom.io"
+
+import type { Store } from "../store"
+import type { Subject } from "../subject"
+import { createReadonlySelector } from "./create-readonly-selector"
+import { createWritableSelector } from "./create-writable-selector"
+
+export function createStandaloneSelector<T>(
+	options: WritableSelectorOptions<T>,
+	store: Store,
+): WritableSelectorToken<T>
+export function createStandaloneSelector<T>(
+	options: ReadonlySelectorOptions<T>,
+	store: Store,
+): ReadonlySelectorToken<T>
+export function createStandaloneSelector<T>(
+	options: ReadonlySelectorOptions<T> | WritableSelectorOptions<T>,
+	store: Store,
+): ReadonlySelectorToken<T> | WritableSelectorToken<T> {
+	const isWritable = `set` in options
+
+	if (isWritable) {
+		return createWritableSelector(options, undefined, store)
+	}
+	return createReadonlySelector(options, undefined, store)
+}

package/internal/src/selector/{create-read-write-selector.ts → create-writable-selector.ts}

@@ -1,20 +1,23 @@
-import type { FamilyMetadata, SelectorOptions, SelectorToken } from "atom.io"
+import type {
+	FamilyMetadata,
+	WritableSelectorOptions,
+	WritableSelectorToken,
+} from "atom.io"
 
+import type { WritableSelector } from ".."
 import { cacheValue } from "../caching"
 import { newest } from "../lineage"
 import { markDone } from "../operation"
 import { become } from "../set-state/become"
 import type { Store } from "../store"
 import { Subject } from "../subject"
-import type { Selector } from "./create-selector"
-import { createSelector } from "./create-selector"
 import { registerSelector } from "./register-selector"
 
-export const createReadWriteSelector = <T>(
-	options: SelectorOptions<T>,
+export const createWritableSelector = <T>(
+	options: WritableSelectorOptions<T>,
 	family: FamilyMetadata | undefined,
 	store: Store,
-): SelectorToken<T> => {
+): WritableSelectorToken<T> => {
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const transactors = registerSelector(options.key, store)
@@ -47,10 +50,10 @@ export const createReadWriteSelector = <T>(
 		}
 		options.set(transactors, newValue)
 	}
-	const mySelector: Selector<T> = {
+	const mySelector: WritableSelector<T> = {
 		...options,
 		subject,
-		install: (s: Store) => createSelector(options, family, s),
+		install: (s: Store) => createWritableSelector(options, family, s),
 		get: getSelf,
 		set: setSelf,
 		type: `selector`,
@@ -59,7 +62,7 @@ export const createReadWriteSelector = <T>(
 	target.selectors.set(options.key, mySelector)
 	const initialValue = getSelf()
 	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue)
-	const token: SelectorToken<T> = {
+	const token: WritableSelectorToken<T> = {
 		key: options.key,
 		type: `selector`,
 	}

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

@@ -1,10 +1,10 @@
-import type { ReadonlySelectorToken, SelectorToken } from "atom.io"
+import type { ReadonlySelectorToken, WritableSelectorToken } from "atom.io"
 
 import { newest } from ".."
 import type { Store } from ".."
 
 export function deleteSelector(
-	selectorToken: ReadonlySelectorToken<unknown> | SelectorToken<unknown>,
+	selectorToken: ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>,
 	store: Store,
 ): void {
 	const target = newest(store)

package/internal/src/selector/index.ts

@@ -1,4 +1,6 @@
-export * from "./create-selector"
+export * from "./create-readonly-selector"
+export * from "./create-standalone-selector"
+export * from "./create-writable-selector"
 export * from "./delete-selector"
 export * from "./get-selector-dependency-keys"
 export * from "./register-selector"

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

@@ -1,4 +1,4 @@
-import type { Store } from ".."
+import type { Selector, Store } from ".."
 import type { AtomKey, StateKey } from "../keys"
 import { isAtomKey } from "../keys"
 import { getSelectorDependencyKeys } from "./get-selector-dependency-keys"
@@ -38,9 +38,10 @@ export const traceSelectorAtoms = (
 }
 
 export const traceAllSelectorAtoms = (
-	selectorKey: string,
+	selector: Selector<any>,
 	store: Store,
 ): AtomKey<unknown>[] => {
+	const selectorKey = selector.key
 	const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store)
 	return directDependencyKeys.flatMap((depKey) =>
 		isAtomKey(depKey, store)

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

@@ -10,7 +10,7 @@ export const updateSelectorAtoms = (
 	store: Store,
 ): void => {
 	const target = newest(store)
-	if (dependency.type === `atom`) {
+	if (dependency.type === `atom` || dependency.type === `mutable_atom`) {
 		target.selectorAtoms.set({
 			selectorKey,
 			atomKey: dependency.key,

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

@@ -1,12 +1,11 @@
 import type { JsonInterface } from "atom.io/json"
 
-import type { Atom } from "../atom"
+import type { MutableAtom, Transceiver } from ".."
 import { Tracker } from "../mutable"
 import type { Store } from "../store"
 
-export function copyMutableIfNeeded<T>(
-	atom: Atom<T>,
-	transform: JsonInterface<T>,
+export function copyMutableIfNeeded<T extends Transceiver<any>>(
+	atom: MutableAtom<T, any>,
 	origin: Store,
 	target: Store,
 ): T {
@@ -14,8 +13,8 @@ export function copyMutableIfNeeded<T>(
 	const targetValue = target.valueMap.get(atom.key)
 	if (originValue === targetValue) {
 		origin.logger.info(`📃`, `atom`, `${atom.key}`, `copying`)
-		const jsonValue = transform.toJson(originValue)
-		const copiedValue = transform.fromJson(jsonValue)
+		const jsonValue = atom.toJson(originValue)
+		const copiedValue = atom.fromJson(jsonValue)
 		target.valueMap.set(atom.key, copiedValue)
 		new Tracker(atom, origin)
 		return copiedValue

package/internal/src/set-state/copy-mutable-in-transaction.ts

@@ -1,51 +1,19 @@
-import type { AtomFamily } from "atom.io"
-import type { Json, JsonInterface } from "atom.io/json"
 import { newest } from ".."
-import type { Store } from ".."
-import type { Atom } from "../atom"
+import type { Atom, Store } from ".."
 import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
 
 export function copyMutableIfWithinTransaction<T>(
 	oldValue: T,
-	atom: Atom<T> | (Atom<T> & JsonInterface<T, Json.Serializable>),
+	atom: Atom<T>,
 	store: Store,
 ): T {
 	const target = newest(store)
 	const parent = target.parent
 	if (parent !== null) {
-		if (`family` in atom) {
-			const family = parent.families.get(atom.family.key)
-			if (family && family.type === `atom_family`) {
-				const result = copyMutableFamilyMemberWithinTransaction<T>(
-					atom,
-					family,
-					parent,
-					target,
-				)
-				if (result) {
-					return result
-				}
-			}
-		}
-		if (`toJson` in atom && `fromJson` in atom) {
-			const copiedValue = copyMutableIfNeeded(atom, atom, parent, target)
+		if (atom.type === `mutable_atom`) {
+			const copiedValue = copyMutableIfNeeded(atom, parent, target)
 			return copiedValue
 		}
 	}
 	return oldValue
 }
-
-export function copyMutableFamilyMemberWithinTransaction<T>(
-	atom: Atom<T>,
-	family:
-		| AtomFamily<T, any>
-		| (AtomFamily<T, any> & JsonInterface<T, Json.Serializable>),
-	origin: Store,
-	target: Store,
-): T | null {
-	if (`toJson` in family && `fromJson` in family) {
-		const copyCreated = copyMutableIfNeeded(atom, family, origin, target)
-		return copyCreated
-	}
-	return null
-}

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

@@ -1,11 +1,10 @@
 import type { StateUpdate } from "atom.io"
 import type { Store } from "atom.io/internal"
 
-import type { Atom } from "../atom"
-import type { ReadonlySelector, Selector } from "../selector"
+import type { Atom, Selector } from ".."
 
 export const emitUpdate = <T>(
-	state: Atom<T> | ReadonlySelector<T> | Selector<T>,
+	state: Atom<T> | Selector<T>,
 	update: StateUpdate<T>,
 	store: Store,
 ): void => {

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

@@ -1,4 +1,4 @@
-import type { Atom } from "../atom"
+import type { Atom } from ".."
 import { evictCachedValue } from "../caching"
 import { isDone, markDone } from "../operation"
 import type { Store } from "../store"

package/internal/src/set-state/set-atom-or-selector.ts

@@ -1,15 +1,15 @@
-import type { Atom } from "../atom"
-import type { Selector } from "../selector"
+import type { WritableState } from ".."
 import type { Store } from "../store"
 import { setAtom } from "./set-atom"
 
 export const setAtomOrSelector = <T>(
-	state: Atom<T> | Selector<T>,
+	state: WritableState<T>,
 	value: T | ((oldValue: T) => T),
 	store: Store,
 ): void => {
 	switch (state.type) {
 		case `atom`:
+		case `mutable_atom`:
 			setAtom(state, value, store)
 			break
 		case `selector`:

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

@@ -1,6 +1,7 @@
-import type { Atom } from "../atom"
+import type { Atom } from ".."
 import { isAtomDefault, markAtomAsNotDefault } from "../atom"
 import { cacheValue } from "../caching"
+import type { Transceiver } from "../mutable"
 import { markDone } from "../operation"
 import { readOrComputeValue } from "../read-or-compute-value"
 import type { Store } from "../store"
@@ -28,9 +29,12 @@ export const setAtom = <T>(
 	const update = { oldValue, newValue }
 	if (target.transactionMeta === null) {
 		emitUpdate(atom, update, target)
-	} else if (target.transactionMeta.phase === `applying` && target.parent) {
-		emitUpdate(atom, update, target.parent)
-	} else {
+	} else if (target.on.transactionApplying && target.parent) {
 		stowUpdate(atom, update, target)
+		if (atom.key.startsWith(`*`)) {
+			const mutableKey = atom.key.slice(1)
+			const mutable: Transceiver<any> = target.valueMap.get(mutableKey)
+			mutable.do(update.newValue)
+		}
 	}
 }

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

@@ -1,6 +1,6 @@
 import type { KeyedStateUpdate, StateUpdate } from "atom.io"
 
-import type { Atom } from "../atom"
+import type { Atom } from ".."
 import { newest } from "../lineage"
 import { isTransceiver } from "../mutable"
 import type { Store } from "../store"