atom.io 0.32.2 → 0.32.4

package/internal/dist/index.d.ts

@@ -185,8 +185,8 @@ type Transaction<F extends Func> = {
 };
 declare function createTransaction<F extends Func>(store: Store, options: TransactionOptions<F>): TransactionToken<F>;
 
-declare function getContinuityKey(store: Store, transactionKey: string): string | undefined;
-declare function getEpochNumberOfContinuity(store: Store, continuityKey: string): number | undefined;
+declare function getContinuityKey(store: RootStore, transactionKey: string): string | undefined;
+declare function getEpochNumberOfContinuity(store: RootStore, continuityKey: string): number | undefined;
 declare function getEpochNumberOfAction(store: Store, transactionKey: string): number | undefined;
 
 declare function setEpochNumberOfContinuity(store: Store, continuityKey: string, newEpoch: number): void;
@@ -423,6 +423,9 @@ declare class Store implements Lineage {
     logger: Logger;
     constructor(config: Store[`config`], store?: Store | null);
 }
+declare global {
+    var ATOM_IO_IMPLICIT_STORE: Store | undefined;
+}
 declare const IMPLICIT: {
     readonly STORE: Store;
 };
@@ -638,6 +641,9 @@ declare class NotFoundError extends Error {
 
 declare function prettyPrintTokenType(token: AtomIOToken): string;
 
+type ReservedIntrospectionKey = `🔍 ${string}`;
+declare function isReservedIntrospectionKey(value: string): value is ReservedIntrospectionKey;
+
 declare const createReadonlySelector: <T>(store: Store, options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined) => ReadonlySelectorToken<T>;
 
 declare function createStandaloneSelector<T>(store: Store, options: WritableSelectorOptions<T>): WritableSelectorToken<T>;
@@ -695,7 +701,7 @@ type RegularAtom<T> = AtomIOState & {
 };
 type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = AtomIOState & JsonInterface<T, J> & {
     type: `mutable_atom`;
-    default: T | (() => T);
+    default: () => T;
     cleanup?: () => void;
 };
 type Atom<T> = RegularAtom<T> | (T extends Transceiver<any> ? MutableAtom<T, any> : never);
@@ -741,4 +747,4 @@ type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelecto
 type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
 type AtomIOInternalResource = ReadableFamily<any, any> | ReadableState<any> | Timeline<any> | Transaction<any>;
 
-export { type Atom, type AtomFamily, type AtomIOInternalResource, type AtomIOState, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, CircularBuffer, type Count, type Each, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Join, type JoinStateFamilies, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionEntriesBase, type JunctionJSON, type JunctionSchema, type JunctionSchemaBase, LazyMap, type Lineage, type Modify, type Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type Refinement, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { type Atom, type AtomFamily, type AtomIOInternalResource, type AtomIOState, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, CircularBuffer, type Count, type Each, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Join, type JoinStateFamilies, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionEntriesBase, type JunctionJSON, type JunctionSchema, type JunctionSchemaBase, LazyMap, type Lineage, type Modify, type Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type Refinement, type RegularAtom, type RegularAtomFamily, type ReservedIntrospectionKey, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };

package/internal/dist/index.js

@@ -1,2 +1,2 @@
-export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Join, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-RXQWAO26.js';
+export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Join, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-7SJVR7FZ.js';
 import '../../dist/chunk-XWL6SNVU.js';

package/internal/src/families/create-writable-selector-family.ts

@@ -76,8 +76,10 @@ export function createWritableSelectorFamily<T, K extends Canonical>(
 		default: (key: K) => {
 			const getFn = options.get(key)
 			return getFn({
-				get: ((...ps: [any]) => getFromStore(store, ...ps)) as typeof getState,
-				find: ((token, k) => findInStore(store, token, k)) as typeof findState,
+				get: ((...args: Parameters<typeof getState>) =>
+					getFromStore(store, ...args)) as typeof getState,
+				find: ((...args: Parameters<typeof findState>) =>
+					findInStore(store, ...args)) as typeof findState,
 				json: (token) => getJsonToken(store, token),
 			})
 		},

package/internal/src/get-state/read-or-compute-value.ts

@@ -10,18 +10,28 @@ export const readOrComputeValue = <T>(
 		target.logger.info(`📖`, state.type, state.key, `reading cached value`)
 		return readCachedValue(state, target)
 	}
-	if (state.type === `selector` || state.type === `readonly_selector`) {
-		target.logger.info(`🧮`, state.type, state.key, `computing value`)
-		return state.get()
+	switch (state.type) {
+		case `selector`:
+		case `readonly_selector`:
+			target.logger.info(`🧮`, state.type, state.key, `computing value`)
+			return state.get()
+		case `atom`:
+		case `mutable_atom`: {
+			const def = state.default
+			let fallback: T
+			if (def instanceof Function) {
+				fallback = def()
+			} else {
+				fallback = def
+			}
+			target.logger.info(
+				`💁`,
+				`atom`,
+				state.key,
+				`could not find cached value; using default`,
+				fallback,
+			)
+			return fallback
+		}
 	}
-	const fallback =
-		state.default instanceof Function ? state.default() : state.default
-	target.logger.info(
-		`💁`,
-		`atom`,
-		state.key,
-		`could not find cached value; using default`,
-		fallback,
-	)
-	return state.default instanceof Function ? state.default() : state.default
 }

package/internal/src/index.ts

@@ -40,6 +40,7 @@ export * from "./mutable"
 export * from "./not-found-error"
 export * from "./operation"
 export * from "./pretty-print"
+export * from "./reserved-keys"
 export * from "./selector"
 export * from "./set-state"
 export * from "./store"
@@ -67,7 +68,7 @@ export type MutableAtom<
 > = AtomIOState &
 	JsonInterface<T, J> & {
 		type: `mutable_atom`
-		default: T | (() => T)
+		default: () => T
 		cleanup?: () => void
 	}
 export type Atom<T> =

package/internal/src/ingest-updates/ingest-creation-disposal.ts

@@ -93,18 +93,6 @@ export function ingestMoleculeDisposalEvent(
 
 		case `oldValue`:
 			{
-				// let first = t rue
-				// for (const ownerString of update.provenance) {
-				// 	// const owner = parseJson(ownerString)
-				// 	// if (first) {
-				// 	// 	first = false
-				// 	// 	allocateIntoStore<any, any, any>(store, owner, update.key)
-				// 	// 	continue
-				// 	// }
-
-				// 	// claimWithinStore<any, any, any>(store, owner, update.key)
-
-				// }
 				const provenanceJson = update.provenance.map(parseJson)
 				allocateIntoStore<any, any, any>(store, provenanceJson, update.key)
 				for (const [familyKey, value] of update.values) {

package/internal/src/join/find-relations-in-store.ts

@@ -26,11 +26,13 @@ export function findRelationsInStore<
 			const keyBA = `${token.b}KeyOf${capitalize(token.a)}`
 			relations = {
 				get [keyAB]() {
+					// @ts-expect-error way too complicated to represent
 					const familyAB = myJoin.states[keyAB as any]
 					const state = findInStore(store, familyAB, key)
 					return state
 				},
 				get [keyBA]() {
+					// @ts-expect-error way too complicated to represent
 					const familyBA = myJoin.states[keyBA as any]
 					const state = findInStore(store, familyBA, key)
 					return state
@@ -41,11 +43,13 @@ export function findRelationsInStore<
 				const entryBA = `${token.b}EntryOf${capitalize(token.a)}`
 				Object.assign(relations, {
 					get [entryAB]() {
+						// @ts-expect-error way too complicated to represent
 						const familyAB = myJoin.states[entryAB as any]
 						const state = findInStore(store, familyAB, key)
 						return state
 					},
 					get [entryBA]() {
+						// @ts-expect-error way too complicated to represent
 						const familyBA = myJoin.states[entryBA as any]
 						const state = findInStore(store, familyBA, key)
 						return state
@@ -59,11 +63,13 @@ export function findRelationsInStore<
 			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`
 			relations = {
 				get [keyAB]() {
+					// @ts-expect-error way too complicated to represent
 					const familyAB = myJoin.states[keyAB as any]
 					const state = findInStore(store, familyAB, key)
 					return state
 				},
 				get [keysBA]() {
+					// @ts-expect-error way too complicated to represent
 					const familyBA = myJoin.states[keysBA as any]
 					const state = findInStore(store, familyBA, key)
 					return state
@@ -74,11 +80,13 @@ export function findRelationsInStore<
 				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`
 				Object.assign(relations, {
 					get [entryAB]() {
+						// @ts-expect-error way too complicated to represent
 						const familyAB = myJoin.states[entryAB as any]
 						const state = findInStore(store, familyAB, key)
 						return state
 					},
 					get [entriesBA]() {
+						// @ts-expect-error way too complicated to represent
 						const familyBA = myJoin.states[entriesBA as any]
 						const state = findInStore(store, familyBA, key)
 						return state
@@ -92,11 +100,13 @@ export function findRelationsInStore<
 			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`
 			relations = {
 				get [keysAB]() {
+					// @ts-expect-error way too complicated to represent
 					const familyAB = myJoin.states[keysAB as any]
 					const state = findInStore(store, familyAB, key)
 					return state
 				},
 				get [keysBA]() {
+					// @ts-expect-error way too complicated to represent
 					const familyBA = myJoin.states[keysBA as any]
 					const state = findInStore(store, familyBA, key)
 					return state
@@ -107,11 +117,13 @@ export function findRelationsInStore<
 				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`
 				Object.assign(relations, {
 					get [entriesAB]() {
+						// @ts-expect-error way too complicated to represent
 						const familyAB = myJoin.states[entriesAB as any]
 						const state = findInStore(store, familyAB, key)
 						return state
 					},
 					get [entriesBA]() {
+						// @ts-expect-error way too complicated to represent
 						const familyBA = myJoin.states[entriesBA as any]
 						const state = findInStore(store, familyBA, key)
 						return state

package/internal/src/reserved-keys.ts

@@ -0,0 +1,7 @@
+export type ReservedIntrospectionKey = `🔍 ${string}`
+
+export function isReservedIntrospectionKey(
+	value: string,
+): value is ReservedIntrospectionKey {
+	return value.startsWith(`🔍 `)
+}

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

@@ -86,6 +86,7 @@ export const registerSelector = (
 		const state = withdraw(target, token)
 		setAtomOrSelector(target, state, value)
 	}) as typeof setState,
-	find: ((token, key) => findInStore(store, token, key)) as typeof findState,
+	find: ((...args: Parameters<typeof findState>) =>
+		findInStore(store, ...args)) as typeof findState,
 	json: (token) => getJsonToken(store, token),
 })

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

@@ -10,17 +10,18 @@ export function copyMutableIfNeeded<T extends Transceiver<any>>(
 	const originValue = origin.valueMap.get(atom.key)
 	const targetValue = target.valueMap.get(atom.key)
 
-	if (originValue === targetValue) {
-		if (originValue === undefined) {
-			return typeof atom.default === `function` ? atom.default() : atom.default
-		}
+	if (originValue !== targetValue) {
+		return targetValue
+	}
 
-		origin.logger.info(`📃`, `atom`, atom.key, `copying`)
-		const jsonValue = atom.toJson(originValue)
-		const copiedValue = atom.fromJson(jsonValue)
-		target.valueMap.set(atom.key, copiedValue)
-		new Tracker(atom, origin)
-		return copiedValue
+	if (originValue === undefined) {
+		return atom.default()
 	}
-	return targetValue
+
+	origin.logger.info(`📃`, `atom`, atom.key, `copying`)
+	const jsonValue = atom.toJson(originValue)
+	const copiedValue = atom.fromJson(jsonValue)
+	target.valueMap.set(atom.key, copiedValue)
+	new Tracker(atom, origin)
+	return copiedValue
 }

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

@@ -10,7 +10,7 @@ export const setAtomOrSelector = <T>(
 	switch (state.type) {
 		case `atom`:
 		case `mutable_atom`:
-			setAtom(state, value, store)
+			setAtom(store, state, value)
 			break
 		case `selector`:
 			state.set(value)

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

@@ -1,21 +1,21 @@
-import type { Atom } from ".."
+import type { KeyedStateUpdate } from "atom.io"
+
+import type { Atom, Store } from ".."
 import { isAtomDefault, markAtomAsNotDefault } from "../atom"
 import { cacheValue } from "../caching"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
-import type { Transceiver } from "../mutable"
+import { isTransceiver, type Transceiver } from "../mutable"
 import { markDone } from "../operation"
-import type { Store } from "../store"
-import { isChildStore, isRootStore } from "../transaction/is-root-store"
+import { isChildStore } from "../transaction/is-root-store"
 import { become } from "./become"
 import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
 import { emitUpdate } from "./emit-update"
 import { evictDownStream } from "./evict-downstream"
-import { stowUpdate } from "./stow-update"
 
 export const setAtom = <T>(
+	target: Store,
 	atom: Atom<T>,
 	next: T | ((oldValue: T) => T),
-	target: Store,
 ): void => {
 	const oldValue = readOrComputeValue(target, atom)
 	let newValue = oldValue
@@ -33,22 +33,44 @@ export const setAtom = <T>(
 	markDone(target, atom.key)
 	evictDownStream(target, atom)
 	const update = { oldValue, newValue }
-	if (isRootStore(target)) {
+	if (!isChildStore(target)) {
 		emitUpdate(target, atom, update)
-	} else if (target.parent) {
-		if (target.on.transactionApplying.state === null) {
-			stowUpdate(target, atom, update)
-		} else if (atom.key.startsWith(`*`)) {
-			const mutableKey = atom.key.slice(1)
-			const mutableAtom = target.atoms.get(mutableKey) as Atom<any>
-			let transceiver: Transceiver<any> = target.valueMap.get(mutableKey)
-			if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
-				const { parent } = target
-				const copiedValue = copyMutableIfNeeded(target, mutableAtom, parent)
-				transceiver = copiedValue
-			}
-			const accepted = transceiver.do(update.newValue) === null
-			if (accepted) evictDownStream(target, mutableAtom)
+		return
+	}
+	if (target.on.transactionApplying.state === null) {
+		const { key } = atom
+		if (isTransceiver(update.newValue)) {
+			return
+		}
+		const atomUpdate: KeyedStateUpdate<T> = {
+			type: `atom_update`,
+			key,
+			...update,
+		}
+		if (atom.family) {
+			atomUpdate.family = atom.family
+		}
+		target.transactionMeta.update.updates.push(atomUpdate)
+		target.logger.info(
+			`📁`,
+			`atom`,
+			key,
+			`stowed (`,
+			update.oldValue,
+			`->`,
+			update.newValue,
+			`)`,
+		)
+	} else if (atom.key.startsWith(`*`)) {
+		const mutableKey = atom.key.slice(1)
+		const mutableAtom = target.atoms.get(mutableKey) as Atom<any>
+		let transceiver: Transceiver<any> = target.valueMap.get(mutableKey)
+		if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
+			const { parent } = target
+			const copiedValue = copyMutableIfNeeded(target, mutableAtom, parent)
+			transceiver = copiedValue
 		}
+		const accepted = transceiver.do(update.newValue) === null
+		if (accepted) evictDownStream(target, mutableAtom)
 	}
 }

package/internal/src/store/store.ts

@@ -20,6 +20,7 @@ import type {
 	WritableSelector,
 	WritableSelectorFamily,
 } from ".."
+import { isReservedIntrospectionKey } from ".."
 import type { Join } from "../join"
 import { Junction } from "../junction"
 import type { Lineage } from "../lineage"
@@ -177,7 +178,7 @@ export class Store implements Lineage {
 	}
 
 	public loggers: AtomIOLogger[] = [
-		new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`🔍`)),
+		new AtomIOLogger(`warn`, (_, __, key) => !isReservedIntrospectionKey(key)),
 	]
 	public logger: Logger = {
 		error: (...messages) => {
@@ -249,15 +250,17 @@ export class Store implements Lineage {
 	}
 }
 
+declare global {
+	var ATOM_IO_IMPLICIT_STORE: Store | undefined
+}
+
 export const IMPLICIT = {
 	get STORE(): Store {
-		if (!globalThis.ATOM_IO_IMPLICIT_STORE) {
-			globalThis.ATOM_IO_IMPLICIT_STORE = new Store({
-				name: `IMPLICIT_STORE`,
-				lifespan: `ephemeral`,
-			})
-		}
-		return globalThis.ATOM_IO_IMPLICIT_STORE as Store
+		globalThis.ATOM_IO_IMPLICIT_STORE ??= new Store({
+			name: `IMPLICIT_STORE`,
+			lifespan: `ephemeral`,
+		})
+		return globalThis.ATOM_IO_IMPLICIT_STORE
 	},
 }
 

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

@@ -79,7 +79,8 @@ export const buildTransaction = (
 			}) as typeof setState,
 			run: (token, identifier = arbitrary()) =>
 				actUponStore(child, token, identifier),
-			find: ((token, k) => findInStore(child, token, k)) as typeof findState,
+			find: ((...ps: Parameters<typeof findState>) =>
+				findInStore(store, ...ps)) as typeof findState,
 			json: (token) => getJsonToken(child, token),
 			dispose: ((...ps: Parameters<typeof disposeState>) => {
 				disposeFromStore(child, ...ps)

package/internal/src/transaction/get-epoch-number.ts

@@ -1,26 +1,22 @@
 import type { Store } from "../store"
+import type { RootStore } from "./is-root-store"
 import { isRootStore } from "./is-root-store"
 
 export function getContinuityKey(
-	store: Store,
+	store: RootStore,
 	transactionKey: string,
 ): string | undefined {
-	const isRoot = isRootStore(store)
-	const continuity = isRoot
-		? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey)
-		: undefined
+	const continuity =
+		store.transactionMeta.actionContinuities.getRelatedKey(transactionKey)
+
 	return continuity
 }
 
 export function getEpochNumberOfContinuity(
-	store: Store,
+	store: RootStore,
 	continuityKey: string,
 ): number | undefined {
-	const isRoot = isRootStore(store)
-	const epoch =
-		isRoot && continuityKey
-			? store.transactionMeta.epoch.get(continuityKey)
-			: undefined
+	const epoch = store.transactionMeta.epoch.get(continuityKey)
 	return epoch
 }
 
@@ -29,12 +25,12 @@ export function getEpochNumberOfAction(
 	transactionKey: string,
 ): number | undefined {
 	const isRoot = isRootStore(store)
-	const continuity = isRoot
-		? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey)
-		: undefined
-	const epoch =
-		isRoot && continuity !== undefined
-			? store.transactionMeta.epoch.get(continuity)
-			: undefined
-	return epoch
+	if (!isRoot) {
+		return undefined
+	}
+	const continuityKey = getContinuityKey(store, transactionKey)
+	if (continuityKey === undefined) {
+		return undefined
+	}
+	return getEpochNumberOfContinuity(store, continuityKey)
 }

package/internal/src/transaction/set-epoch-number.ts

@@ -1,4 +1,5 @@
 import type { Store } from "../store"
+import { getContinuityKey } from "./get-epoch-number"
 import { isRootStore } from "./is-root-store"
 
 export function setEpochNumberOfContinuity(
@@ -21,8 +22,7 @@ export function setEpochNumberOfAction(
 	if (!isRoot) {
 		return
 	}
-	const continuityKey =
-		store.transactionMeta.actionContinuities.getRelatedKey(transactionKey)
+	const continuityKey = getContinuityKey(store, transactionKey)
 
 	if (continuityKey !== undefined) {
 		store.transactionMeta.epoch.set(continuityKey, newEpoch)

package/introspection/dist/index.js

@@ -1,3 +1,3 @@
-export { Auditor, Differ, Refinery, attachIntrospectionStates, diffArray, diffBoolean, diffNumber, diffObject, diffString, discoverType, isPlainObject, jsonRefinery, jsonTreeRefinery, prettyJson, primitiveRefinery, sprawl } from '../../dist/chunk-KMBRCA5Q.js';
-import '../../dist/chunk-RXQWAO26.js';
+export { Auditor, Differ, Refinery, attachIntrospectionStates, diffArray, diffBoolean, diffNumber, diffObject, diffString, discoverType, isPlainObject, jsonRefinery, jsonTreeRefinery, prettyJson, primitiveRefinery, sprawl } from '../../dist/chunk-Q6OOJWM4.js';
+import '../../dist/chunk-7SJVR7FZ.js';
 import '../../dist/chunk-XWL6SNVU.js';

package/introspection/src/attach-atom-index.ts

@@ -4,6 +4,7 @@ import {
 	createRegularAtom,
 	createStandaloneSelector,
 	deposit,
+	isReservedIntrospectionKey,
 } from "atom.io/internal"
 
 import type { WritableTokenIndex } from "."
@@ -20,21 +21,22 @@ export const attachAtomIndex = (
 			default: () => {
 				const base: AtomTokenIndex = new Map()
 				for (const [key, val] of store.atoms) {
-					if (!key.includes(`🔍`)) {
-						const token = deposit(val)
-						if (val.family) {
-							let familyNode = base.get(val.family.key)
-							if (!familyNode || !(`familyMembers` in familyNode)) {
-								familyNode = {
-									key: val.family.key,
-									familyMembers: new Map(),
-								}
-								base.set(val.family.key, familyNode)
+					if (isReservedIntrospectionKey(key)) {
+						continue
+					}
+					const token = deposit(val)
+					if (val.family) {
+						let familyNode = base.get(val.family.key)
+						if (!familyNode || !(`familyMembers` in familyNode)) {
+							familyNode = {
+								key: val.family.key,
+								familyMembers: new Map(),
 							}
-							familyNode.familyMembers.set(val.family.subKey, token)
-						} else {
-							base.set(key, token)
+							base.set(val.family.key, familyNode)
 						}
+						familyNode.familyMembers.set(val.family.subKey, token)
+					} else {
+						base.set(key, token)
 					}
 				}
 				return base
@@ -42,7 +44,7 @@ export const attachAtomIndex = (
 			effects: [
 				({ setSelf }) => {
 					store.on.atomCreation.subscribe(`introspection`, (atomToken) => {
-						if (atomToken.key.includes(`🔍`)) {
+						if (isReservedIntrospectionKey(atomToken.key)) {
 							return
 						}
 

package/introspection/src/attach-selector-index.ts

@@ -4,6 +4,7 @@ import {
 	createRegularAtom,
 	createStandaloneSelector,
 	deposit,
+	isReservedIntrospectionKey,
 } from "atom.io/internal"
 
 import type { WritableTokenIndex } from "."
@@ -23,21 +24,22 @@ export const attachSelectorIndex = (
 					const base: SelectorTokenIndex = new Map()
 					for (const map of [store.readonlySelectors, store.selectors]) {
 						for (const [key, val] of map) {
-							if (!key.includes(`🔍`)) {
-								const token = deposit(val)
-								if (val.family) {
-									let familyNode = base.get(val.family.key)
-									if (!familyNode || !(`familyMembers` in familyNode)) {
-										familyNode = {
-											key: val.family.key,
-											familyMembers: new Map(),
-										}
-										base.set(val.family.key, familyNode)
+							if (isReservedIntrospectionKey(key)) {
+								continue
+							}
+							const token = deposit(val)
+							if (val.family) {
+								let familyNode = base.get(val.family.key)
+								if (!familyNode || !(`familyMembers` in familyNode)) {
+									familyNode = {
+										key: val.family.key,
+										familyMembers: new Map(),
 									}
-									familyNode.familyMembers.set(val.family.subKey, token)
-								} else {
-									base.set(key, token)
+									base.set(val.family.key, familyNode)
 								}
+								familyNode.familyMembers.set(val.family.subKey, token)
+							} else {
+								base.set(key, token)
 							}
 						}
 					}
@@ -48,7 +50,7 @@ export const attachSelectorIndex = (
 						store.on.selectorCreation.subscribe(
 							`introspection`,
 							(selectorToken) => {
-								if (selectorToken.key.includes(`🔍`)) {
+								if (isReservedIntrospectionKey(selectorToken.key)) {
 									return
 								}
 

package/json/dist/index.js

@@ -1,2 +1,2 @@
-export { JSON_DEFAULTS, JSON_TYPE_NAMES, fromEntries, isJson, parseJson, selectJson, selectJsonFamily, stringifyJson, toEntries } from '../../dist/chunk-RXQWAO26.js';
+export { JSON_DEFAULTS, JSON_TYPE_NAMES, fromEntries, isJson, parseJson, selectJson, selectJsonFamily, stringifyJson, toEntries } from '../../dist/chunk-7SJVR7FZ.js';
 import '../../dist/chunk-XWL6SNVU.js';