atom.io 0.32.3 → 0.33.0

package/{internal/src → src/internal}/index.ts

@@ -30,6 +30,7 @@ export * from "./get-environment-data"
 export * from "./get-state"
 export * from "./get-trace"
 export * from "./ingest-updates"
+export * from "./install-into-store"
 export * from "./join"
 export * from "./junction"
 export * from "./keys"

package/{internal/src → src/internal}/join/find-relations-in-store.ts

@@ -26,11 +26,13 @@ export function findRelationsInStore<
 			const keyBA = `${token.b}KeyOf${capitalize(token.a)}`
 			relations = {
 				get [keyAB]() {
+					// @ts-expect-error way too complicated to represent
 					const familyAB = myJoin.states[keyAB as any]
 					const state = findInStore(store, familyAB, key)
 					return state
 				},
 				get [keyBA]() {
+					// @ts-expect-error way too complicated to represent
 					const familyBA = myJoin.states[keyBA as any]
 					const state = findInStore(store, familyBA, key)
 					return state
@@ -41,11 +43,13 @@ export function findRelationsInStore<
 				const entryBA = `${token.b}EntryOf${capitalize(token.a)}`
 				Object.assign(relations, {
 					get [entryAB]() {
+						// @ts-expect-error way too complicated to represent
 						const familyAB = myJoin.states[entryAB as any]
 						const state = findInStore(store, familyAB, key)
 						return state
 					},
 					get [entryBA]() {
+						// @ts-expect-error way too complicated to represent
 						const familyBA = myJoin.states[entryBA as any]
 						const state = findInStore(store, familyBA, key)
 						return state
@@ -59,11 +63,13 @@ export function findRelationsInStore<
 			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`
 			relations = {
 				get [keyAB]() {
+					// @ts-expect-error way too complicated to represent
 					const familyAB = myJoin.states[keyAB as any]
 					const state = findInStore(store, familyAB, key)
 					return state
 				},
 				get [keysBA]() {
+					// @ts-expect-error way too complicated to represent
 					const familyBA = myJoin.states[keysBA as any]
 					const state = findInStore(store, familyBA, key)
 					return state
@@ -74,11 +80,13 @@ export function findRelationsInStore<
 				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`
 				Object.assign(relations, {
 					get [entryAB]() {
+						// @ts-expect-error way too complicated to represent
 						const familyAB = myJoin.states[entryAB as any]
 						const state = findInStore(store, familyAB, key)
 						return state
 					},
 					get [entriesBA]() {
+						// @ts-expect-error way too complicated to represent
 						const familyBA = myJoin.states[entriesBA as any]
 						const state = findInStore(store, familyBA, key)
 						return state
@@ -92,11 +100,13 @@ export function findRelationsInStore<
 			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`
 			relations = {
 				get [keysAB]() {
+					// @ts-expect-error way too complicated to represent
 					const familyAB = myJoin.states[keysAB as any]
 					const state = findInStore(store, familyAB, key)
 					return state
 				},
 				get [keysBA]() {
+					// @ts-expect-error way too complicated to represent
 					const familyBA = myJoin.states[keysBA as any]
 					const state = findInStore(store, familyBA, key)
 					return state
@@ -107,11 +117,13 @@ export function findRelationsInStore<
 				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`
 				Object.assign(relations, {
 					get [entriesAB]() {
+						// @ts-expect-error way too complicated to represent
 						const familyAB = myJoin.states[entriesAB as any]
 						const state = findInStore(store, familyAB, key)
 						return state
 					},
 					get [entriesBA]() {
+						// @ts-expect-error way too complicated to represent
 						const familyBA = myJoin.states[entriesBA as any]
 						const state = findInStore(store, familyBA, key)
 						return state

package/{internal/src → src/internal}/junction.ts

@@ -83,8 +83,9 @@ export class Junction<
 	public readonly a: ASide
 	public readonly b: BSide
 	public readonly cardinality: `1:1` | `1:n` | `n:n`
-	public readonly relations = new Map<AType | BType, Set<AType> | Set<BType>>()
-	public readonly contents = new Map<string, Content>()
+	public readonly relations: Map<AType | BType, Set<AType> | Set<BType>> =
+		new Map()
+	public readonly contents: Map<string, Content> = new Map()
 
 	public isAType?: Refinement<string, AType> | null
 	public isBType?: Refinement<string, BType> | null

package/{internal/src → src/internal}/lazy-map.ts

@@ -1,5 +1,5 @@
 export class LazyMap<K, V> extends Map<K, V> {
-	public deleted = new Set<K>()
+	public deleted: Set<K> = new Set()
 	protected readonly source: Map<K, V>
 
 	public constructor(source: Map<K, V>) {

package/{internal/src → src/internal}/mutable/tracker-family.ts

@@ -12,12 +12,9 @@ export class FamilyTracker<
 	FamilyMemberKey extends Canonical,
 > {
 	private trackers: Map<FamilyMemberKey, Tracker<Core>> = new Map()
-	private readonly Update: Core extends Transceiver<infer Signal>
-		? Signal
-		: never
 
 	public readonly latestUpdateAtoms: RegularAtomFamily<
-		typeof this.Update | null,
+		(Core extends Transceiver<infer Signal> ? Signal : never) | null,
 		FamilyMemberKey
 	>
 	public readonly mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>
@@ -27,7 +24,7 @@ export class FamilyTracker<
 		store: Store,
 	) {
 		const updateAtoms = createRegularAtomFamily<
-			typeof this.Update | null,
+			(Core extends Transceiver<infer Signal> ? Signal : never) | null,
 			FamilyMemberKey
 		>(
 			store,

package/{internal/src → src/internal}/mutable/tracker.ts

@@ -19,12 +19,12 @@ import type { Transceiver } from "./transceiver"
  * the tracker will update its own state to reflect the change.
  */
 export class Tracker<Mutable extends Transceiver<any>> {
-	private Update: Mutable extends Transceiver<infer Signal> ? Signal : never
-
 	private initializeState(
 		mutableState: MutableAtomToken<Mutable, Json.Serializable>,
 		store: Store,
-	): RegularAtomToken<typeof this.Update | null> {
+	): RegularAtomToken<
+		(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
+	> {
 		const latestUpdateStateKey = `*${mutableState.key}`
 		store.atoms.delete(latestUpdateStateKey)
 		store.valueMap.delete(latestUpdateStateKey)
@@ -52,11 +52,13 @@ export class Tracker<Mutable extends Transceiver<any>> {
 		return latestUpdateState
 	}
 
-	private unsubscribeFromInnerValue: () => void
-	private unsubscribeFromState: () => void
+	private unsubscribeFromInnerValue!: () => void
+	private unsubscribeFromState!: () => void
 	private observeCore(
 		mutableState: MutableAtomToken<Mutable, any>,
-		latestUpdateState: RegularAtomToken<typeof this.Update | null>,
+		latestUpdateState: RegularAtomToken<
+			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
+		>,
 		target: Store,
 	): void {
 		const subscriptionKey = `tracker:${target.config.name}:${
@@ -89,7 +91,9 @@ export class Tracker<Mutable extends Transceiver<any>> {
 
 	private updateCore<Core extends Transceiver<any>>(
 		mutableState: MutableAtomToken<Core, Json.Serializable>,
-		latestUpdateState: RegularAtomToken<typeof this.Update | null>,
+		latestUpdateState: RegularAtomToken<
+			(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
+		>,
 		target: Store,
 	): void {
 		const subscriptionKey = `tracker:${target.config.name}:${
@@ -158,9 +162,11 @@ export class Tracker<Mutable extends Transceiver<any>> {
 	}
 
 	public mutableState: MutableAtomToken<Mutable, Json.Serializable>
-	public latestUpdateState: RegularAtomToken<typeof this.Update | null>
+	public latestUpdateState: RegularAtomToken<
+		(Mutable extends Transceiver<infer Signal> ? Signal : never) | null
+	>
 
-	public [Symbol.dispose]: () => void
+	public [Symbol.dispose]!: () => void
 
 	public constructor(
 		mutableState: MutableAtomToken<Mutable, Json.Serializable>,

package/{internal/src → src/internal}/selector/register-selector.ts

@@ -86,6 +86,7 @@ export const registerSelector = (
 		const state = withdraw(target, token)
 		setAtomOrSelector(target, state, value)
 	}) as typeof setState,
-	find: ((token, key) => findInStore(store, token, key)) as typeof findState,
+	find: ((...args: Parameters<typeof findState>) =>
+		findInStore(store, ...args)) as typeof findState,
 	json: (token) => getJsonToken(store, token),
 })

package/{internal/src → src/internal}/store/store.ts

@@ -43,25 +43,26 @@ export class Store implements Lineage {
 	public parent: Store | null = null
 	public child: Store | null = null
 
-	public valueMap = new Map<string, any>()
-	public defaults = new Map<string, any>()
+	public valueMap: Map<string, any> = new Map()
+	public defaults: Map<string, any> = new Map()
 
-	public atoms = new Map<string, Atom<any>>()
-	public selectors = new Map<string, WritableSelector<any>>()
-	public readonlySelectors = new Map<string, ReadonlySelector<any>>()
+	public atoms: Map<string, Atom<any>> = new Map()
+	public selectors: Map<string, WritableSelector<any>> = new Map()
+	public readonlySelectors: Map<string, ReadonlySelector<any>> = new Map()
 
-	public atomsThatAreDefault = new Set<string>()
-	public selectorAtoms = new Junction({
-		between: [`selectorKey`, `atomKey`],
-		cardinality: `n:n`,
-	})
-	public selectorGraph = new Junction<
+	public atomsThatAreDefault: Set<string> = new Set()
+	public selectorAtoms: Junction<`selectorKey`, string, `atomKey`, string> =
+		new Junction({
+			between: [`selectorKey`, `atomKey`],
+			cardinality: `n:n`,
+		})
+	public selectorGraph: Junction<
 		`upstreamSelectorKey`,
 		string,
 		`downstreamSelectorKey`,
 		string,
 		{ source: string }
-	>(
+	> = new Junction(
 		{
 			between: [`upstreamSelectorKey`, `downstreamSelectorKey`],
 			cardinality: `n:n`,
@@ -70,17 +71,17 @@ export class Store implements Lineage {
 			makeContentKey: (...keys) => keys.sort().join(`:`),
 		},
 	)
-	public trackers = new Map<string, Tracker<Transceiver<any>>>()
-	public families = new Map<
+	public trackers: Map<string, Tracker<Transceiver<any>>> = new Map()
+	public families: Map<
 		string,
 		| MutableAtomFamily<any, any, any>
 		| ReadonlySelectorFamily<any, any>
 		| RegularAtomFamily<any, any>
 		| WritableSelectorFamily<any, any>
-	>()
-	public joins = new Map<string, Join<any, any, any, any, any, any>>()
+	> = new Map()
+	public joins: Map<string, Join<any, any, any, any, any, any>> = new Map()
 
-	public transactions = new Map<string, Transaction<Func>>()
+	public transactions: Map<string, Transaction<Func>> = new Map()
 	public transactionMeta: TransactionEpoch | TransactionProgress<Func> = {
 		epoch: new Map<string, number>(),
 		actionContinuities: new Junction({
@@ -89,27 +90,28 @@ export class Store implements Lineage {
 		}),
 	}
 
-	public timelines = new Map<string, Timeline<any>>()
-	public timelineTopics = new Junction<
+	public timelines: Map<string, Timeline<any>> = new Map()
+	public timelineTopics: Junction<
 		`timelineKey`,
 		string,
 		`topicKey`,
 		string,
 		{ topicType: `atom_family` | `atom` | `molecule_family` | `molecule` }
-	>({
+	> = new Junction({
 		between: [`timelineKey`, `topicKey`],
 		cardinality: `1:n`,
 	})
 
-	public disposalTraces = new CircularBuffer<{ key: string; trace: string }>(100)
+	public disposalTraces: CircularBuffer<{ key: string; trace: string }> =
+		new CircularBuffer(100)
 
-	public molecules = new Map<string, Molecule<Canonical>>()
-	public moleculeJoins = new Junction<
+	public molecules: Map<string, Molecule<Canonical>> = new Map()
+	public moleculeJoins: Junction<
 		`moleculeKey`,
 		stringified<Canonical>,
 		`joinKey`,
 		string
-	>(
+	> = new Junction(
 		{
 			between: [`moleculeKey`, `joinKey`],
 			cardinality: `n:n`,
@@ -118,13 +120,13 @@ export class Store implements Lineage {
 			makeContentKey: (...keys) => keys.sort().join(`:`),
 		},
 	)
-	public moleculeGraph = new Junction<
+	public moleculeGraph: Junction<
 		`upstreamMoleculeKey`,
 		stringified<Canonical> | `root`,
 		`downstreamMoleculeKey`,
 		stringified<Canonical>,
 		{ source: stringified<Canonical> }
-	>(
+	> = new Junction(
 		{
 			between: [`upstreamMoleculeKey`, `downstreamMoleculeKey`],
 			cardinality: `n:n`,
@@ -133,12 +135,12 @@ export class Store implements Lineage {
 			makeContentKey: (...keys) => keys.sort().join(`:`),
 		},
 	)
-	public moleculeData = new Junction<
+	public moleculeData: Junction<
 		`moleculeKey`,
 		stringified<Canonical>,
 		`stateFamilyKey`,
 		string
-	>(
+	> = new Junction(
 		{
 			between: [`moleculeKey`, `stateFamilyKey`],
 			cardinality: `n:n`,
@@ -147,25 +149,19 @@ export class Store implements Lineage {
 			makeContentKey: (...keys) => keys.sort().join(`:`),
 		},
 	)
-	public miscResources = new Map<string, Disposable>()
+	public miscResources: Map<string, Disposable> = new Map()
 
-	public on = {
-		atomCreation: new Subject<AtomToken<unknown>>(),
-		atomDisposal: new Subject<AtomToken<unknown>>(),
-		selectorCreation: new Subject<
-			ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>
-		>(),
-		selectorDisposal: new Subject<
-			ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>
-		>(),
-		timelineCreation: new Subject<TimelineToken<unknown>>(),
-		transactionCreation: new Subject<TransactionToken<Func>>(),
-		transactionApplying: new StatefulSubject<TransactionProgress<Func> | null>(
-			null,
-		),
-		operationClose: new Subject<OperationProgress>(),
-		moleculeCreation: new Subject<MoleculeCreation>(),
-		moleculeDisposal: new Subject<MoleculeDisposal>(),
+	public on: StoreEventCarrier = {
+		atomCreation: new Subject(),
+		atomDisposal: new Subject(),
+		selectorCreation: new Subject(),
+		selectorDisposal: new Subject(),
+		timelineCreation: new Subject(),
+		transactionCreation: new Subject(),
+		transactionApplying: new StatefulSubject(null),
+		operationClose: new Subject(),
+		moleculeCreation: new Subject(),
+		moleculeDisposal: new Subject(),
 	}
 	public operation: OperationProgress = { open: false }
 
@@ -250,15 +246,34 @@ export class Store implements Lineage {
 	}
 }
 
+export type StoreEventCarrier = {
+	atomCreation: Subject<AtomToken<unknown>>
+	atomDisposal: Subject<AtomToken<unknown>>
+	selectorCreation: Subject<
+		ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>
+	>
+	selectorDisposal: Subject<
+		ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>
+	>
+	timelineCreation: Subject<TimelineToken<unknown>>
+	transactionCreation: Subject<TransactionToken<Func>>
+	transactionApplying: StatefulSubject<TransactionProgress<Func> | null>
+	operationClose: Subject<OperationProgress>
+	moleculeCreation: Subject<MoleculeCreation>
+	moleculeDisposal: Subject<MoleculeDisposal>
+}
+
+declare global {
+	var ATOM_IO_IMPLICIT_STORE: Store | undefined
+}
+
 export const IMPLICIT = {
 	get STORE(): Store {
-		if (!globalThis.ATOM_IO_IMPLICIT_STORE) {
-			globalThis.ATOM_IO_IMPLICIT_STORE = new Store({
-				name: `IMPLICIT_STORE`,
-				lifespan: `ephemeral`,
-			})
-		}
-		return globalThis.ATOM_IO_IMPLICIT_STORE as Store
+		globalThis.ATOM_IO_IMPLICIT_STORE ??= new Store({
+			name: `IMPLICIT_STORE`,
+			lifespan: `ephemeral`,
+		})
+		return globalThis.ATOM_IO_IMPLICIT_STORE
 	},
 }
 

package/{internal/src → src/internal}/subject.ts

@@ -1,5 +1,5 @@
 export class Subject<T> {
-	public Subscriber: (value: T) => void
+	public Subscriber!: (value: T) => void
 
 	public subscribers: Map<string, this[`Subscriber`]> = new Map()
 

package/{internal/src → src/internal}/transaction/build-transaction.ts

@@ -79,7 +79,8 @@ export const buildTransaction = (
 			}) as typeof setState,
 			run: (token, identifier = arbitrary()) =>
 				actUponStore(child, token, identifier),
-			find: ((token, k) => findInStore(child, token, k)) as typeof findState,
+			find: ((...ps: Parameters<typeof findState>) =>
+				findInStore(store, ...ps)) as typeof findState,
 			json: (token) => getJsonToken(child, token),
 			dispose: ((...ps: Parameters<typeof disposeState>) => {
 				disposeFromStore(child, ...ps)

package/{introspection/src → src/introspection}/auditor.ts

@@ -73,7 +73,7 @@ export class Auditor {
 			)
 	}
 
-	public static readonly DEFAULT_LIST_RESOURCES_PARAM = {
+	public static readonly DEFAULT_LIST_RESOURCES_PARAM: ListResourcesParam = {
 		atomFamilies: true,
 		selectorFamilies: true,
 	} satisfies ListResourcesParam

package/{introspection/src → src/introspection}/differ.ts

@@ -157,7 +157,18 @@ export class Differ<
 	}
 }
 
-export const prettyJson = new Differ(primitiveRefinery, jsonTreeRefinery, {
+export const prettyJson: Differ<
+	{
+		number: (input: unknown) => input is number
+		string: (input: unknown) => input is string
+		boolean: (input: unknown) => input is boolean
+		null: (input: unknown) => input is null
+	},
+	{
+		object: (input: unknown) => input is Json.Tree.Object
+		array: (input: unknown) => input is Json.Tree.Array
+	}
+> = new Differ(primitiveRefinery, jsonTreeRefinery, {
 	number: diffNumber,
 	string: diffString,
 	boolean: diffBoolean,

package/{introspection/src → src/introspection}/refinery.ts

@@ -59,7 +59,12 @@ export class Refinery<SupportedTypes extends RefinementSupport> {
 	}
 }
 
-export const primitiveRefinery = new Refinery({
+export const primitiveRefinery: Refinery<{
+	number: (input: unknown) => input is number
+	string: (input: unknown) => input is string
+	boolean: (input: unknown) => input is boolean
+	null: (input: unknown) => input is null
+}> = new Refinery({
 	number: (input: unknown): input is number => typeof input === `number`,
 	string: (input: unknown): input is string => typeof input === `string`,
 	boolean: (input: unknown): input is boolean => typeof input === `boolean`,
@@ -74,12 +79,22 @@ export function isPlainObject(input: unknown): input is Json.Tree.Object {
 	return prototype === Object.prototype
 }
 
-export const jsonTreeRefinery = new Refinery({
+export const jsonTreeRefinery: Refinery<{
+	object: (input: unknown) => input is Json.Tree.Object
+	array: (input: unknown) => input is Json.Tree.Array
+}> = new Refinery({
 	object: isPlainObject,
 	array: (input: unknown): input is Json.Tree.Array => Array.isArray(input),
 })
 
-export const jsonRefinery = new Refinery({
+export const jsonRefinery: Refinery<{
+	object: (input: unknown) => input is Json.Tree.Object
+	array: (input: unknown) => input is Json.Tree.Array
+	number: (input: unknown) => input is number
+	string: (input: unknown) => input is string
+	boolean: (input: unknown) => input is boolean
+	null: (input: unknown) => input is null
+}> = new Refinery({
 	...primitiveRefinery.supported,
 	...jsonTreeRefinery.supported,
 })

package/{json/src → src/json}/entries.ts

@@ -1,6 +1,6 @@
 import type { Count, Flat } from "atom.io/internal"
 
-export type Entries<K extends PropertyKey = keyof any, V = any> = [K, V][]
+export type Entries<K extends PropertyKey = PropertyKey, V = any> = [K, V][]
 
 export type KeyOfEntries<E extends Entries> = E extends [infer K, any][]
 	? K

package/{json/src → src/json}/select-json-family.ts

@@ -1,7 +1,7 @@
 import type * as AtomIO from "atom.io"
 import type { Store, Transceiver } from "atom.io/internal"
+import { createWritableSelectorFamily } from "atom.io/internal"
 
-import { createWritableSelectorFamily } from "../../internal/src/families/create-writable-selector-family"
 import type { Canonical, Json, JsonInterface } from "."
 
 export function selectJsonFamily<

package/src/{realm.ts → main/realm.ts}

@@ -9,7 +9,7 @@ import {
 } from "atom.io/internal"
 import type { Canonical } from "atom.io/json"
 
-export const $claim = Symbol(`claim`)
+export const $claim: unique symbol = Symbol.for(`claim`)
 export type Claim<K extends Canonical> = K & { [$claim]?: true }
 
 export class Realm<H extends Hierarchy> {

package/src/{silo.ts → main/silo.ts}

@@ -12,13 +12,13 @@ import {
 	findInStore,
 	getFromStore,
 	IMPLICIT,
+	installIntoStore,
 	setIntoStore,
 	Store,
 	subscribeInStore,
 	timeTravel,
 } from "atom.io/internal"
 
-import { installIntoStore } from "../internal/src/install-into-store"
 import type {
 	AtomIOToken,
 	disposeState,

package/src/{transaction.ts → main/transaction.ts}

@@ -133,7 +133,7 @@ export function transaction<F extends Func>(
 
 export function runTransaction<F extends Func>(
 	token: TransactionToken<F>,
-	id = arbitrary(),
+	id: string = arbitrary(),
 ): (...parameters: Parameters<F>) => ReturnType<F> {
 	return actUponStore(IMPLICIT.STORE, token, id)
 }

package/{react/src → src/react}/store-context.tsx

@@ -2,7 +2,9 @@ import type { Store } from "atom.io/internal"
 import { IMPLICIT } from "atom.io/internal"
 import * as React from "react"
 
-export const StoreContext = React.createContext<Store>(IMPLICIT.STORE)
+export const StoreContext: React.Context<Store> = React.createContext(
+	IMPLICIT.STORE,
+)
 
 export const StoreProvider: React.FC<{
 	children: React.ReactNode

package/{react/src → src/react}/use-i.ts

@@ -20,13 +20,11 @@ export function useI<T, K extends Canonical>(
 ): <New extends T>(next: New | ((old: T) => New)) => void {
 	const store = React.useContext(StoreContext)
 	const token = parseStateOverloads(store, ...params)
-	const setter: React.MutableRefObject<
+	const setter: React.RefObject<
 		(<New extends T>(next: New | ((old: T) => New)) => void) | null
 	> = React.useRef(null)
-	if (setter.current === null) {
-		setter.current = (next) => {
-			setIntoStore(store, token, next)
-		}
+	setter.current ??= (next) => {
+		setIntoStore(store, token, next)
 	}
 	return setter.current
 }

package/{react-devtools/src → src/react-devtools}/AtomIODevtools.tsx

@@ -1,4 +1,4 @@
-import "./devtools.scss"
+import "./devtools.css"
 
 import { StoreContext, useI, useO } from "atom.io/react"
 import { LayoutGroup, motion, spring } from "motion/react"

package/{react-devtools/src → src/react-devtools}/Button.tsx

@@ -22,6 +22,8 @@ export const OpenClose: FC<{
 	)
 }
 
-export const button = {
+export const button: {
+	OpenClose: typeof OpenClose
+} = {
 	OpenClose,
 }

package/{react-devtools/src → src/react-devtools}/Updates.tsx

@@ -210,7 +210,11 @@ export const TimelineUpdateFC: React.FC<{
 	) : null
 }
 
-export const article = {
+export const article: {
+	AtomUpdate: typeof AtomUpdateFC
+	TransactionUpdate: typeof TransactionUpdateFC
+	TimelineUpdate: typeof TimelineUpdateFC
+} = {
 	AtomUpdate: AtomUpdateFC,
 	TransactionUpdate: TransactionUpdateFC,
 	TimelineUpdate: TimelineUpdateFC,