atom.io 0.6.6 → 0.6.8

package/src/internal/operation.ts

@@ -1,6 +1,3 @@
-import type { Hamt } from "hamt_plus"
-import HAMT from "hamt_plus"
-
 import type { Atom, ReadonlySelector, Selector } from "."
 import { target } from "."
 import type { Store } from "./store"
@@ -14,7 +11,7 @@ export type OperationProgress =
 	| {
 			open: true
 			done: Set<string>
-			prev: Hamt<any, string>
+			prev: Map<string, any>
 			time: number
 			token: StateToken<any>
 	  }
@@ -30,7 +27,7 @@ export const openOperation = (token: StateToken<any>, store: Store): void => {
 	core.operation = {
 		open: true,
 		done: new Set(),
-		prev: store.valueMap,
+		prev: new Map(store.valueMap),
 		time: Date.now(),
 		token,
 	}
@@ -74,9 +71,9 @@ export const recallState = <T>(
 		store.config.logger?.warn(
 			`recall called outside of an operation. This is probably a bug.`,
 		)
-		return HAMT.get(state.key, core.valueMap)
+		return core.valueMap.get(state.key)
 	}
-	return HAMT.get(state.key, core.operation.prev)
+	return core.operation.prev.get(state.key)
 }
 
 export const cacheValue = (
@@ -85,7 +82,7 @@ export const cacheValue = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.valueMap = HAMT.set(key, value, core.valueMap)
+	core.valueMap.set(key, value)
 }
 
 export const evictCachedValue = (
@@ -93,24 +90,24 @@ export const evictCachedValue = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.valueMap = HAMT.remove(key, core.valueMap)
+	core.valueMap.delete(key)
 }
 export const readCachedValue = <T>(
 	key: string,
 	store: Store = IMPLICIT.STORE,
-): T => HAMT.get(key, target(store).valueMap)
+): T => target(store).valueMap.get(key)
 
 export const isValueCached = (
 	key: string,
 	store: Store = IMPLICIT.STORE,
-): boolean => HAMT.has(key, target(store).valueMap)
+): boolean => target(store).valueMap.has(key)
 
 export const storeAtom = (
 	atom: Atom<any>,
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.atoms = HAMT.set(atom.key, atom, core.atoms)
+	core.atoms.set(atom.key, atom)
 }
 
 export const storeSelector = (
@@ -118,7 +115,7 @@ export const storeSelector = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.selectors = HAMT.set(selector.key, selector, core.selectors)
+	core.selectors.set(selector.key, selector)
 }
 
 export const storeReadonlySelector = (
@@ -126,11 +123,7 @@ export const storeReadonlySelector = (
 	store: Store = IMPLICIT.STORE,
 ): void => {
 	const core = target(store)
-	core.readonlySelectors = HAMT.set(
-		selector.key,
-		selector,
-		core.readonlySelectors,
-	)
+	core.readonlySelectors.set(selector.key, selector)
 }
 
 export const hasKeyBeenUsed = (
@@ -139,8 +132,8 @@ export const hasKeyBeenUsed = (
 ): boolean => {
 	const core = target(store)
 	return (
-		HAMT.has(key, core.atoms) ||
-		HAMT.has(key, core.selectors) ||
-		HAMT.has(key, core.readonlySelectors)
+		core.atoms.has(key) ||
+		core.selectors.has(key) ||
+		core.readonlySelectors.has(key)
 	)
 }

package/src/internal/selector/create-read-write-selector.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import { become } from "~/packages/anvl/src/function"
 
 import { Subject } from ".."
@@ -30,8 +28,14 @@ export const createReadWriteSelector = <T>(
 	}
 
 	const setSelf = (next: T | ((oldValue: T) => T)): void => {
-		store.config.logger?.info(`   <- "${options.key}" became`, next)
 		const oldValue = getSelf()
+		store.config.logger?.info(
+			`   <- "${options.key}" went (`,
+			oldValue,
+			`->`,
+			next,
+			`)`,
+		)
 		const newValue = become(next)(oldValue)
 		cacheValue(options.key, newValue, store)
 		markDone(options.key, store)
@@ -49,13 +53,15 @@ export const createReadWriteSelector = <T>(
 		type: `selector`,
 		...(family && { family }),
 	}
-	core.selectors = HAMT.set(options.key, mySelector, core.selectors)
+	core.selectors.set(options.key, mySelector)
 	const initialValue = getSelf()
 	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
 	const token: SelectorToken<T> = {
 		key: options.key,
 		type: `selector`,
-		family,
+	}
+	if (family) {
+		token.family = family
 	}
 	store.subject.selectorCreation.next(token)
 	return token

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

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import { registerSelector } from "./register-selector"
 import { Subject } from ".."
 import type {
@@ -35,17 +33,15 @@ export const createReadonlySelector = <T>(
 		type: `readonly_selector`,
 		...(family && { family }),
 	}
-	core.readonlySelectors = HAMT.set(
-		options.key,
-		readonlySelector,
-		core.readonlySelectors,
-	)
+	core.readonlySelectors.set(options.key, readonlySelector)
 	const initialValue = getSelf()
 	store.config.logger?.info(`   ✨ "${options.key}" =`, initialValue)
 	const token: ReadonlySelectorToken<T> = {
 		key: options.key,
 		type: `readonly_selector`,
-		family,
+	}
+	if (family) {
+		token.family = family
 	}
 	store.subject.selectorCreation.next(token)
 	return token

package/src/internal/selector-internal.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import { target, IMPLICIT } from "."
 import type { Store, Subject } from "."
 import { createReadWriteSelector } from "./selector/create-read-write-selector"
@@ -47,7 +45,7 @@ export function selector__INTERNAL<T>(
 ): ReadonlySelectorToken<T> | SelectorToken<T> {
 	const core = target(store)
 
-	if (HAMT.has(options.key, core.selectors)) {
+	if (core.selectors.has(options.key)) {
 		store.config.logger?.error(
 			`Key "${options.key}" already exists in the store.`,
 		)

package/src/internal/set.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import { become } from "~/packages/anvl/src/function"
 
 import type { Atom, Selector, Store } from "."
@@ -37,8 +35,7 @@ export const evictDownStream = <T>(
 			return
 		}
 		const state =
-			HAMT.get(stateKey, core.selectors) ??
-			HAMT.get(stateKey, core.readonlySelectors)
+			core.selectors.get(stateKey) ?? core.readonlySelectors.get(stateKey)
 		if (!state) {
 			store.config.logger?.info(
 				`   || ${stateKey} is an atom, and can't be downstream`,

package/src/internal/store.ts

@@ -1,6 +1,3 @@
-import type { Hamt } from "hamt_plus"
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 import { doNothing } from "~/packages/anvl/src/function"
 import { Join } from "~/packages/anvl/src/join"
@@ -40,16 +37,16 @@ export type StoreCore = Pick<
 >
 
 export interface Store {
-	atoms: Hamt<Atom<any>, string>
+	atoms: Map<string, Atom<any>>
 	atomsThatAreDefault: Set<string>
-	readonlySelectors: Hamt<ReadonlySelector<any>, string>
+	readonlySelectors: Map<string, ReadonlySelector<any>>
 	selectorAtoms: Join<null, `selectorKey`, `atomKey`>
 	selectorGraph: Join<{ source: string }>
-	selectors: Hamt<Selector<any>, string>
+	selectors: Map<string, Selector<any>>
 	timelineAtoms: Join<null, `timelineKey`, `atomKey`>
-	timelines: Hamt<Timeline, string>
-	transactions: Hamt<Transaction<any>, string>
-	valueMap: Hamt<any, string>
+	timelines: Map<string, Timeline>
+	transactions: Map<string, Transaction<any>>
+	valueMap: Map<string, any>
 
 	subject: {
 		atomCreation: Subject<AtomToken<unknown>>
@@ -71,7 +68,7 @@ export interface Store {
 }
 
 export const createStore = (name: string, store: Store | null = null): Store => {
-	const copiedStore = {
+	const created = {
 		...(store ??
 			(() => ({
 				atomsThatAreDefault: new Set(),
@@ -79,14 +76,14 @@ export const createStore = (name: string, store: Store | null = null): Store =>
 					.from(`selectorKey`)
 					.to(`atomKey`),
 				selectorGraph: new Join({ relationType: `n:n` }),
-				valueMap: HAMT.make<any, string>(),
 			}))()),
 
-		atoms: HAMT.make<Atom<any>, string>(),
-		readonlySelectors: HAMT.make<ReadonlySelector<any>, string>(),
-		selectors: HAMT.make<Selector<any>, string>(),
-		transactions: HAMT.make<Transaction<any>, string>(),
-		timelines: HAMT.make<Timeline, string>(),
+		valueMap: new Map(store?.valueMap),
+		atoms: new Map(),
+		readonlySelectors: new Map(),
+		selectors: new Map(),
+		transactions: new Map(),
+		timelines: new Map(),
 
 		timelineAtoms: new Join({ relationType: `1:n` })
 			.from(`timelineKey`)
@@ -122,22 +119,22 @@ export const createStore = (name: string, store: Store | null = null): Store =>
 
 	store?.atoms.forEach((atom) => {
 		const copiedAtom = { ...atom, subject: new Subject() } satisfies Atom<any>
-		copiedStore.atoms = HAMT.set(atom.key, copiedAtom, copiedStore.atoms)
+		created.atoms.set(atom.key, copiedAtom)
 	})
 	store?.readonlySelectors.forEach((selector) => {
-		selector.install(copiedStore)
+		selector.install(created)
 	})
 	store?.selectors.forEach((selector) => {
-		selector.install(copiedStore)
+		selector.install(created)
 	})
 	store?.transactions.forEach((tx) => {
-		tx.install(copiedStore)
+		tx.install(created)
 	})
 	store?.timelines.forEach((timeline) => {
-		timeline.install(copiedStore)
+		timeline.install(created)
 	})
 
-	return copiedStore
+	return created
 }
 
 export const IMPLICIT = {

package/src/internal/subscribe-internal.ts

@@ -74,7 +74,13 @@ export const subscribeToRootAtoms = <T>(
 						)
 						const oldValue = recallState(state, store)
 						const newValue = getState__INTERNAL(state, store)
-						store.config.logger?.info(`   <- ${state.key} became`, newValue)
+						store.config.logger?.info(
+							`   <- "${state.key}" went (`,
+							oldValue,
+							`->`,
+							newValue,
+							`)`,
+						)
 						state.subject.next({ newValue, oldValue })
 					})
 			  })

package/src/internal/time-travel-internal.ts

@@ -21,7 +21,7 @@ export const redo__INTERNAL = (
 		)
 		return
 	}
-	timelineData.timeTraveling = true
+	timelineData.timeTraveling = `into_future`
 	const update = timelineData.history[timelineData.at]
 	switch (update.type) {
 		case `atom_update`: {
@@ -40,7 +40,7 @@ export const redo__INTERNAL = (
 	}
 	++timelineData.at
 	timelineData.subject.next(`redo`)
-	timelineData.timeTraveling = false
+	timelineData.timeTraveling = null
 	store.config.logger?.info(
 		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
 	)
@@ -64,7 +64,7 @@ export const undo__INTERNAL = (
 		)
 		return
 	}
-	timelineData.timeTraveling = true
+	timelineData.timeTraveling = `into_past`
 
 	--timelineData.at
 	const update = timelineData.history[timelineData.at]
@@ -84,7 +84,7 @@ export const undo__INTERNAL = (
 		}
 	}
 	timelineData.subject.next(`undo`)
-	timelineData.timeTraveling = false
+	timelineData.timeTraveling = null
 	store.config.logger?.info(
 		`⏹️ "${token.key}" is now at ${timelineData.at} / ${timelineData.history.length}`,
 	)

package/src/internal/timeline/add-atom-to-timeline.ts

@@ -49,7 +49,7 @@ export const addAtomToTimeline = (
 				: `)`,
 		)
 
-		if (tl.timeTraveling === false) {
+		if (tl.timeTraveling === null) {
 			if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
 				const mostRecentUpdate: TimelineUpdate | undefined = tl.history.at(-1)
 				if (mostRecentUpdate === undefined) {
@@ -80,7 +80,7 @@ export const addAtomToTimeline = (
 					tl.transactionKey = currentTransactionKey
 					const subscription = currentTransaction.subject.subscribe((update) => {
 						subscription.unsubscribe()
-						if (tl.timeTraveling === false && currentTransactionTime) {
+						if (tl.timeTraveling === null && currentTransactionTime) {
 							if (tl.at !== tl.history.length) {
 								tl.history.splice(tl.at)
 							}

package/src/internal/timeline-internal.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store } from "."
@@ -33,7 +31,7 @@ export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
 export type Timeline = {
 	key: string
 	at: number
-	timeTraveling: boolean
+	timeTraveling: `into_future` | `into_past` | null
 	history: TimelineUpdate[]
 	selectorTime: number | null
 	transactionKey: string | null
@@ -55,7 +53,7 @@ export function timeline__INTERNAL(
 	const tl: Timeline = {
 		key: options.key,
 		at: 0,
-		timeTraveling: false,
+		timeTraveling: null,
 		selectorTime: null,
 		transactionKey: null,
 		...data,
@@ -99,7 +97,7 @@ export function timeline__INTERNAL(
 		})
 	}
 
-	store.timelines = HAMT.set(options.key, tl, store.timelines)
+	store.timelines.set(options.key, tl)
 	const token: TimelineToken = {
 		key: options.key,
 		type: `timeline`,

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

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store } from ".."
@@ -26,10 +24,15 @@ export const applyTransaction = <ƒ extends ƒn>(
 
 	for (const { key, newValue } of atomUpdates) {
 		const token: AtomToken<unknown> = { key, type: `atom` }
-		if (!HAMT.has(token.key, store.valueMap)) {
-			const newAtom = HAMT.get(token.key, store.transactionStatus.core.atoms)
-			store.atoms = HAMT.set(newAtom.key, newAtom, store.atoms)
-			store.valueMap = HAMT.set(newAtom.key, newAtom.default, store.valueMap)
+		if (!store.valueMap.has(token.key)) {
+			const newAtom = store.transactionStatus.core.atoms.get(token.key)
+			if (!newAtom) {
+				throw new Error(
+					`Absurd Error: Atom "${token.key}" not found while copying updates from transaction "${store.transactionStatus.key}" to store "${store.config.name}"`,
+				)
+			}
+			store.atoms.set(newAtom.key, newAtom)
+			store.valueMap.set(newAtom.key, newAtom.default)
 			store.config.logger?.info(`🔧`, `add atom "${newAtom.key}"`)
 		}
 		setState(token, newValue, store)

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

@@ -10,17 +10,17 @@ export const buildTransaction = (
 		phase: `building`,
 		time: Date.now(),
 		core: {
-			atoms: store.atoms,
+			atoms: new Map(store.atoms),
 			atomsThatAreDefault: store.atomsThatAreDefault,
 			operation: { open: false },
-			readonlySelectors: store.readonlySelectors,
-			timelines: store.timelines,
+			readonlySelectors: new Map(store.readonlySelectors),
+			timelines: new Map(store.timelines),
 			timelineAtoms: store.timelineAtoms,
-			transactions: store.transactions,
+			transactions: new Map(store.transactions),
 			selectorAtoms: store.selectorAtoms,
 			selectorGraph: store.selectorGraph,
-			selectors: store.selectors,
-			valueMap: store.valueMap,
+			selectors: new Map(store.selectors),
+			valueMap: new Map(store.valueMap),
 		},
 		atomUpdates: [],
 		params,

package/src/internal/transaction-internal.ts

@@ -1,5 +1,3 @@
-import HAMT from "hamt_plus"
-
 import type { ƒn } from "~/packages/anvl/src/function"
 
 import type { Store, StoreCore } from "."
@@ -51,11 +49,7 @@ export function transaction__INTERNAL<ƒ extends ƒn>(
 		subject: new Subject(),
 	}
 	const core = target(store)
-	core.transactions = HAMT.set(
-		newTransaction.key,
-		newTransaction,
-		core.transactions,
-	)
+	core.transactions.set(newTransaction.key, newTransaction)
 	const token = deposit(newTransaction)
 	store.subject.transactionCreation.next(token)
 	return token

package/src/introspection/attach-timeline-family.ts

@@ -1,7 +1,7 @@
 import type { ReadonlySelectorFamily, Store } from "atom.io"
-import { __INTERNAL__ } from "atom.io"
+import { __INTERNAL__, timeline } from "atom.io"
 
-import type { Timeline } from "../internal"
+import { withdraw, type Timeline, Subject } from "../internal"
 
 export const attachTimelineFamily = (
 	store: Store = __INTERNAL__.IMPLICIT.STORE,
@@ -12,11 +12,21 @@ export const attachTimelineFamily = (
 	>(
 		{
 			key: `👁‍🗨 Timeline Update Log (Internal)`,
-			default: (key) => store.timelines.get(key),
+			default: (key) =>
+				store.timelines.get(key) ?? {
+					key: ``,
+					at: 0,
+					timeTraveling: null,
+					history: [],
+					selectorTime: null,
+					transactionKey: null,
+					install: () => {},
+					subject: new Subject(),
+				},
 			effects: (key) => [
 				({ setSelf }) => {
 					const tl = store.timelines.get(key)
-					tl.subject.subscribe((_) => {
+					tl?.subject.subscribe((_) => {
 						if (store.operation.open === true) {
 							const subscription = store.subject.operationStatus.subscribe(
 								(operationStatus) => {

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

@@ -16,7 +16,7 @@ export const attachTransactionLogs = (
 			effects: (key) => [
 				({ setSelf }) => {
 					const tx = store.transactions.get(key)
-					tx.subject.subscribe((transactionUpdate) => {
+					tx?.subject.subscribe((transactionUpdate) => {
 						if (transactionUpdate.key === key) {
 							setSelf((state) => [...state, transactionUpdate])
 						}

package/src/json/select-json.ts

@@ -2,7 +2,7 @@ import * as AtomIO from "atom.io"
 
 import type { Json, JsonInterface } from "~/packages/anvl/src/json"
 
-export const selectJson = <T, J extends Json>(
+export const selectJson = <T, J extends Json.Serializable>(
 	atom: AtomIO.AtomToken<T>,
 	transform: JsonInterface<T, J>,
 	store: AtomIO.Store = AtomIO.__INTERNAL__.IMPLICIT.STORE,

package/src/react-devtools/AtomIODevtools.tsx

@@ -1,7 +1,6 @@
 import { useO, useIO } from "atom.io/react"
 import { LayoutGroup, motion, spring } from "framer-motion"
 import { useRef } from "react"
-import type { FC } from "react"
 
 import {
 	atomIndex,
@@ -16,7 +15,7 @@ import { TransactionIndex } from "./TransactionIndex"
 
 import "./devtools.scss"
 
-export const AtomIODevtools: FC = () => {
+export const AtomIODevtools = (): JSX.Element => {
 	const constraintsRef = useRef(null)
 
 	const [devtoolsAreOpen, setDevtoolsAreOpen] = useIO(devtoolsAreOpenState)

package/src/react-devtools/StateEditor.tsx

@@ -3,7 +3,9 @@ import { useO, useIO } from "atom.io/react"
 import type { FC } from "react"
 
 import { fallback } from "~/packages/anvl/src/function"
-import { isJson } from "~/packages/anvl/src/json"
+import { Join } from "~/packages/anvl/src/join"
+import { isJson } from "~/packages/anvl/src/refinement/refine-json"
+import { RelationEditor } from "~/packages/hamr/src/react-data-designer"
 import { ElasticInput } from "~/packages/hamr/src/react-elastic-input"
 import { JsonEditor } from "~/packages/hamr/src/react-json-editor"
 
@@ -13,6 +15,8 @@ export const StateEditor: FC<{
 	const [data, set] = useIO(token)
 	return isJson(data) ? (
 		<JsonEditor data={data} set={set} schema={true} />
+	) : data instanceof Join ? (
+		<RelationEditor data={data} set={set} />
 	) : (
 		<div className="json_editor">
 			<ElasticInput

package/src/react-devtools/StateIndex.tsx

@@ -3,7 +3,10 @@ import { getState, selectorFamily } from "atom.io"
 import { useO, useIO } from "atom.io/react"
 import type { FC } from "react"
 
-import { isJson, refineJsonType } from "~/packages/anvl/src/json"
+import {
+	isJson,
+	refineJsonType,
+} from "~/packages/anvl/src/refinement/refine-json"
 
 import { findViewIsOpenState, primitiveRefinery } from "."
 import { button } from "./Button"

package/src/react-devtools/devtools.scss

@@ -241,7 +241,6 @@ main.atom_io_devtools {
 
   .json_editor {
     input {
-      // font-size: 20px;
       font-family: theia;
       border: none;
       border-bottom: 1px solid;

package/src/react-explorer/AtomIOExplorer.tsx

@@ -3,7 +3,7 @@ import type { FC, ReactNode } from "react"
 import { useEffect } from "react"
 import { Link, MemoryRouter, useLocation } from "react-router-dom"
 
-import { ErrorBoundary } from "~/packages/hamr/src/react-error-boundary"
+import { RecoverableErrorBoundary } from "~/packages/hamr/src/react-error-boundary"
 import type { WC } from "~/packages/hamr/src/react-json-editor"
 
 import { attachExplorerState } from "./explorer-states"
@@ -132,14 +132,14 @@ export const composeExplorer = ({
 		const view = useO(findViewState(focusedViewId))
 		return (
 			<div className="space">
-				<ErrorBoundary>
+				<RecoverableErrorBoundary>
 					<MemoryRouter
 						initialEntries={view.location ? [view.location.pathname] : []}
 					>
 						<TabBar spaceId={spaceId} viewIds={viewIds} />
 						<View viewId={focusedViewId}>{children}</View>
 					</MemoryRouter>
-				</ErrorBoundary>
+				</RecoverableErrorBoundary>
 			</div>
 		)
 	}

package/src/realtime/hook-composition/expose-family.ts

@@ -17,7 +17,7 @@ const subscribeToTokenCreation = <T>(
 
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 export const useExposeFamily = ({ socket, store }: ServerConfig) => {
-	return function exposeFamily<J extends Json>(
+	return function exposeFamily<J extends Json.Serializable>(
 		family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
 		index: AtomIO.StateToken<Set<string>>,
 	): () => void {
@@ -39,7 +39,7 @@ export const useExposeFamily = ({ socket, store }: ServerConfig) => {
 			}
 		}
 
-		const fillSubRequest = (subKey?: AtomIO.Serializable) => {
+		const fillSubRequest = (subKey?: AtomIO.Json.Serializable) => {
 			if (subKey === undefined) {
 				const keys = AtomIO.getState(index, store)
 				keys.forEach((key) => {

package/src/realtime/hook-composition/expose-single.ts

@@ -5,7 +5,7 @@ import type { ServerConfig } from ".."
 
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 export const useExposeSingle = ({ socket, store }: ServerConfig) => {
-	return function exposeSingle<J extends Json>(
+	return function exposeSingle<J extends Json.Serializable>(
 		token: AtomIO.StateToken<J>,
 	): () => void {
 		let unsubscribeFromStateUpdates: (() => void) | null = null

package/src/realtime/hook-composition/receive-state.ts

@@ -5,7 +5,7 @@ import type { ServerConfig } from ".."
 
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 export const useReceiveState = ({ socket, store }: ServerConfig) => {
-	return function receiveState<J extends Json>(
+	return function receiveState<J extends Json.Serializable>(
 		token: AtomIO.StateToken<J>,
 	): () => void {
 		const publish = (newValue: J) => AtomIO.setState(token, newValue, store)