atom.io 0.20.3 → 0.21.0

package/introspection/src/auditor.ts

@@ -0,0 +1,135 @@
+import type {
+	AtomToken,
+	ReadableToken,
+	ReadonlySelectorToken,
+	SelectorToken,
+} from "atom.io"
+import * as Internal from "atom.io/internal"
+
+import { getState } from "../../src/get-state"
+import type { FamilyNode } from "."
+import type { AtomTokenIndex } from "./attach-atom-index"
+import { attachAtomIndex } from "./attach-atom-index"
+import type { SelectorTokenIndex } from "./attach-selector-index"
+import { attachSelectorIndex } from "./attach-selector-index"
+
+export type ListResourcesParam = {
+	atomFamilies: boolean
+	selectorFamilies: boolean
+}
+
+/**
+ * Auditor is a tool for identifying lingering resources in your store that may result in memory leaks.
+ * @experimental
+ */
+export class Auditor {
+	public auditorCreatedAt: number = performance.now()
+	public statesCreatedAt: Map<string, number> = new Map()
+	public readonly atomIndex: ReadonlySelectorToken<AtomTokenIndex>
+	public readonly selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>
+	public disposed = false
+
+	private readonly unsubscribeFromAtomCreation: () => void
+	private readonly unsubscribeFromAtomDisposal: () => void
+	private readonly unsubscribeFromSelectorCreation: () => void
+	private readonly unsubscribeFromSelectorDisposal: () => void
+
+	/**
+	 * @param {Store} store - The store to audit.
+	 */
+	public constructor(
+		public readonly store: Internal.Store = Internal.IMPLICIT.STORE,
+	) {
+		this.atomIndex = attachAtomIndex(this.store)
+		this.selectorIndex = attachSelectorIndex(this.store)
+		this.unsubscribeFromAtomCreation = this.store.on.atomCreation.subscribe(
+			`auditor-${this.auditorCreatedAt}`,
+			({ key }) => {
+				this.statesCreatedAt.set(key, performance.now() - this.auditorCreatedAt)
+			},
+		)
+		this.unsubscribeFromAtomDisposal = this.store.on.atomDisposal.subscribe(
+			`auditor-${this.auditorCreatedAt}`,
+			({ key }) => {
+				this.statesCreatedAt.delete(key)
+			},
+		)
+		this.unsubscribeFromSelectorCreation =
+			this.store.on.selectorCreation.subscribe(
+				`auditor-${this.auditorCreatedAt}`,
+				({ key }) => {
+					this.statesCreatedAt.set(
+						key,
+						performance.now() - this.auditorCreatedAt,
+					)
+				},
+			)
+		this.unsubscribeFromSelectorDisposal =
+			this.store.on.selectorDisposal.subscribe(
+				`auditor-${this.auditorCreatedAt}`,
+				({ key }) => {
+					this.statesCreatedAt.delete(key)
+				},
+			)
+	}
+
+	public static readonly DEFAULT_LIST_RESOURCES_PARAM = {
+		atomFamilies: true,
+		selectorFamilies: true,
+	} satisfies ListResourcesParam
+	/**
+	 * Lists all resources in the store, along with their creation time.
+	 *
+	 * @param {ListResourcesParam} [param] - Optional parameters for filtering the list of resources.
+	 * @returns {readonly [ReadableToken<unknown>, number]}[] - An array of tuples, where each tuple contains a state token belonging to a family in the store and that state's creation time.
+	 */
+	public listResources(
+		param: ListResourcesParam = Auditor.DEFAULT_LIST_RESOURCES_PARAM,
+	): (readonly [ReadableToken<unknown>, number])[] {
+		if (this.disposed) {
+			throw new Error(`This Auditor has been disposed`)
+		}
+		const atoms = getState(this.atomIndex)
+		const selectors = getState(this.selectorIndex)
+		const atomFamilyNodes = [...atoms.values()].filter(
+			(node): node is FamilyNode<AtomToken<unknown>> => `familyMembers` in node,
+		)
+		const selectorFamilyNodes = [...selectors.values()].filter(
+			(node): node is FamilyNode<SelectorToken<unknown>> =>
+				`familyMembers` in node,
+		)
+		const currentTime = performance.now()
+		const resources: (readonly [ReadableToken<unknown>, number])[] = []
+		if (param.atomFamilies) {
+			for (const familyNode of atomFamilyNodes) {
+				const tokens = familyNode.familyMembers.values()
+				for (const token of tokens) {
+					const storedTime = this.statesCreatedAt.get(token.key)
+					const creationTime = storedTime ?? this.auditorCreatedAt
+					const age = currentTime - creationTime
+					resources.push([token, age])
+				}
+			}
+		}
+		if (param.selectorFamilies) {
+			for (const familyNode of selectorFamilyNodes) {
+				const tokens = familyNode.familyMembers.values()
+				for (const token of tokens) {
+					const storedTime = this.statesCreatedAt.get(token.key)
+					const creationTime = storedTime ?? this.auditorCreatedAt
+					const age = currentTime - creationTime
+					resources.push([token, age])
+				}
+			}
+		}
+		return resources
+	}
+
+	public [Symbol.dispose](): void {
+		this.unsubscribeFromAtomCreation()
+		this.unsubscribeFromAtomDisposal()
+		this.unsubscribeFromSelectorCreation()
+		this.unsubscribeFromSelectorDisposal()
+		this.disposed = true
+	}
+}

