atom.io 0.29.4 → 0.30.0

package/json/src/entries.ts

@@ -1,4 +1,4 @@
-import type { Flat, Range } from "atom.io/internal"
+import type { Count, Flat } from "atom.io/internal"
 
 export type Entries<K extends PropertyKey = keyof any, V = any> = [K, V][]
 
@@ -7,8 +7,8 @@ export type KeyOfEntries<E extends Entries> = E extends [infer K, any][]
 	: never
 
 export type ValueOfEntry<E extends Entries, K extends KeyOfEntries<E>> = {
-	[P in Range<E[`length`]>]: E[P] extends [K, infer V] ? V : never
-}[Range<E[`length`]>]
+	[P in Count<E[`length`]>]: E[P] extends [K, infer V] ? V : never
+}[Count<E[`length`]>]
 
 export type FromEntries<E extends Entries> = Flat<{
 	[K in KeyOfEntries<E>]: ValueOfEntry<E, K>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.29.4",
+  "version": "0.30.0",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -57,34 +57,34 @@
     "@types/estree": "1.0.6",
     "@types/http-proxy": "1.17.15",
     "@types/npmlog": "7.0.0",
-    "@types/react": "18.3.8",
+    "@types/react": "18.3.11",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.6.0",
-    "@typescript-eslint/rule-tester": "8.6.0",
-    "@vitest/coverage-v8": "2.1.1",
-    "@vitest/ui": "2.1.1",
+    "@typescript-eslint/parser": "8.8.0",
+    "@typescript-eslint/rule-tester": "8.8.0",
+    "@vitest/coverage-v8": "2.1.2",
+    "@vitest/ui": "2.1.2",
     "concurrently": "9.0.1",
     "drizzle-kit": "0.24.2",
     "drizzle-orm": "0.33.0",
-    "eslint": "9.11.0",
-    "framer-motion": "11.5.6",
+    "eslint": "9.11.1",
+    "framer-motion": "11.11.0",
     "happy-dom": "15.7.4",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
-    "preact": "10.24.0",
+    "preact": "10.24.2",
     "react": "18.3.1",
     "react-dom": "18.3.1",
     "react-router-dom": "6.26.2",
-    "socket.io": "4.7.5",
-    "socket.io-client": "4.7.5",
+    "socket.io": "4.8.0",
+    "socket.io-client": "4.8.0",
     "tmp": "0.2.3",
     "tsup": "8.3.0",
     "tsx": "4.19.1",
     "typescript": "5.6.2",
-    "vite": "5.4.7",
+    "vite": "5.4.8",
     "vite-tsconfig-paths": "5.0.1",
-    "vitest": "2.1.1",
+    "vitest": "2.1.2",
     "zod": "3.23.8"
   },
   "main": "dist/index.js",

package/react-devtools/dist/index.js

@@ -6,7 +6,7 @@ import { undo, redo, getState } from 'atom.io';
 import { IMPLICIT, createStandaloneAtom, createAtomFamily, findInStore, become } from 'atom.io/internal';
 import { jsonRefinery, attachIntrospectionStates, primitiveRefinery, prettyJson, discoverType } from 'atom.io/introspection';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
