atom.io 0.9.10 → 0.10.1

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/caching.ts

@@ -28,10 +28,7 @@ export const cacheValue = (
 			})
 			.catch((error) => {
 				if (error !== `canceled`) {
-					store.config.logger?.error(
-						`Promised value for "${key}" rejected:`,
-						error,
-					)
+					store.logger.error(`🙅‍♂️ Promised value for "${key}" rejected:`, error)
 				}
 			})
 	} else {
@@ -58,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/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/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/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 rootKeys = traceSelectorAtoms(selectorKey, dependency.key, store)
-	store.config.logger?.info(
-		`   || adding roots for "${selectorKey}":`,
-		rootKeys.map((r) => r),
-	)
-	for (const atomKey of rootKeys) {
-		core.selectorAtoms = core.selectorAtoms.set({
-			selectorKey,
-			atomKey,
-		})
+	} 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,14 +10,14 @@ export const emitUpdate = <T>(
 	store: Store,
 ): void => {
 	const { key } = state
-	const { logger } = store.config
-	logger?.info(
+	const { logger } = store
+	logger.info(
 		`📢 ${state.type} "${key}" went (`,
 		update.oldValue,
 		`->`,
 		update.newValue,
 		`)`,
 	)
-	logger?.info(`📢 notifying subscribers:`, state.subject.subscribers)
+	logger.info(`📢 notifying subscribers:`, state.subject.subscribers)
 	state.subject.next(update)
 }

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/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: (...messages: unknown[]) => {
+			for (const logger of this.loggers) {
+				logger.error(...messages)
+			}
+		},
+		info: (...messages: unknown[]) => {
+			for (const logger of this.loggers) {
+				logger.info(...messages)
+			}
+		},
+		warn: (...messages: unknown[]) => {
+			for (const logger of this.loggers) {
+				logger.warn(...messages)
+			}
+		},
 	}
 
 	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)
 	}

package/internal/src/subscribe/subscribe-to-root-atoms.ts