package/introspection/src/index.ts

@@ -1,24 +1,14 @@
-import type {
-	AtomToken,
-	ReadonlySelectorToken,
-	WritableSelectorToken,
-} from "atom.io"
+import type { ReadableToken } from "atom.io"
 
 export * from "./attach-introspection-states"
+export * from "./auditor"
 
-export type FamilyNode<
-	Token extends
-		| AtomToken<unknown>
-		| ReadonlySelectorToken<unknown>
-		| WritableSelectorToken<unknown>,
-> = {
+export type FamilyNode<Token extends ReadableToken<unknown>> = {
 	key: string
-	familyMembers: Record<string, Token>
+	familyMembers: Map<string, Token>
 }
 
-export type WritableTokenIndex<
-	Token extends
-		| AtomToken<unknown>
-		| ReadonlySelectorToken<unknown>
-		| WritableSelectorToken<unknown>,
-> = Record<string, FamilyNode<Token> | Token>
+export type WritableTokenIndex<Token extends ReadableToken<unknown>> = Map<
+	string,
+	FamilyNode<Token> | Token
+>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.20.3",
+  "version": "0.21.0",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -48,7 +48,7 @@
     }
   },
   "devDependencies": {
-    "@testing-library/react": "15.0.5",
+    "@testing-library/react": "15.0.6",
     "@types/eslint": "npm:@types/eslint@8.56.10",
     "@types/eslint-v9": "npm:@types/eslint@8.56.10",
     "@types/estree": "1.0.5",
@@ -58,19 +58,19 @@
     "@types/tmp": "0.2.6",
     "@typescript-eslint/parser": "7.8.0",
     "@typescript-eslint/rule-tester": "7.8.0",
-    "@vitest/coverage-v8": "1.5.2",
-    "@vitest/ui": "1.5.2",
+    "@vitest/coverage-v8": "1.6.0",
+    "@vitest/ui": "1.6.0",
     "concurrently": "8.2.2",
     "drizzle-kit": "0.20.17",
-    "drizzle-orm": "0.30.9",
+    "drizzle-orm": "0.30.10",
     "eslint": "npm:eslint@8.57.0",
-    "eslint-v9": "npm:eslint@9.1.1",
+    "eslint-v9": "npm:eslint@9.2.0",
     "framer-motion": "11.1.7",
     "happy-dom": "14.7.1",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
-    "preact": "10.20.2",
+    "preact": "10.21.0",
     "react": "18.3.1",
     "react-dom": "18.3.1",
     "react-router-dom": "6.23.0",
@@ -79,9 +79,9 @@
     "tmp": "0.2.3",
     "tsup": "8.0.2",
     "typescript": "5.4.5",
-    "vite": "5.2.10",
+    "vite": "5.2.11",
     "vite-tsconfig-paths": "4.3.2",
-    "vitest": "1.5.2"
+    "vitest": "1.6.0"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/react-devtools/dist/index.cjs

@@ -1717,7 +1717,7 @@ var StateIndexLeafNode = ({ node, isOpenState, typeState }) => {
 var StateIndexTreeNode = ({ node, isOpenState }) => {
   const setIsOpen = react$1.useI(isOpenState);
   const isOpen = react$1.useO(isOpenState);
-  for (const [key, childNode] of recordToEntries(node.familyMembers)) {
+  for (const [key, childNode] of node.familyMembers) {
     atom_io.findState(findViewIsOpenState, key);
     atom_io.findState(findStateTypeState, childNode);
   }
@@ -1736,7 +1736,7 @@ var StateIndexTreeNode = ({ node, isOpenState }) => {
         /* @__PURE__ */ jsxRuntime.jsx("span", { className: "type detail", children: " (family)" })
       ] })
     ] }),