-import { isJson, fromEntries, toEntries, JSON_DEFAULTS } from 'atom.io/json';
+import { isJson, fromEntries, toEntries, JSON_DEFAULTS, stringifyJson } from 'atom.io/json';
 import { persistSync } from 'atom.io/web';
 
 var OpenClose = ({ isOpen, setIsOpen, disabled, testid }) => {
@@ -1131,7 +1131,9 @@ var TransactionUpdateFC = ({ serialNumber, transactionUpdate }) => {
           ] }),
           /* @__PURE__ */ jsxs("section", { className: "transaction_impact", children: [
             /* @__PURE__ */ jsx("span", { className: "detail", children: "impact: " }),
-            transactionUpdate.updates.filter((token) => `key` in token && !token.key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)).map((update, index) => {
+            transactionUpdate.updates.filter(
+              (token) => token.type !== `molecule_creation` && token.type !== `molecule_disposal` && token.type !== `state_creation` && token.type !== `state_disposal` && !token.key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)
+            ).map((update, index) => {
               switch (update.type) {
                 case `atom_update`:
                 case `selector_update`:
@@ -1165,7 +1167,7 @@ var TimelineUpdateFC = ({ timelineUpdate, serialNumber }) => {
     "article",
     {
       className: "node timeline_update",
-      "data-testid": `timeline-update-${timelineUpdate.key}-${serialNumber}`,
+      "data-testid": `timeline-update-${typeof timelineUpdate.key === `string` ? timelineUpdate.key : stringifyJson(timelineUpdate.key)}-${serialNumber}`,
       children: [
         /* @__PURE__ */ jsx("header", { children: /* @__PURE__ */ jsxs("h4", { children: [
           timelineUpdate.timestamp,
@@ -1175,7 +1177,9 @@ var TimelineUpdateFC = ({ timelineUpdate, serialNumber }) => {
           timelineUpdate.key,
           ")"
         ] }) }),
-        /* @__PURE__ */ jsx("main", { children: timelineUpdate.type === `transaction_update` ? timelineUpdate.updates.filter((token) => `key` in token && !token.key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)).map((update, index) => {
+        /* @__PURE__ */ jsx("main", { children: timelineUpdate.type === `transaction_update` ? timelineUpdate.updates.filter(
+          (token) => token.type !== `molecule_creation` && token.type !== `molecule_disposal` && token.type !== `state_creation` && token.type !== `state_disposal` && !token.key.startsWith(`\u{1F441}\u200D\u{1F5E8}`)
+        ).map((update, index) => {
           switch (update.type) {
             case `atom_update`:
             case `selector_update`:
@@ -1276,7 +1280,7 @@ var TimelineLog = ({ token, isOpenState, timelineState }) => {
       ] })
     ] }),
     isOpen ? /* @__PURE__ */ jsx("main", { children: timeline.history.map(
-      (update, index) => `key` in update ? /* @__PURE__ */ jsxs(Fragment$1, { children: [
+      (update, index) => update.type !== `molecule_creation` && update.type !== `molecule_disposal` && update.type !== `state_creation` && update.type !== `state_disposal` ? /* @__PURE__ */ jsxs(Fragment$1, { children: [
         index === timeline.at ? /* @__PURE__ */ jsx(YouAreHere, {}) : null,
         /* @__PURE__ */ jsx(
           article.TimelineUpdate,

package/react-devtools/src/TimelineIndex.tsx

@@ -64,7 +64,10 @@ export const TimelineLog: FC<{
 			{isOpen ? (
 				<main>
 					{timeline.history.map((update, index) =>
-						`key` in update ? (
+						update.type !== `molecule_creation` &&
+						update.type !== `molecule_disposal` &&
+						update.type !== `state_creation` &&
+						update.type !== `state_disposal` ? (
 							<Fragment key={update.key + index + timeline.at}>
 								{index === timeline.at ? <YouAreHere /> : null}
 								<article.TimelineUpdate

package/react-devtools/src/Updates.tsx

@@ -5,6 +5,7 @@ import type {
 } from "atom.io"
 import type { Func } from "atom.io/internal"
 import { discoverType, prettyJson } from "atom.io/introspection"
+import { stringifyJson } from "atom.io/json"
 import * as React from "react"
 
 /* eslint-disable no-console */
@@ -90,7 +91,14 @@ const TransactionUpdateFC: React.FC<{
 				<section className="transaction_impact">
 					<span className="detail">impact: </span>
 					{transactionUpdate.updates
-						.filter((token) => `key` in token && !token.key.startsWith(`👁‍🗨`))
+						.filter(
+							(token) =>
+								token.type !== `molecule_creation` &&
+								token.type !== `molecule_disposal` &&
+								token.type !== `state_creation` &&
+								token.type !== `state_disposal` &&
+								!token.key.startsWith(`👁‍🗨`),
+						)
 						.map((update, index) => {
 							switch (update.type) {
 								case `atom_update`:
@@ -125,7 +133,7 @@ export const TimelineUpdateFC: React.FC<{
 	return `key` in timelineUpdate ? (
 		<article
 			className="node timeline_update"
-			data-testid={`timeline-update-${timelineUpdate.key}-${serialNumber}`}
+			data-testid={`timeline-update-${typeof timelineUpdate.key === `string` ? timelineUpdate.key : stringifyJson(timelineUpdate.key)}-${serialNumber}`}
 		>
 			<header>
 				<h4>
@@ -136,7 +144,14 @@ export const TimelineUpdateFC: React.FC<{
 			<main>
 				{timelineUpdate.type === `transaction_update` ? (
 					timelineUpdate.updates
-						.filter((token) => `key` in token && !token.key.startsWith(`👁‍🗨`))
+						.filter(
+							(token) =>
+								token.type !== `molecule_creation` &&
+								token.type !== `molecule_disposal` &&
+								token.type !== `state_creation` &&
+								token.type !== `state_disposal` &&
+								!token.key.startsWith(`👁‍🗨`),
+						)
 						.map((update, index) => {
 							switch (update.type) {
 								case `atom_update`:

package/realtime-testing/dist/index.d.ts

@@ -35,12 +35,12 @@ type RealtimeTestClientBuilder = {
     init: () => RealtimeTestClient;
 };
 type RealtimeTestServer = RealtimeTestTools & {
-    dispose: () => void;
+    dispose: () => Promise<void>;
     port: number;
 };
 type RealtimeTestAPI = {
     server: RealtimeTestServer;
-    teardown: () => void;
+    teardown: () => Promise<void>;
 };
 type RealtimeTestAPI__SingleClient = RealtimeTestAPI & {
     client: RealtimeTestClientBuilder;

package/realtime-testing/dist/index.js

@@ -81,8 +81,8 @@ var setupRealtimeTestServer = (options) => {
       console.log(`${userKey} disconnected`);
     });
   });
-  const dispose = () => {
-    server.close();
+  const dispose = async () => {
+    await server.close();
     const roomKeys = getFromStore(silo.store, RT.roomIndex);
     for (const roomKey of roomKeys) {
       const roomState = findInStore(silo.store, RTS.roomSelectors, roomKey);
@@ -157,8 +157,8 @@ var singleClient = (options) => {
   return {
     client,
     server,
-    teardown: () => {
-      server.dispose();
+    teardown: async () => {
+      await server.dispose();
       client.dispose();
     }
   };
@@ -179,8 +179,8 @@ var multiClient = (options) => {
   return {
     clients,
     server,
-    teardown: () => {
-      server.dispose();
+    teardown: async () => {
+      await server.dispose();
       for (const [, client] of toEntries(clients)) {
         client.dispose();
       }

package/realtime-testing/src/setup-realtime-test.tsx

@@ -76,14 +76,13 @@ export type RealtimeTestClientBuilder = {
 }
 
 export type RealtimeTestServer = RealtimeTestTools & {
-	dispose: () => void
+	dispose: () => Promise<void>
 	port: number
-	// enableLogging: () => void
 }
 
 export type RealtimeTestAPI = {
 	server: RealtimeTestServer
-	teardown: () => void
+	teardown: () => Promise<void>
 }
 export type RealtimeTestAPI__SingleClient = RealtimeTestAPI & {
 	client: RealtimeTestClientBuilder
@@ -152,8 +151,8 @@ export const setupRealtimeTestServer = (
 		})
 	})
 
-	const dispose = () => {
-		server.close()
+	const dispose = async () => {
+		await server.close()
 		const roomKeys = getFromStore(silo.store, RT.roomIndex)
 		for (const roomKey of roomKeys) {
 			const roomState = findInStore(silo.store, RTS.roomSelectors, roomKey)
@@ -245,8 +244,8 @@ export const singleClient = (
 	return {
 		client,
 		server,
-		teardown: () => {
-			server.dispose()
+		teardown: async () => {
+			await server.dispose()
 			client.dispose()
 		},
 	}
@@ -271,8 +270,8 @@ export const multiClient = <ClientNames extends string>(
 	return {
 		clients,
 		server,
-		teardown: () => {
-			server.dispose()
+		teardown: async () => {
+			await server.dispose()
 			for (const [, client] of toEntries(clients)) {
 				client.dispose()
 			}

package/src/allocate.ts

@@ -0,0 +1,278 @@
+import type { Each, Store } from "atom.io/internal"
+import {
+	disposeFromStore,
+	isChildStore,
+	Molecule,
+	newest,
+} from "atom.io/internal"
+import type { Canonical } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
+
+import { makeRootMoleculeInStore } from "./molecule"
+import type {
+	MoleculeCreationModern,
+	MoleculeDisposalModern,
+} from "./transaction"
+
+export const $provenance = Symbol(`provenance`)
+export type Claim<
+	H extends Hierarchy,
+	V extends Vassal<H>,
+	A extends Above<V, H>,
+> = V & {
+	[$provenance]?: A
+}
+
+export function allocateIntoStore<
+	H extends Hierarchy,
+	V extends Vassal<H>,
+	A extends Above<V, H>,
+>(store: Store, provenance: A, key: V): Claim<H, V, A> {
+	const stringKey = stringifyJson(key)
+
+	try {
+		const above: Molecule<any>[] = []
+
+		let allocationAttachmentStyle: `all` | `any`
+		if (provenance === `root`) {
+			// biome-ignore lint/style/noNonNullAssertion: let's assume we made the root molecule to get here
+			above.push(store.molecules.get(`"root"`)!)
+			allocationAttachmentStyle = `all`
+		} else if (provenance[0][0] === T$) {
+			allocationAttachmentStyle = `any`
+			const provenanceKey = stringifyJson(provenance as Canonical)
+			const provenanceMolecule = store.molecules.get(provenanceKey)
+			if (!provenanceMolecule) {
+				throw new Error(
+					`Molecule ${provenanceKey} not found in store "${store.config.name}"`,
+				)
+			}
+			above.push(provenanceMolecule)
+		} else {
+			const allocationIsCompound = key[0][0] === T$
+			if (allocationIsCompound) {
+				allocationAttachmentStyle = `all`
+				for (const claim of provenance as SingularTypedKey[]) {
+					const provenanceKey = stringifyJson(claim)
+					const provenanceMolecule = store.molecules.get(provenanceKey)
+					if (!provenanceMolecule) {
+						throw new Error(
+							`Molecule ${provenanceKey} not found in store "${store.config.name}"`,
+						)
+					}
+					above.push(provenanceMolecule)
+				}
+			} else {
+				allocationAttachmentStyle = `any`
+				const provenanceKey = stringifyJson(provenance as Canonical)
+				const provenanceMolecule = store.molecules.get(provenanceKey)
+				if (!provenanceMolecule) {
+					throw new Error(
+						`Molecule ${provenanceKey} not found in store "${store.config.name}"`,
+					)
+				}
+				above.push(provenanceMolecule)
+			}
+		}
+
+		const molecule = new Molecule(above, key)
+		molecule._dependsOn = allocationAttachmentStyle
+
+		store.molecules.set(stringKey, molecule)
+
+		for (const aboveMolecule of above) {
+			aboveMolecule.below.set(molecule.stringKey, molecule)
+		}
+
+		const creationEvent: MoleculeCreationModern = {
+			type: `molecule_creation`,
+			subType: `modern`,
+			key: molecule.key,
+			provenance: provenance as Canonical,
+		}
+		const target = newest(store)
+		const isTransaction =
+			isChildStore(target) && target.transactionMeta.phase === `building`
+		if (isTransaction) {
+			target.transactionMeta.update.updates.push(creationEvent)
+		} else {
+			target.on.moleculeCreationStart.next(creationEvent)
+		}
+	} catch (thrown) {
+		if (thrown instanceof Error) {
+			store.logger.error(
+				`❌`,
+				`molecule`,
+				stringKey,
+				`allocation failed:`,
+				thrown.message,
+			)
+		}
+	}
+
+	return key as Claim<H, V, A>
+}
+
+export function deallocateFromStore<
+	H extends Hierarchy,
+	V extends Vassal<H>,
+	A extends Above<V, H>,
+>(store: Store, claim: Claim<H, V, A>): void {
+	const stringKey = stringifyJson(claim)
+	const molecule = store.molecules.get(stringKey)
+	if (!molecule) {
+		throw new Error(
+			`Molecule ${stringKey} not found in store "${store.config.name}"`,
+		)
+	}
+
+	for (const join of molecule.joins.values()) {
+		join.relations.delete(molecule.key)
+		join.molecules.delete(molecule.stringKey)
+	}
+
+	let provenance: Canonical
+	if (molecule.above.size === 1) {
+		const above = molecule.above.values().next().value
+		provenance = above.key
+	} else {
+		provenance = [...molecule.above.values()].map(({ key }) => key)
+	}
+	const values: [string, any][] = []
+	for (const stateToken of molecule.tokens.values()) {
+		// biome-ignore lint/style/noNonNullAssertion: tokens of molecules must have a family
+		const tokenFamily = stateToken.family!
+		values.push([tokenFamily.key, store.valueMap.get(stateToken.key)])
+	}
+
+	for (const state of molecule.tokens.values()) {
+		disposeFromStore(store, state)
+	}
+	for (const child of molecule.below.values()) {
+		if (child.dependsOn === `all`) {
+			deallocateFromStore(store, child.key)
+		} else {
+			child.above.delete(molecule.stringKey)
+			if (child.above.size === 0) {
+				deallocateFromStore(store, child.key)
+			}
+		}
+	}
+	molecule.below.clear()
+
+	const disposalEvent: MoleculeDisposalModern = {
+		type: `molecule_disposal`,
+		subType: `modern`,
+		key: molecule.key,
+		values,
+		provenance,
+	}
+	const target = newest(store)
+	const isTransaction =
+		isChildStore(target) && target.transactionMeta.phase === `building`
+	if (isTransaction) {
+		target.transactionMeta.update.updates.push(disposalEvent)
+	} else {
+		target.on.moleculeDisposal.next(disposalEvent)
+	}
+	target.molecules.delete(molecule.stringKey)
+
+	for (const parent of molecule.above.values()) {
+		parent.below.delete(molecule.stringKey)
+	}
+}
+
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+export function realm<H extends Hierarchy>(store: Store) {
+	const root = makeRootMoleculeInStore(`root`, store)
+	return {
+		root,
+		allocate: <V extends Vassal<H>, A extends Above<V, H>>(
+			provenance: A,
+			key: V,
+		): Claim<H, V, A> => {
+			return allocateIntoStore(store, provenance, key)
+		},
+		deallocate: <V extends Vassal<H>, A extends Above<V, H>>(
+			claim: Claim<H, V, A>,
+		): void => {
+			deallocateFromStore(store, claim)
+		},
+	}
+}
+
+export const T$ = `T$`
+export type T$ = typeof T$
+export type TypeTag<T extends string> = [T$, T]
+export type SingularTypedKey<T extends string = string> = [T, string]
+export type CompoundTypedKey<
+	A extends string = string,
+	B extends string = string,
+	C extends string = string,
+> = [TypeTag<A>, TypedKey<B>, TypedKey<C>]
+export type TypedKey<
+	A extends string = string,
+	B extends string = string,
+	C extends string = string,
+> = CompoundTypedKey<A, B, C> | SingularTypedKey<A>
+type Scope = SingularTypedKey[]
+type MutualFealty = {
+	above: Scope
+	below: CompoundTypedKey
+	style: `all` | `any`
+}
+type ExclusiveFealty = {
+	above: TypedKey | `root`
+	below: Scope
+}
+type Fealty = ExclusiveFealty | MutualFealty
+
+export type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>
+
+export type Vassal<H extends Hierarchy> = {
+	[K in keyof H]: H[K] extends MutualFealty
+		? H[K][`below`]
+		: H[K] extends { below: Array<infer V> }
+			? V extends TypedKey
+				? V
+				: never
+			: never
+}[keyof H]
+
+export type Above<TK extends TypedKey, H extends Hierarchy> = {
+	[K in keyof H]: H[K] extends MutualFealty
+		? TK extends H[K][`below`]
+			? H[K][`above`]
+			: never
+		: H[K] extends { below: Array<infer V> }
+			? TK extends V
+				? H[K] extends ExclusiveFealty
+					? H[K][`above`]
+					: never
+				: never
+			: never
+}[keyof H]
+
+export type Below<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
+	[K in keyof H]: H[K] extends MutualFealty
+		? TK extends H[K][`above`]
+			? H[K][`below`]
+			: TK extends H[K][`above`][number]
+				? H[K][`below`]
+				: never
+		: H[K] extends { above: infer V }
+			? TK extends V
+				? H[K] extends ExclusiveFealty
+					? H[K][`below`][number]
+					: never
+				: never
+			: never
+}[keyof H]
+
+export type Mutuals<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
+	[K in keyof H]: H[K] extends MutualFealty
+		? TK extends H[K][`above`][number]
+			? [mutual: Exclude<H[K][`above`][number], TK>, below: H[K][`below`]]
+			: never
+		: never
+}[keyof H]

package/src/molecule.ts

@@ -1,7 +1,9 @@
 import type {
 	ActorToolkit,
 	MoleculeCreation,
+	MoleculeCreationClassic,
 	MoleculeDisposal,
+	MoleculeDisposalClassic,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
@@ -86,7 +88,7 @@ export type MoleculeFamilyToken<M extends MoleculeConstructor> = {
 }
 export type MoleculeFamily<M extends MoleculeConstructor> = Flat<
 	MoleculeFamilyToken<M> & {
-		subject: Subject<MoleculeCreation<M> | MoleculeDisposal>
+		subject: Subject<MoleculeCreationClassic<M> | MoleculeDisposalClassic>
 		dependsOn: `all` | `any`
 		new: M
 	}
@@ -121,7 +123,7 @@ export type MoleculeType<T extends MoleculeFamilyToken<any>> =
 			: never
 export type MoleculeKey<M extends MoleculeConstructor> = InstanceType<M>[`key`]
 
-export function makeRootMolecule(
+export function makeRootMoleculeInStore(
 	key: string,
 	store: Store = IMPLICIT.STORE,
 ): MoleculeToken<ObjectConstructor> {

package/src/transaction.ts

@@ -16,7 +16,7 @@ import {
 	createTransaction,
 	IMPLICIT,
 } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import type {
 	disposeState,
@@ -25,7 +25,6 @@ import type {
 	ReadableToken,
 	TokenType,
 	WritableSelectorToken,
-	WritableToken,
 } from "."
 
 export type TransactionToken<F extends Func> = {
@@ -44,20 +43,39 @@ export type StateDisposal<Token extends ReadableToken<any>> = {
 	value?: TokenType<Token>
 }
 
-export type MoleculeCreation<M extends MoleculeConstructor> = {
+export type MoleculeCreationClassic<M extends MoleculeConstructor> = {
 	type: `molecule_creation`
+	subType: `classic`
 	token: MoleculeToken<M>
 	family: MoleculeFamilyToken<M>
 	context: MoleculeToken<any>[]
 	params: MoleculeParams<M>
 }
-export type MoleculeDisposal = {
+export type MoleculeCreationModern = {
+	type: `molecule_creation`
+	subType: `modern`
+	key: Canonical
+	provenance: Canonical
+}
+export type MoleculeCreation<M extends MoleculeConstructor> =
+	| MoleculeCreationClassic<M>
+	| MoleculeCreationModern
+export type MoleculeDisposalClassic = {
 	type: `molecule_disposal`
+	subType: `classic`
 	token: MoleculeToken<any>
 	family: MoleculeFamilyToken<any>
 	context: MoleculeToken<any>[]
 	values: [key: string, value: any][]
 }
+export type MoleculeDisposalModern = {
+	type: `molecule_disposal`
+	subType: `modern`
+	key: Canonical
+	provenance: Canonical
+	values: [key: string, value: any][]
+}
+export type MoleculeDisposal = MoleculeDisposalClassic | MoleculeDisposalModern
 
 export type TransactionUpdateContent =
 	| KeyedStateUpdate<unknown>