@@ -21,7 +21,7 @@ export const subscribeToRootAtoms = <T>(
 					return atom.subject.subscribe(
 						`${state.type}:${state.key}`,
 						(atomChange) => {
-							store.config.logger?.info(
+							store.logger.info(
 								`📢 selector "${state.key}" saw root "${atomKey}" go (`,
 								atomChange.oldValue,
 								`->`,
@@ -31,8 +31,8 @@ export const subscribeToRootAtoms = <T>(
 							const oldValue = recallState(state, store)
 							// ❗ this retrieves a stale cached value when applying a transaction on the server
 							const newValue = getState__INTERNAL(state, store)
-							store.config.logger?.info(
-								`   <- "${state.key}" went (`,
+							store.logger.info(
+								`✨ "${state.key}" went (`,
 								oldValue,
 								`->`,
 								newValue,

package/internal/src/timeline/add-atom-to-timeline.ts

@@ -38,7 +38,7 @@ export const addAtomToTimeline = (
 				? store.transactionStatus.time
 				: null
 
-		store.config.logger?.info(
+		store.logger.info(
 			`⏳ timeline "${tl.key}" saw atom "${atomToken.key}" go (`,
 			update.oldValue,
 			`->`,
@@ -74,8 +74,8 @@ export const addAtomToTimeline = (
 				}
 				if (tl.transactionKey !== currentTransactionKey) {
 					if (tl.transactionKey) {
-						store.config.logger?.error(
-							`Timeline "${tl.key}" was unable to resolve transaction "${tl.transactionKey}. This is probably a bug.`,
+						store.logger.error(
+							`🐞 Timeline "${tl.key}" was unable to resolve transaction "${tl.transactionKey}. This is probably a bug.`,
 						)
 					}
 					tl.transactionKey = currentTransactionKey
@@ -118,7 +118,7 @@ export const addAtomToTimeline = (
 								}
 							}
 							tl.transactionKey = null
-							store.config.logger?.info(
+							store.logger.info(
 								`⌛ timeline "${tl.key}" got a transaction_update "${update.key}"`,
 							)
 						},
@@ -145,7 +145,7 @@ export const addAtomToTimeline = (
 
 					tl.history.push(latestUpdate)
 
-					store.config.logger?.info(
+					store.logger.info(
 						`⌛ timeline "${tl.key}" got a selector_update "${currentSelectorKey}" with`,
 						latestUpdate.atomUpdates.map((atomUpdate) => atomUpdate.key),
 					)
@@ -159,8 +159,8 @@ export const addAtomToTimeline = (
 							type: `atom_update`,
 							...update,
 						})
-						store.config.logger?.info(
-							`   ⌛ timeline "${tl.key}" set selector_update "${currentSelectorKey}" to`,
+						store.logger.info(
+							`⌛ timeline "${tl.key}" set selector_update "${currentSelectorKey}" to`,
 							latestUpdate?.atomUpdates.map((atomUpdate) => atomUpdate.key),
 						)
 					}
@@ -192,7 +192,7 @@ export const addAtomToTimeline = (
 					atomUpdate.family = atom.family
 				}
 				const willCapture = tl.shouldCapture?.(atomUpdate, tl) ?? true
-				store.config.logger?.info(
+				store.logger.info(
 					`⌛ timeline "${tl.key}" got an atom_update to "${atom.key}"`,
 				)
 				if (willCapture) {

package/internal/src/timeline/time-travel-internal.ts

@@ -8,17 +8,17 @@ export const redo__INTERNAL = (
 	token: TimelineToken,
 	store: Store = IMPLICIT.STORE,
 ): void => {
-	store.config.logger?.info(`⏩ redo "${token.key}"`)
+	store.logger.info(`⏩ redo "${token.key}"`)
 	const timelineData = store.timelines.get(token.key)
 	if (!timelineData) {
-		store.config.logger?.error(
-			`Failed to redo on timeline "${token.key}". This timeline has not been initialized.`,
+		store.logger.error(
+			`🐞 Failed to redo on timeline "${token.key}". This timeline has not been initialized.`,
 		)
 		return
 	}
 	if (timelineData.at === timelineData.history.length) {
-		store.config.logger?.warn(
-			`Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`,
+		store.logger.warn(
+			`☝️ Failed to redo at the end of timeline "${token.key}". There is nothing to redo.`,
 		)
 		return
 	}
@@ -42,7 +42,7 @@ export const redo__INTERNAL = (
 	++timelineData.at
 	timelineData.subject.next(`redo`)
 	timelineData.timeTraveling = null
-	store.config.logger?.info(
+	store.logger.info(
 		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
 	)
 }
@@ -51,17 +51,17 @@ export const undo__INTERNAL = (
 	token: TimelineToken,
 	store: Store = IMPLICIT.STORE,
 ): void => {
-	store.config.logger?.info(`⏪ undo "${token.key}"`)
+	store.logger.info(`⏪ undo "${token.key}"`)
 	const timelineData = store.timelines.get(token.key)
 	if (!timelineData) {
-		store.config.logger?.error(
-			`Failed to undo on timeline "${token.key}". This timeline has not been initialized.`,
+		store.logger.error(
+			`🐞 Failed to undo on timeline "${token.key}". This timeline has not been initialized.`,
 		)
 		return
 	}
 	if (timelineData.at === 0) {
-		store.config.logger?.warn(
-			`Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`,
+		store.logger.warn(
+			`☝️ Failed to undo at the beginning of timeline "${token.key}". There is nothing to undo.`,
 		)
 		return
 	}
@@ -85,7 +85,7 @@ export const undo__INTERNAL = (
 	}
 	timelineData.subject.next(`undo`)
 	timelineData.timeTraveling = null
-	store.config.logger?.info(
+	store.logger.info(
 		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
 	)
 }

package/internal/src/timeline/timeline-internal.ts

@@ -76,7 +76,7 @@ export function timeline__INTERNAL(
 	for (const tokenOrFamily of options.atoms) {
 		const timelineKey = core.timelineAtoms.getRelatedKey(tokenOrFamily.key)
 		if (timelineKey) {
-			store.config.logger?.error(
+			store.logger.error(
 				`❌ Failed to add atom "${tokenOrFamily.key}" to timeline "${options.key}" because it belongs to timeline "${timelineKey}"`,
 			)
 			continue
@@ -100,7 +100,7 @@ export function timeline__INTERNAL(
 					token.family.key,
 				)
 				if (familyTimelineKey) {
-					store.config.logger?.error(
+					store.logger.error(
 						`❌ Failed to add atom "${token.key}" to timeline "${options.key}" because its family "${token.family.key}" belongs to timeline "${familyTimelineKey}"`,
 					)
 					continue