atom.io 0.17.0 → 0.18.1

package/src/atom.ts

@@ -45,23 +45,30 @@ export type RegularAtomFamilyOptions<T, K extends Json.Serializable> = {
 	effects?: (key: K) => AtomEffect<T>[]
 }
 
-export type RegularAtomFamily<
-	T,
-	K extends Json.Serializable = Json.Serializable,
-> = ((key: K) => RegularAtomToken<T>) & {
-	key: string
-	type: `atom_family`
-	subject: Subject<RegularAtomToken<T>>
-	install: (store: Store) => void
-	__T?: T
-	__K?: K
-}
 export type RegularAtomFamilyToken<T, K extends Json.Serializable> = {
 	key: string
 	type: `atom_family`
 	__T?: T
 	__K?: K
 }
+// biome-ignore format: intersection
+export type RegularAtomFamilyTokenWithCall<
+	T,
+	K extends Json.Serializable,
+> = 
+	& RegularAtomFamilyToken<T, K>
+	& {
+		/** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
+		(key: K): RegularAtomToken<T>
+	}
+// biome-ignore format: intersection
+export type RegularAtomFamily<T, K extends Json.Serializable> = 
+	& RegularAtomFamilyToken<T, K>
+	& {
+		(key: K): RegularAtomToken<T>
+		subject: Subject<RegularAtomToken<T>>
+		install: (store: Store) => void
+	}
 
 // biome-ignore format: intersection
 export type MutableAtomFamilyOptions<
@@ -77,23 +84,6 @@ export type MutableAtomFamilyOptions<
 		mutable: true,
 	}
 
-// biome-ignore format: intersection
-export type MutableAtomFamily<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-	K extends Json.Serializable,
-> = 
-	& JsonInterface<T, J>
-	& ((key: K) => MutableAtomToken<T, J>) 
-	& {
-			key: string
-			type: `mutable_atom_family`
-			subject: Subject<MutableAtomToken<T, J>>
-			install: (store: Store) => void
-			__T?: T
-			__J?: J
-			__K?: K
-		}
 export type MutableAtomFamilyToken<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
@@ -105,6 +95,30 @@ export type MutableAtomFamilyToken<
 	__J?: J
 	__K?: K
 }
+// biome-ignore format: intersection
+export type MutableAtomFamilyTokenWithCall<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+> = 
+	& MutableAtomFamilyToken<T, J, K>
+	& {
+		/** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
+		(key: K): MutableAtomToken<T, J>
+	}
+// biome-ignore format: intersection
+export type MutableAtomFamily<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+> = 
+	& JsonInterface<T, J>
+	& MutableAtomFamilyToken<T, J, K>
+	& {
+			(key: K): MutableAtomToken<T, J>
+			subject: Subject<MutableAtomToken<T, J>>
+			install: (store: Store) => void
+		}
 
 export type AtomFamily<T, K extends Json.Serializable = Json.Serializable> =
 	| MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K>
@@ -117,14 +131,18 @@ export function atomFamily<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 	K extends Json.Serializable,
->(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamily<T, J, K>
+>(
+	options: MutableAtomFamilyOptions<T, J, K>,
+): MutableAtomFamilyTokenWithCall<T, J, K>
 export function atomFamily<T, K extends Json.Serializable>(
 	options: RegularAtomFamilyOptions<T, K>,
-): RegularAtomFamily<T, K>
+): RegularAtomFamilyTokenWithCall<T, K>
 export function atomFamily<T, K extends Json.Serializable>(
 	options:
 		| MutableAtomFamilyOptions<any, any, any>
 		| RegularAtomFamilyOptions<T, K>,
-): MutableAtomFamily<any, any, any> | RegularAtomFamily<T, K> {
+):
+	| MutableAtomFamilyTokenWithCall<any, any, any>
+	| RegularAtomFamilyTokenWithCall<T, K> {
 	return createAtomFamily(options, IMPLICIT.STORE)
 }

package/src/logger.ts

@@ -6,20 +6,23 @@ const LoggerIconDictionary = {
 	"⏮️": `Transaction undo`,
 	"⏳": `Timeline event partially captured`,
 	"⏹️": `Time-travel complete`,
-	"💁": `Notice`,
-	"🔄": `Realtime transaction synchronized`,
 	"✅": `Realtime transaction success`,
 	"✨": `Computation complete`,
 	"❌": `Conflict prevents attempted action`,
 	"⭕": `Operation start`,
 	"🐞": `Possible bug in AtomIO`,
 	"👀": `Subscription added`,
+	"👋": `Greeting`,
+	"👍": `Realtime acknowledgment`,
 	"👪": `Family member added`,
+	"💁": `Notice`,
+	"💥": `Caught`,
 	"📁": `Stow update`,
 	"📃": `Copy mutable`,
 	"📖": `Read state`,
 	"📝": `Write state`,
 	"📢": `Notify subscribers`,
+	"🔄": `Realtime transaction synchronized`,
 	"🔌": `Register dependency`,
 	"🔍": `Discover root`,
 	"🔥": `Delete state`,
@@ -27,8 +30,8 @@ const LoggerIconDictionary = {
 	"🔨": `Create immutable atom`,
 	"🔴": `Operation complete`,
 	"🗑": `Evict cached value`,
-	"💥": `Caught`,
 	"🙈": `Subscription canceled`,
+	"🚀": `Performance measure`,
 	"🛄": `Apply transaction`,
 	"🛠️": `Install atom into store`,
 	"🛫": `Begin transaction`,
@@ -36,14 +39,20 @@ const LoggerIconDictionary = {
 	"🧮": `Computing selector`,
 	"🧹": `Prepare to evict`,
 	"🪂": `Abort transaction`,
-	"🚀": `Performance measure`,
+	"🤞": `Realtime optimistic update enqueued`,
+	"👈": `Realtime confirmed update enqueued`,
+	"🧑‍⚖️": `Realtime update beginning reconciliation`,
+	"🛎️": `Realtime transaction received`,
+	"🔭": `Determining realtime perspective`,
+	"🖌": `Redacting realtime update`,
+	"👁": `Determining perspective`,
 } as const
 export type LoggerIcon = keyof typeof LoggerIconDictionary
 export type TokenDenomination =
 	| `atom`
+	| `continuity`
 	| `mutable_atom`
 	| `readonly_selector`
-	| `realtime_sync_group`
 	| `selector`
 	| `state`
 	| `timeline`

package/src/selector.ts

@@ -41,41 +41,58 @@ export type ReadonlySelectorFamilyOptions<T, K extends Json.Serializable> = {
 	get: (key: K) => Read<() => T>
 }
 
-export type WritableSelectorFamily<
-	T,
-	K extends Json.Serializable = Json.Serializable,
-> = ((key: K) => WritableSelectorToken<T>) & {
-	key: string
-	type: `selector_family`
-	subject: Subject<WritableSelectorToken<T>>
-	install: (store: Store) => void
-	__T?: T
-	__K?: K
-}
 export type WritableSelectorFamilyToken<T, K extends Json.Serializable> = {
 	key: string
 	type: `selector_family`
 	__T?: T
 	__K?: K
 }
-
-export type ReadonlySelectorFamily<
+// biome-ignore format: intersection
+export type WritableSelectorFamilyTokenWithCall<
 	T,
-	K extends Json.Serializable = Json.Serializable,
-> = ((key: K) => ReadonlySelectorToken<T>) & {
-	key: string
-	type: `readonly_selector_family`
-	subject: Subject<ReadonlySelectorToken<T>>
-	install: (store: Store) => void
-	__T?: T
-	__K?: K
-}
+	K extends Json.Serializable,
+> = 
+	& WritableSelectorFamilyToken<T, K>
+	& {
+		/** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
+		(key: K): WritableSelectorToken<T>
+	}
+// biome-ignore format: intersection
+export type WritableSelectorFamily<T, K extends Json.Serializable> = 
+	& WritableSelectorFamilyToken<T, K> 
+	& {
+		(key: K): WritableSelectorToken<T>
+		subject: Subject<WritableSelectorToken<T>>
+		install: (store: Store) => void
+	}
+
 export type ReadonlySelectorFamilyToken<T, K extends Json.Serializable> = {
 	key: string
 	type: `readonly_selector_family`
 	__T?: T
 	__K?: K
 }
+// biome-ignore format: intersection
+export type ReadonlySelectorFamilyTokenWithCall<
+	T,
+	K extends Json.Serializable,
+> = 
+	& ReadonlySelectorFamilyToken<T, K>
+	& {
+		/** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
+		(key: K): ReadonlySelectorToken<T>
+	}
+// biome-ignore format: intersection
+export type ReadonlySelectorFamily<T, K extends Json.Serializable> = 
+	& ((key: K) => ReadonlySelectorToken<T>)
+	& {
+		key: string
+		type: `readonly_selector_family`
+		subject: Subject<ReadonlySelectorToken<T>>
+		install: (store: Store) => void
+		__T?: T
+		__K?: K
+	}
 
 export type SelectorFamily<T, K extends Json.Serializable> =
 	| ReadonlySelectorFamily<T, K>
@@ -86,14 +103,16 @@ export type SelectorFamilyToken<T, K extends Json.Serializable> =
 
 export function selectorFamily<T, K extends Json.Serializable>(
 	options: WritableSelectorFamilyOptions<T, K>,
-): WritableSelectorFamily<T, K>
+): WritableSelectorFamilyTokenWithCall<T, K>
 export function selectorFamily<T, K extends Json.Serializable>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
-): ReadonlySelectorFamily<T, K>
+): ReadonlySelectorFamilyTokenWithCall<T, K>
 export function selectorFamily<T, K extends Json.Serializable>(
 	options:
 		| ReadonlySelectorFamilyOptions<T, K>
 		| WritableSelectorFamilyOptions<T, K>,
-): ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K> {
+):
+	| ReadonlySelectorFamilyTokenWithCall<T, K>
+	| WritableSelectorFamilyTokenWithCall<T, K> {
 	return createSelectorFamily(options, IMPLICIT.STORE)
 }

package/src/subscribe.ts

@@ -1,6 +1,7 @@
 import type { Store } from "atom.io/internal"
 import {
 	IMPLICIT,
+	arbitrary,
 	subscribeToState,
 	subscribeToTimeline,
 	subscribeToTransaction,
@@ -49,7 +50,7 @@ export function subscribe<M extends TimelineManageable>(
 export function subscribe(
 	token: ReadableToken<any> | TimelineToken<any> | TransactionToken<any>,
 	handleUpdate: (update: any) => void,
-	key: string = Math.random().toString(36).slice(2),
+	key: string = arbitrary(),
 	store = IMPLICIT.STORE,
 ): () => void {
 	switch (token.type) {

package/src/timeline.ts

@@ -6,14 +6,14 @@ import type {
 } from "atom.io/internal"
 import { IMPLICIT, createTimeline, timeTravel } from "atom.io/internal"
 
-import type { AtomFamily, AtomToken } from "."
+import type { AtomFamilyToken, AtomToken } from "."
 
-export type TimelineManageable = AtomFamily<any, any> | AtomToken<any>
+export type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>
 
-export type TimelineToken<_> = {
+export type TimelineToken<M> = {
 	key: string
 	type: `timeline`
-	__brand?: _
+	__M?: M
 }
 
 export type TimelineOptions<ManagedAtom extends TimelineManageable> = {

package/src/transaction.ts

@@ -1,5 +1,10 @@
-import type { EnvironmentData, Store } from "atom.io/internal"
-import { IMPLICIT, createTransaction, withdraw } from "atom.io/internal"
+import type { EnvironmentData } from "atom.io/internal"
+import {
+	IMPLICIT,
+	actUponStore,
+	arbitrary,
+	createTransaction,
+} from "atom.io/internal"
 
 import type {
 	KeyedStateUpdate,
@@ -77,18 +82,9 @@ export function transaction<ƒ extends ƒn>(
 	return createTransaction(options, IMPLICIT.STORE)
 }
 
-export const runTransaction =
-	<ƒ extends ƒn>(
-		token: TransactionToken<ƒ>,
-		id?: string,
-		store: Store = IMPLICIT.STORE,
-	) =>
-	(...parameters: Parameters<ƒ>): ReturnType<ƒ> => {
-		const tx = withdraw(token, store)
-		if (tx) {
-			return tx.run(parameters, id)
-		}
-		throw new Error(
-			`Cannot run transaction "${token.key}": transaction not found in store "${store.config.name}".`,
-		)
-	}
+export function runTransaction<ƒ extends ƒn>(
+	token: TransactionToken<ƒ>,
+	id = arbitrary(),
+): (...parameters: Parameters<ƒ>) => ReturnType<ƒ> {
+	return actUponStore(token, id, IMPLICIT.STORE)
+}

package/src/validators.ts

@@ -1,23 +1,29 @@
 import type {
 	MutableAtomFamily,
+	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamily,
+	ReadableFamilyToken,
 	ReadableToken,
 	ReadonlySelectorFamily,
+	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
 	RegularAtomFamily,
+	RegularAtomFamilyToken,
 	RegularAtomToken,
 	WritableFamily,
+	WritableFamilyToken,
 	WritableSelectorFamily,
+	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
 
 export type TokenType<
-	Comparison extends ReadableFamily<any, any> | ReadableToken<any>,
+	Comparison extends ReadableFamilyToken<any, any> | ReadableToken<any>,
 > = Comparison extends ReadableToken<infer RepresentedValue>
 	? RepresentedValue
-	: Comparison extends ReadableFamily<infer RepresentedValue, any>
+	: Comparison extends ReadableFamilyToken<infer RepresentedValue, any>
 	  ? RepresentedValue
 	  : never
 
@@ -52,31 +58,31 @@ export function isToken<KnownToken extends ReadableToken<any>>(
 	return knownToken.key === unknownToken.key
 }
 
-export function belongsTo<Family extends RegularAtomFamily<any, any>>(
+export function belongsTo<Family extends RegularAtomFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is RegularAtomToken<TokenType<Family>>
-export function belongsTo<Family extends MutableAtomFamily<any, any, any>>(
+export function belongsTo<Family extends MutableAtomFamilyToken<any, any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is MutableAtomToken<TokenType<Family>, any>
-export function belongsTo<Family extends WritableSelectorFamily<any, any>>(
+export function belongsTo<Family extends WritableSelectorFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is WritableSelectorToken<TokenType<Family>>
-export function belongsTo<Family extends ReadonlySelectorFamily<any, any>>(
+export function belongsTo<Family extends ReadonlySelectorFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is ReadonlySelectorToken<TokenType<Family>>
-export function belongsTo<Family extends WritableFamily<any, any>>(
+export function belongsTo<Family extends WritableFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is WritableToken<TokenType<Family>>
-export function belongsTo<Family extends ReadableFamily<any, any>>(
+export function belongsTo<Family extends ReadableFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is ReadableToken<TokenType<Family>>
-export function belongsTo<Family extends ReadableFamily<any, any>>(
+export function belongsTo<Family extends ReadableFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is ReadableToken<TokenType<Family>> {

package/dist/chunk-H4Q5FTPZ.js

@@ -1,11 +0,0 @@
-// internal/src/transaction/is-root-store.ts
-function isRootStore(store) {
-  return `epoch` in store.transactionMeta;
-}
-function isChildStore(store) {
-  return `phase` in store.transactionMeta;
-}
-
-export { isChildStore, isRootStore };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-H4Q5FTPZ.js.map

package/dist/chunk-H4Q5FTPZ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../internal/src/transaction/is-root-store.ts"],"names":[],"mappings":";AAgBO,SAAS,YAAY,OAAkC;AAC7D,SAAO,WAAW,MAAM;AACzB;AAEO,SAAS,aAAa,OAAmC;AAC/D,SAAO,WAAW,MAAM;AACzB","sourcesContent":["import type { ƒn } from \"atom.io\"\n\nimport type { TransactionEpoch, TransactionProgress } from \".\"\nimport type { Store } from \"../store\"\n\nexport interface RootStore extends Store {\n\ttransactionMeta: TransactionEpoch\n\tparent: null\n\tchild: ChildStore | null\n}\nexport interface ChildStore extends Store {\n\ttransactionMeta: TransactionProgress<ƒn>\n\tparent: ChildStore | RootStore\n\tchild: ChildStore | null\n}\n\nexport function isRootStore(store: Store): store is RootStore {\n\treturn `epoch` in store.transactionMeta\n}\n\nexport function isChildStore(store: Store): store is ChildStore {\n\treturn `phase` in store.transactionMeta\n}\n"]}

package/internal/src/set-state/copy-mutable-in-transaction.ts

@@ -1,19 +0,0 @@
-import { newest } from ".."
-import type { Atom, Store } from ".."
-import { copyMutableIfNeeded } from "./copy-mutable-if-needed"
-
-export function copyMutableIfWithinTransaction<T>(
-	oldValue: T,
-	atom: Atom<T>,
-	store: Store,
-): T {
-	const target = newest(store)
-	const parent = target.parent
-	if (parent !== null) {
-		if (atom.type === `mutable_atom`) {
-			const copiedValue = copyMutableIfNeeded(atom, parent, target)
-			return copiedValue
-		}
-	}
-	return oldValue
-}

package/realtime-client/src/sync-server-action.ts

@@ -1,170 +0,0 @@
-import * as AtomIO from "atom.io"
-import * as Internal from "atom.io/internal"
-import type { Socket } from "socket.io-client"
-
-import { isRootStore } from "../../internal/src/transaction/is-root-store"
-import {
-	confirmedUpdateQueueState,
-	optimisticUpdateQueueState,
-} from "./realtime-client-stores"
-
-export function syncAction<ƒ extends AtomIO.ƒn>(
-	token: AtomIO.TransactionToken<ƒ>,
-	socket: Socket,
-	store: Internal.Store,
-): () => void {
-	const optimisticQueue = Internal.getFromStore(
-		optimisticUpdateQueueState,
-		store,
-	)
-	const confirmedQueue = Internal.getFromStore(confirmedUpdateQueueState, store)
-
-	const unsubscribeFromLocalUpdates = Internal.subscribeToTransaction(
-		token,
-		(clientUpdate) => {
-			const optimisticUpdateQueueIndex = optimisticQueue.findIndex(
-				(update) => update.id === clientUpdate.id,
-			)
-			if (optimisticUpdateQueueIndex === -1) {
-				Internal.setIntoStore(
-					optimisticUpdateQueueState,
-					(queue) => {
-						queue.push(clientUpdate)
-						queue.sort((a, b) => a.epoch - b.epoch)
-						return queue
-					},
-					store,
-				)
-				socket.emit(`tx-run:${token.key}`, clientUpdate)
-			} else {
-				Internal.setIntoStore(
-					optimisticUpdateQueueState,
-					(queue) => {
-						queue[optimisticUpdateQueueIndex] = clientUpdate
-						return queue
-					},
-					store,
-				)
-				socket.emit(`tx-run:${token.key}`, clientUpdate)
-			}
-		},
-		`tx-run:${token.key}`,
-		store,
-	)
-	const reconcileUpdates = (
-		optimisticUpdate: AtomIO.TransactionUpdate<ƒ>,
-		confirmedUpdate: AtomIO.TransactionUpdate<ƒ>,
-	) => {
-		Internal.setIntoStore(
-			optimisticUpdateQueueState,
-			(queue) => {
-				queue.shift()
-				return queue
-			},
-			store,
-		)
-		if (optimisticUpdate.id === confirmedUpdate.id) {
-			const clientResult = JSON.stringify(optimisticUpdate.updates)
-			const serverResult = JSON.stringify(confirmedUpdate.updates)
-			if (clientResult === serverResult) {
-				store.logger.info(
-					`✅`,
-					`transaction`,
-					token.key,
-					`results for ${optimisticUpdate.id} match between client and server`,
-				)
-				socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch)
-				return
-			}
-		} else {
-			// id mismatch
-			store.logger.info(
-				`❌`,
-				`transaction`,
-				token.key,
-				`${store.config.name} thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`,
-			)
-		}
-		for (const subsequentOptimistic of optimisticQueue.toReversed()) {
-			Internal.ingestTransactionUpdate(`oldValue`, subsequentOptimistic, store)
-		}
-		Internal.ingestTransactionUpdate(`oldValue`, optimisticUpdate, store)
-		Internal.ingestTransactionUpdate(`newValue`, confirmedUpdate, store)
-		socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch)
-		for (const subsequentOptimistic of optimisticQueue) {
-			const token = Object.assign(
-				{ type: `transaction` } as const,
-				subsequentOptimistic,
-			)
-			const { id, params } = subsequentOptimistic
-			AtomIO.runTransaction(token, id, store)(...params)
-		}
-	}
-
-	const registerAndAttemptConfirmedUpdate = (
-		confirmedUpdate: AtomIO.TransactionUpdate<ƒ>,
-	) => {
-		const zerothOptimisticUpdate = optimisticQueue[0]
-		if (zerothOptimisticUpdate) {
-			if (zerothOptimisticUpdate.epoch === confirmedUpdate.epoch) {
-				reconcileUpdates(zerothOptimisticUpdate, confirmedUpdate)
-				for (const nextConfirmed of confirmedQueue) {
-					const nextOptimistic = optimisticQueue[0]
-					if (nextConfirmed.epoch === nextOptimistic.epoch) {
-						reconcileUpdates(nextOptimistic, nextConfirmed)
-					} else {
-						break
-					}
-				}
-			} else {
-				// epoch mismatch
-
-				const hasEnqueuedOptimisticUpdate = optimisticQueue.some(
-					(update) => update.epoch === confirmedUpdate.epoch,
-				)
-				if (hasEnqueuedOptimisticUpdate) {
-					Internal.setIntoStore(
-						confirmedUpdateQueueState,
-						(queue) => {
-							queue.push(confirmedUpdate)
-							queue.sort((a, b) => a.epoch - b.epoch)
-							return queue
-						},
-						store,
-					)
-				}
-			}
-		} else {
-			if (
-				isRootStore(store) &&
-				store.transactionMeta.epoch === confirmedUpdate.epoch - 1
-			) {
-				Internal.ingestTransactionUpdate(`newValue`, confirmedUpdate, store)
-				socket.emit(`tx-ack:${token.key}`, confirmedUpdate.epoch)
-				store.transactionMeta.epoch = confirmedUpdate.epoch
-			} else if (isRootStore(store)) {
-				store.logger.info(
-					`❌`,
-					`transaction`,
-					token.key,
-					`received out-of-order update from server`,
-					{
-						clientEpoch: store.transactionMeta.epoch,
-						serverEpoch: confirmedUpdate.epoch,
-					},
-				)
-			}
-		}
-	}
-	socket.off(`tx-new:${token.key}`, registerAndAttemptConfirmedUpdate)
-	socket.on(`tx-new:${token.key}`, registerAndAttemptConfirmedUpdate)
-	socket.emit(`tx-sub:${token.key}`)
-	const unsubscribeFromIncomingUpdates = () => {
-		socket.off(`tx-new:${token.key}`, registerAndAttemptConfirmedUpdate)
-		socket.emit(`tx-unsub:${token.key}`)
-	}
-	return () => {
-		unsubscribeFromLocalUpdates()
-		unsubscribeFromIncomingUpdates()
-	}
-}

package/realtime-client/src/sync-state.ts

@@ -1,19 +0,0 @@
-import type * as AtomIO from "atom.io"
-import { type Store, setIntoStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
-import type { Socket } from "socket.io-client"
-
-export function syncState<J extends Json.Serializable>(
-	token: AtomIO.WritableToken<J>,
-	socket: Socket,
-	store: Store,
-): () => void {
-	const setServedValue = (data: J) => {
-		setIntoStore(token, data, store)
-	}
-	socket.on(`value:${token.key}`, setServedValue)
-	socket.emit(`get:${token.key}`)
-	return () => {
-		socket.off(`value:${token.key}`, setServedValue)
-	}
-}

package/realtime-react/src/use-pull-family-member.ts

@@ -1,16 +0,0 @@
-import type * as AtomIO from "atom.io"
-import type { Json } from "atom.io/json"
-import { StoreContext } from "atom.io/react"
-import * as RTC from "atom.io/realtime-client"
-import * as React from "react"
-
-import { useRealtimeService } from "./use-realtime-service"
-
-export function usePullFamilyMember<J extends Json.Serializable>(
-	token: AtomIO.WritableToken<J>,
-): void {
-	const store = React.useContext(StoreContext)
-	useRealtimeService(`pull:${token.key}`, (socket) =>
-		RTC.pullFamilyMember(token, socket, store),
-	)
-}

package/realtime-react/src/use-sync-server-action.ts

@@ -1,16 +0,0 @@
-import * as AtomIO from "atom.io"
-import { StoreContext } from "atom.io/react"
-import * as RTC from "atom.io/realtime-client"
-import * as React from "react"
-
-import { useRealtimeService } from "./use-realtime-service"
-
-export function useSyncAction<ƒ extends AtomIO.ƒn>(
-	token: AtomIO.TransactionToken<ƒ>,
-): (...parameters: Parameters<ƒ>) => ReturnType<ƒ> {
-	const store = React.useContext(StoreContext)
-	useRealtimeService(`tx-sync:${token.key}`, (socket) => {
-		return RTC.syncAction(token, socket, store)
-	})
-	return AtomIO.runTransaction(token, undefined, store)
-}