atom.io 0.14.7 → 0.15.0

package/internal/src/operation.ts

@@ -19,17 +19,16 @@ export const openOperation = (
 	token: StateToken<any>,
 	store: Store,
 ): `rejection` | undefined => {
-	const target = newest(store)
-	if (target.operation.open) {
+	if (store.operation.open) {
 		store.logger.error(
 			`❌`,
 			token.type,
 			token.key,
-			`failed to setState during a setState for "${target.operation.token.key}"`,
+			`failed to setState during a setState for "${store.operation.token.key}"`,
 		)
 		return `rejection`
 	}
-	target.operation = {
+	store.operation = {
 		open: true,
 		done: new Set(),
 		prev: new Map(),
@@ -41,29 +40,27 @@ export const openOperation = (
 		token.type,
 		token.key,
 		`operation start in store "${store.config.name}"${
-			target.transactionMeta === null
+			store.transactionMeta === null
 				? ``
-				: ` ${target.transactionMeta.phase} "${target.transactionMeta.update.key}"`
+				: ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`
 		}`,
 	)
 }
 export const closeOperation = (store: Store): void => {
-	const target = newest(store)
-	if (target.operation.open) {
+	if (store.operation.open) {
 		store.logger.info(
 			`🔴`,
-			target.operation.token.type,
-			target.operation.token.key,
+			store.operation.token.type,
+			store.operation.token.key,
 			`operation done in store "${store.config.name}"`,
 		)
 	}
-	target.operation = { open: false }
-	store.subject.operationStatus.next(target.operation)
+	store.operation = { open: false }
+	store.subject.operationStatus.next(store.operation)
 }
 
 export const isDone = (key: string, store: Store): boolean => {
-	const target = newest(store)
-	if (!target.operation.open) {
+	if (!store.operation.open) {
 		store.logger.warn(
 			`🐞`,
 			`unknown`,
@@ -72,11 +69,10 @@ export const isDone = (key: string, store: Store): boolean => {
 		)
 		return true
 	}
-	return target.operation.done.has(key)
+	return store.operation.done.has(key)
 }
 export const markDone = (key: string, store: Store): void => {
-	const target = newest(store)
-	if (!target.operation.open) {
+	if (!store.operation.open) {
 		store.logger.warn(
 			`🐞`,
 			`unknown`,
@@ -85,5 +81,5 @@ export const markDone = (key: string, store: Store): void => {
 		)
 		return
 	}
-	target.operation.done.add(key)
+	store.operation.done.add(key)
 }

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

@@ -21,14 +21,13 @@ export const createReadWriteSelector = <T>(
 	const { get, set } = registerSelector(options.key, store)
 	const getSelf = () => {
 		const value = options.get({ get })
-		cacheValue(options.key, value, subject, store)
+		cacheValue(options.key, value, subject, newest(store))
 		return value
 	}
 
 	const setSelf = (next: T | ((oldValue: T) => T)): void => {
 		const oldValue = getSelf()
 		const newValue = become(next)(oldValue)
-		// store.logger.info(`📝 set "${options.key}" (`, oldValue, `->`, newValue, `)`)
 		store.logger.info(
 			`📝`,
 			`selector`,
@@ -55,7 +54,7 @@ export const createReadWriteSelector = <T>(
 		type: `selector`,
 		...(family && { family }),
 	}
-	target.selectors.set(options.key, mySelector) // ❓
+	target.selectors.set(options.key, mySelector)
 	const initialValue = getSelf()
 	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue)
 	const token: SelectorToken<T> = {

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

@@ -54,7 +54,7 @@ export function createSelector<T>(
 			`❌`,
 			existingReadonly ? `readonly_selector` : `selector`,
 			options.key,
-			`Tried to create selector, but it already exists in the store. (Ignore if you are in development using hot module replacement.)`,
+			`Tried to create selector, but it already exists in the store.`,
 		)
 	}
 

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

@@ -13,9 +13,6 @@ export const registerSelector = (
 ): Transactors => ({
 	get: (dependency) => {
 		const target = newest(store)
-		const alreadyRegistered = target.selectorGraph
-			.getRelationEntries({ downstreamSelectorKey: selectorKey })
-			.some(([_, { source }]) => source === dependency.key)
 
 		const dependencyState = withdraw(dependency, store)
 		if (dependencyState === undefined) {
@@ -34,17 +31,15 @@ export const registerSelector = (
 			`)`,
 		)
 
-		if (!alreadyRegistered) {
-			target.selectorGraph.set(
-				{
-					upstreamSelectorKey: dependency.key,
-					downstreamSelectorKey: selectorKey,
-				},
-				{
-					source: dependency.key,
-				},
-			)
-		}
+		target.selectorGraph.set(
+			{
+				upstreamSelectorKey: dependency.key,
+				downstreamSelectorKey: selectorKey,
+			},
+			{
+				source: dependency.key,
+			},
+		)
 		updateSelectorAtoms(selectorKey, dependency, store)
 		return dependencyValue
 	},

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

@@ -1,12 +1,10 @@
 import type { Atom } from "../atom"
 import { evictCachedValue } from "../caching"
-import { newest } from "../lineage"
 import { isDone, markDone } from "../operation"
 import type { Store } from "../store"
 
 export const evictDownStream = <T>(atom: Atom<T>, store: Store): void => {
-	const target = newest(store)
-	const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom.key)
+	const downstreamKeys = store.selectorAtoms.getRelatedKeys(atom.key)
 	store.logger.info(
 		`🧹`,
 		atom.type,
@@ -17,12 +15,12 @@ export const evictDownStream = <T>(atom: Atom<T>, store: Store): void => {
 		downstreamKeys ?? `to evict`,
 	)
 	if (downstreamKeys) {
-		if (target.operation.open) {
+		if (store.operation.open) {
 			store.logger.info(
 				`🧹`,
 				atom.type,
 				atom.key,
-				`[ ${[...target.operation.done].join(`, `)} ] already done`,
+				`[ ${[...store.operation.done].join(`, `)} ] already done`,
 			)
 		}
 		for (const key of downstreamKeys) {

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

@@ -1,7 +1,6 @@
 import type { Atom } from "../atom"
 import { isAtomDefault, markAtomAsNotDefault } from "../atom"
 import { cacheValue } from "../caching"
-import { newest } from "../lineage"
 import { markDone } from "../operation"
 import { readOrComputeValue } from "../read-or-compute-value"
 import type { Store } from "../store"
@@ -14,26 +13,24 @@ import { stowUpdate } from "./stow-update"
 export const setAtom = <T>(
 	atom: Atom<T>,
 	next: T | ((oldValue: T) => T),
-	store: Store,
+	target: Store,
 ): void => {
-	const target = newest(store)
-	const oldValue = readOrComputeValue(atom, store)
-	let newValue = copyMutableIfWithinTransaction(oldValue, atom, store)
+	const oldValue = readOrComputeValue(atom, target)
+	let newValue = copyMutableIfWithinTransaction(oldValue, atom, target)
 	newValue = become(next)(newValue)
-	store.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
-	newValue = cacheValue(atom.key, newValue, atom.subject, store)
-	if (isAtomDefault(atom.key, store)) {
-		markAtomAsNotDefault(atom.key, store)
+	target.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
+	newValue = cacheValue(atom.key, newValue, atom.subject, target)
+	if (isAtomDefault(atom.key, target)) {
+		markAtomAsNotDefault(atom.key, target)
 	}
-	markDone(atom.key, store)
-	evictDownStream(atom, store)
+	markDone(atom.key, target)
+	evictDownStream(atom, target)
 	const update = { oldValue, newValue }
-	if (
-		target.transactionMeta === null ||
-		target.transactionMeta.phase === `applying`
-	) {
-		emitUpdate(atom, update, store)
+	if (target.transactionMeta === null) {
+		emitUpdate(atom, update, target)
+	} else if (target.transactionMeta.phase === `applying` && target.parent) {
+		emitUpdate(atom, update, target.parent)
 	} else {
-		stowUpdate(atom, update, store)
+		stowUpdate(atom, update, target)
 	}
 }

package/internal/src/store/store.ts

@@ -16,30 +16,19 @@ import { Junction } from "~/packages/rel8/junction/src"
 
 import type { Atom } from "../atom"
 import type { Lineage } from "../lineage"
-import type { MutableAtom, Tracker, Transceiver } from "../mutable"
+import {
+	type MutableAtom,
+	type Tracker,
+	type Transceiver,
+	getJsonToken,
+	getUpdateToken,
+} from "../mutable"
 import type { OperationProgress } from "../operation"
 import type { ReadonlySelector, Selector } from "../selector"
 import { StatefulSubject, Subject } from "../subject"
 import type { Timeline } from "../timeline"
 import type { Transaction, TransactionMeta } from "../transaction"
 
-// export type StoreCore = Pick<
-// 	Store,
-// 	| `atoms`
-// 	| `atomsThatAreDefault`
-// 	| `families`
-// 	| `operation`
-// 	| `readonlySelectors`
-// 	| `selectorAtoms`
-// 	| `selectorGraph`
-// 	| `selectors`
-// 	| `timelineAtoms`
-// 	| `timelines`
-// 	| `trackers`
-// 	| `transactions`
-// 	| `valueMap`
-// >
-
 export class Store implements Lineage {
 	public parent: Store | null = null
 	public child: Store | null = null
@@ -130,14 +119,29 @@ export class Store implements Lineage {
 				...store?.config,
 				name,
 			}
-
+			for (const [, family] of store.families) {
+				family.install(this)
+			}
+			const mutableHelpers = new Set<string>()
 			for (const [, atom] of store.atoms) {
+				if (mutableHelpers.has(atom.key)) {
+					continue
+				}
 				atom.install(this)
+				if (`mutable` in atom) {
+					const originalJsonToken = getJsonToken(atom)
+					const originalUpdateToken = getUpdateToken(atom)
+					mutableHelpers.add(originalJsonToken.key)
+					mutableHelpers.add(originalUpdateToken.key)
+				}
 			}
 			for (const [, selector] of store.readonlySelectors) {
 				selector.install(this)
 			}
 			for (const [, selector] of store.selectors) {
+				if (mutableHelpers.has(selector.key)) {
+					continue
+				}
 				selector.install(this)
 			}
 			for (const [, tx] of store.transactions) {

package/internal/src/store/withdraw.ts

@@ -9,12 +9,18 @@ import type {
 } from "atom.io"
 
 import type { Atom } from "../atom"
-import { newest } from "../lineage"
 import type { ReadonlySelector, Selector } from "../selector"
 import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
 import type { Store } from "./store"
 
+type Withdrawable<T> =
+	| Atom<T>
+	| ReadonlySelector<T>
+	| Selector<T>
+	| Timeline
+	| Transaction<T extends ƒn ? T : never>
+
 export function withdraw<T>(
 	token: AtomToken<T>,
 	store: Store,
@@ -50,74 +56,30 @@ export function withdraw<T>(
 		| TimelineToken
 		| TransactionToken<T>,
 	store: Store,
-):
-	| Atom<T>
-	| ReadonlySelector<T>
-	| Selector<T>
-	| Timeline
-	| Transaction<T extends ƒn ? T : never>
-	| undefined {
-	const target = newest(store)
-	const state =
-		target.atoms.get(token.key) ??
-		target.selectors.get(token.key) ??
-		target.readonlySelectors.get(token.key) ??
-		target.transactions.get(token.key) ??
-		target.timelines.get(token.key)
-	if (state) {
-		return state
+): Withdrawable<T> | undefined {
+	let withdrawn: Withdrawable<T> | undefined
+	let target: Store | null = store
+	while (target !== null) {
+		switch (token.type) {
+			case `atom`:
+				withdrawn = target.atoms.get(token.key)
+				break
+			case `selector`:
+				withdrawn = target.selectors.get(token.key)
+				break
+			case `readonly_selector`:
+				withdrawn = target.readonlySelectors.get(token.key)
+				break
+			case `timeline`:
+				withdrawn = target.timelines.get(token.key)
+				break
+			case `transaction`:
+				withdrawn = target.transactions.get(token.key)
+				break
+		}
+		if (withdrawn) {
+			return withdrawn
+		}
+		target = target.child
 	}
-	// if (target.transactionMeta?.phase === `applying`) {
-
-	// 	state =
-	// 		target.atoms.get(token.key) ??
-	// 		core.selectors.get(token.key) ??
-	// 		core.readonlySelectors.get(token.key) ??
-	// 		core.transactions.get(token.key) ??
-	// 		core.timelines.get(token.key)
-
-	// 	if (state) {
-	// 		store.logger.info(
-	// 			`🛠️`,
-	// 			token.type,
-	// 			token.key,
-	// 			`add ${token.type} "${token.key}"`,
-	// 		)
-	// 		switch (state.type) {
-	// 			case `atom`: {
-	// 				store.atoms.set(token.key, state)
-	// 				store.valueMap.set(token.key, state.default)
-	// 				const stateKey = state.key
-	// 				const familyKey = state.family?.key
-	// 				let timelineKey = core.timelineAtoms.getRelatedKey(stateKey)
-	// 				if (timelineKey === undefined && typeof familyKey === `string`) {
-	// 					timelineKey = core.timelineAtoms.getRelatedKey(familyKey)
-	// 				}
-	// 				const timeline =
-	// 					typeof timelineKey === `string`
-	// 						? store.timelines.get(timelineKey)
-	// 						: undefined
-
-	// 				if (timeline) {
-	// 					addAtomToTimeline(state, timeline, store)
-	// 				}
-	// 				break
-	// 			}
-	// 			case `selector`:
-	// 				core.selectors.set(token.key, state)
-	// 				break
-	// 			case `readonly_selector`:
-	// 				core.readonlySelectors.set(token.key, state)
-	// 				break
-	// 			case `transaction`:
-	// 				core.transactions.set(token.key, state)
-	// 				break
-	// 			case `timeline`:
-	// 				core.timelines.set(token.key, state)
-	// 				break
-	// 		}
-	// 		return state
-	// 	}
-	// }
-	return undefined
 }

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

@@ -1,3 +1,4 @@
+import { newest } from "../lineage"
 import { readOrComputeValue } from "../read-or-compute-value"
 import type { ReadonlySelector, Selector } from "../selector"
 import { traceAllSelectorAtoms } from "../selector"
@@ -8,11 +9,12 @@ export const subscribeToRootAtoms = <T>(
 	state: ReadonlySelector<T> | Selector<T>,
 	store: Store,
 ): (() => void)[] | null => {
+	const target = newest(store)
 	const dependencySubscriptions =
 		`default` in state
 			? null
 			: traceAllSelectorAtoms(state.key, store).map((atomKey) => {
-					const atom = store.atoms.get(atomKey)
+					const atom = target.atoms.get(atomKey)
 					if (atom === undefined) {
 						throw new Error(
 							`Atom "${atomKey}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`,
@@ -32,9 +34,9 @@ export const subscribeToRootAtoms = <T>(
 								`->`,
 								atomChange.newValue,
 							)
-							const oldValue = recallState(state, store)
+							const oldValue = recallState(state, target)
 							// ❌ this retrieves a stale cached value when applying a transaction on the server
-							const newValue = readOrComputeValue(state, store)
+							const newValue = readOrComputeValue(state, target)
 							store.logger.info(
 								`✨`,
 								state.type,

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

@@ -1,6 +1,7 @@
 import type { ReadonlySelectorToken, StateToken, UpdateHandler } from "atom.io"
-import type { Store } from "atom.io/internal"
-import { subscribeToRootAtoms, withdraw } from "atom.io/internal"
+import type { Store } from "../store"
+import { withdraw, withdrawNewFamilyMember } from "../store"
+import { subscribeToRootAtoms } from "./subscribe-to-root-atoms"
 
 export function subscribeToState<T>(
 	token: ReadonlySelectorToken<T> | StateToken<T>,
@@ -8,7 +9,8 @@ export function subscribeToState<T>(
 	key: string,
 	store: Store,
 ): () => void {
-	const state = withdraw<T>(token, store)
+	const state =
+		withdraw<T>(token, store) ?? withdrawNewFamilyMember(token, store)
 	if (state === undefined) {
 		throw new Error(
 			`State "${token.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`,

package/internal/src/transaction/apply-transaction.ts

@@ -82,8 +82,27 @@ export const applyTransaction = <ƒ extends ƒn>(
 		`Applying transaction with ${updates.length} updates:`,
 		updates,
 	)
+	for (const tracker of child.trackers.values()) {
+		const mutableKey = tracker.mutableState.key
+		if (!parent.atoms.has(mutableKey)) {
+			const atom = child.atoms.get(mutableKey)
+			atom?.install(parent)
+		}
+	}
+	for (const atom of child.atoms.values()) {
+		if (!parent.atoms.has(atom.key)) {
+			parent.atoms.set(atom.key, atom)
+			parent.valueMap.set(atom.key, atom.default)
+			parent.logger.info(
+				`🔨`,
+				`transaction`,
+				child.transactionMeta.update.key,
+				`Adding atom "${atom.key}"`,
+			)
+		}
+	}
+	ingestTransactionUpdate(child.transactionMeta.update, parent, child)
 	if (parent.transactionMeta === null) {
-		ingestTransactionUpdate(child.transactionMeta.update, parent, child)
 		const myTransaction = withdraw<ƒ>(
 			{ key: child.transactionMeta.update.key, type: `transaction` },
 			store,
@@ -96,7 +115,6 @@ export const applyTransaction = <ƒ extends ƒn>(
 			`Finished applying transaction.`,
 		)
 	} else {
-		ingestTransactionUpdate(child.transactionMeta.update, parent, child)
 		parent.transactionMeta.update.updates.push(child.transactionMeta.update)
 	}
 	parent.subject.transactionApplying.next(null)

package/internal/src/transaction/build-transaction.ts

@@ -1,5 +1,6 @@
 import { Junction } from "~/packages/rel8/junction/src"
 
+import { getState, runTransaction, setState } from "~/packages/atom.io/src"
 import { LazyMap } from "../lazy-map"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -10,23 +11,14 @@ export const buildTransaction = (
 	store: Store,
 ): void => {
 	const parent = newest(store)
-	parent.child = {
+	const child: Store = {
 		parent,
 		child: null,
 		subject: parent.subject,
 		loggers: parent.loggers,
 		logger: parent.logger,
 		config: parent.config,
-		transactionMeta: {
-			phase: `building`,
-			time: Date.now(),
-			update: {
-				key,
-				updates: [],
-				params,
-				output: undefined,
-			},
-		},
+		transactionMeta: null,
 		atoms: new LazyMap(parent.atoms),
 		atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
 		families: new LazyMap(parent.families),
@@ -43,6 +35,22 @@ export const buildTransaction = (
 		selectors: new LazyMap(parent.selectors),
 		valueMap: new LazyMap(parent.valueMap),
 	}
+	child.transactionMeta = {
+		phase: `building`,
+		time: Date.now(),
+		update: {
+			key,
+			updates: [],
+			params,
+			output: undefined,
+		},
+		transactors: {
+			get: (token) => getState(token, child),
+			set: (token, value) => setState(token, value, child),
+			run: (token) => runTransaction(token, child),
+		},
+	}
+	parent.child = child
 	store.logger.info(
 		`🛫`,
 		`transaction`,

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

@@ -4,7 +4,6 @@ import type {
 	TransactionUpdate,
 	ƒn,
 } from "atom.io"
-import { getState, runTransaction, setState } from "atom.io"
 
 import { newest } from "../lineage"
 import { deposit } from "../store"
@@ -32,18 +31,14 @@ export function createTransaction<ƒ extends ƒn>(
 		run: (...params: Parameters<ƒ>) => {
 			buildTransaction(options.key, params, store)
 			try {
-				const output = options.do(
-					{
-						get: (token) => getState(token, store),
-						set: (token, value) => setState(token, value, store),
-						run: (token) => runTransaction(token, store),
-					},
-					...params,
-				)
-				applyTransaction(output, store)
+				const target = newest(store)
+				// biome-ignore lint/style/noNonNullAssertion: this happens right above
+				const { transactors } = target.transactionMeta!
+				const output = options.do(transactors, ...params)
+				applyTransaction(output, target)
 				return output
 			} catch (thrown) {
-				abortTransaction(store)
+				abortTransaction(target)
 				store.logger.warn(`💥`, `transaction`, options.key, `caught:`, thrown)
 				throw thrown
 			}

package/internal/src/transaction/index.ts

@@ -1,11 +1,9 @@
-import type { TransactionUpdate, ƒn } from "atom.io"
+import type { TransactionUpdate, TransactorsWithRun, ƒn } from "atom.io"
 
 export * from "./abort-transaction"
 export * from "./apply-transaction"
 export * from "./build-transaction"
 export * from "./create-transaction"
-export * from "./redo-transaction"
-export * from "./undo-transaction"
 
 export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
 export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
@@ -14,4 +12,5 @@ export type TransactionMeta<ƒ extends ƒn> = {
 	phase: `applying` | `building`
 	time: number
 	update: TransactionUpdate<ƒ>
+	transactors: TransactorsWithRun
 }

package/introspection/dist/index.cjs

@@ -42,7 +42,7 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var attachAtomIndex = (store = Internal.IMPLICIT.STORE) => {
-  const atomTokenIndexState__INTERNAL = Internal.createAtom(
+  const atomTokenIndexState__INTERNAL = Internal.createRegularAtom(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index (Internal)`,
       default: () => {
@@ -109,7 +109,7 @@ var attachAtomIndex = (store = Internal.IMPLICIT.STORE) => {
   );
 };
 var attachSelectorIndex = (store = Internal.IMPLICIT.STORE) => {
-  const readonlySelectorTokenIndexState__INTERNAL = Internal.createAtom(
+  const readonlySelectorTokenIndexState__INTERNAL = Internal.createRegularAtom(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Selector Token Index (Internal)`,
       default: () => Object.assign(
@@ -182,7 +182,7 @@ var attachSelectorIndex = (store = Internal.IMPLICIT.STORE) => {
   );
 };
 var attachTimelineFamily = (store = Internal.IMPLICIT.STORE) => {
-  const findTimelineLogState__INTERNAL = Internal.createAtomFamily(
+  const findTimelineLogState__INTERNAL = Internal.createRegularAtomFamily(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log (Internal)`,
       default: (key) => {
@@ -233,7 +233,7 @@ var attachTimelineFamily = (store = Internal.IMPLICIT.STORE) => {
   return findTimelineLogState;
 };
 var attachTimelineIndex = (store = Internal.IMPLICIT.STORE) => {
-  const timelineTokenIndexState__INTERNAL = Internal.createAtom(
+  const timelineTokenIndexState__INTERNAL = Internal.createRegularAtom(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Timeline Token Index (Internal)`,
       default: () => [...store.timelines].map(([key]) => {
@@ -264,7 +264,7 @@ var attachTimelineIndex = (store = Internal.IMPLICIT.STORE) => {
   return timelineTokenIndex;
 };
 var attachTransactionIndex = (store = Internal.IMPLICIT.STORE) => {
-  const transactionTokenIndexState__INTERNAL = Internal.createAtom(
+  const transactionTokenIndexState__INTERNAL = Internal.createRegularAtom(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Transaction Token Index (Internal)`,
       default: () => [...store.transactions].map(([key]) => {
@@ -295,7 +295,7 @@ var attachTransactionIndex = (store = Internal.IMPLICIT.STORE) => {
   return transactionTokenIndex;
 };
 var attachTransactionLogs = (store = Internal.IMPLICIT.STORE) => {
-  const findTransactionUpdateLog = Internal.createAtomFamily(
+  const findTransactionUpdateLog = Internal.createRegularAtomFamily(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log (Internal)`,
       default: () => [],