atom.io 0.36.2 → 0.37.0

package/src/react-devtools/Updates.tsx

@@ -1,9 +1,10 @@
 import type {
-	KeyedStateUpdate,
-	TimelineUpdate,
-	TransactionUpdate,
+	AtomToken,
+	AtomUpdateEvent,
+	TimelineEvent,
+	TransactionOutcomeEvent,
+	TransactionToken,
 } from "atom.io"
-import type { Fn } from "atom.io/internal"
 import { discoverType, prettyJson } from "atom.io/introspection"
 import { stringifyJson } from "atom.io/json"
 import * as React from "react"
@@ -12,11 +13,11 @@ import * as React from "react"
 
 const AtomUpdateFC: React.FC<{
 	serialNumber: number
-	atomUpdate: KeyedStateUpdate<unknown>
+	atomUpdate: AtomUpdateEvent<AtomToken<unknown>>
 }> = ({ atomUpdate }) => {
 	return (
 		<article
-			key={atomUpdate.key}
+			key={atomUpdate.token.key}
 			className="node atom_update"
 			onClick={() => {
 				console.log(atomUpdate)
@@ -25,10 +26,15 @@ const AtomUpdateFC: React.FC<{
 				console.log(atomUpdate)
 			}}
 		>
-			<span className="detail">{atomUpdate.key}: </span>
+			<span className="detail">{atomUpdate.token.key}: </span>
 			<span>
 				<span className="summary">
-					{prettyJson.diff(atomUpdate.oldValue, atomUpdate.newValue).summary}
+					{
+						prettyJson.diff(
+							atomUpdate.update.oldValue,
+							atomUpdate.update.newValue,
+						).summary
+					}
 				</span>
 			</span>
 		</article>
@@ -37,12 +43,12 @@ const AtomUpdateFC: React.FC<{
 
 const TransactionUpdateFC: React.FC<{
 	serialNumber: number
-	transactionUpdate: TransactionUpdate<Fn>
+	transactionUpdate: TransactionOutcomeEvent<TransactionToken<any>>
 }> = ({ serialNumber, transactionUpdate }) => {
 	return (
 		<article
 			className="node transaction_update"
-			data-testid={`transaction-update-${transactionUpdate.key}-${serialNumber}`}
+			data-testid={`transaction-update-${transactionUpdate.token.key}-${serialNumber}`}
 		>
 			<header>
 				<h4>{serialNumber}</h4>
@@ -88,31 +94,30 @@ const TransactionUpdateFC: React.FC<{
 				</section>
 				<section className="transaction_impact">
 					<span className="detail">impact: </span>
-					{transactionUpdate.updates
+					{transactionUpdate.subEvents
 						.filter(
-							(token) =>
-								token.type !== `molecule_creation` &&
-								token.type !== `molecule_disposal` &&
-								token.type !== `molecule_transfer` &&
-								token.type !== `state_creation` &&
-								token.type !== `state_disposal` &&
-								!token.key.startsWith(`👁‍🗨`),
+							(txSubEvent) =>
+								txSubEvent.type !== `molecule_creation` &&
+								txSubEvent.type !== `molecule_disposal` &&
+								txSubEvent.type !== `molecule_transfer` &&
+								txSubEvent.type !== `state_creation` &&
+								txSubEvent.type !== `state_disposal` &&
+								!txSubEvent.token.key.startsWith(`👁‍🗨`),
 						)
 						.map((update, index) => {
 							switch (update.type) {
 								case `atom_update`:
-								case `selector_update`:
 									return (
 										<article.AtomUpdate
-											key={`${transactionUpdate.key}:${index}:${update.key}`}
+											key={`${transactionUpdate.token.key}:${index}:${update.token.key}`}
 											serialNumber={index}
 											atomUpdate={update}
 										/>
 									)
-								case `transaction_update`:
+								case `transaction_outcome`:
 									return (
 										<TransactionUpdateFC
-											key={`${transactionUpdate.key}:${index}:${update.key}`}
+											key={`${transactionUpdate.token.key}:${index}:${update.token.key}`}
 											serialNumber={index}
 											transactionUpdate={update}
 										/>
@@ -132,49 +137,50 @@ const TransactionUpdateFC: React.FC<{
 }
 
 export const TimelineUpdateFC: React.FC<{
-	timelineUpdate: TimelineUpdate<any>
+	timelineUpdate: TimelineEvent<any>
 	serialNumber: number
 }> = ({ timelineUpdate, serialNumber }) => {
-	return `key` in timelineUpdate ? (
+	return timelineUpdate.type === `atom_update` ||
+		timelineUpdate.type === `selector_update` ||
+		timelineUpdate.type === `transaction_outcome` ? (
 		<article
 			className="node timeline_update"
-			data-testid={`timeline-update-${typeof timelineUpdate.key === `string` ? timelineUpdate.key : stringifyJson(timelineUpdate.key)}-${serialNumber}`}
+			data-testid={`timeline-update-${typeof timelineUpdate.token.key === `string` ? timelineUpdate.token.key : stringifyJson(timelineUpdate.token.key)}-${serialNumber}`}
 		>
 			<header>
 				<h4>
-					{timelineUpdate.timestamp}: {timelineUpdate.type} ({timelineUpdate.key}
-					)
+					{timelineUpdate.timestamp}: {timelineUpdate.type} (
+					{timelineUpdate.token.key})
 				</h4>
 			</header>
 			<main>
-				{timelineUpdate.type === `transaction_update` ? (
-					timelineUpdate.updates
+				{timelineUpdate.type === `transaction_outcome` ? (
+					timelineUpdate.subEvents
 						.filter(
-							(token) =>
-								token.type !== `molecule_creation` &&
-								token.type !== `molecule_disposal` &&
-								token.type !== `molecule_transfer` &&
-								token.type !== `state_creation` &&
-								token.type !== `state_disposal` &&
-								!token.key.startsWith(`👁‍🗨`),
+							(subEvent) =>
+								subEvent.type !== `molecule_creation` &&
+								subEvent.type !== `molecule_disposal` &&
+								subEvent.type !== `molecule_transfer` &&
+								subEvent.type !== `state_creation` &&
+								subEvent.type !== `state_disposal` &&
+								!subEvent.token.key.startsWith(`👁‍🗨`),
 						)
-						.map((update, index) => {
-							switch (update.type) {
+						.map((subEvent, index) => {
+							switch (subEvent.type) {
 								case `atom_update`:
-								case `selector_update`:
 									return (
 										<article.AtomUpdate
-											key={`${timelineUpdate.key}:${index}:${update.key}`}
+											key={`${timelineUpdate.token.key}:${index}:${subEvent.token.key}`}
 											serialNumber={index}
-											atomUpdate={update}
+											atomUpdate={subEvent}
 										/>
 									)
-								case `transaction_update`:
+								case `transaction_outcome`:
 									return (
 										<TransactionUpdateFC
-											key={`${timelineUpdate.key}:${index}:${update.key}`}
+											key={`${timelineUpdate.token.key}:${index}:${subEvent.token.key}`}
 											serialNumber={index}
-											transactionUpdate={update}
+											transactionUpdate={subEvent}
 										/>
 									)
 								case `molecule_creation`:
@@ -187,11 +193,13 @@ export const TimelineUpdateFC: React.FC<{
 						})
 				) : timelineUpdate.type === `selector_update` ? (
 					timelineUpdate.atomUpdates
-						.filter((token) => !token.key.startsWith(`👁‍🗨`))
+						.filter(
+							(atomUpdateEvent) => !atomUpdateEvent.token.key.startsWith(`👁‍🗨`),
+						)
 						.map((atomUpdate, index) => {
 							return (
 								<article.AtomUpdate
-									key={`${timelineUpdate.key}:${index}:${atomUpdate.key}`}
+									key={`${timelineUpdate.token.key}:${index}:${atomUpdate.token.key}`}
 									serialNumber={index}
 									atomUpdate={atomUpdate}
 								/>

package/src/realtime-client/continuity/register-and-attempt-confirmed-update.ts

@@ -19,13 +19,23 @@ export const useRegisterAndAttemptConfirmedUpdate =
 		store: Store,
 		continuityKey: string,
 		socket: Socket,
-		optimisticUpdates: AtomIO.TransactionUpdate<any>[],
-		confirmedUpdates: AtomIO.TransactionUpdate<any>[],
+		optimisticUpdates: AtomIO.TransactionOutcomeEvent<
+			AtomIO.TransactionToken<Fn>
+		>[],
+		confirmedUpdates: AtomIO.TransactionOutcomeEvent<
+			AtomIO.TransactionToken<Fn>
+		>[],
 	) =>
-	(confirmed: AtomIO.TransactionUpdate<Fn>): void => {
+	(
+		confirmed: AtomIO.TransactionOutcomeEvent<AtomIO.TransactionToken<Fn>>,
+	): void => {
 		function reconcileEpoch(
-			optimisticUpdate: AtomIO.TransactionUpdate<any>,
-			confirmedUpdate: AtomIO.TransactionUpdate<any>,
+			optimisticUpdate: AtomIO.TransactionOutcomeEvent<
+				AtomIO.TransactionToken<Fn>
+			>,
+			confirmedUpdate: AtomIO.TransactionOutcomeEvent<
+				AtomIO.TransactionToken<Fn>
+			>,
 		): void {
 			store.logger.info(
 				`🧑‍⚖️`,
@@ -38,8 +48,8 @@ export const useRegisterAndAttemptConfirmedUpdate =
 				return queue
 			})
 			if (optimisticUpdate.id === confirmedUpdate.id) {
-				const clientResult = JSON.stringify(optimisticUpdate.updates)
-				const serverResult = JSON.stringify(confirmedUpdate.updates)
+				const clientResult = JSON.stringify(optimisticUpdate.subEvents)
+				const serverResult = JSON.stringify(confirmedUpdate.subEvents)
 				if (clientResult === serverResult) {
 					store.logger.info(
 						`✅`,
@@ -56,7 +66,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 					`❌`,
 					`continuity`,
 					continuityKey,
-					`thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.key}:${confirmedUpdate.id}`,
+					`thought update #${confirmedUpdate.epoch} was ${optimisticUpdate.token.key}:${optimisticUpdate.id}, but it was actually ${confirmedUpdate.token.key}:${confirmedUpdate.id}`,
 				)
 			}
 			store.logger.info(
@@ -99,7 +109,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 			for (const subsequentOptimistic of optimisticUpdates) {
 				const token = {
 					type: `transaction`,
-					key: subsequentOptimistic.key,
+					key: subsequentOptimistic.token.key,
 				} as const
 				const { id, params } = subsequentOptimistic
 				actUponStore(store, token, id)(...params)
@@ -188,7 +198,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 					`✅`,
 					`continuity`,
 					continuityKey,
-					`integrating update #${confirmed.epoch} (${confirmed.key} ${confirmed.id})`,
+					`integrating update #${confirmed.epoch} (${confirmed.token.key} ${confirmed.id})`,
 				)
 				ingestTransactionUpdate(`newValue`, confirmed, store)
 				socket.emit(`ack:${continuityKey}`, confirmed.epoch)

package/src/realtime-client/realtime-client-stores/client-sync-store.ts

@@ -1,15 +1,15 @@
 import * as AtomIO from "atom.io"
 
 export const optimisticUpdateQueue: AtomIO.RegularAtomToken<
-	AtomIO.TransactionUpdate<any>[]
-> = AtomIO.atom<AtomIO.TransactionUpdate<any>[]>({
+	AtomIO.TransactionOutcomeEvent<any>[]
+> = AtomIO.atom<AtomIO.TransactionOutcomeEvent<any>[]>({
 	key: `updateQueue`,
 	default: () => [],
 })
 
 export const confirmedUpdateQueue: AtomIO.RegularAtomToken<
-	AtomIO.TransactionUpdate<any>[]
-> = AtomIO.atom<AtomIO.TransactionUpdate<any>[]>({
+	AtomIO.TransactionOutcomeEvent<any>[]
+> = AtomIO.atom<AtomIO.TransactionOutcomeEvent<any>[]>({
 	key: `serverConfirmedUpdateQueue`,
 	default: () => [],
 })

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

@@ -102,7 +102,7 @@ export function syncContinuity(
 				}
 				socket.emit(`tx-run:${continuityKey}`, {
 					id: clientUpdate.id,
-					key: transaction.key,
+					token: transaction,
 					params: clientUpdate.params,
 				})
 			},

package/src/realtime-server/continuity/prepare-to-serve-transaction-request.ts

@@ -1,19 +1,25 @@
-import type { TransactionUpdate } from "atom.io"
+import type { TransactionOutcomeEvent, TransactionToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import { actUponStore } from "atom.io/internal"
-import type { JsonIO } from "atom.io/json"
+import type { Json, JsonIO } from "atom.io/json"
 import type { ContinuityToken } from "atom.io/realtime"
 
 export function prepareToServeTransactionRequest(
 	store: Store,
 	continuity: ContinuityToken,
 	userKey: string,
-): (update: Pick<TransactionUpdate<JsonIO>, `id` | `key` | `params`>) => void {
+): (
+	event: Json.Serializable &
+		Pick<
+			TransactionOutcomeEvent<TransactionToken<JsonIO>>,
+			`id` | `params` | `token`
+		>,
+) => void {
 	const continuityKey = continuity.key
-	return function serveTransactionRequest(update) {
-		store.logger.info(`🛎️`, `continuity`, continuityKey, `received`, update)
-		const transactionKey = update.key
-		const updateId = update.id
+	return function serveTransactionRequest(txOutcome) {
+		store.logger.info(`🛎️`, `continuity`, continuityKey, `received`, txOutcome)
+		const transactionKey = txOutcome.token.key
+		const updateId = txOutcome.id
 		const performanceKey = `tx-run:${transactionKey}:${updateId}`
 		const performanceKeyStart = `${performanceKey}:start`
 		const performanceKeyEnd = `${performanceKey}:end`
@@ -23,7 +29,7 @@ export function prepareToServeTransactionRequest(
 				store,
 				{ type: `transaction`, key: transactionKey },
 				updateId,
-			)(...update.params)
+			)(...txOutcome.params)
 		} catch (thrown) {
 			if (thrown instanceof Error) {
 				store.logger.error(

package/src/realtime-server/continuity/prepare-to-track-client-acknowledgement.ts

@@ -2,13 +2,16 @@ import type { Store } from "atom.io/internal"
 import { setIntoStore } from "atom.io/internal"
 import type { ContinuityToken } from "atom.io/realtime"
 
-import type { ContinuitySyncTransactionUpdate } from "../realtime-server-stores"
+import type {
+	ContinuitySyncTransactionUpdate,
+	UserKey,
+} from "../realtime-server-stores"
 import { userUnacknowledgedQueues } from "../realtime-server-stores"
 
 export function prepareToTrackClientAcknowledgement(
 	store: Store,
 	continuity: ContinuityToken,
-	userKey: string,
+	userKey: UserKey,
 	userUnacknowledgedUpdates: ContinuitySyncTransactionUpdate[],
 ): (epoch: number) => void {
 	const continuityKey = continuity.key

package/src/realtime-server/continuity/subscribe-to-continuity-actions.ts

@@ -59,7 +59,7 @@ export function subscribeToContinuityActions(
 						)
 					const redactedUpdates = redactTransactionUpdateContent(
 						visibleKeys,
-						update.updates,
+						update.subEvents,
 					)
 					const redactedUpdate = {
 						...update,

package/src/realtime-server/realtime-action-receiver.ts

@@ -1,4 +1,4 @@
-import type * as AtomIO from "atom.io"
+import type { TransactionOutcomeEvent, TransactionToken } from "atom.io"
 import { actUponStore, IMPLICIT } from "atom.io/internal"
 import type { JsonIO } from "atom.io/json"
 
@@ -10,10 +10,13 @@ export function realtimeActionReceiver({
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	return function actionReceiver<F extends JsonIO>(
-		tx: AtomIO.TransactionToken<F>,
+		tx: TransactionToken<F>,
 	): () => void {
 		const fillTransactionRequest = (
-			update: Pick<AtomIO.TransactionUpdate<F>, `id` | `params`>,
+			update: Pick<
+				TransactionOutcomeEvent<TransactionToken<F>>,
+				`id` | `params`
+			>,
 		) => {
 			const performanceKey = `tx-run:${tx.key}:${update.id}`
 			const performanceKeyStart = `${performanceKey}:start`

package/src/realtime-server/realtime-server-stores/server-sync-store.ts

@@ -1,7 +1,7 @@
 import type {
 	RegularAtomFamilyToken,
-	TransactionUpdate,
-	TransactionUpdateContent,
+	TransactionOutcomeEvent,
+	TransactionSubEvent,
 } from "atom.io"
 import { atomFamily } from "atom.io"
 
@@ -17,20 +17,19 @@ import type { UserKey } from "./server-user-store"
 
 export function redactTransactionUpdateContent(
 	visibleStateKeys: string[],
-	updates: TransactionUpdateContent[],
-): TransactionUpdateContent[] {
+	updates: TransactionSubEvent[],
+): TransactionSubEvent[] {
 	return updates
-		.map((update): TransactionUpdateContent => {
+		.map((update): TransactionSubEvent => {
 			switch (update.type) {
-				case `transaction_update`: {
+				case `transaction_outcome`: {
 					const redacted = redactTransactionUpdateContent(
 						visibleStateKeys,
-						update.updates,
+						update.subEvents,
 					)
-					return { ...update, updates: redacted }
+					return { ...update, subEvents: redacted }
 				}
 				case `atom_update`:
-				case `selector_update`:
 				case `molecule_creation`:
 				case `molecule_disposal`:
 				case `molecule_transfer`:
@@ -42,13 +41,11 @@ export function redactTransactionUpdateContent(
 		.filter((update) => {
 			switch (update.type) {
 				case `atom_update`:
-				case `selector_update`:
-					return visibleStateKeys.includes(update.key)
 				case `state_creation`:
 				case `state_disposal`:
 					return visibleStateKeys.includes(update.token.key)
 				case `molecule_creation`:
-				case `transaction_update`:
+				case `transaction_outcome`:
 				case `molecule_disposal`:
 				case `molecule_transfer`:
 					return true
@@ -58,12 +55,12 @@ export function redactTransactionUpdateContent(
 
 export const redactorAtoms: RegularAtomFamilyToken<
 	{
-		occlude: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[]
+		occlude: (updates: TransactionSubEvent[]) => TransactionSubEvent[]
 	},
 	UserKey
 > = atomFamily<
 	{
-		occlude: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[]
+		occlude: (updates: TransactionSubEvent[]) => TransactionSubEvent[]
 	},
 	UserKey
 >({
@@ -89,8 +86,8 @@ export const redactorAtoms: RegularAtomFamilyToken<
 // })
 
 export type ContinuitySyncTransactionUpdate = Pick<
-	TransactionUpdate<any>,
-	`epoch` | `id` | `key` | `output` | `updates`
+	TransactionOutcomeEvent<any>,
+	`epoch` | `id` | `output` | `subEvents` | `token`
 >
 export const userUnacknowledgedQueues: RegularAtomFamilyToken<
 	ContinuitySyncTransactionUpdate[],

package/src/transceivers/set-rtx/set-rtx.ts

@@ -51,9 +51,7 @@ export class SetRTX<P extends primitive>
 		}
 	}
 
-	public view(): SetRTXView<P> {
-		return this
-	}
+	public readonly READONLY_VIEW: SetRTXView<P> = this
 
 	public toJSON(): SetRTXJson<P> {
 		return {

package/src/web/persist-sync.ts

@@ -1,7 +1,7 @@
-import type { AtomEffect } from "atom.io"
+import type { AtomEffect, ViewOf } from "atom.io"
 
 export type StringInterface<T> = {
-	stringify: (t: T) => string
+	stringify: (t: ViewOf<T>) => string
 	parse: (s: string) => T
 }
 

package/src/internal/set-state/emit-update.ts

@@ -1,40 +0,0 @@
-import type { StateUpdate } from "atom.io"
-
-import type { Atom, Selector, Store } from ".."
-
-export const emitUpdate = <T>(
-	store: Store,
-	state: Atom<T> | Selector<T>,
-	update: StateUpdate<T>,
-): void => {
-	switch (state.type) {
-		case `mutable_atom`:
-			store.logger.info(
-				`📢`,
-				state.type,
-				state.key,
-				`is now (`,
-				update.newValue,
-				`) subscribers:`,
-				state.subject.subscribers,
-			)
-			break
-		case `atom`:
-		case `writable_pure_selector`:
-		case `readonly_pure_selector`:
-		case `writable_held_selector`:
-		case `readonly_held_selector`:
-			store.logger.info(
-				`📢`,
-				state.type,
-				state.key,
-				`went (`,
-				update.oldValue,
-				`->`,
-				update.newValue,
-				`) subscribers:`,
-				state.subject.subscribers,
-			)
-	}
-	state.subject.next(update)
-}