atom.io 0.40.6 → 0.40.7

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

@@ -1,67 +1,49 @@
-import type { WritableFamilyToken, WritableToken } from "atom.io"
+import type { Setter, WritableFamilyToken, WritableToken } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
 import type { Store } from "../store"
 import { operateOnStore, OWN_OP } from "./operate-on-store"
 import type { RESET_STATE } from "./reset-in-store"
 
-export function setIntoStore<T, New extends T, E>(
+export function setIntoStore<T, TT extends T>(
 	store: Store,
-	token: WritableToken<T, any, E>,
-	value: New | typeof RESET_STATE | ((oldValue: T) => New),
+	token: WritableToken<T, any, any>,
+	value: Setter<TT> | TT | typeof RESET_STATE,
 ): void
 
-export function setIntoStore<
-	T,
-	K extends Canonical,
-	New extends T,
-	Key extends K,
-	E,
->(
+export function setIntoStore<T, TT extends T, K extends Canonical>(
 	store: Store,
-	token: WritableFamilyToken<T, K, E>,
-	key: Key,
-	value: New | typeof RESET_STATE | ((oldValue: T) => New),
+	token: WritableFamilyToken<T, K, any>,
+	key: NoInfer<K>,
+	value: Setter<TT> | TT | typeof RESET_STATE,
 ): void
 
-export function setIntoStore<
-	T,
-	K extends Canonical,
-	New extends T,
-	Key extends K,
-	E,
->(
+export function setIntoStore<T, TT extends T, K extends Canonical>(
 	store: Store,
 	...params:
 		| [
-				token: WritableFamilyToken<T, K, E>,
-				key: Key,
-				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+				token: WritableFamilyToken<T, K, any>,
+				key: NoInfer<K>,
+				value: Setter<TT> | TT | typeof RESET_STATE,
 		  ]
 		| [
-				token: WritableToken<T, any, E>,
-				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+				token: WritableToken<T, any, any>,
+				value: Setter<TT> | TT | typeof RESET_STATE,
 		  ]
 ): void
 
-export function setIntoStore<
-	T,
-	K extends Canonical,
-	New extends T,
-	Key extends K,
-	E,
->(
+export function setIntoStore<T, TT extends T, K extends Canonical>(
 	store: Store,
 	...params:
 		| [
-				token: WritableFamilyToken<T, K, E>,
-				key: Key,
-				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+				token: WritableFamilyToken<T, K, any>,
+				key: NoInfer<K>,
+				value: Setter<TT> | TT | typeof RESET_STATE,
 		  ]
 		| [
-				token: WritableToken<T, any, E>,
-				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+				token: WritableToken<T, any, any>,
+				value: Setter<TT> | TT | typeof RESET_STATE,
 		  ]
 ): void {
-	operateOnStore(store, OWN_OP, ...params)
+	operateOnStore(OWN_OP, store, ...params)
 }

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

@@ -1,6 +1,7 @@
-import { readOrComputeValue, type WritableSelector } from ".."
 import { writeToCache } from "../caching"
+import { readOrComputeValue } from "../get-state"
 import { markDone, type OpenOperation } from "../operation"
+import type { WritableSelector } from "../state-types"
 import type { Store } from "../store"
 import { become } from "./become"
 import type { ProtoUpdate } from "./operate-on-store"
@@ -8,7 +9,7 @@ import type { ProtoUpdate } from "./operate-on-store"
 export function setSelector<T>(
 	target: Store & { operation: OpenOperation<any> },
 	selector: WritableSelector<T, any>,
-	next: T | ((oldValue: T) => T),
+	next: NoInfer<T> | ((oldValue: T) => NoInfer<T>),
 ): ProtoUpdate<T> {
 	let oldValue: T
 	let newValue: T

package/src/internal/state-types.ts

@@ -0,0 +1,228 @@
+import type {
+	FamilyMetadata,
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadonlyHeldSelectorFamilyToken,
+	ReadonlyHeldSelectorToken,
+	ReadonlyPureSelectorFamilyToken,
+	ReadonlyPureSelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	StateLifecycleEvent,
+	StateUpdate,
+	WritableHeldSelectorFamilyToken,
+	WritableHeldSelectorToken,
+	WritablePureSelectorFamilyToken,
+	WritablePureSelectorToken,
+} from "atom.io"
+import type { Canonical } from "atom.io/json"
+
+import type { InternalRole } from "./atom"
+import type { ConstructorOf, Transceiver } from "./mutable"
+import type { Store } from "./store"
+import type { Subject } from "./subject"
+import type { Timeline } from "./timeline"
+import type { RootStore, Transaction } from "./transaction"
+import type { Ctor, Flat } from "./utility-types"
+
+export type AtomIOState = {
+	key: string
+	family?: FamilyMetadata
+	install: (store: RootStore) => void
+	subject: Subject<StateUpdate<any>>
+}
+export type RegularAtom<T, E> = Flat<
+	AtomIOState & {
+		type: `atom`
+		default: T | (() => T)
+		cleanup?: () => void
+		internalRoles?: InternalRole[]
+		catch?: readonly Ctor<E>[]
+		__T?: T
+		__E?: E
+	}
+>
+export type MutableAtom<T extends Transceiver<any, any, any>> = Flat<
+	AtomIOState & {
+		type: `mutable_atom`
+		class: ConstructorOf<T>
+		cleanup?: () => void
+		__T?: T
+	}
+>
+export type Atom<T, E> =
+	| RegularAtom<T, E>
+	| (T extends Transceiver<any, any, any> ? MutableAtom<T> : never)
+
+export type WritableHeldSelector<T> = Flat<
+	AtomIOState & {
+		type: `writable_held_selector`
+		const: T
+		getFrom: (target: Store) => T
+		setSelf: (newValue: T) => void
+		__T?: T
+	}
+>
+export type ReadonlyHeldSelector<T> = Flat<
+	AtomIOState & {
+		type: `readonly_held_selector`
+		const: T
+		getFrom: (target: Store) => T
+		__T?: T
+	}
+>
+export type WritablePureSelector<T, E> = Flat<
+	AtomIOState & {
+		type: `writable_pure_selector`
+		getFrom: (target: Store) => E | T
+		setSelf: (newValue: T) => void
+		catch?: readonly Ctor<E>[]
+		__T?: T
+		__E?: E
+	}
+>
+export type ReadonlyPureSelector<T, E> = Flat<
+	AtomIOState & {
+		type: `readonly_pure_selector`
+		getFrom: (target: Store) => E | T
+		catch?: readonly Ctor<E>[]
+		__T?: T
+		__E?: E
+	}
+>
+export type ReadonlySelector<T, E> =
+	| ReadonlyHeldSelector<T>
+	| ReadonlyPureSelector<T, E>
+export type WritableSelector<T, E> =
+	| WritableHeldSelector<T>
+	| WritablePureSelector<T, E>
+export type HeldSelector<T> = ReadonlyHeldSelector<T> | WritableHeldSelector<T>
+export type PureSelector<T, E> =
+	| ReadonlyPureSelector<T, E>
+	| WritablePureSelector<T, E>
+export type Selector<T, E> =
+	| ReadonlyHeldSelector<T>
+	| ReadonlyPureSelector<T, E>
+	| WritableHeldSelector<T>
+	| WritablePureSelector<T, E>
+
+export type WritableState<T, E> = Atom<T, E> | WritableSelector<T, E>
+export type ReadableState<T, E> = Atom<T, E> | Selector<T, E>
+
+// biome-ignore format: intersection
+export type RegularAtomFamily<T, K extends Canonical, E = never> =
+	& Flat<
+		& RegularAtomFamilyToken<T, K, E>
+		& {
+			create: <Key extends K>(key: Key) => RegularAtomToken<T, Key, E>
+			default: T | ((key: K) => T)
+			install: (store: RootStore) => void
+			internalRoles: string[] | undefined
+			subject: Subject<StateLifecycleEvent<RegularAtomToken<T, K, E>>>
+		}
+	>
+
+// biome-ignore format: intersection
+export type MutableAtomFamily<
+	T extends Transceiver<any, any, any>,
+	K extends Canonical,
+> =
+	& Flat<
+		& MutableAtomFamilyToken<T, K>
+		& {
+				create: <Key extends K>(key: Key) => MutableAtomToken<T, Key>
+				class: ConstructorOf<T>
+				install: (store: RootStore) => void
+				internalRoles: string[] | undefined
+				subject: Subject<StateLifecycleEvent<MutableAtomToken<T>>>
+			}
+	>
+
+export type AtomFamily<T, K extends Canonical, E> =
+	| MutableAtomFamily<T extends Transceiver<any, any, any> ? T : never, K>
+	| RegularAtomFamily<T, K, E>
+
+// biome-ignore format: intersection
+export type WritablePureSelectorFamily<T, K extends Canonical, E> =
+	& Flat<
+		& WritablePureSelectorFamilyToken<T, K, E>
+		& {
+			create: <Key extends K>(key: Key) => WritablePureSelectorToken<T, Key, E>
+			default: (key: K) => T,
+			install: (store: RootStore) => void
+			internalRoles: string[] | undefined
+			subject: Subject<StateLifecycleEvent<WritablePureSelectorToken<T, K, E>>>
+		}
+	>
+
+// biome-ignore format: intersection
+export type WritableHeldSelectorFamily<T , K extends Canonical> =
+	& Flat<
+		& WritableHeldSelectorFamilyToken<T, K>
+		& {
+			create: <Key extends K>(key: Key) => WritableHeldSelectorToken<T, Key>
+			default: (key: K) => T,
+			install: (store: RootStore) => void
+			internalRoles: string[] | undefined
+			subject: Subject<StateLifecycleEvent<WritableHeldSelectorToken<T, K>>>
+		}
+	>
+
+// biome-ignore format: intersection
+export type ReadonlyPureSelectorFamily<T, K extends Canonical, E> =
+	& Flat<
+		& ReadonlyPureSelectorFamilyToken<T, K, E>
+		& {
+			create: <Key extends K>(key: Key) => ReadonlyPureSelectorToken<T, Key, E>
+			default: (key: K) => T,
+			install: (store: RootStore) => void
+			internalRoles: string[] | undefined
+			subject: Subject<StateLifecycleEvent<ReadonlyPureSelectorToken<T, K, E>>>
+		}
+	>
+
+// biome-ignore format: intersection
+export type ReadonlyHeldSelectorFamily<T , K extends Canonical> =
+	& Flat<
+		& ReadonlyHeldSelectorFamilyToken<T, K>
+		& {
+			create: <Key extends K>(key: Key) => ReadonlyHeldSelectorToken<T, Key>
+			default: (key: K) => T,
+			install: (store: RootStore) => void
+			internalRoles: string[] | undefined
+			subject: Subject<StateLifecycleEvent<ReadonlyHeldSelectorToken<T>>>
+		}
+	>
+
+export type PureSelectorFamily<T, K extends Canonical, E> =
+	| ReadonlyPureSelectorFamily<T, K, E>
+	| WritablePureSelectorFamily<T, K, E>
+
+export type HeldSelectorFamily<T, K extends Canonical> =
+	| ReadonlyHeldSelectorFamily<T, K>
+	| WritableHeldSelectorFamily<T, K>
+
+export type ReadonlySelectorFamily<T, K extends Canonical, E> =
+	| ReadonlyHeldSelectorFamily<T, K>
+	| ReadonlyPureSelectorFamily<T, K, E>
+
+export type WritableSelectorFamily<T, K extends Canonical, E> =
+	| WritableHeldSelectorFamily<T, K>
+	| WritablePureSelectorFamily<T, K, E>
+
+export type SelectorFamily<T, K extends Canonical, E> =
+	| HeldSelectorFamily<T, K>
+	| PureSelectorFamily<T, K, E>
+
+export type WritableFamily<T, K extends Canonical, E> =
+	| AtomFamily<T, K, E>
+	| WritableSelectorFamily<T, K, E>
+export type ReadableFamily<T, K extends Canonical, E> =
+	| AtomFamily<T, K, E>
+	| SelectorFamily<T, K, E>
+
+export type AtomIOInternalResource =
+	| ReadableFamily<any, any, any>
+	| ReadableState<any, any>
+	| Timeline<any>
+	| Transaction<any>

package/src/internal/store/deposit.ts

@@ -22,11 +22,11 @@ import type {
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
+import type { Transceiver } from "../mutable"
 import type {
 	Atom,
 	AtomFamily,
 	AtomIOInternalResource,
-	Fn,
 	MutableAtom,
 	MutableAtomFamily,
 	ReadableFamily,
@@ -37,14 +37,14 @@ import type {
 	RegularAtomFamily,
 	Selector,
 	SelectorFamily,
-	Timeline,
-	Transceiver,
 	WritableFamily,
 	WritablePureSelector,
 	WritablePureSelectorFamily,
 	WritableState,
-} from ".."
+} from "../state-types"
+import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
+import type { Fn } from "../utility-types"
 
 export function deposit<T, E>(
 	state: RegularAtom<T, E>,

package/src/internal/store/index.ts

@@ -1,5 +1,4 @@
 export * from "./circular-buffer"
 export * from "./deposit"
-export * from "./mint-or-counterfeit"
 export * from "./store"
 export * from "./withdraw"

package/src/internal/store/store.ts

@@ -10,6 +10,14 @@ import type {
 import { AtomIOLogger } from "atom.io"
 import type { Canonical, stringified } from "atom.io/json"
 
+import type { Join } from "../join"
+import { Junction } from "../junction"
+import type { Lineage } from "../lineage"
+import type { Molecule } from "../molecule"
+import type { Tracker, Transceiver } from "../mutable"
+import { getJsonToken, getUpdateToken } from "../mutable"
+import type { OperationProgress } from "../operation"
+import { isReservedIntrospectionKey } from "../reserved-keys"
 import type {
 	Atom,
 	HeldSelectorFamily,
@@ -18,15 +26,7 @@ import type {
 	ReadonlySelector,
 	RegularAtomFamily,
 	WritableSelector,
-} from ".."
-import { isReservedIntrospectionKey } from ".."
-import type { Join } from "../join"
-import { Junction } from "../junction"
-import type { Lineage } from "../lineage"
-import type { Molecule } from "../molecule"
-import type { Tracker, Transceiver } from "../mutable"
-import { getJsonToken, getUpdateToken } from "../mutable"
-import type { OperationProgress } from "../operation"
+} from "../state-types"
 import { StatefulSubject, Subject } from "../subject"
 import type { Timeline } from "../timeline"
 import type {

package/src/internal/store/withdraw.ts

@@ -34,11 +34,12 @@ import type {
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
+import type { Transceiver } from "../mutable"
+import { NotFoundError } from "../not-found-error"
 import type {
 	Atom,
 	AtomFamily,
 	AtomIOInternalResource,
-	Fn,
 	HeldSelector,
 	HeldSelectorFamily,
 	MutableAtom,
@@ -57,7 +58,6 @@ import type {
 	RegularAtomFamily,
 	Selector,
 	SelectorFamily,
-	Transceiver,
 	WritableFamily,
 	WritableHeldSelector,
 	WritableHeldSelectorFamily,
@@ -66,10 +66,10 @@ import type {
 	WritableSelector,
 	WritableSelectorFamily,
 	WritableState,
-} from ".."
-import { NotFoundError } from ".."
+} from "../state-types"
 import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
+import type { Fn } from "../utility-types"
 import type { Store } from "./store"
 
 export function withdraw<T, E>(

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

@@ -1,5 +1,5 @@
-import type { ReadableState } from ".."
 import { newest } from "../lineage"
+import type { ReadableState } from "../state-types"
 import type { Store } from "../store"
 
 export const recallState = <T, E>(

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

@@ -1,5 +1,5 @@
-import type { Atom, Selector } from ".."
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
+import type { Atom, Selector } from "../state-types"
 import type { Store } from "../store"
 import { recallState } from "./recall-state"
 
@@ -37,14 +37,3 @@ export const subscribeToRootDependency = (
 		},
 	)
 }
-
-// export const subscribeToRootAtoms = (
-// 	store: Store,
-// 	selector: Selector<any>,
-// ): (() => void)[] => {
-// 	const target = newest(store)
-// 	const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
-// 		(atom) => subscribeToRootDependency(target, selector, atom),
-// 	)
-// 	return dependencySubscriptions
-// }

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

@@ -1,7 +1,8 @@
 import type { TransactionToken, TransactionUpdateHandler } from "atom.io"
 
-import type { Fn, Store } from ".."
-import { withdraw } from ".."
+import type { Store } from "../store"
+import { withdraw } from "../store"
+import type { Fn } from "../utility-types"
 
 export const subscribeToTransaction = <F extends Fn>(
 	store: Store,

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

@@ -16,9 +16,10 @@ import { getJsonToken } from "../mutable"
 import { MapOverlay } from "../overlays/map-overlay"
 import { resetInStore, setIntoStore } from "../set-state"
 import type { Fn } from "../utility-types"
-import type { TransactionProgress } from "."
-import { actUponStore, getEpochNumberOfAction } from "."
+import { actUponStore } from "./act-upon-store"
+import { getEpochNumberOfAction } from "./get-epoch-number"
 import type { ChildStore, RootStore } from "./is-root-store"
+import type { TransactionProgress } from "./transaction-meta-progress"
 
 export const buildTransaction = (
 	store: RootStore,

package/src/internal/transaction/index.ts

@@ -1,12 +1,3 @@
-import type {
-	ActorToolkit,
-	TransactionOutcomeEvent,
-	TransactionToken,
-} from "atom.io"
-
-import type { Junction } from "../junction"
-import type { Fn } from "../utility-types"
-
 export * from "./abort-transaction"
 export * from "./act-upon-store"
 export * from "./apply-transaction"
@@ -16,17 +7,4 @@ export * from "./create-transaction"
 export * from "./get-epoch-number"
 export * from "./is-root-store"
 export * from "./set-epoch-number"
-
-export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
-export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
-
-export type TransactionProgress<F extends Fn> = {
-	phase: `applying` | `building`
-	update: TransactionOutcomeEvent<TransactionToken<F>>
-	toolkit: ActorToolkit
-}
-
-export type TransactionEpoch = {
-	epoch: Map<string, number>
-	actionContinuities: Junction<`continuity`, string, `action`, string>
-}
+export * from "./transaction-meta-progress"

package/src/internal/transaction/is-root-store.ts

@@ -1,7 +1,10 @@
 import type { MapOverlay } from "../overlays/map-overlay"
 import type { Store } from "../store"
 import type { Fn } from "../utility-types"
-import type { TransactionEpoch, TransactionProgress } from "."
+import type {
+	TransactionEpoch,
+	TransactionProgress,
+} from "./transaction-meta-progress"
 
 export interface RootStore extends Store {
 	transactionMeta: TransactionEpoch

package/src/internal/transaction/transaction-meta-progress.ts

@@ -0,0 +1,22 @@
+import type {
+	ActorToolkit,
+	TransactionOutcomeEvent,
+	TransactionToken,
+} from "atom.io"
+
+import type { Junction } from "../junction"
+import type { Fn } from "../utility-types"
+
+export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
+export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
+
+export type TransactionProgress<F extends Fn> = {
+	phase: `applying` | `building`
+	update: TransactionOutcomeEvent<TransactionToken<F>>
+	toolkit: ActorToolkit
+}
+
+export type TransactionEpoch = {
+	epoch: Map<string, number>
+	actionContinuities: Junction<`continuity`, string, `action`, string>
+}

package/src/main/atom.ts

@@ -9,7 +9,6 @@ import {
 import type { Canonical } from "atom.io/json"
 
 import type { StateUpdate } from "./events"
-import type { Setter } from "./set-state"
 import type {
 	MutableAtomFamilyToken,
 	MutableAtomToken,
@@ -78,7 +77,7 @@ export type Effectors<T> = {
 	 * Set the value of the atom
 	 * @param next - The new value of the atom, or a setter function
 	 */
-	setSelf: <New extends T>(next: New | Setter<T, New>) => void
+	setSelf: <New extends T>(next: New | ((old: T) => New)) => void
 	/** Subscribe to changes to the atom */
 	onSet: (callback: (options: StateUpdate<T>) => void) => void
 }

package/src/main/find-state.ts

@@ -50,7 +50,7 @@ export function findState<
 export function findState<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-): RegularAtomToken<T, K>
+): RegularAtomToken<T, Key>
 /**
  * Finds a {@link WritableSelectorToken} in the store, without accessing its value.
  *
@@ -67,7 +67,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T, K>
+): WritableSelectorToken<T, Key>
 /**
  * Finds a {@link ReadonlySelectorToken} in the store, without accessing its value.
  *
@@ -84,7 +84,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T, K>
+): ReadonlySelectorToken<T, Key>
 /**
  * Finds a {@link WritableToken} in the store, without accessing its value.
  *
@@ -101,7 +101,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-): WritableToken<T, K>
+): WritableToken<T, Key>
 /**
  * Finds a {@link MutableAtomToken} in the store, without accessing its value.
  *
@@ -119,7 +119,7 @@ export function findState<T, K extends Canonical, Key extends K>(
 export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-): ReadableToken<T, K>
+): ReadableToken<T, Key>
 
 export function findState(
 	token: ReadableFamilyToken<any, any>,

package/src/main/get-state.ts

@@ -22,14 +22,14 @@ export function getState<T, E = never>(
  * @return The current value of the state
  * @overload Streamlined
  */
-export function getState<T, K extends Canonical, Key extends K, E = never>(
+export function getState<T, K extends Canonical, E = never>(
 	token: ReadableFamilyToken<T, K, E>,
-	key: Key,
+	key: NoInfer<K>,
 ): ViewOf<E | T>
 
-export function getState<T, K extends Canonical, Key extends K, E = never>(
+export function getState<T, K extends Canonical, E = never>(
 	...params:
-		| [token: ReadableFamilyToken<T, K, E>, key: Key]
+		| [token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>]
 		| [token: ReadableToken<T, any, E>]
 ): ViewOf<E | T> {
 	return getFromStore(IMPLICIT.STORE, ...params)

package/src/main/realm.ts

@@ -34,7 +34,7 @@ export class Realm<H extends Hierarchy> {
 		this.store = store
 		this.deallocateTX = createDeallocateTX(store)
 		this.claimTX = createClaimTX(store)
-		makeRootMoleculeInStore(`root`, store)
+		makeRootMoleculeInStore(store, `root`)
 	}
 	/**
 	 * Make space for a new subject of the realm
@@ -117,7 +117,7 @@ export class Anarchy {
 		this.store = store
 		this.deallocateTX = createDeallocateTX(store)
 		this.claimTX = createClaimTX(store)
-		makeRootMoleculeInStore(`root`, store)
+		makeRootMoleculeInStore(store, `root`)
 	}
 	/**
 	 * Declare a new entity