atom.io 0.9.9 → 0.10.0

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

@@ -29,16 +29,16 @@ export function createAtom<T>(
 	family?: FamilyMetadata,
 	store: Store = IMPLICIT.STORE,
 ): AtomToken<T> {
-	store.config.logger?.info?.(
+	store.logger.info(
 		`🔨 creating atom "${options.key}" in store "${store.config.name}"`,
 	)
 	const core = target(store)
 	const existing = core.atoms.get(options.key)
 	if (existing) {
-		store.config.logger?.error?.(
-			`Tried to create atom "${options.key}",`,
+		store.logger.error(
+			`❓ Tried to create atom "${options.key}",`,
 			`but it already exists in the store.`,
-			`(Ignore if you are using hot module replacement.)`,
+			`(Ignore if you are in development using hot module replacement.)`,
 		)
 		return deposit(existing)
 	}
@@ -47,7 +47,7 @@ export function createAtom<T>(
 		...options,
 		type: `atom`,
 		install: (store: Store) => {
-			store.config.logger?.info?.(
+			store.logger.info(
 				`🛠️  installing atom "${options.key}" in store "${store.config.name}"`,
 			)
 			return `mutable` in options

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

@@ -1,10 +1,17 @@
-import type { StoreCore } from ".."
+import type { AtomToken } from "~/packages/atom.io/src"
+import type { Store } from ".."
 import { IMPLICIT, target } from ".."
 
-export function deleteAtom(key: string, core: StoreCore = IMPLICIT.STORE): void {
+export function deleteAtom(
+	atomToken: AtomToken<unknown>,
+	store: Store = IMPLICIT.STORE,
+): void {
+	const core = target(store)
+	const { key } = atomToken
 	core.atoms.delete(key)
 	core.valueMap.delete(key)
 	core.selectorAtoms.delete(key)
 	core.atomsThatAreDefault.delete(key)
 	core.timelineAtoms.delete(key)
+	store.logger.info(`🔥 Atom "${key}" deleted`)
 }

package/internal/src/atom/is-default.ts

@@ -32,6 +32,6 @@ export const isSelectorDefault = (
 	key: string,
 	store: Store = IMPLICIT.STORE,
 ): boolean => {
-	const roots = traceAllSelectorAtoms(key, store)
-	return roots.every((root) => isAtomDefault(root.key, store))
+	const rootKeys = traceAllSelectorAtoms(key, store)
+	return rootKeys.every((rootKey) => isAtomDefault(rootKey, store))
 }

package/internal/src/caching.ts

@@ -27,10 +27,9 @@ export const cacheValue = (
 				subject.next({ newValue: value, oldValue: value })
 			})
 			.catch((error) => {
-				store.config.logger?.error(
-					`Promised value for "${key}" rejected:`,
-					error,
-				)
+				if (error !== `canceled`) {
+					store.logger.error(`🙅‍♂️ Promised value for "${key}" rejected:`, error)
+				}
 			})
 	} else {
 		target(store).valueMap.set(key, value)
@@ -56,6 +55,9 @@ export const evictCachedValue = (
 	if (currentValue instanceof Future) {
 		currentValue.cancel()
 	}
+	if (core.operation.open) {
+		core.operation.prev.set(key, currentValue)
+	}
 	core.valueMap.delete(key)
-	store.config.logger?.info(`   xx evicted "${key}"`)
+	store.logger.info(`🗑 evicted "${key}"`)
 }

package/internal/src/get-state-internal.ts

@@ -9,15 +9,15 @@ export const getState__INTERNAL = <T>(
 	store: Store = IMPLICIT.STORE,
 ): T => {
 	if (isValueCached(state.key, store)) {
-		store.config.logger?.info(`>> read "${state.key}"`)
+		store.logger.info(`📖 reading "${state.key}"`)
 		return readCachedValue(state.key, store)
 	}
 	if (state.type !== `atom`) {
-		store.config.logger?.info(`-> calc "${state.key}"`)
+		store.logger.info(`🧮 calculating "${state.key}"`)
 		return state.get()
 	}
-	store.config.logger?.error(
-		`Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`,
+	store.logger.error(
+		`🐞 Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`,
 	)
 	return state.default
 }

package/internal/src/index.ts

@@ -3,6 +3,7 @@ export * from "./caching"
 export * from "./families"
 export * from "./future"
 export * from "./get-state-internal"
+export * from "./keys"
 export * from "./operation"
 export * from "./mutable"
 export * from "./selector"

package/internal/src/keys.ts

@@ -0,0 +1,30 @@
+import type { Store } from "./store"
+import { target } from "./transaction"
+
+export type AtomKey<T> = string & { __atomKey?: never; __brand?: T }
+export type SelectorKey<T> = string & { __selectorKey?: never; __brand?: T }
+export type ReadonlySelectorKey<T> = string & {
+	__readonlySelectorKey?: never
+	__brand?: T
+}
+
+export const isAtomKey = (key: string, store: Store): key is AtomKey<unknown> =>
+	target(store).atoms.has(key)
+export const isSelectorKey = (
+	key: string,
+	store: Store,
+): key is SelectorKey<unknown> => target(store).selectors.has(key)
+export const isReadonlySelectorKey = (
+	key: string,
+	store: Store,
+): key is ReadonlySelectorKey<unknown> =>
+	target(store).readonlySelectors.has(key)
+
+export type StateKey<T> = AtomKey<T> | ReadonlySelectorKey<T> | SelectorKey<T>
+export const isStateKey = (
+	key: string,
+	store: Store,
+): key is StateKey<unknown> =>
+	isAtomKey(key, store) ||
+	isSelectorKey(key, store) ||
+	isReadonlySelectorKey(key, store)

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

@@ -17,7 +17,7 @@ export function createMutableAtom<
 	options: MutableAtomOptions<Core, SerializableCore>,
 	store: Store = IMPLICIT.STORE,
 ): MutableAtomToken<Core, SerializableCore> {
-	store.config.logger?.info(
+	store.logger.info(
 		`🔧 creating mutable atom "${options.key}" in store "${store.config.name}"`,
 	)
 	const coreState = createAtom<Core>(options, undefined, store)
@@ -26,7 +26,7 @@ export function createMutableAtom<
 	subscribe(
 		jsonState,
 		() => {
-			store.config.logger?.info(
+			store.logger.info(
 				`🔍 tracker-initializer:${store?.config.name}:${
 					store.transactionStatus.phase === `idle`
 						? `main`

package/internal/src/mutable/tracker.ts

@@ -21,7 +21,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		store: Store = IMPLICIT.STORE,
 	): AtomToken<typeof this.Update | null> {
 		const latestUpdateStateKey = `*${mutableState.key}`
-		deleteAtom(latestUpdateStateKey, target(store))
+		deleteAtom({ type: `atom`, key: latestUpdateStateKey }, store)
 		const familyMetaData: FamilyMetadata | undefined = mutableState.family
 			? {
 					key: `*${mutableState.family.key}`,

package/internal/src/operation.ts

@@ -22,7 +22,7 @@ export const openOperation = (
 ): `rejection` | undefined => {
 	const core = target(store)
 	if (core.operation.open) {
-		store.config.logger?.error(
+		store.logger.error(
 			`❌ failed to setState to "${token.key}" during a setState for "${core.operation.token.key}"`,
 		)
 		return `rejection`
@@ -30,11 +30,11 @@ export const openOperation = (
 	core.operation = {
 		open: true,
 		done: new Set(),
-		prev: new Map(store.valueMap),
+		prev: new Map(),
 		time: Date.now(),
 		token,
 	}
-	store.config.logger?.info(
+	store.logger.info(
 		`⭕ operation start from "${token.key}" in store "${store.config.name}"${
 			store.transactionStatus.phase === `idle`
 				? ``
@@ -45,14 +45,14 @@ export const openOperation = (
 export const closeOperation = (store: Store): void => {
 	const core = target(store)
 	core.operation = { open: false }
-	store.config.logger?.info(`🔴 operation done`)
+	store.logger.info(`🔴 operation done`)
 	store.subject.operationStatus.next(core.operation)
 }
 
 export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {
 	const core = target(store)
 	if (!core.operation.open) {
-		store.config.logger?.warn(
+		store.logger.warn(
 			`isDone called outside of an operation. This is probably a bug.`,
 		)
 		return true
@@ -62,8 +62,8 @@ export const isDone = (key: string, store: Store = IMPLICIT.STORE): boolean => {
 export const markDone = (key: string, store: Store = IMPLICIT.STORE): void => {
 	const core = target(store)
 	if (!core.operation.open) {
-		store.config.logger?.warn(
-			`markDone called outside of an operation. This is probably a bug.`,
+		store.logger.warn(
+			`🐞 markDone called outside of an operation. This is probably a bug.`,
 		)
 		return
 	}

package/internal/src/selector/create-read-write-selector.ts

@@ -27,13 +27,7 @@ export const createReadWriteSelector = <T>(
 	const setSelf = (next: T | ((oldValue: T) => T)): void => {
 		const oldValue = getSelf()
 		const newValue = become(next)(oldValue)
-		store.config.logger?.info(
-			`   <- "${options.key}" went (`,
-			oldValue,
-			`->`,
-			newValue,
-			`)`,
-		)
+		store.logger.info(`📝 set "${options.key}" (`, oldValue, `->`, newValue, `)`)
 		cacheValue(options.key, newValue, subject, store)
 		markDone(options.key, store)
 		if (store.transactionStatus.phase === `idle`) {
@@ -52,7 +46,7 @@ export const createReadWriteSelector = <T>(
 	}
 	core.selectors.set(options.key, mySelector)
 	const initialValue = getSelf()
-	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
+	store.logger.info(`✨ "${options.key}" =`, initialValue)
 	const token: SelectorToken<T> = {
 		key: options.key,
 		type: `selector`,

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

@@ -36,7 +36,7 @@ export const createReadonlySelector = <T>(
 	}
 	core.readonlySelectors.set(options.key, readonlySelector)
 	const initialValue = getSelf()
-	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
+	store.logger.info(`✨ "${options.key}" =`, initialValue)
 	const token: ReadonlySelectorToken<T> = {
 		key: options.key,
 		type: `readonly_selector`,

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

@@ -51,10 +51,12 @@ export function createSelector<T>(
 	const existingReadonly = core.readonlySelectors.get(options.key)
 
 	if (existingWritable || existingReadonly) {
-		store.config.logger?.error?.(
-			`Tried to create ${existingReadonly ? `readonly selector` : `selector`}`,
+		store.logger.error(
+			`❓ Tried to create ${
+				existingReadonly ? `readonly selector` : `selector`
+			}`,
 			`"${options.key}", but it already exists in the store.`,
-			`(Ignore if you are using hot module replacement.)`,
+			`(Ignore if you are in development using hot module replacement.)`,
 		)
 	}
 

package/internal/src/selector/get-selector-dependency-keys.ts

@@ -0,0 +1,20 @@
+import type { AtomKey, ReadonlySelectorKey, SelectorKey } from "../keys"
+import { isStateKey } from "../keys"
+import type { Store } from "../store"
+import { target } from "../transaction"
+
+export const getSelectorDependencyKeys = (
+	key: string,
+	store: Store,
+): (
+	| AtomKey<unknown>
+	| ReadonlySelectorKey<unknown>
+	| SelectorKey<unknown>
+)[] => {
+	const sources = target(store)
+		.selectorGraph.getRelationEntries({ downstreamSelectorKey: key })
+		.filter(([_, { source }]) => source !== key)
+		.map(([_, { source }]) => source)
+		.filter((source) => isStateKey(source, store))
+	return sources
+}

package/internal/src/selector/index.ts

@@ -1,4 +1,4 @@
-export * from "./lookup-selector-sources"
+export * from "./get-selector-dependency-keys"
 export * from "./register-selector"
 export * from "./create-selector"
 export * from "./trace-selector-atoms"

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

@@ -25,17 +25,10 @@ export const registerSelector = (
 		}
 		const dependencyValue = getState__INTERNAL(dependencyState, store)
 
-		if (alreadyRegistered) {
-			store.config.logger?.info(
-				`   || ${selectorKey} <- ${dependency.key} =`,
-				dependencyValue,
-			)
-		} else {
-			store.config.logger?.info(
-				`🔌 registerSelector "${selectorKey}" <- ( "${dependency.key}" =`,
-				dependencyValue,
-				`)`,
-			)
+		store.logger.info(
+			`🔌 selector "${selectorKey}" registers dependency ( "${dependency.key}" = ${dependencyValue} )`,
+		)
+		if (!alreadyRegistered) {
 			core.selectorGraph = core.selectorGraph.set(
 				{
 					upstreamSelectorKey: dependency.key,

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

@@ -1,50 +1,50 @@
-import type { AtomToken, ReadonlySelectorToken, StateToken } from "atom.io"
-
 import type { Store } from ".."
-import { lookupSelectorSources } from "./lookup-selector-sources"
+import type { AtomKey, StateKey } from "../keys"
+import { isAtomKey } from "../keys"
+import { getSelectorDependencyKeys } from "./get-selector-dependency-keys"
 
 export const traceSelectorAtoms = (
 	selectorKey: string,
-	dependency: ReadonlySelectorToken<unknown> | StateToken<unknown>,
+	directDependencyKey: StateKey<unknown>,
 	store: Store,
-): AtomToken<unknown>[] => {
-	const roots: AtomToken<unknown>[] = []
+): AtomKey<unknown>[] => {
+	const rootKeys: AtomKey<unknown>[] = []
 
-	const sources = lookupSelectorSources(dependency.key, store)
+	const indirectDependencyKeys = getSelectorDependencyKeys(
+		directDependencyKey,
+		store,
+	)
 	let depth = 0
-	while (sources.length > 0) {
+	while (indirectDependencyKeys.length > 0) {
 		// biome-ignore lint/style/noNonNullAssertion: just checked length ^^^
-		const source = sources.shift()!
+		const indirectDependencyKey = indirectDependencyKeys.shift()!
 		++depth
-		if (depth > 999) {
-			store.config.logger?.warn(
-				`Maximum selector dependency depth exceeded 999 in selector "${selectorKey}".`,
-			)
-		}
 		if (depth > 99999) {
 			throw new Error(
-				`Maximum selector dependency depth exceeded in selector "${selectorKey}".`,
+				`Maximum selector dependency depth exceeded (> 99999) in selector "${selectorKey}". This is likely due to a circular dependency.`,
 			)
 		}
 
-		if (source.type !== `atom`) {
-			sources.push(...lookupSelectorSources(source.key, store))
-		} else {
-			roots.push(source)
+		if (!isAtomKey(indirectDependencyKey, store)) {
+			indirectDependencyKeys.push(
+				...getSelectorDependencyKeys(indirectDependencyKey, store),
+			)
+		} else if (!rootKeys.includes(indirectDependencyKey)) {
+			rootKeys.push(indirectDependencyKey)
 		}
 	}
 
-	return roots
+	return rootKeys
 }
 
 export const traceAllSelectorAtoms = (
 	selectorKey: string,
 	store: Store,
-): AtomToken<unknown>[] => {
-	const sources = lookupSelectorSources(selectorKey, store)
-	return sources.flatMap((source) =>
-		source.type === `atom`
-			? source
-			: traceSelectorAtoms(selectorKey, source, store),
+): AtomKey<unknown>[] => {
+	const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store)
+	return directDependencyKeys.flatMap((depKey) =>
+		isAtomKey(depKey, store)
+			? depKey
+			: traceSelectorAtoms(selectorKey, depKey, store),
 	)
 }

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

@@ -15,20 +15,20 @@ export const updateSelectorAtoms = (
 			selectorKey,
 			atomKey: dependency.key,
 		})
-		store.config.logger?.info(
-			`   || adding root for "${selectorKey}": ${dependency.key}`,
+		store.logger.info(
+			`🔍 selector "${selectorKey}" discovers root atom "${dependency.key}"`,
 		)
-		return
-	}
-	const roots = traceSelectorAtoms(selectorKey, dependency, store)
-	store.config.logger?.info(
-		`   || adding roots for "${selectorKey}":`,
-		roots.map((r) => r.key),
-	)
-	for (const root of roots) {
-		core.selectorAtoms = core.selectorAtoms.set({
-			selectorKey,
-			atomKey: root.key,
-		})
+	} else {
+		const rootKeys = traceSelectorAtoms(selectorKey, dependency.key, store)
+		store.logger.info(
+			`🔍 selector "${selectorKey}" discovers root atoms:`,
+			rootKeys.map((r) => r),
+		)
+		for (const atomKey of rootKeys) {
+			core.selectorAtoms = core.selectorAtoms.set({
+				selectorKey,
+				atomKey,
+			})
+		}
 	}
 }

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

@@ -13,7 +13,7 @@ export function copyMutableIfNeeded<T>(
 	const originValue = origin.valueMap.get(atom.key)
 	const targetValue = target.valueMap.get(atom.key)
 	if (originValue === targetValue) {
-		origin.config.logger?.info(`📃 copying`, `${atom.key}`)
+		origin.logger.info(`📃 copying`, `${atom.key}`)
 		const copiedValue = transform.fromJson(transform.toJson(originValue))
 		target.valueMap.set(atom.key, copiedValue)
 		new Tracker(atom, origin)

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

@@ -14,7 +14,7 @@ export function copyMutableIfWithinTransaction<T>(
 		store.transactionStatus.phase === `applying`
 	) {
 		if (`toJson` in atom && `fromJson` in atom) {
-			store.config.logger?.info(
+			store.logger.info(
 				`📄 copyMutableIfWithinTransaction: ${atom.key} is mutable`,
 			)
 			const copiedValue = copyMutableIfNeeded(

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

@@ -10,7 +10,7 @@ export const emitUpdate = <T>(
 	store: Store,
 ): void => {
 	const { key } = state
-	const { logger } = store.config
+	const { logger } = store
 	logger?.info(
 		`📢 ${state.type} "${key}" went (`,
 		update.oldValue,

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

@@ -11,23 +11,22 @@ export const evictDownStream = <T>(
 ): void => {
 	const core = target(store)
 	const downstreamKeys = core.selectorAtoms.getRelatedKeys(state.key)
-	store.config.logger?.info(
-		`   || ${downstreamKeys?.size ?? `none`} downstream:`,
+	store.logger.info(
+		`🧹 evicting ${downstreamKeys?.size} states downstream from ${state.type} "${state.key}":`,
 		downstreamKeys,
 	)
 	if (core.operation.open) {
-		store.config.logger?.info(`   ||`, [...core.operation.done], `already done`)
+		store.logger.info(`🧹`, [...core.operation.done], `already done`)
 	}
 	if (downstreamKeys) {
 		for (const key of downstreamKeys) {
 			if (isDone(key, store)) {
-				store.config.logger?.info(`   || ${key} already done`)
 				continue
 			}
 			const state = core.selectors.get(key) ?? core.readonlySelectors.get(key)
 			if (!state) {
-				store.config.logger?.info(
-					`   || ${key} was not found in selectors or readonlySelectors`,
+				store.logger.error(
+					`🐞 "${key}" was not found in selectors or readonlySelectors`,
 				)
 				return
 			}

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

@@ -19,15 +19,12 @@ export const setAtom = <T>(
 	const oldValue = getState__INTERNAL(atom, store)
 	let newValue = copyMutableIfWithinTransaction(atom, store)
 	newValue = become(next)(newValue)
-	store.config.logger?.info(`<< setting atom "${atom.key}" to`, newValue)
+	store.logger.info(`📝 setting atom "${atom.key}" to`, newValue)
 	cacheValue(atom.key, newValue, atom.subject, store)
 	if (isAtomDefault(atom.key, store)) {
 		markAtomAsNotDefault(atom.key, store)
 	}
 	markDone(atom.key, store)
-	store.config.logger?.info(
-		`   || evicting caches downstream from "${atom.key}"`,
-	)
 	evictDownStream(atom, store)
 	const update = { oldValue, newValue }
 	if (store.transactionStatus.phase !== `building`) {

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

@@ -22,10 +22,10 @@ export const stowUpdate = <T>(
 	store: Store,
 ): void => {
 	const { key } = state
-	const { logger } = store.config
+	const { logger } = store
 	if (store.transactionStatus.phase !== `building`) {
-		store.config.logger?.warn(
-			`stowUpdate called outside of a transaction. This is probably a bug.`,
+		store.logger.warn(
+			`🐞 stowUpdate called outside of a transaction. This is probably a bug.`,
 		)
 		return
 	}
@@ -38,5 +38,11 @@ export const stowUpdate = <T>(
 		atomUpdate.family = state.family
 	}
 	store.transactionStatus.atomUpdates.push(atomUpdate)
-	logger?.info(`📝 ${key} stowed (`, update.oldValue, `->`, update.newValue, `)`)
+	store.logger.info(
+		`📁 ${key} stowed (`,
+		update.oldValue,
+		`->`,
+		update.newValue,
+		`)`,
+	)
 }

package/internal/src/store/index.ts

@@ -1,5 +1,4 @@
 export * from "./deposit"
-export * from "./lookup"
 export * from "./store"
 export * from "./withdraw"
 export * from "./withdraw-new-family-member"

package/internal/src/store/store.ts

@@ -1,3 +1,4 @@
+import { AtomIOLogger } from "atom.io"
 import type {
 	AtomFamily,
 	AtomToken,
@@ -94,12 +95,33 @@ export class Store {
 
 	public config: {
 		name: string
-		logger: Logger | null
-		logger__INTERNAL: Logger
 	} = {
 		name: `IMPLICIT_STORE`,
-		logger: { ...console, info: () => undefined },
-		logger__INTERNAL: console,
+	}
+
+	public loggers: AtomIOLogger[] = [
+		new AtomIOLogger(
+			{ ...console },
+			`warn`,
+			(message) => !message.includes(`👁‍🗨`),
+		),
+	]
+	public logger: Logger = {
+		error: (message: string) => {
+			for (const logger of this.loggers) {
+				logger.error(message)
+			}
+		},
+		info: (message: string) => {
+			for (const logger of this.loggers) {
+				logger.info(message)
+			}
+		},
+		warn: (message: string) => {
+			for (const logger of this.loggers) {
+				logger.warn(message)
+			}
+		},
 	}
 
 	public constructor(name: string, store: Store | null = null) {
@@ -110,14 +132,9 @@ export class Store {
 			this.transactionStatus = { ...store?.transactionStatus }
 			this.config = {
 				...store?.config,
-				logger__INTERNAL: console,
-				logger: {
-					...console,
-					info: () => undefined,
-					...store?.config?.logger,
-				},
 				name,
 			}
+
 			for (const [, atom] of store.atoms) {
 				atom.install(this)
 			}

package/internal/src/store/withdraw-new-family-member.ts

@@ -36,7 +36,7 @@ export function withdrawNewFamilyMember<T>(
 		| StateToken<T>,
 	store: Store,
 ): Atom<T> | ReadonlySelector<T> | Selector<T> | undefined {
-	store.config.logger?.info(
+	store.logger.info(
 		`👪 creating new family member "${token.key}" in store "${store.config.name}"`,
 	)
 	if (token.family) {

package/internal/src/store/withdraw.ts

@@ -78,7 +78,7 @@ export function withdraw<T>(
 			core.timelines.get(token.key)
 
 		if (state) {
-			store.config.logger?.info(`🛠️ add ${token.type} "${token.key}"`)
+			store.logger.info(`🛠️ add ${token.type} "${token.key}"`)
 			switch (state.type) {
 				case `atom`: {
 					store.atoms.set(token.key, state)

package/internal/src/subscribe/recall-state.ts

@@ -10,8 +10,8 @@ export const recallState = <T>(
 ): T => {
 	const core = target(store)
 	if (!core.operation.open) {
-		store.config.logger?.warn(
-			`recall called outside of an operation. This is probably a bug.`,
+		store.logger.warn(
+			`🐞recall called outside of an operation. This is probably a bug.`,
 		)
 		return core.valueMap.get(state.key)
 	}