-    isOpen ? Object.entries(node.familyMembers).map(([key, childNode]) => /* @__PURE__ */ jsxRuntime.jsx(
+    isOpen ? [...node.familyMembers.entries()].map(([key, childNode]) => /* @__PURE__ */ jsxRuntime.jsx(
       StateIndexNode,
       {
         node: childNode,
@@ -1759,7 +1759,7 @@ var StateIndexNode = ({ node, isOpenState, typeState }) => {
 };
 var StateIndex = ({ tokenIndex }) => {
   const tokenIds = react$1.useO(tokenIndex);
-  return /* @__PURE__ */ jsxRuntime.jsx("article", { className: "index state_index", "data-testid": "state-index", children: Object.entries(tokenIds).filter(([key]) => !key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)).sort().map(([key, node]) => {
+  return /* @__PURE__ */ jsxRuntime.jsx("article", { className: "index state_index", "data-testid": "state-index", children: [...tokenIds.entries()].filter(([key]) => !key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)).sort().map(([key, node]) => {
     return /* @__PURE__ */ jsxRuntime.jsx(
       StateIndexNode,
       {

package/react-devtools/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as Internal from 'atom.io/internal';
 import * as atom_io from 'atom.io';
-import { AtomToken, ReadonlySelectorToken, WritableSelectorToken } from 'atom.io';
+import { AtomToken, ReadableToken, SelectorToken } from 'atom.io';
 
 type ClassSignature = abstract new (...args: any) => any;
 
@@ -24,13 +24,13 @@ type PlainObject = Record<keyof any, unknown>;
 
 type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>;
 
-type FamilyNode<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>> = {
+type FamilyNode<Token extends ReadableToken<unknown>> = {
     key: string;
-    familyMembers: Record<string, Token>;
+    familyMembers: Map<string, Token>;
 };
-type WritableTokenIndex<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>> = Record<string, FamilyNode<Token> | Token>;
+type WritableTokenIndex<Token extends ReadableToken<unknown>> = Map<string, FamilyNode<Token> | Token>;
 
-type SelectorTokenIndex = WritableTokenIndex<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
+type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>;
 
 type Delta = {
     summary: string;

package/react-devtools/dist/index.js

@@ -1,4 +1,4 @@
-import { pipe, ifDefined, isArray, isRecord, doesExtend, isPlainObject, raiseError, sprawl, recordToEntries, fallback, doNothing, become, mapObject, delve } from '../../dist/chunk-3V3VWQ7X.js';
+import { pipe, ifDefined, isArray, isRecord, doesExtend, isPlainObject, raiseError, sprawl, fallback, doNothing, become, mapObject, delve } from '../../dist/chunk-3V3VWQ7X.js';
 import { lazyLocalStorageEffect } from '../../dist/chunk-BWWVY5O5.js';
 import { JSON_TYPE_NAMES, isString, isNumber, isBoolean, stringifyJson, JSON_DEFAULTS } from '../../dist/chunk-BF4MVQF6.js';
 import { __spreadProps, __spreadValues, __objRest, __restKey } from '../../dist/chunk-F2X4B4VY.js';
@@ -1500,7 +1500,7 @@ var StateIndexLeafNode = ({ node, isOpenState, typeState }) => {
 var StateIndexTreeNode = ({ node, isOpenState }) => {
   const setIsOpen = useI(isOpenState);
   const isOpen = useO(isOpenState);
-  for (const [key, childNode] of recordToEntries(node.familyMembers)) {
+  for (const [key, childNode] of node.familyMembers) {
     findState(findViewIsOpenState, key);
     findState(findStateTypeState, childNode);
   }
@@ -1519,7 +1519,7 @@ var StateIndexTreeNode = ({ node, isOpenState }) => {
         /* @__PURE__ */ jsx("span", { className: "type detail", children: " (family)" })
       ] })
     ] }),
-    isOpen ? Object.entries(node.familyMembers).map(([key, childNode]) => /* @__PURE__ */ jsx(
+    isOpen ? [...node.familyMembers.entries()].map(([key, childNode]) => /* @__PURE__ */ jsx(
       StateIndexNode,
       {
         node: childNode,
@@ -1542,7 +1542,7 @@ var StateIndexNode = ({ node, isOpenState, typeState }) => {
 };
 var StateIndex = ({ tokenIndex }) => {
   const tokenIds = useO(tokenIndex);
-  return /* @__PURE__ */ jsx("article", { className: "index state_index", "data-testid": "state-index", children: Object.entries(tokenIds).filter(([key]) => !key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)).sort().map(([key, node]) => {
+  return /* @__PURE__ */ jsx("article", { className: "index state_index", "data-testid": "state-index", children: [...tokenIds.entries()].filter(([key]) => !key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)).sort().map(([key, node]) => {
     return /* @__PURE__ */ jsx(
       StateIndexNode,
       {

package/react-devtools/src/StateIndex.tsx

@@ -1,15 +1,13 @@
 import type {
-	AtomToken,
+	ReadableToken,
 	ReadonlySelectorToken,
 	RegularAtomToken,
-	WritableSelectorToken,
 } from "atom.io"
 import { findState, getState, selectorFamily } from "atom.io"
 import type { FamilyNode, WritableTokenIndex } from "atom.io/introspection"
 import { useI, useO } from "atom.io/react"
 import type { FC } from "react"
 
-import { recordToEntries } from "~/packages/anvl/src/object"
 import { isJson, refineJsonType } from "~/packages/anvl/src/refinement"
 
 import { findViewIsOpenState, primitiveRefinery } from "."
@@ -34,10 +32,7 @@ const findStateTypeState = selectorFamily<string, { key: string }>({
 })
 
 export const StateIndexLeafNode: FC<{
-	node:
-		| AtomToken<unknown>
-		| ReadonlySelectorToken<unknown>
-		| WritableSelectorToken<unknown>
+	node: ReadableToken<unknown>
 	isOpenState: RegularAtomToken<boolean>
 	typeState: ReadonlySelectorToken<string>
 }> = ({ node, isOpenState, typeState }) => {
@@ -80,16 +75,12 @@ export const StateIndexLeafNode: FC<{
 	)
 }
 export const StateIndexTreeNode: FC<{
-	node: FamilyNode<
-		| AtomToken<unknown>
-		| ReadonlySelectorToken<unknown>
-		| WritableSelectorToken<unknown>
-	>
+	node: FamilyNode<ReadableToken<unknown>>
 	isOpenState: RegularAtomToken<boolean>
 }> = ({ node, isOpenState }) => {
 	const setIsOpen = useI(isOpenState)
 	const isOpen = useO(isOpenState)
-	for (const [key, childNode] of recordToEntries(node.familyMembers)) {
+	for (const [key, childNode] of node.familyMembers) {
 		findState(findViewIsOpenState, key)
 		findState(findStateTypeState, childNode)
 	}
@@ -107,7 +98,7 @@ export const StateIndexTreeNode: FC<{
 				</label>
 			</header>
 			{isOpen
-				? Object.entries(node.familyMembers).map(([key, childNode]) => (
+				? [...node.familyMembers.entries()].map(([key, childNode]) => (
 						<StateIndexNode
 							key={key}
 							node={childNode}
@@ -121,11 +112,7 @@ export const StateIndexTreeNode: FC<{
 }
 
 export const StateIndexNode: FC<{
-	node: WritableTokenIndex<
-		| AtomToken<unknown>
-		| ReadonlySelectorToken<unknown>
-		| WritableSelectorToken<unknown>
-	>[string]
+	node: FamilyNode<ReadableToken<unknown>> | ReadableToken<unknown>
 	isOpenState: RegularAtomToken<boolean>
 	typeState: ReadonlySelectorToken<string>
 }> = ({ node, isOpenState, typeState }) => {
@@ -145,18 +132,12 @@ export const StateIndexNode: FC<{
 }
 
 export const StateIndex: FC<{
-	tokenIndex: ReadonlySelectorToken<
-		WritableTokenIndex<
-			| AtomToken<unknown>
-			| ReadonlySelectorToken<unknown>
-			| WritableSelectorToken<unknown>
-		>
-	>
+	tokenIndex: ReadonlySelectorToken<WritableTokenIndex<ReadableToken<unknown>>>
 }> = ({ tokenIndex }) => {
 	const tokenIds = useO(tokenIndex)
 	return (
 		<article className="index state_index" data-testid="state-index">
-			{Object.entries(tokenIds)
+			{[...tokenIds.entries()]
 				.filter(([key]) => !key.startsWith(`👁‍🗨`))
 				.sort()
 				.map(([key, node]) => {

package/realtime-client/dist/index.cjs

@@ -542,7 +542,7 @@ function syncContinuity(continuity, socket, store) {
     `conceal:${continuityKey}`,
     (concealed) => {
       for (const token of concealed) {
-        Internal.deleteAtom(token, store);
+        Internal.disposeAtom(token, store);
       }
     }
   );

package/realtime-client/dist/index.js

@@ -1,4 +1,4 @@
-export { syncContinuity } from '../../dist/chunk-2AIFLP2B.js';
+export { syncContinuity } from '../../dist/chunk-RT43TVKP.js';
 export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue } from '../../dist/chunk-O47EQUM6.js';
 import '../../dist/chunk-BWWVY5O5.js';
 import '../../dist/chunk-F2X4B4VY.js';

package/realtime-client/src/sync-continuity.ts

@@ -3,7 +3,7 @@ import type { Store } from "atom.io/internal"
 import {
 	actUponStore,
 	assignTransactionToContinuity,
-	deleteAtom,
+	disposeAtom,
 	getEpochNumberOfContinuity,
 	getFromStore,
 	getJsonToken,
@@ -353,7 +353,7 @@ export function syncContinuity<F extends AtomIO.Func>(
 		`conceal:${continuityKey}`,
 		(concealed: AtomIO.AtomToken<unknown>[]) => {
 			for (const token of concealed) {
-				deleteAtom(token, store)
+				disposeAtom(token, store)
 			}
 		},
 	)

package/realtime-react/dist/index.cjs

@@ -480,7 +480,7 @@ function syncContinuity(continuity, socket, store) {
     `conceal:${continuityKey}`,
     (concealed) => {
       for (const token of concealed) {
-        internal.deleteAtom(token, store);
+        internal.disposeAtom(token, store);
       }
     }
   );

package/realtime-react/dist/index.js

@@ -1,4 +1,4 @@
-import { syncContinuity } from '../../dist/chunk-2AIFLP2B.js';
+import { syncContinuity } from '../../dist/chunk-RT43TVKP.js';
 import '../../dist/chunk-F2X4B4VY.js';
 import { useI, StoreContext, useO } from 'atom.io/react';
 import * as RTC from 'atom.io/realtime-client';

package/realtime-server/dist/index.cjs

@@ -216,8 +216,8 @@ var SubjectSocket = class extends CustomSocket {
     });
   }
   dispose() {
-    for (const dispose2 of this.disposalFunctions) {
-      dispose2();
+    for (const dispose of this.disposalFunctions) {
+      dispose();
     }
   }
 };

package/realtime-server/dist/index.js

@@ -1,4 +1,4 @@
-import { findRelationsInStore } from '../../dist/chunk-SMZRGPN6.js';
+import { findRelationsInStore } from '../../dist/chunk-KGZGBCYS.js';
 import '../../dist/chunk-FTONNX2R.js';
 import { __spreadProps, __spreadValues } from '../../dist/chunk-F2X4B4VY.js';
 import { parseJson, stringifyJson } from 'atom.io/json';

package/realtime-testing/dist/index.cjs

@@ -172,7 +172,7 @@ var setupRealtimeTestServer = (options) => {
   server.on(`connection`, (socket) => {
     options.server({ socket, silo });
   });
-  const dispose2 = () => {
+  const dispose = () => {
     server.close();
     const roomKeys = internal.getFromStore(RT__namespace.roomIndex, silo.store);
     for (const roomKey of roomKeys) {
@@ -187,7 +187,7 @@ var setupRealtimeTestServer = (options) => {
   return {
     name: `SERVER`,
     silo,
-    dispose: dispose2,
+    dispose,
     port
   };
 };
@@ -216,12 +216,12 @@ var setupRealtimeTestClient = (options, name, port) => {
     const prettyPrint = () => {
       console.log(react.prettyDOM(renderResult.container));
     };
-    const dispose2 = () => {
+    const dispose = () => {
       renderResult.unmount();
       socket.disconnect();
       internal.clearStore(silo.store);
     };
-    testClient.dispose = dispose2;
+    testClient.dispose = dispose;
     return {
       name,
       silo,

package/realtime-testing/dist/index.js

@@ -1,5 +1,5 @@
 import { myUsernameState } from '../../dist/chunk-O47EQUM6.js';
-import { editRelationsInStore } from '../../dist/chunk-SMZRGPN6.js';
+import { editRelationsInStore } from '../../dist/chunk-KGZGBCYS.js';
 import '../../dist/chunk-FTONNX2R.js';
 import { recordToEntries } from '../../dist/chunk-3V3VWQ7X.js';
 import '../../dist/chunk-BWWVY5O5.js';

package/src/dispose.ts

@@ -2,18 +2,18 @@ import * as Internal from "atom.io/internal"
 
 import type { ReadableToken } from "."
 
-export function dispose(
+export function disposeState(
 	token: ReadableToken<any>,
 	store: Internal.Store = Internal.IMPLICIT.STORE,
 ): void {
 	switch (token.type) {
 		case `atom`:
 		case `mutable_atom`:
-			Internal.deleteAtom(token, store)
+			Internal.disposeAtom(token, store)
 			break
 		case `selector`:
 		case `readonly_selector`:
-			Internal.deleteSelector(token, store)
+			Internal.disposeSelector(token, store)
 			break
 	}
 }

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

@@ -1,40 +0,0 @@
-import type { AtomToken } from "atom.io"
-
-import type { Store } from ".."
-import { deleteSelector, getUpdateToken, newest } from ".."
-
-export function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void {
-	const target = newest(store)
-	const { key } = atomToken
-	const atom = target.atoms.get(key)
-	if (!atom) {
-		store.logger.error(
-			`❌`,
-			`atom`,
-			key,
-			`Tried to delete atom, but it does not exist in the store.`,
-		)
-	}
-	atom?.cleanup?.()
-	target.atoms.delete(key)
-	target.valueMap.delete(key)
-	const selectorKeys = target.selectorAtoms.getRelatedKeys(key)
-	if (selectorKeys) {
-		for (const selectorKey of selectorKeys) {
-			const token =
-				target.selectors.get(selectorKey) ??
-				target.readonlySelectors.get(selectorKey)
-			if (token) {
-				deleteSelector(token, store)
-			}
-		}
-	}
-	target.selectorAtoms.delete(key)
-	target.atomsThatAreDefault.delete(key)
-	target.timelineAtoms.delete(key)
-	if (atomToken.type === `mutable_atom`) {
-		const updateToken = getUpdateToken(atomToken)
-		deleteAtom(updateToken, store)
-	}
-	store.logger.info(`🔥`, `atom`, key, `deleted`)
-}