atom.io 0.40.0 → 0.40.1

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> {
@@ -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,
@@ -267,7 +268,7 @@ function joinTransaction(
 
 					const timelineTransactionUpdate: TimelineEvent<any> &
 						TransactionOutcomeEvent<TransactionToken<any>> = {
-						write: true,
+						checkpoint: true,
 						...transactionUpdate,
 						subEvents: subEventsFiltered,
 					}
@@ -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-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-timeline-family.ts

@@ -1,5 +1,5 @@
 import type { ReadonlyPureSelectorFamilyToken } from "atom.io"
-import type { Store, Timeline } from "atom.io/internal"
+import type { RootStore, Timeline } from "atom.io/internal"
 import {
 	createRegularAtomFamily,
 	createSelectorFamily,
@@ -7,7 +7,7 @@ import {
 } from "atom.io/internal"
 
 export const attachTimelineFamily = (
-	store: Store,
+	store: RootStore,
 ): ReadonlyPureSelectorFamilyToken<Timeline<any>, string> => {
 	const findTimelineLogState__INTERNAL = createRegularAtomFamily<
 		Timeline<any>,

package/src/introspection/attach-transaction-logs.ts

@@ -3,11 +3,11 @@ import type {
 	TransactionOutcomeEvent,
 	TransactionToken,
 } from "atom.io"
-import type { Store } from "atom.io/internal"
+import type { RootStore } from "atom.io/internal"
 import { createRegularAtomFamily, createSelectorFamily } from "atom.io/internal"
 
 export const attachTransactionLogs = (
-	store: Store,
+	store: RootStore,
 ): ReadonlyPureSelectorFamilyToken<
 	TransactionOutcomeEvent<TransactionToken<any>>[],
 	string

package/src/introspection/attach-type-selectors.ts

@@ -1,11 +1,11 @@
 import type { Loadable, ReadonlyPureSelectorFamilyToken } from "atom.io"
-import type { Store } from "atom.io/internal"
+import type { RootStore } from "atom.io/internal"
 import { createReadonlyPureSelectorFamily } from "atom.io/internal"
 
 import { discoverType } from "./refinery"
 
 export const attachTypeSelectors = (
-	store: Store,
+	store: RootStore,
 ): ReadonlyPureSelectorFamilyToken<Loadable<string>, string> => {
 	const typeSelectors = createReadonlyPureSelectorFamily<
 		Loadable<string>,

package/src/main/dispose-state.ts

@@ -30,9 +30,5 @@ export function disposeState(
 		| [token: ReadableFamilyToken<any, any>, key: Canonical]
 		| [token: ReadableToken<any>]
 ): void {
-	if (params.length === 2) {
-		disposeFromStore(IMPLICIT.STORE, ...params)
-	} else {
-		disposeFromStore(IMPLICIT.STORE, ...params)
-	}
+	disposeFromStore(IMPLICIT.STORE, ...params)
 }

package/src/main/events.ts

@@ -114,11 +114,9 @@ export type TransactionOutcomeEvent<T extends TransactionToken<any>> = {
 }
 
 export type TimelineEvent<ManagedAtom extends TimelineManageable> = {
-	write?: true
+	checkpoint?: true
 } & (
 	| AtomUpdateEvent<AtomOnly<ManagedAtom>>
-	| MoleculeCreationEvent
-	| MoleculeDisposalEvent
 	| StateCreationEvent<AtomOnly<ManagedAtom>>
 	| StateDisposalEvent<AtomOnly<ManagedAtom>>
 	| TimelineSelectorUpdateEvent<ManagedAtom>

package/src/main/get-state.ts

@@ -25,13 +25,10 @@ export function getState<T, K extends Canonical, Key extends K>(
 	key: Key,
 ): ViewOf<T>
 
-export function getState(
+export function getState<T, K extends Canonical, Key extends K>(
 	...params:
-		| [token: ReadableFamilyToken<any, any>, key: Canonical]
-		| [token: ReadableToken<any>]
+		| [token: ReadableFamilyToken<T, K>, key: Key]
+		| [token: ReadableToken<T>]
 ): any {
-	if (params.length === 2) {
-		return getFromStore(IMPLICIT.STORE, ...params)
-	}
 	return getFromStore(IMPLICIT.STORE, ...params)
 }

package/src/main/realm.ts

@@ -1,24 +1,39 @@
-import type { Each, Store } from "atom.io/internal"
+import type { Each, RootStore } from "atom.io/internal"
 import {
+	actUponStore,
 	allocateIntoStore,
+	arbitrary,
 	claimWithinStore,
-	deallocateFromStore,
+	createClaimTX,
+	createDeallocateTX,
 	fuseWithinStore,
 	IMPLICIT,
 	makeRootMoleculeInStore,
 } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
 
+import type { TransactionToken } from "./tokens"
+
 export const $claim: unique symbol = Symbol.for(`claim`)
 export type Claim<K extends Canonical> = K & { [$claim]?: true }
 
 export class Realm<H extends Hierarchy> {
-	public store: Store
+	public store: RootStore
+	public deallocateTX: TransactionToken<(claim: Claim<Vassal<H>>) => void>
+	public claimTX: TransactionToken<
+		<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(
+			newProvenance: A,
+			claim: Claim<V>,
+			exclusive?: `exclusive`,
+		) => void
+	>
 	/**
 	 * @param store - The store to which the realm will be attached
 	 */
-	public constructor(store: Store = IMPLICIT.STORE) {
+	public constructor(store: RootStore = IMPLICIT.STORE) {
 		this.store = store
+		this.deallocateTX = createDeallocateTX(store)
+		this.claimTX = createClaimTX(store)
 		makeRootMoleculeInStore(`root`, store)
 	}
 	/**
@@ -66,7 +81,7 @@ export class Realm<H extends Hierarchy> {
 	 * @param claim - The subject to be deallocated
 	 */
 	public deallocate<V extends Vassal<H>>(claim: Claim<V>): void {
-		deallocateFromStore<H, V>(this.store, claim)
+		actUponStore(this.store, this.deallocateTX, arbitrary())(claim)
 	}
 	/**
 	 * Transfer a subject of the realm from one owner to another
@@ -79,21 +94,30 @@ export class Realm<H extends Hierarchy> {
 	public claim<
 		V extends Exclude<Vassal<H>, CompoundTypedKey>,
 		A extends Above<V, H>,
-	>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V> {
-		return claimWithinStore<H, V, A>(this.store, newProvenance, claim, exclusive)
+	>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): void {
+		actUponStore(this.store, this.claimTX, arbitrary())(
+			newProvenance,
+			claim,
+			exclusive,
+		)
 	}
 }
 
 export class Anarchy {
-	public store: Store
-	public realm: Realm<any>
+	public store: RootStore
+	public deallocateTX: TransactionToken<(key: Canonical) => void>
+	public claimTX: TransactionToken<
+		(newProvenance: Canonical, key: Canonical, exclusive?: `exclusive`) => void
+	>
 
 	/**
 	 * @param store - The store to which the anarchy-realm will be attached
 	 */
-	public constructor(store: Store = IMPLICIT.STORE) {
+	public constructor(store: RootStore = IMPLICIT.STORE) {
 		this.store = store
-		this.realm = new Realm(store)
+		this.deallocateTX = createDeallocateTX(store)
+		this.claimTX = createClaimTX(store)
+		makeRootMoleculeInStore(`root`, store)
 	}
 	/**
 	 * Declare a new entity
@@ -118,7 +142,7 @@ export class Anarchy {
 	 * @param key - The entity to be deallocated
 	 */
 	public deallocate(key: Canonical): void {
-		deallocateFromStore<any, any>(this.store, key)
+		actUponStore(this.store, this.deallocateTX, arbitrary())(key)
 	}
 	/**
 	 * Transfer an entity from one owner to another

package/src/main/reset-state.ts

@@ -25,9 +25,5 @@ export function resetState(
 		| [token: WritableFamilyToken<any, Canonical>, key: Canonical]
 		| [token: WritableToken<any>]
 ): void {
-	if (params.length === 2) {
-		resetInStore(IMPLICIT.STORE, ...params)
-	} else {
-		resetInStore(IMPLICIT.STORE, ...params)
-	}
+	resetInStore(IMPLICIT.STORE, ...params)
 }

package/src/main/set-state.ts

@@ -35,18 +35,11 @@ export function setState<T, K extends Canonical, New extends T, Key extends K>(
 	key: Key,
 	value: New | Setter<T, New>,
 ): void
-export function setState<T, New extends T>(
+
+export function setState<T, K extends Canonical, New extends T, Key extends K>(
 	...params:
-		| [
-				token: WritableFamilyToken<T, Canonical>,
-				key: Canonical,
-				value: New | Setter<T, New>,
-		  ]
+		| [token: WritableFamilyToken<T, K>, key: Key, value: New | Setter<T, New>]
 		| [token: WritableToken<T>, value: New | Setter<T, New>]
 ): void {
-	if (params.length === 2) {
-		setIntoStore(IMPLICIT.STORE, ...params)
-	} else {
-		setIntoStore(IMPLICIT.STORE, ...params)
-	}
+	setIntoStore(IMPLICIT.STORE, ...params)
 }

package/src/main/silo.ts

@@ -1,4 +1,5 @@
 import type { findState } from "atom.io"
+import type { RootStore } from "atom.io/internal"
 import {
 	actUponStore,
 	arbitrary,
@@ -38,7 +39,7 @@ import type { selector, selectorFamily } from "./selector"
 import type { runTransaction, transaction } from "./transaction"
 
 export class Silo {
-	public store: Store
+	public store: RootStore
 	public atom: typeof atom
 	public mutableAtom: typeof mutableAtom
 	public atomFamily: typeof atomFamily
@@ -56,10 +57,10 @@ export class Silo {
 	public undo: typeof undo
 	public redo: typeof redo
 	public runTransaction: typeof runTransaction
-	public install: (tokens: AtomIOToken[], store?: Store) => void
+	public install: (tokens: AtomIOToken[], store?: RootStore) => void
 
 	public constructor(config: Store[`config`], fromStore: Store | null = null) {
-		const s = (this.store = new Store(config, fromStore))
+		const s = (this.store = new Store(config, fromStore) as RootStore)
 		this.atom = ((options: Parameters<typeof atom>[0]) =>
 			createRegularAtom(s, options, undefined)) as typeof atom
 		this.mutableAtom = ((options: Parameters<typeof mutableAtom>[0]) =>

package/src/react/store-context.tsx

@@ -1,14 +1,14 @@
-import type { Store } from "atom.io/internal"
+import type { RootStore } from "atom.io/internal"
 import { IMPLICIT } from "atom.io/internal"
 import * as React from "react"
 
-export const StoreContext: React.Context<Store> = React.createContext(
+export const StoreContext: React.Context<RootStore> = React.createContext(
 	IMPLICIT.STORE,
 )
 
 export const StoreProvider: React.FC<{
 	children: React.ReactNode
-	store?: Store
+	store?: RootStore
 }> = ({ children, store = IMPLICIT.STORE }) => (
 	<StoreContext.Provider value={store}>{children}</StoreContext.Provider>
 )

package/src/react-devtools/Button.tsx

@@ -1,9 +1,10 @@
-import type { Modify } from "atom.io/internal"
 import type { FC } from "react"
 
 export const OpenClose: FC<{
 	isOpen: boolean
-	setIsOpen?: ((next: Modify<boolean> | boolean) => void) | undefined
+	setIsOpen?:
+		| ((next: boolean | ((prev: boolean) => boolean)) => void)
+		| undefined
 	onShiftClick?: (
 		event: React.MouseEvent<HTMLButtonElement, MouseEvent>,
 	) => boolean

package/src/react-devtools/TimelineIndex.tsx

@@ -64,8 +64,6 @@ export const TimelineLog: FC<{
 			{isOpen ? (
 				<main>
 					{timeline.history.map((update, index) =>
-						update.type !== `molecule_creation` &&
-						update.type !== `molecule_disposal` &&
 						update.type !== `state_creation` &&
 						update.type !== `state_disposal` ? (
 							<Fragment key={update.token.key + index + timeline.at}>

package/src/react-devtools/store.ts

@@ -5,11 +5,11 @@ import type {
 	SelectorToken,
 	TransactionToken,
 } from "atom.io"
+import type { RootStore, Store } from "atom.io/internal"
 import {
 	createRegularAtom,
 	createRegularAtomFamily,
 	createTransaction,
-	type Store,
 } from "atom.io/internal"
 import type {
 	IntrospectionStates,
@@ -34,7 +34,7 @@ export type DevtoolsStates = {
 }
 
 export function attachDevtoolsStates(
-	store: Store,
+	store: RootStore,
 	hideByDefault = false,
 ): DevtoolsStates & IntrospectionStates & { store: Store } {
 	const introspectionStates = attachIntrospectionStates(store)

package/src/realtime-client/continuity/register-and-attempt-confirmed-update.ts

@@ -1,10 +1,9 @@
 import type * as AtomIO from "atom.io"
-import type { Fn, Store } from "atom.io/internal"
+import type { Fn, RootStore } from "atom.io/internal"
 import {
 	actUponStore,
 	getEpochNumberOfContinuity,
 	ingestTransactionOutcomeEvent,
-	isRootStore,
 	setEpochNumberOfContinuity,
 	setIntoStore,
 } from "atom.io/internal"
@@ -16,7 +15,7 @@ import type { Socket } from "atom.io/realtime-server"
 
 export const useRegisterAndAttemptConfirmedUpdate =
 	(
-		store: Store,
+		store: RootStore,
 		continuityKey: string,
 		socket: Socket,
 		optimisticUpdates: AtomIO.TransactionOutcomeEvent<
@@ -187,11 +186,8 @@ export const useRegisterAndAttemptConfirmedUpdate =
 				continuityKey,
 				`has no optimistic updates to deal with`,
 			)
-			const isRoot = isRootStore(store)
 			let continuityEpoch: number | undefined
-			if (isRoot) {
-				continuityEpoch = getEpochNumberOfContinuity(store, continuityKey)
-			}
+			continuityEpoch = getEpochNumberOfContinuity(store, continuityKey)
 
 			if (continuityEpoch === confirmed.epoch - 1) {
 				store.logger.info(
@@ -203,7 +199,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 				ingestTransactionOutcomeEvent(store, confirmed, `newValue`)
 				socket.emit(`ack:${continuityKey}`, confirmed.epoch)
 				setEpochNumberOfContinuity(store, continuityKey, confirmed.epoch)
-			} else if (isRoot && continuityEpoch !== undefined) {
+			} else if (continuityEpoch !== undefined) {
 				store.logger.info(
 					`🧑‍⚖️`,
 					`continuity`,