atom.io 0.16.3 → 0.18.0

package/internal/src/arbitrary.ts

@@ -0,0 +1,3 @@
+export function arbitrary(random: () => number = Math.random): string {
+	return random().toString(36).slice(2)
+}

package/internal/src/atom/create-regular-atom.ts

@@ -5,9 +5,8 @@ import type {
 	RegularAtomToken,
 	UpdateHandler,
 } from "atom.io"
-import { setState } from "atom.io"
 
-import type { RegularAtom } from ".."
+import { type RegularAtom, setIntoStore } from ".."
 import { cacheValue } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -69,7 +68,7 @@ export function createRegularAtom<T>(
 		const cleanupFunctions: (() => void)[] = []
 		for (const effect of options.effects) {
 			const cleanup = effect({
-				setSelf: (next) => setState(token, next, store),
+				setSelf: (next) => setIntoStore(token, next, store),
 				onSet: (handle: UpdateHandler<T>) =>
 					subscribeToState(token, handle, `effect[${effectIndex}]`, store),
 			})

package/internal/src/caching.ts

@@ -1,7 +1,7 @@
 import type { StateUpdate } from "atom.io"
-import type { ReadableState } from "."
+import { type ReadableState, isChildStore } from "."
 import { Future } from "./future"
-import { copyMutableIfWithinTransaction } from "./set-state/copy-mutable-in-transaction"
+import { copyMutableIfNeeded } from "./set-state/copy-mutable-if-needed"
 import type { Store } from "./store"
 import type { Subject } from "./subject"
 
@@ -53,10 +53,12 @@ export const readCachedValue = <T>(
 	token: ReadableState<any>,
 	target: Store,
 ): T => {
-	let value = target.valueMap.get(token.key) as T
-	if (token.type === `atom`) {
-		value = copyMutableIfWithinTransaction(value, token, target)
-	}
+	const value = target.valueMap.get(token.key) as T
+	// if (token.type === `mutable_atom` && isChildStore(target)) {
+	// 	const { parent } = target
+	// 	const copiedValue = copyMutableIfNeeded(token, parent, target)
+	// 	value = copiedValue
+	// }
 	return value
 }
 

package/internal/src/families/find-in-store.ts

@@ -1,6 +1,8 @@
 import type { Json } from "atom.io/json"
 
 import type {
+	AtomFamilyToken,
+	AtomToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
@@ -9,6 +11,8 @@ import type {
 	ReadonlySelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
+	SelectorFamilyToken,
+	SelectorToken,
 	WritableFamilyToken,
 	WritableSelectorFamilyToken,
 	WritableSelectorToken,
@@ -35,6 +39,12 @@ export function findInStore<T, K extends Json.Serializable, Key extends K>(
 	store: Store,
 ): RegularAtomToken<T>
 
+export function findInStore<T, K extends Json.Serializable, Key extends K>(
+	token: AtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): AtomToken<T>
+
 export function findInStore<T, K extends Json.Serializable, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
@@ -47,6 +57,12 @@ export function findInStore<T, K extends Json.Serializable, Key extends K>(
 	store: Store,
 ): ReadonlySelectorToken<T>
 
+export function findInStore<T, K extends Json.Serializable, Key extends K>(
+	token: SelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): SelectorToken<T>
+
 export function findInStore<T, K extends Json.Serializable, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,

package/internal/src/get-environment-data.ts

@@ -1,18 +1,15 @@
 import type { Store } from "./store"
 
 export type EnvironmentData = {
-	runtime: `browser` | `node` | `unknown`
+	window: typeof window | undefined
+	global: typeof global | undefined
 	store: Store
 }
 
 export function getEnvironmentData(store: Store): EnvironmentData {
 	return {
-		runtime:
-			typeof window === `undefined`
-				? typeof global === `object`
-					? `node`
-					: `unknown`
-				: `browser`,
+		window: typeof window === `undefined` ? undefined : window,
+		global: typeof global === `undefined` ? undefined : global,
 		store,
 	}
 }

package/internal/src/get-state/get-from-store.ts

@@ -0,0 +1,14 @@
+import type { ReadableToken } from "atom.io"
+
+import { NotFoundError } from "../not-found-error"
+import type { Store } from "../store"
+import { withdraw, withdrawNewFamilyMember } from "../store"
+import { readOrComputeValue } from "./read-or-compute-value"
+
+export function getFromStore<T>(token: ReadableToken<T>, store: Store): T {
+	const state = withdraw(token, store) ?? withdrawNewFamilyMember(token, store)
+	if (state === undefined) {
+		throw new NotFoundError(token, store)
+	}
+	return readOrComputeValue(state, store)
+}

package/internal/src/get-state/index.ts

@@ -0,0 +1,2 @@
+export * from "./get-from-store"
+export * from "./read-or-compute-value"

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

@@ -1,6 +1,6 @@
-import type { ReadableState } from "."
-import { readCachedValue } from "./caching"
-import type { Store } from "./store"
+import type { ReadableState } from ".."
+import { readCachedValue } from "../caching"
+import type { Store } from "../store"
 
 export const readOrComputeValue = <T>(
 	state: ReadableState<T>,

package/internal/src/index.ts

@@ -6,18 +6,19 @@ import type { Store } from "./store"
 import type { Subject } from "./subject"
 
 export * from "./atom"
+export * from "./arbitrary"
 export * from "./caching"
 export * from "./lineage"
 export * from "./families"
 export * from "./future"
 export * from "./get-environment-data"
+export * from "./get-state"
 export * from "./ingest-updates"
 export * from "./keys"
 export * from "./lazy-map"
 export * from "./mutable"
 export * from "./not-found-error"
 export * from "./operation"
-export * from "./read-or-compute-value"
 export * from "./selector"
 export * from "./set-state"
 export * from "./store"
@@ -26,14 +27,14 @@ export * from "./subscribe"
 export * from "./timeline"
 export * from "./transaction"
 
-export type BaseStateData = {
+export type AtomIOState = {
 	key: string
 	family?: FamilyMetadata
 	install: (store: Store) => void
 	subject: Subject<{ newValue: any; oldValue: any }>
 }
 
-export type RegularAtom<T> = BaseStateData & {
+export type RegularAtom<T> = AtomIOState & {
 	type: `atom`
 	default: T | (() => T)
 	cleanup?: () => void
@@ -41,7 +42,7 @@ export type RegularAtom<T> = BaseStateData & {
 export type MutableAtom<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-> = BaseStateData &
+> = AtomIOState &
 	JsonInterface<T, J> & {
 		type: `mutable_atom`
 		default: T | (() => T)
@@ -51,12 +52,12 @@ export type Atom<T> =
 	| RegularAtom<T>
 	| (T extends Transceiver<any> ? MutableAtom<T, any> : never)
 
-export type WritableSelector<T> = BaseStateData & {
+export type WritableSelector<T> = AtomIOState & {
 	type: `selector`
 	get: () => T
 	set: (newValue: T | ((oldValue: T) => T)) => void
 }
-export type ReadonlySelector<T> = BaseStateData & {
+export type ReadonlySelector<T> = AtomIOState & {
 	type: `readonly_selector`
 	get: () => T
 }

package/internal/src/ingest-updates/ingest-atom-update.ts

@@ -1,6 +1,6 @@
 import type { KeyedStateUpdate } from "atom.io"
-import { setState } from "atom.io"
 
+import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
 
 export function ingestAtomUpdate(
@@ -10,5 +10,5 @@ export function ingestAtomUpdate(
 ): void {
 	const { key, newValue, oldValue } = atomUpdate
 	const value = applying === `newValue` ? newValue : oldValue
-	setState({ key, type: `atom` }, value, store)
+	setIntoStore({ key, type: `atom` }, value, store)
 }

package/internal/src/ingest-updates/ingest-transaction-update.ts

@@ -1,7 +1,6 @@
 import type { TransactionUpdate } from "atom.io"
 
 import type { Store } from "../store"
-import { isRootStore } from "../transaction/is-root-store"
 import { ingestAtomUpdate } from "./ingest-atom-update"
 
 export function ingestTransactionUpdate(

package/internal/src/mutable/create-mutable-atom.ts

@@ -4,12 +4,11 @@ import type {
 	MutableAtomOptions,
 	MutableAtomToken,
 } from "atom.io"
-import { setState } from "atom.io"
 import type { Json } from "atom.io/json"
 import { selectJson } from "atom.io/json"
 
-import { type MutableAtom, cacheValue } from ".."
-import { createRegularAtom, markAtomAsDefault } from "../atom"
+import { type MutableAtom, cacheValue, setIntoStore } from ".."
+import { markAtomAsDefault } from "../atom"
 import { newest } from "../lineage"
 import { type Store, deposit } from "../store"
 import { Subject } from "../subject"
@@ -70,7 +69,7 @@ export function createMutableAtom<
 		const cleanupFunctions: (() => void)[] = []
 		for (const effect of options.effects) {
 			const cleanup = effect({
-				setSelf: (next) => setState(token, next, store),
+				setSelf: (next) => setIntoStore(token, next, store),
 				onSet: (handle: UpdateHandler<T>) =>
 					subscribeToState(token, handle, `effect[${effectIndex}]`, store),
 			})

package/internal/src/mutable/tracker.ts

@@ -1,11 +1,16 @@
 import type { FamilyMetadata, MutableAtomToken, RegularAtomToken } from "atom.io"
-import { getState, setState } from "atom.io"
 import type { Json } from "atom.io/json"
 
 import type { Store } from ".."
-import { newest, subscribeToState, subscribeToTimeline } from ".."
+import {
+	getFromStore,
+	newest,
+	setIntoStore,
+	subscribeToState,
+	subscribeToTimeline,
+} from ".."
 import { createRegularAtom } from "../atom"
-import { isChildStore, isRootStore } from "../transaction/is-root-store"
+import { isChildStore } from "../transaction/is-root-store"
 import type { Transceiver } from "./transceiver"
 
 /**
@@ -57,7 +62,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		const subscriptionKey = `tracker:${target.config.name}:${
 			isChildStore(target) ? target.transactionMeta.update.key : `main`
 		}:${mutableState.key}`
-		const originalInnerValue = getState(mutableState, target)
+		const originalInnerValue = getFromStore(mutableState, target)
 		this.unsubscribeFromInnerValue = originalInnerValue.subscribe(
 			subscriptionKey,
 			(update) => {
@@ -66,12 +71,12 @@ export class Tracker<Mutable extends Transceiver<any>> {
 						subscriptionKey,
 						() => {
 							unsubscribe()
-							setState(latestUpdateState, update, target)
+							setIntoStore(latestUpdateState, update, target)
 						},
 					)
 				} else {
-					setState(mutableState, (current) => current, target)
-					setState(latestUpdateState, update, target)
+					setIntoStore(mutableState, (current) => current, target)
+					setIntoStore(latestUpdateState, update, target)
 				}
 			},
 		)
@@ -88,12 +93,12 @@ export class Tracker<Mutable extends Transceiver<any>> {
 									subscriptionKey,
 									() => {
 										unsubscribe()
-										setState(latestUpdateState, update, target)
+										setIntoStore(latestUpdateState, update, target)
 									},
 								)
 							} else {
-								setState(mutableState, (current) => current, target)
-								setState(latestUpdateState, update, target)
+								setIntoStore(mutableState, (current) => current, target)
+								setIntoStore(latestUpdateState, update, target)
 							}
 						},
 					)
@@ -126,7 +131,7 @@ export class Tracker<Mutable extends Transceiver<any>> {
 							{ key: timelineId, type: `timeline` },
 							(update) => {
 								unsubscribe()
-								setState(
+								setIntoStore(
 									mutableState,
 									(transceiver) => {
 										if (update === `redo` && newValue) {
@@ -150,12 +155,12 @@ export class Tracker<Mutable extends Transceiver<any>> {
 					subscriptionKey,
 					() => {
 						unsubscribe()
-						const mutable = getState(mutableState, target)
+						const mutable = getFromStore(mutableState, target)
 						const updateNumber =
 							newValue === null ? -1 : mutable.getUpdateNumber(newValue)
 						const eventOffset = updateNumber - mutable.cacheUpdateNumber
 						if (newValue && eventOffset === 1) {
-							setState(
+							setIntoStore(
 								mutableState,
 								(transceiver) => (transceiver.do(newValue), transceiver),
 								target,

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

@@ -1,5 +1,4 @@
 import type {
-	FamilyMetadata,
 	ReadonlySelectorOptions,
 	ReadonlySelectorToken,
 	WritableSelectorOptions,
@@ -7,7 +6,6 @@ import type {
 } from "atom.io"
 
 import type { Store } from "../store"
-import type { Subject } from "../subject"
 import { createReadonlySelector } from "./create-readonly-selector"
 import { createWritableSelector } from "./create-writable-selector"
 

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

@@ -1,8 +1,8 @@
 import type { Transactors, findState } from "atom.io"
 
 import { findInStore } from "../families"
+import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { newest } from "../lineage"
-import { readOrComputeValue } from "../read-or-compute-value"
 import { setAtomOrSelector } from "../set-state"
 import type { Store } from "../store"
 import { withdraw, withdrawNewFamilyMember } from "../store"

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

@@ -1,2 +1,3 @@
 export * from "./become"
 export * from "./set-atom-or-selector"
+export * from "./set-into-store"

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

@@ -1,13 +1,13 @@
 import type { Atom } 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 { markDone } from "../operation"
-import { readOrComputeValue } from "../read-or-compute-value"
 import type { Store } from "../store"
-import { isRootStore } from "../transaction/is-root-store"
+import { isChildStore, isRootStore } from "../transaction/is-root-store"
 import { become } from "./become"
-import { copyMutableIfWithinTransaction } from "./copy-mutable-in-transaction"
+import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
 import { emitUpdate } from "./emit-update"
 import { evictDownStream } from "./evict-downstream"
 import { stowUpdate } from "./stow-update"
@@ -18,7 +18,12 @@ export const setAtom = <T>(
 	target: Store,
 ): void => {
 	const oldValue = readOrComputeValue(atom, target)
-	let newValue = copyMutableIfWithinTransaction(oldValue, atom, target)
+	let newValue = oldValue
+	if (atom.type === `mutable_atom` && isChildStore(target)) {
+		const { parent } = target
+		const copiedValue = copyMutableIfNeeded(atom, parent, target)
+		newValue = copiedValue
+	}
 	newValue = become(next)(newValue)
 	target.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
 	newValue = cacheValue(atom.key, newValue, atom.subject, target)
@@ -36,22 +41,13 @@ export const setAtom = <T>(
 		} else if (atom.key.startsWith(`*`)) {
 			const mutableKey = atom.key.slice(1)
 			const mutableAtom = target.atoms.get(mutableKey) as Atom<any>
-			let mutable: Transceiver<any> = target.valueMap.get(mutableKey)
-			mutable = copyMutableIfWithinTransaction(mutable, mutableAtom, target)
-			const output = mutable.do(update.newValue)
-			if (output !== null) {
-				target.logger.warn(
-					`❌`,
-					`mutable_atom`,
-					mutableKey,
-					`could not be updated.`,
-					typeof output === `number`
-						? `Expected update number ${
-								mutable.cacheUpdateNumber + 1
-						  }, but got ${output}`
-						: output,
-				)
+			let transceiver: Transceiver<any> = target.valueMap.get(mutableKey)
+			if (atom.type === `mutable_atom` && isChildStore(target)) {
+				const { parent } = target
+				const copiedValue = copyMutableIfNeeded(atom, parent, target)
+				transceiver = copiedValue
 			}
+			transceiver.do(update.newValue)
 		}
 	}
 }

package/internal/src/set-state/set-into-store.ts

@@ -0,0 +1,24 @@
+import type { WritableToken } from "atom.io"
+
+import { NotFoundError } from "../not-found-error"
+import { closeOperation, openOperation } from "../operation"
+import type { Store } from "../store"
+import { withdraw, withdrawNewFamilyMember } from "../store"
+import { setAtomOrSelector } from "./set-atom-or-selector"
+
+export function setIntoStore<T, New extends T>(
+	token: WritableToken<T>,
+	value: New | ((oldValue: T) => New),
+	store: Store,
+): void {
+	const rejection = openOperation(token, store)
+	if (rejection) {
+		return
+	}
+	const state = withdraw(token, store) ?? withdrawNewFamilyMember(token, store)
+	if (state === undefined) {
+		throw new NotFoundError(token, store)
+	}
+	setAtomOrSelector(state, value, store)
+	closeOperation(store)
+}

package/internal/src/store/store.ts

@@ -32,6 +32,7 @@ import type {
 	TransactionEpoch,
 	TransactionProgress,
 } from "../transaction"
+import { isRootStore } from "../transaction/is-root-store"
 
 export class Store implements Lineage {
 	public parent: Store | null = null
@@ -93,7 +94,11 @@ export class Store implements Lineage {
 	}
 	public operation: OperationProgress = { open: false }
 	public transactionMeta: TransactionEpoch | TransactionProgress<ƒn> = {
-		epoch: -1,
+		epoch: new Map<string, number>(),
+		actionContinuities: new Junction({
+			between: [`continuity`, `action`],
+			cardinality: `1:n`,
+		}),
 	}
 
 	public config: {
@@ -121,7 +126,14 @@ export class Store implements Lineage {
 		if (store !== null) {
 			this.valueMap = new Map(store?.valueMap)
 			this.operation = { ...store?.operation }
-			this.transactionMeta = { ...store?.transactionMeta }
+			if (isRootStore(store)) {
+				this.transactionMeta = {
+					epoch: new Map(store?.transactionMeta.epoch),
+					actionContinuities: new Junction(
+						store?.transactionMeta.actionContinuities.toJSON(),
+					),
+				}
+			}
 
 			this.config = {
 				...store?.config,

package/internal/src/store/withdraw.ts

@@ -1,18 +1,31 @@
 import type {
+	AtomFamily,
+	AtomFamilyToken,
 	AtomToken,
+	MutableAtomFamily,
+	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableToken,
+	ReadonlySelectorFamily,
+	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
+	RegularAtomFamily,
+	RegularAtomFamilyToken,
 	RegularAtomToken,
+	SelectorFamily,
+	SelectorFamilyToken,
 	SelectorToken,
 	TimelineManageable,
 	TimelineToken,
 	TransactionToken,
+	WritableSelectorFamily,
+	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
 	ƒn,
 } from "atom.io"
 
+import type { Json } from "atom.io/json"
 import type {
 	Atom,
 	MutableAtom,
@@ -28,7 +41,24 @@ import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
 import type { Store } from "./store"
 
-export type Withdrawable = ReadableState<any> | Timeline<any> | Transaction<any>
+export type Withdrawable =
+	| Atom<any>
+	| AtomFamily<any, any>
+	| MutableAtom<any, any>
+	| MutableAtomFamily<any, any, any>
+	| ReadableState<any>
+	| ReadableState<any>
+	| ReadonlySelector<any>
+	| ReadonlySelectorFamily<any, any>
+	| RegularAtom<any>
+	| RegularAtomFamily<any, any>
+	| Selector<any>
+	| SelectorFamily<any, any>
+	| Timeline<any>
+	| Transaction<any>
+	| WritableSelector<any>
+	| WritableSelectorFamily<any, any>
+	| WritableState<any>
 
 export function withdraw<T>(
 	token: RegularAtomToken<T>,
@@ -62,6 +92,36 @@ export function withdraw<T>(
 	token: ReadableToken<T>,
 	store: Store,
 ): ReadableState<T> | undefined
+
+export function withdraw<T, K extends Json.Serializable>(
+	token: RegularAtomFamilyToken<T, K>,
+	store: Store,
+): RegularAtomFamily<T, K> | undefined
+export function withdraw<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+>(
+	token: MutableAtomFamilyToken<T, J, K>,
+	store: Store,
+): MutableAtomFamily<T, J, K> | undefined
+export function withdraw<T, K extends Json.Serializable>(
+	token: AtomFamilyToken<T>,
+	store: Store,
+): AtomFamily<T, any> | undefined
+export function withdraw<T, K extends Json.Serializable>(
+	token: ReadonlySelectorFamilyToken<T, K>,
+	store: Store,
+): ReadonlySelectorFamily<T, any> | undefined
+export function withdraw<T, K extends Json.Serializable>(
+	token: WritableSelectorFamilyToken<T, K>,
+	store: Store,
+): WritableSelectorFamily<T, any> | undefined
+export function withdraw<T, K extends Json.Serializable>(
+	token: SelectorFamilyToken<T, K>,
+	store: Store,
+): SelectorFamily<T, any> | undefined
+
 export function withdraw<T>(
 	token: TransactionToken<T>,
 	store: Store,
@@ -72,11 +132,15 @@ export function withdraw<T>(
 ): Timeline<T extends TimelineManageable ? T : never> | undefined
 export function withdraw<T>(
 	token:
+		| RegularAtomFamilyToken<T, any>
 		| RegularAtomToken<T>
+		| SelectorFamilyToken<T, any>
 		| SelectorToken<T>
 		| TimelineToken<T>
 		| TransactionToken<T>
-		| (T extends Transceiver<any> ? MutableAtomToken<T, any> : never),
+		| (T extends Transceiver<any>
+				? MutableAtomFamilyToken<T, any, any> | MutableAtomToken<T, any>
+				: never),
 	store: Store,
 ): Withdrawable | undefined {
 	let withdrawn: Withdrawable | undefined
@@ -93,6 +157,12 @@ export function withdraw<T>(
 			case `readonly_selector`:
 				withdrawn = target.readonlySelectors.get(token.key)
 				break
+			case `atom_family`:
+			case `mutable_atom_family`:
+			case `selector_family`:
+			case `readonly_selector_family`:
+				withdrawn = target.families.get(token.key)
+				break
 			case `timeline`:
 				withdrawn = target.timelines.get(token.key)
 				break

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

@@ -1,6 +1,6 @@
 import type { Selector } from ".."
+import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { newest } from "../lineage"
-import { readOrComputeValue } from "../read-or-compute-value"
 import { traceAllSelectorAtoms } from "../selector"
 import type { Store } from "../store"
 import { recallState } from "./recall-state"

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

@@ -1,6 +1,6 @@
 import type { TimelineManageable, TimelineToken, TimelineUpdate } from "atom.io"
-import type { Store } from "atom.io/internal"
-import { withdraw } from "atom.io/internal"
+import type { Store } from ".."
+import { withdraw } from ".."
 
 export const subscribeToTimeline = <ManagedAtom extends TimelineManageable>(
 	token: TimelineToken<ManagedAtom>,

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

@@ -1,6 +1,6 @@
 import type { TransactionToken, TransactionUpdateHandler, ƒn } from "atom.io"
-import type { Store } from "atom.io/internal"
-import { withdraw } from "atom.io/internal"
+import type { Store } from ".."
+import { withdraw } from ".."
 
 export const subscribeToTransaction = <ƒ extends ƒn>(
 	token: TransactionToken<ƒ>,