atom.io 0.14.1 → 0.14.2

package/internal/dist/index.d.cts

@@ -36,14 +36,16 @@ type AtomFamily<T, K extends Serializable = Serializable> = ((key: K) => AtomTok
     key: string;
     type: `atom_family`;
     subject: Subject<AtomToken<T>>;
+    mutable?: boolean;
 };
 type MutableAtomFamilyOptions<T extends Transceiver<any>, J extends Serializable, K extends Serializable> = AtomFamilyOptions<T, K> & JsonInterface<T, J> & {
     mutable: true;
 };
 type MutableAtomFamily<Core extends Transceiver<any>, SerializableCore extends Serializable, Key extends Serializable> = JsonInterface<Core, SerializableCore> & ((key: Key) => MutableAtomToken<Core, SerializableCore>) & {
-    key: `${string}::mutable`;
+    key: `${string}`;
     type: `atom_family`;
     subject: Subject<MutableAtomToken<Core, SerializableCore>>;
+    mutable: true;
 };
 
 declare const LoggerIconDictionary: {
@@ -405,7 +407,7 @@ declare const getJsonToken: <Core extends Transceiver<Serializable>, Serializabl
 
 declare const getUpdateToken: <Core extends Transceiver<Serializable>, SerializableCore extends Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => AtomToken<Signal<Core>>;
 
-declare function isAtomTokenMutable(token: AtomToken<any>): token is MutableAtomToken<any, any>;
+declare const getUpdateFamily: <Core extends Transceiver<Serializable>, SerializableCore extends Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>, store: Store) => AtomFamily<Signal<Core> | null, Key>;
 
 /**
  * @internal Give the tracker a transceiver state and a store, and it will
@@ -433,7 +435,6 @@ declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey exten
 interface MutableAtom<T> extends Atom<T> {
     mutable: true;
 }
-declare const isAtomMutable: <T>(atom: Atom<T>) => atom is MutableAtom<T>;
 
 type OperationProgress = {
     open: false;
@@ -541,6 +542,7 @@ declare function withdrawNewFamilyMember<T>(token: ReadonlySelectorToken<T> | St
 type Atom<T> = {
     key: string;
     type: `atom`;
+    mutable?: boolean;
     family?: FamilyMetadata;
     install: (store: Store) => void;
     subject: Subject<{
@@ -617,4 +619,4 @@ declare const subscribeToTimeline: (token: TimelineToken, handleUpdate: (update:
 
 declare const subscribeToTransaction: <ƒ extends ƒn>(token: TransactionToken<ƒ>, handleUpdate: TransactionUpdateHandler<ƒ>, key: string, store: Store) => (() => void);
 
-export { type Atom, type AtomKey, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadonlySelector, type ReadonlySelectorKey, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionMeta, type TransactionPhase, type Transceiver, type TransceiverMode, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, isAtomDefault, isAtomKey, isAtomMutable, isAtomTokenMutable, isDone, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, redoTransactionUpdate, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, undoTransactionUpdate, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { type Atom, type AtomKey, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, type ReadonlySelector, type ReadonlySelectorKey, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionMeta, type TransactionPhase, type Transceiver, type TransceiverMode, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, redoTransactionUpdate, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, undoTransactionUpdate, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };

package/internal/dist/index.js

@@ -1,3 +1,3 @@
-export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, isAtomDefault, isAtomKey, isAtomMutable, isAtomTokenMutable, isDone, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, redoTransactionUpdate, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, undoTransactionUpdate, updateSelectorAtoms, withdraw, withdrawNewFamilyMember } from '../../dist/chunk-TE3ZSTQ6.js';
+export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, addAtomToTimeline, applyTransaction, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtom, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelectorFamily, createSelector, createSelectorFamily, createTimeline, createTransaction, deleteAtom, deleteSelector, deposit, eldest, evictCachedValue, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, isAtomDefault, isAtomKey, isDone, isReadonlySelectorKey, isSelectorDefault, isSelectorKey, isStateKey, isTransceiver, isValueCached, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, redoTransactionUpdate, registerSelector, setAtomOrSelector, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, undoTransactionUpdate, updateSelectorAtoms, withdraw, withdrawNewFamilyMember } from '../../dist/chunk-PURABO5G.js';
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.js.map

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

@@ -6,10 +6,11 @@ import type {
 	UpdateHandler,
 } from "atom.io"
 import { setState } from "atom.io"
+import { Json } from "atom.io/json"
 
 import { cacheValue } from "../caching"
 import { newest } from "../lineage"
-import { createMutableAtom } from "../mutable"
+import { Transceiver, createMutableAtom } from "../mutable"
 import type { Store } from "../store"
 import { deposit } from "../store"
 import { Subject } from "../subject"
@@ -19,6 +20,7 @@ import { markAtomAsDefault } from "./is-default"
 export type Atom<T> = {
 	key: string
 	type: `atom`
+	mutable?: boolean
 	family?: FamilyMetadata
 	install: (store: Store) => void
 	subject: Subject<{ newValue: T; oldValue: T }>

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

@@ -39,10 +39,6 @@ export function createAtomFamily<T, K extends Json.Serializable>(
 				if (options.effects) {
 					individualOptions.effects = options.effects(key)
 				}
-				// if (`toJson` in options && `fromJson` in options) {
-				// 	individualOptions.toJson = options.toJson
-				// 	individualOptions.fromJson
-				// }
 				token = createAtom<T>(individualOptions, family, store)
 				subject.next(token)
 			}
@@ -54,6 +50,9 @@ export function createAtomFamily<T, K extends Json.Serializable>(
 			subject,
 		} as const,
 	)
+	if (`mutable` in options && typeof options.mutable === `boolean`) {
+		Object.assign(atomFamily, { mutable: options.mutable })
+	}
 	const target = newest(store)
 	target.families.set(options.key, atomFamily)
 	return atomFamily

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

@@ -0,0 +1,23 @@
+import type { AtomFamily, MutableAtomFamily, SelectorFamily } from "atom.io"
+import type { Json } from "atom.io/json"
+
+import { newest } from "../lineage"
+import type { Store } from "../store"
+import type { Signal, Transceiver } from "./transceiver"
+
+export const getUpdateFamily = <
+	Core extends Transceiver<Json.Serializable>,
+	SerializableCore extends Json.Serializable,
+	Key extends string,
+>(
+	mutableAtomFamily: MutableAtomFamily<Core, SerializableCore, Key>,
+	store: Store,
+): AtomFamily<Signal<Core> | null, Key> => {
+	const target = newest(store)
+	const key = `*${mutableAtomFamily.key}`
+	const updateFamily = target.families.get(key) as AtomFamily<
+		Signal<Core> | null,
+		Key
+	>
+	return updateFamily
+}

package/internal/src/mutable/index.ts

@@ -5,7 +5,7 @@ export * from "./create-mutable-atom-family"
 export * from "./get-json-family"
 export * from "./get-json-token"
 export * from "./get-update-token"
-export * from "./is-atom-token-mutable"
+export * from "./get-update-family"
 export * from "./tracker"
 export * from "./tracker-family"
 export * from "./transceiver"
@@ -13,6 +13,3 @@ export * from "./transceiver"
 export interface MutableAtom<T> extends Atom<T> {
 	mutable: true
 }
-
-export const isAtomMutable = <T>(atom: Atom<T>): atom is MutableAtom<T> =>
-	`isMutable` in atom

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

@@ -0,0 +1,44 @@
+import type {
+	AtomFamily,
+	AtomToken,
+	MutableAtomFamily,
+	MutableAtomToken,
+} from "~/packages/atom.io/src"
+import type { MutableAtom } from "."
+import type { Atom } from "../atom"
+import type { Store } from "../store"
+import { withdraw } from "../store"
+
+export function isMutable(
+	token: AtomToken<any>,
+	store: Store,
+): token is MutableAtomToken<any, any>
+export function isMutable(atom: Atom<any>): atom is MutableAtom<any>
+export function isMutable(
+	family: AtomFamily<any, any>,
+): family is MutableAtomFamily<any, any, any>
+export function isMutable(
+	atomOrTokenOrFamily: Atom<any> | AtomFamily<any, any> | AtomToken<any>,
+	store?: Store,
+): boolean {
+	if (`mutable` in atomOrTokenOrFamily) {
+		return atomOrTokenOrFamily.mutable
+	}
+	if (atomOrTokenOrFamily.type === `atom_family`) {
+		return false
+	}
+	if (`default` in atomOrTokenOrFamily) {
+		return false
+	}
+	if (!store) {
+		throw new Error(`Cannot check mutability without a store`)
+	}
+	const atom = withdraw(atomOrTokenOrFamily, store)
+	if (!atom) {
+		throw new Error(`Cannot check mutability without an atom`)
+	}
+	if (`mutable` in atom) {
+		return atom.mutable
+	}
+	return false
+}

package/internal/src/mutable/tracker.ts

@@ -20,7 +20,8 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		store: Store,
 	): AtomToken<typeof this.Update | null> {
 		const latestUpdateStateKey = `*${mutableState.key}`
-		deleteAtom({ type: `atom`, key: latestUpdateStateKey }, store)
+		store.atoms.delete(latestUpdateStateKey)
+		store.valueMap.delete(latestUpdateStateKey)
 		const familyMetaData: FamilyMetadata | undefined = mutableState.family
 			? {
 					key: `*${mutableState.family.key}`,
@@ -37,6 +38,10 @@ export class Tracker<Mutable extends Transceiver<any>> {
 			familyMetaData,
 			store,
 		)
+		if (store.parent) {
+			const parentValue = store.parent.valueMap.get(latestUpdateStateKey)
+			store.valueMap.set(latestUpdateStateKey, parentValue)
+		}
 
 		return latestUpdateState
 	}
@@ -137,7 +142,9 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					() => {
 						unsubscribe()
 						const mutable = getState(mutableState, store)
-						const updateNumber = mutable.getUpdateNumber(newValue)
+						// debugger
+						const updateNumber =
+							newValue === null ? -1 : mutable.getUpdateNumber(newValue)
 						const eventOffset = updateNumber - mutable.cacheUpdateNumber
 						if (newValue && eventOffset === 1) {
 							// ❗ new:"0=add:\"myHand\"",old:"0=add:\"deckId\""

package/internal/src/subject.ts

@@ -14,7 +14,8 @@ export class Subject<T> {
 	}
 
 	public next(value: T): void {
-		for (const subscriber of this.subscribers.values()) {
+		const subscribers = this.subscribers.values()
+		for (const subscriber of subscribers) {
 			subscriber(value)
 		}
 	}

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

@@ -2,6 +2,7 @@ import type { TransactionUpdate, ƒn } from "atom.io"
 import type { AtomToken, TimelineUpdate } from "atom.io"
 
 import { newest } from "../lineage"
+import { getUpdateToken } from "../mutable"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 import type {
@@ -15,13 +16,21 @@ export const addAtomToTimeline = (
 	tl: Timeline,
 	store: Store,
 ): void => {
-	const atom = withdraw(atomToken, store)
+	let maybeAtom = withdraw(atomToken, store)
+	if (maybeAtom?.mutable) {
+		console.log(`adding transceiver to timeline`, atomToken.key)
+		const updateToken = getUpdateToken(atomToken)
+		maybeAtom = withdraw(updateToken, store)
+	}
+	const atom = maybeAtom
 	if (atom === undefined) {
 		throw new Error(
 			`Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`,
 		)
 	}
+
 	atom.subject.subscribe(`timeline`, (update) => {
+		// debugger
 		const target = newest(store)
 		const currentSelectorKey =
 			store.operation.open && store.operation.token.type === `selector`

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

@@ -9,7 +9,10 @@ import type {
 } from "atom.io"
 
 import { newest } from "../lineage"
-import type { Store } from "../store"
+import { getUpdateToken } from "../mutable"
+import { getUpdateFamily } from "../mutable/get-update-family"
+import { isMutable } from "../mutable/is-mutable"
+import { type Store, withdraw } from "../store"
 import { Subject } from "../subject"
 import { addAtomToTimeline } from "./add-atom-to-timeline"
 
@@ -70,21 +73,26 @@ export function createTimeline(
 	if (options.shouldCapture) {
 		tl.shouldCapture = options.shouldCapture
 	}
-
+	const timelineKey = options.key
 	const target = newest(store)
 	for (const tokenOrFamily of options.atoms) {
-		const timelineKey = target.timelineAtoms.getRelatedKey(tokenOrFamily.key)
-		if (timelineKey) {
+		let atomKey = tokenOrFamily.key
+		const existingTimelineKey = target.timelineAtoms.getRelatedKey(atomKey)
+		if (existingTimelineKey) {
 			store.logger.error(
 				`❌`,
 				`timeline`,
 				options.key,
-				`Failed to add atom "${tokenOrFamily.key}" because it already belongs to timeline "${timelineKey}"`,
+				`Failed to add atom "${atomKey}" because it already belongs to timeline "${existingTimelineKey}"`,
 			)
 			continue
 		}
 		if (tokenOrFamily.type === `atom_family`) {
-			const family = tokenOrFamily
+			let family = tokenOrFamily
+			if (isMutable(family)) {
+				family = getUpdateFamily(family, store)
+				atomKey = family.key
+			}
 			family.subject.subscribe(`timeline:${options.key}`, (token) => {
 				addAtomToTimeline(token, tl, store)
 			})
@@ -94,32 +102,52 @@ export function createTimeline(
 				}
 			}
 		} else {
-			const token = tokenOrFamily
-			if (`family` in token && token.family) {
+			let atom = withdraw(tokenOrFamily, store)
+			if (atom === undefined) {
+				store.logger.error(
+					`❌`,
+					`timeline`,
+					options.key,
+					`Failed to add atom "${atomKey}" because it does not exist in the store`,
+				)
+				continue
+			}
+			if (isMutable(atom)) {
+				const updateAtom = withdraw(getUpdateToken(atom), store)
+				if (updateAtom === undefined) {
+					store.logger.error(
+						`❌`,
+						`timeline`,
+						options.key,
+						`Failed to add update atom "${atomKey}" because it does not exist in the store`,
+					)
+					continue
+				}
+				atom = updateAtom
+				atomKey = atom.key
+			}
+			if (`family` in atom) {
 				const familyTimelineKey = target.timelineAtoms.getRelatedKey(
-					token.family.key,
+					atom.family.key,
 				)
 				if (familyTimelineKey) {
 					store.logger.error(
 						`❌`,
 						`timeline`,
 						options.key,
-						`Failed to add atom "${token.key}" because its family "${token.family.key}" already belongs to timeline "${familyTimelineKey}"`,
+						`Failed to add atom "${atom.key}" because its family "${atom.family.key}" already belongs to timeline "${familyTimelineKey}"`,
 					)
 					continue
 				}
 			}
-			addAtomToTimeline(token, tl, store)
+			addAtomToTimeline(atom, tl, store)
 		}
-		target.timelineAtoms = target.timelineAtoms.set({
-			atomKey: tokenOrFamily.key,
-			timelineKey: options.key,
-		})
+		target.timelineAtoms.set({ atomKey, timelineKey })
 	}
 
 	store.timelines.set(options.key, tl)
 	const token: TimelineToken = {
-		key: options.key,
+		key: timelineKey,
 		type: `timeline`,
 	}
 	store.subject.timelineCreation.next(token)

package/introspection/dist/index.cjs

@@ -274,7 +274,8 @@ var Subject = class {
     this.subscribers.delete(key);
   }
   next(value) {
-    for (const subscriber of this.subscribers.values()) {
+    const subscribers = this.subscribers.values();
+    for (const subscriber of subscribers) {
       subscriber(value);
     }
   }
@@ -1081,35 +1082,6 @@ function createSelector(options, family, store) {
   return createReadonlySelector(options, family, store);
 }
 
-// internal/src/selector/delete-selector.ts
-function deleteSelector(selectorToken, store) {
-  const target = newest(store);
-  const { key } = selectorToken;
-  switch (selectorToken.type) {
-    case `selector`:
-      target.selectors.delete(key);
-      break;
-    case `readonly_selector`:
-      target.readonlySelectors.delete(key);
-      break;
-  }
-  target.valueMap.delete(key);
-  target.selectorAtoms.delete(key);
-  const downstreamTokens = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
-    ([downstreamSelectorKey]) => {
-      var _a;
-      return (_a = target.selectors.get(downstreamSelectorKey)) != null ? _a : target.readonlySelectors.get(downstreamSelectorKey);
-    }
-  );
-  for (const downstreamToken of downstreamTokens) {
-    if (downstreamToken) {
-      deleteSelector(downstreamToken, store);
-    }
-  }
-  target.selectorGraph.delete(key);
-  store.logger.info(`\u{1F525}`, selectorToken.type, `${key}`, `deleted`);
-}
-
 // internal/src/subscribe/recall-state.ts
 var recallState = (state, store) => {
   const target = newest(store);
@@ -1228,7 +1200,8 @@ var Tracker = class {
   }
   initializeState(mutableState, store) {
     const latestUpdateStateKey = `*${mutableState.key}`;
-    deleteAtom({ type: `atom`, key: latestUpdateStateKey }, store);
+    store.atoms.delete(latestUpdateStateKey);
+    store.valueMap.delete(latestUpdateStateKey);
     const familyMetaData = mutableState.family ? {
       key: `*${mutableState.family.key}`,
       subKey: mutableState.family.subKey
@@ -1241,6 +1214,10 @@ var Tracker = class {
       familyMetaData,
       store
     );
+    if (store.parent) {
+      const parentValue = store.parent.valueMap.get(latestUpdateStateKey);
+      store.valueMap.set(latestUpdateStateKey, parentValue);
+    }
     return latestUpdateState;
   }
   observeCore(mutableState, latestUpdateState, store) {
@@ -1321,7 +1298,7 @@ var Tracker = class {
           () => {
             unsubscribe();
             const mutable = getState(mutableState, store);
-            const updateNumber = mutable.getUpdateNumber(newValue);
+            const updateNumber = newValue === null ? -1 : mutable.getUpdateNumber(newValue);
             const eventOffset = updateNumber - mutable.cacheUpdateNumber;
             if (newValue && eventOffset === 1) {
               setState(
@@ -1396,6 +1373,9 @@ function createAtomFamily(options, store) {
       subject
     }
   );
+  if (`mutable` in options && typeof options.mutable === `boolean`) {
+    Object.assign(atomFamily, { mutable: options.mutable });
+  }
   const target = newest(store);
   target.families.set(options.key, atomFamily);
   return atomFamily;
@@ -1554,38 +1534,6 @@ function createAtom(options, family, store) {
   return token;
 }
 
-// internal/src/atom/delete-atom.ts
-function deleteAtom(atomToken, store) {
-  var _a, _b;
-  const target = newest(store);
-  const { key } = atomToken;
-  const atom = target.atoms.get(key);
-  if (!atom) {
-    store.logger.error(
-      `\u274C`,
-      `atom`,
-      `${key}`,
-      `Tried to delete atom, but it does not exist in the store.`
-    );
-  }
-  (_a = atom == null ? void 0 : atom.cleanup) == null ? void 0 : _a.call(atom);
-  target.atoms.delete(key);
-  target.valueMap.delete(key);
-  const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
-  if (selectorKeys) {
-    for (const selectorKey of selectorKeys) {
-      const token = (_b = target.selectors.get(selectorKey)) != null ? _b : target.readonlySelectors.get(selectorKey);
-      if (token) {
-        deleteSelector(token, store);
-      }
-    }
-  }
-  target.selectorAtoms.delete(key);
-  target.atomsThatAreDefault.delete(key);
-  target.timelineAtoms.delete(key);
-  store.logger.info(`\u{1F525}`, `atom`, `${key}`, `deleted`);
-}
-
 // internal/src/not-found-error.ts
 var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 function prettyPrintTokenType(token) {