atom.io 0.40.0 → 0.40.2

package/src/internal/store/withdraw.ts

@@ -72,15 +72,18 @@ import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
 import type { Store } from "./store"
 
-export function withdraw<T>(
+export function withdraw<T, E>(
 	store: Store,
-	token: RegularAtomToken<T>,
-): RegularAtom<T>
+	token: RegularAtomToken<T, any, E>,
+): RegularAtom<T, E>
 export function withdraw<T extends Transceiver<any, any, any>>(
 	store: Store,
 	token: MutableAtomToken<T, any>,
 ): MutableAtom<T>
-export function withdraw<T>(store: Store, token: AtomToken<T>): Atom<T>
+export function withdraw<T, E>(
+	store: Store,
+	token: AtomToken<T, any, E>,
+): Atom<T, E>
 export function withdraw<T>(
 	store: Store,
 	token: WritableHeldSelectorToken<T>,
@@ -89,52 +92,55 @@ export function withdraw<T>(
 	store: Store,
 	token: ReadonlyHeldSelectorToken<T>,
 ): ReadonlyHeldSelector<T>
-export function withdraw<T>(
+export function withdraw<T, E>(
 	store: Store,
-	token: WritablePureSelectorToken<T>,
-): WritablePureSelector<T>
-export function withdraw<T>(
+	token: WritablePureSelectorToken<T, any, E>,
+): WritablePureSelector<T, E>
+export function withdraw<T, E>(
 	store: Store,
-	token: ReadonlyPureSelectorToken<T>,
-): ReadonlyPureSelector<T>
-export function withdraw<T>(
+	token: ReadonlyPureSelectorToken<T, any, E>,
+): ReadonlyPureSelector<T, E>
+export function withdraw<T, E>(
 	store: Store,
-	token: ReadonlySelectorToken<T>,
-): ReadonlySelector<T>
-export function withdraw<T>(
+	token: ReadonlySelectorToken<T, any, E>,
+): ReadonlySelector<T, E>
+export function withdraw<T, E>(
 	store: Store,
-	token: WritableSelectorToken<T>,
-): WritableSelector<T>
+	token: WritableSelectorToken<T, any, E>,
+): WritableSelector<T, E>
 export function withdraw<T>(
 	store: Store,
 	token: HeldSelectorToken<T>,
 ): HeldSelector<T>
-export function withdraw<T>(
+export function withdraw<T, E>(
 	store: Store,
-	token: PureSelectorToken<T>,
-): PureSelector<T>
-export function withdraw<T>(store: Store, token: SelectorToken<T>): Selector<T>
-export function withdraw<T>(
+	token: PureSelectorToken<T, any, E>,
+): PureSelector<T, E>
+export function withdraw<T, E>(
 	store: Store,
-	token: WritableToken<T>,
-): WritableState<T>
-export function withdraw<T>(
+	token: SelectorToken<T, any, E>,
+): Selector<T, E>
+export function withdraw<T, E>(
 	store: Store,
-	token: ReadableToken<T>,
-): ReadableState<T>
+	token: WritableToken<T, any, E>,
+): WritableState<T, E>
+export function withdraw<T, E>(
+	store: Store,
+	token: ReadableToken<T, any, E>,
+): ReadableState<T, E>
 
-export function withdraw<T, K extends Canonical>(
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: RegularAtomFamilyToken<T, K>,
-): RegularAtomFamily<T, K>
+	token: RegularAtomFamilyToken<T, K, E>,
+): RegularAtomFamily<T, K, E>
 export function withdraw<
 	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 >(store: Store, token: MutableAtomFamilyToken<T, K>): MutableAtomFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: AtomFamilyToken<T, K>,
-): AtomFamily<T, K>
+	token: AtomFamilyToken<T, K, E>,
+): AtomFamily<T, K, E>
 export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: ReadonlyHeldSelectorFamilyToken<T, K>,
@@ -143,42 +149,42 @@ export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: WritableHeldSelectorFamilyToken<T, K>,
 ): WritableHeldSelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: ReadonlyPureSelectorFamilyToken<T, K>,
-): ReadonlyPureSelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+	token: ReadonlyPureSelectorFamilyToken<T, K, E>,
+): ReadonlyPureSelectorFamily<T, K, E>
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: WritablePureSelectorFamilyToken<T, K>,
-): WritablePureSelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+	token: WritablePureSelectorFamilyToken<T, K, E>,
+): WritablePureSelectorFamily<T, K, E>
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: ReadonlySelectorFamilyToken<T, K>,
-): ReadonlySelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+	token: ReadonlySelectorFamilyToken<T, K, E>,
+): ReadonlySelectorFamily<T, K, E>
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: WritableSelectorFamilyToken<T, K>,
-): WritableSelectorFamily<T, K>
+	token: WritableSelectorFamilyToken<T, K, E>,
+): WritableSelectorFamily<T, K, E>
 export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: HeldSelectorFamilyToken<T, K>,
 ): HeldSelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: PureSelectorFamilyToken<T, K>,
-): PureSelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+	token: PureSelectorFamilyToken<T, K, E>,
+): PureSelectorFamily<T, K, E>
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: SelectorFamilyToken<T, K>,
-): SelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+	token: SelectorFamilyToken<T, K, E>,
+): SelectorFamily<T, K, E>
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: WritableFamilyToken<T, K>,
-): WritableFamily<T, K>
-export function withdraw<T, K extends Canonical>(
+	token: WritableFamilyToken<T, K, E>,
+): WritableFamily<T, K, E>
+export function withdraw<T, K extends Canonical, E>(
 	store: Store,
-	token: ReadableFamilyToken<T, K>,
-): ReadableFamily<T, K>
+	token: ReadableFamilyToken<T, K, E>,
+): ReadableFamily<T, K, E>
 
 export function withdraw<T extends Fn>(
 	store: Store,
@@ -189,14 +195,14 @@ export function withdraw<T>(
 	token: TimelineToken<T>,
 ): Timeline<T extends TimelineManageable ? T : never>
 
-export function withdraw<T>(
+export function withdraw<T, E>(
 	store: Store,
-	token: WritableToken<T>,
-): WritableState<T>
-export function withdraw<T>(
+	token: WritableToken<T, any, E>,
+): WritableState<T, E>
+export function withdraw<T, E>(
 	store: Store,
-	token: ReadableToken<T>,
-): ReadableState<T>
+	token: ReadableToken<T, any, E>,
+): ReadableState<T, E>
 
 export function withdraw(
 	store: Store,

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

@@ -2,7 +2,10 @@ import type { ReadableState } from ".."
 import { newest } from "../lineage"
 import type { Store } from "../store"
 
-export const recallState = <T>(store: Store, state: ReadableState<T>): T => {
+export const recallState = <T, E>(
+	store: Store,
+	state: ReadableState<T, E>,
+): T => {
 	const target = newest(store)
 	if (target.operation.open) {
 		return target.operation.prev.get(state.key)

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

@@ -5,8 +5,8 @@ import { recallState } from "./recall-state"
 
 export const subscribeToRootDependency = (
 	target: Store,
-	selector: Selector<any>,
-	atom: Atom<any>,
+	selector: Selector<any, any>,
+	atom: Atom<any, any>,
 ): (() => void) => {
 	return atom.subject.subscribe(
 		`${selector.type}:${selector.key}`,

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

@@ -7,11 +7,11 @@ import type { Store } from "../store"
 import { withdraw } from "../store"
 import { subscribeToRootDependency } from "./subscribe-to-root-atoms"
 
-export function subscribeToState<T>(
+export function subscribeToState<T, E>(
 	store: Store,
-	token: ReadableToken<T>,
+	token: ReadableToken<T, any, E>,
 	key: string,
-	handleUpdate: UpdateHandler<T>,
+	handleUpdate: UpdateHandler<E | T>,
 ): () => void {
 	function safelyHandleUpdate(update: StateUpdate<any>): void {
 		if (store.operation.open) {
@@ -33,7 +33,7 @@ export function subscribeToState<T>(
 		state.type === `writable_pure_selector` ||
 		state.type === `readonly_pure_selector`
 	const rootSubs = new Map<string, () => void>()
-	let updateHandler: UpdateHandler<T> = safelyHandleUpdate
+	let updateHandler: UpdateHandler<E | T> = safelyHandleUpdate
 	if (isSelector) {
 		readOrComputeValue(store, state)
 		for (const [atomKey, atom] of traceRootSelectorAtoms(store, state.key)) {

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

@@ -21,6 +21,7 @@ import { newest } from "../lineage"
 import { getUpdateToken } from "../mutable"
 import { deposit, type Store, withdraw } from "../store"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 import { isChildStore } from "../transaction"
 
 export type Timeline<ManagedAtom extends TimelineManageable> = {
@@ -31,13 +32,13 @@ export type Timeline<ManagedAtom extends TimelineManageable> = {
 	history: TimelineEvent<ManagedAtom>[]
 	selectorTime: number | null
 	transactionKey: string | null
-	install: (store: Store) => void
+	install: (store: RootStore) => void
 	subject: Subject<TimelineEvent<ManagedAtom> | `redo` | `undo`>
 	subscriptions: Map<string, () => void>
 }
 
 export function createTimeline<ManagedAtom extends TimelineManageable>(
-	store: Store,
+	store: RootStore,
 	options: TimelineOptions<ManagedAtom>,
 	data?: Timeline<ManagedAtom>,
 ): TimelineToken<ManagedAtom> {
@@ -62,7 +63,7 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 			case `atom`:
 			case `mutable_atom`:
 				{
-					const atomToken: AtomToken<ManagedAtom> = initialTopic
+					const atomToken: AtomToken<any, any, any> = initialTopic
 					const atomKey = atomToken.key
 					let existingTimelineKey = target.timelineTopics.getRelatedKey(atomKey)
 					if (`family` in atomToken) {
@@ -94,7 +95,7 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 			case `atom_family`:
 			case `mutable_atom_family`:
 				{
-					const familyToken: AtomFamilyToken<any, any> = initialTopic
+					const familyToken: AtomFamilyToken<any, any, any> = initialTopic
 					const familyKey = familyToken.key
 					const existingTimelineKey =
 						target.timelineTopics.getRelatedKey(familyKey)
@@ -124,7 +125,7 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 
 function addAtomToTimeline(
 	store: Store,
-	atomToken: AtomToken<any>,
+	atomToken: AtomToken<any, any, any>,
 	tl: Timeline<any>,
 ): void {
 	reduceReference(store, atomToken)
@@ -191,7 +192,7 @@ function addAtomToTimeline(
 						tl.selectorTime = null
 
 						const atomUpdate: AtomUpdateEvent<any> & TimelineEvent<any> = {
-							write: true,
+							checkpoint: true,
 							type: `atom_update`,
 							token: deposit(atom),
 							update,
@@ -213,7 +214,7 @@ function addAtomToTimeline(
 
 function addAtomFamilyToTimeline(
 	store: Store,
-	atomFamilyToken: AtomFamilyToken<any, any>,
+	atomFamilyToken: AtomFamilyToken<any, any, any>,
 	tl: Timeline<any>,
 ): void {
 	const family = withdraw(store, atomFamilyToken)
@@ -267,7 +268,7 @@ function joinTransaction(
 
 					const timelineTransactionUpdate: TimelineEvent<any> &
 						TransactionOutcomeEvent<TransactionToken<any>> = {
-						write: true,
+						checkpoint: true,
 						...transactionUpdate,
 						subEvents: subEventsFiltered,
 					}
@@ -282,7 +283,7 @@ function joinTransaction(
 function buildSelectorUpdate(
 	store: Store,
 	tl: Timeline<any>,
-	atomToken: AtomToken<any>,
+	atomToken: AtomToken<any, any, any>,
 	eventOrUpdate: StateCreationEvent<any> | StateUpdate<any>,
 	currentSelectorToken: WritablePureSelectorToken<any>,
 	currentSelectorTime: number,
@@ -291,7 +292,7 @@ function buildSelectorUpdate(
 	if (currentSelectorTime !== tl.selectorTime) {
 		const selectorUpdate: TimelineEvent<any> & TimelineSelectorUpdateEvent<any> =
 			(latestUpdate = {
-				write: true,
+				checkpoint: true,
 				type: `selector_update`,
 				timestamp: currentSelectorTime,
 				token: currentSelectorToken,

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

@@ -52,7 +52,10 @@ export const timeTravel = (
 	switch (action) {
 		case `undo`:
 			--nextIndex
-			while (nextIndex !== 0 && timelineData.history[nextIndex].write !== true) {
+			while (
+				nextIndex !== 0 &&
+				timelineData.history[nextIndex].checkpoint !== true
+			) {
 				--nextIndex
 			}
 			events = timelineData.history.slice(nextIndex, timelineData.at).reverse()
@@ -88,8 +91,6 @@ export const timeTravel = (
 				ingestDisposalEvent(store, event, applying)
 				break
 			}
-			case `molecule_creation`:
-			case `molecule_disposal`:
 		}
 	}
 

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

@@ -1,19 +1,7 @@
-import { newest } from "../lineage"
-import type { Store } from "../store"
-import { isChildStore } from "./is-root-store"
+import type { ChildStore } from "./is-root-store"
 
-export const abortTransaction = (store: Store): void => {
-	const target = newest(store)
-	if (!isChildStore(target)) {
-		store.logger.warn(
-			`🐞`,
-			`transaction`,
-			`???`,
-			`abortTransaction called outside of a transaction. This is probably a bug in AtomIO.`,
-		)
-		return
-	}
-	store.logger.info(
+export const abortTransaction = (target: ChildStore): void => {
+	target.logger.info(
 		`🪂`,
 		`transaction`,
 		target.transactionMeta.update.token.key,

package/src/internal/transaction/act-upon-store.ts

@@ -1,6 +1,5 @@
 import type { TransactionToken } from "atom.io"
 
-import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 import type { Fn } from "../utility-types"
@@ -12,9 +11,6 @@ export function actUponStore<F extends Fn>(
 ): (...parameters: Parameters<F>) => ReturnType<F> {
 	return (...parameters: Parameters<F>): ReturnType<F> => {
 		const tx = withdraw(store, token)
-		if (tx) {
-			return tx.run(parameters, id)
-		}
-		throw new NotFoundError(token, store)
+		return tx.run(parameters, id)
 	}
 }

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

@@ -1,30 +1,18 @@
 import { ingestTransactionOutcomeEvent } from "../events"
 import { newest } from "../lineage"
-import type { Store } from "../store"
 import { withdraw } from "../store"
 import type { Fn } from "../utility-types"
+import type { ChildStore } from "./is-root-store"
 import { isChildStore, isRootStore } from "./is-root-store"
 import { setEpochNumberOfAction } from "./set-epoch-number"
 
 export function applyTransaction<F extends Fn>(
-	store: Store,
+	store: ChildStore,
 	output: ReturnType<F>,
 ): void {
 	const child = newest(store)
 	const { parent } = child
-	if (
-		parent === null ||
-		!isChildStore(child) ||
-		child.transactionMeta?.phase !== `building`
-	) {
-		store.logger.warn(
-			`🐞`,
-			`transaction`,
-			`???`,
-			`applyTransaction called outside of a transaction. This is probably a bug in AtomIO.`,
-		)
-		return
-	}
+
 	child.transactionMeta.phase = `applying`
 	child.transactionMeta.update.output = output
 	parent.child = null

package/src/internal/transaction/assign-transaction-to-continuity.ts

@@ -1,15 +1,10 @@
-import type { Store } from "../store"
-import { isRootStore } from "./is-root-store"
+import type { RootStore } from "./is-root-store"
 
 export function assignTransactionToContinuity(
-	store: Store,
+	store: RootStore,
 	continuityKey: string,
 	transactionKey: string,
 ): void {
-	const isRoot = isRootStore(store)
-	if (!isRoot) {
-		return
-	}
 	const { epoch, actionContinuities } = store.transactionMeta
 	actionContinuities.set(continuityKey, transactionKey)
 	if (!epoch.has(continuityKey)) {

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

@@ -15,19 +15,18 @@ import { newest } from "../lineage"
 import { getJsonToken } from "../mutable"
 import { MapOverlay } from "../overlays/map-overlay"
 import { resetInStore, setIntoStore } from "../set-state"
-import type { Store } from "../store"
 import type { Fn } from "../utility-types"
 import type { TransactionProgress } from "."
 import { actUponStore, getEpochNumberOfAction } from "."
 import type { ChildStore, RootStore } from "./is-root-store"
 
 export const buildTransaction = (
-	store: Store,
+	store: RootStore,
 	token: TransactionToken<any>,
 	params: any[],
 	id: string,
 ): ChildStore => {
-	const parent = newest(store) as ChildStore | RootStore
+	const parent = newest(store)
 	const childBase: Omit<ChildStore, `transactionMeta`> = {
 		parent,
 		child: null,

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

@@ -5,24 +5,24 @@ import type {
 } from "atom.io"
 
 import { newest } from "../lineage"
-import type { Store } from "../store"
 import { deposit } from "../store"
 import { Subject } from "../subject"
 import type { Fn } from "../utility-types"
 import { abortTransaction } from "./abort-transaction"
 import { applyTransaction } from "./apply-transaction"
 import { buildTransaction } from "./build-transaction"
+import type { RootStore } from "./is-root-store"
 
 export type Transaction<F extends Fn> = {
 	key: string
 	type: `transaction`
-	install: (store: Store) => void
+	install: (store: RootStore) => void
 	subject: Subject<TransactionOutcomeEvent<TransactionToken<F>>>
 	run: (parameters: Parameters<F>, id?: string) => ReturnType<F>
 }
 
 export function createTransaction<F extends Fn>(
-	store: Store,
+	store: RootStore,
 	options: TransactionOptions<F>,
 ): TransactionToken<F> {
 	const { key } = options
@@ -32,10 +32,9 @@ export function createTransaction<F extends Fn>(
 		type: `transaction`,
 		run: (params: Parameters<F>, id: string) => {
 			const token = deposit(newTransaction)
-			const childStore = buildTransaction(store, token, params, id)
+			const target = buildTransaction(store, token, params, id)
 			try {
-				const target = newest(store)
-				const { toolkit } = childStore.transactionMeta
+				const { toolkit } = target.transactionMeta
 				const output = options.do(toolkit, ...params)
 				applyTransaction<F>(target, output)
 				return output

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

@@ -1,6 +1,4 @@
-import type { Store } from "../store"
 import type { RootStore } from "./is-root-store"
-import { isRootStore } from "./is-root-store"
 
 export function getContinuityKey(
 	store: RootStore,
@@ -21,13 +19,9 @@ export function getEpochNumberOfContinuity(
 }
 
 export function getEpochNumberOfAction(
-	store: Store,
+	store: RootStore,
 	transactionKey: string,
 ): number | undefined {
-	const isRoot = isRootStore(store)
-	if (!isRoot) {
-		return undefined
-	}
 	const continuityKey = getContinuityKey(store, transactionKey)
 	if (continuityKey === undefined) {
 		return undefined

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

@@ -1,27 +1,19 @@
-import type { Store } from "../store"
 import { getContinuityKey } from "./get-epoch-number"
-import { isRootStore } from "./is-root-store"
+import type { RootStore } from "./is-root-store"
 
 export function setEpochNumberOfContinuity(
-	store: Store,
+	store: RootStore,
 	continuityKey: string,
 	newEpoch: number,
 ): void {
-	const isRoot = isRootStore(store)
-	if (isRoot && continuityKey) {
-		store.transactionMeta.epoch.set(continuityKey, newEpoch)
-	}
+	store.transactionMeta.epoch.set(continuityKey, newEpoch)
 }
 
 export function setEpochNumberOfAction(
-	store: Store,
+	store: RootStore,
 	transactionKey: string,
 	newEpoch: number,
 ): void {
-	const isRoot = isRootStore(store)
-	if (!isRoot) {
-		return
-	}
 	const continuityKey = getContinuityKey(store, transactionKey)
 
 	if (continuityKey !== undefined) {

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

@@ -8,10 +8,10 @@ import {
 
 import type { WritableTokenIndex } from "."
 
-export type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>
+export type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown, any, unknown>>
 
 export const attachAtomIndex = (store: Store): AtomToken<AtomTokenIndex> => {
-	return createRegularAtom<AtomTokenIndex>(
+	return createRegularAtom<AtomTokenIndex, never, never>(
 		store,
 		{
 			key: `🔍 Atom Token Index`,

package/src/introspection/attach-introspection-states.ts

@@ -6,7 +6,7 @@ import type {
 	TransactionOutcomeEvent,
 	TransactionToken,
 } from "atom.io"
-import type { Fn, Store, Timeline } from "atom.io/internal"
+import type { Fn, RootStore, Store, Timeline } from "atom.io/internal"
 
 import { type AtomTokenIndex, attachAtomIndex } from "./attach-atom-index"
 import type { SelectorTokenIndex } from "./attach-selector-index"
@@ -30,7 +30,9 @@ export type IntrospectionStates = {
 	typeSelectors: ReadonlyPureSelectorFamilyToken<Loadable<string>, string>
 }
 
-export const attachIntrospectionStates = (store: Store): IntrospectionStates => {
+export const attachIntrospectionStates = (
+	store: RootStore,
+): IntrospectionStates => {
 	return {
 		atomIndex: attachAtomIndex(store),
 		selectorIndex: attachSelectorIndex(store),

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

@@ -8,12 +8,14 @@ import {
 
 import type { WritableTokenIndex } from "."
 
-export type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>
+export type SelectorTokenIndex = WritableTokenIndex<
+	SelectorToken<unknown, any, any>
+>
 
 export const attachSelectorIndex = (
 	store: Store,
 ): AtomToken<SelectorTokenIndex> => {
-	return createRegularAtom<SelectorTokenIndex>(
+	return createRegularAtom<SelectorTokenIndex, never, never>(
 		store,
 		{
 			key: `🔍 Selector Token Index`,