atom.io 0.31.1 → 0.32.1

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

@@ -20,9 +20,9 @@ export function prepareToServeTransactionRequest(
 		performance.mark(performanceKeyStart)
 		try {
 			actUponStore(
+				store,
 				{ type: `transaction`, key: transactionKey },
 				updateId,
-				store,
 			)(...update.params)
 		} catch (thrown) {
 			if (thrown instanceof Error) {

package/realtime-server/src/continuity/prepare-to-sync-realtime-continuity.ts

@@ -1,6 +1,6 @@
-import { findRelationsInStore } from "atom.io/data"
 import {
 	findInStore,
+	findRelationsInStore,
 	getFromStore,
 	IMPLICIT,
 	subscribeToState,
@@ -50,7 +50,9 @@ export function prepareToExposeRealtimeContinuity({
 			store,
 		).socketKeyOfUser
 		const unsubscribeFromSocketTracking = subscribeToState(
+			store,
 			socketKeyState,
+			`sync-continuity:${continuityKey}:${userKey}`,
 			({ newValue: newSocketKey }) => {
 				store.logger.info(
 					`👋`,
@@ -77,8 +79,6 @@ export function prepareToExposeRealtimeContinuity({
 					)
 				}
 			},
-			`sync-continuity:${continuityKey}:${userKey}`,
-			store,
 		)
 
 		const userUnacknowledgedUpdates = getFromStore(

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

@@ -28,7 +28,9 @@ export function subscribeToContinuityActions(
 
 	for (const transaction of continuity.actions) {
 		const unsubscribeFromTransaction = subscribeToTransaction(
+			store,
 			transaction,
+			`sync-continuity:${continuityKey}:${userKey}`,
 			(update) => {
 				try {
 					const visibleKeys = continuity.globals
@@ -97,8 +99,6 @@ export function subscribeToContinuityActions(
 					}
 				}
 			},
-			`sync-continuity:${continuityKey}:${userKey}`,
-			store,
 		)
 		unsubscribeFunctions.push(unsubscribeFromTransaction)
 	}

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

@@ -22,7 +22,9 @@ export function subscribeToContinuityPerspectives(
 		const { viewAtoms } = perspective
 		const userViewState = findInStore(store, viewAtoms, userKey)
 		const unsubscribeFromUserView = subscribeToState(
+			store,
 			userViewState,
+			`sync-continuity:${continuityKey}:${userKey}:perspective:${perspective.resourceAtoms.key}`,
 			({ oldValue, newValue }) => {
 				const oldKeys = oldValue.map((token) => token.key)
 				const newKeys = newValue.map((token) => token.key)
@@ -51,8 +53,6 @@ export function subscribeToContinuityPerspectives(
 					socket?.emit(`conceal:${continuityKey}`, concealed)
 				}
 			},
-			`sync-continuity:${continuityKey}:${userKey}:perspective:${perspective.resourceAtoms.key}`,
-			store,
 		)
 		unsubFns.push(unsubscribeFromUserView)
 	}

package/realtime-server/src/ipc-sockets/child-socket.ts

@@ -36,6 +36,8 @@ export class ChildSocket<
 				case `e`:
 					this.logger.error(...rest)
 					break
+				default:
+					return
 			}
 		}
 	}

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

@@ -19,7 +19,7 @@ export function realtimeActionReceiver({
 			const performanceKeyStart = `${performanceKey}:start`
 			const performanceKeyEnd = `${performanceKey}:end`
 			performance.mark(performanceKeyStart)
-			actUponStore<F>(tx, update.id, store)(...update.params)
+			actUponStore<F>(store, tx, update.id)(...update.params)
 			performance.mark(performanceKeyEnd)
 			const metric = performance.measure(
 				performanceKey,

package/realtime-server/src/realtime-family-provider.ts

@@ -40,12 +40,12 @@ export function realtimeAtomFamilyProvider({
 					const token = findInStore(store, family, subKey)
 					socket.emit(`serve:${token.key}`, getFromStore(store, token))
 					const unsubscribe = subscribeToState(
+						store,
 						token,
+						`expose-family:${family.key}:${socket.id}`,
 						({ newValue }) => {
 							socket.emit(`serve:${token.key}`, newValue)
 						},
-						`expose-family:${family.key}:${socket.id}`,
-						store,
 					)
 					unsubCallbacksByKey.set(token.key, unsubscribe)
 					socket.on(`unsub:${token.key}`, () => {

package/realtime-server/src/realtime-mutable-family-provider.ts

@@ -49,12 +49,12 @@ export function realtimeMutableFamilyProvider({
 					const updateToken = getUpdateToken(token)
 					socket.emit(`init:${token.key}`, getFromStore(store, jsonToken))
 					const unsubscribe = subscribeToState(
+						store,
 						updateToken,
+						`expose-family:${family.key}:${socket.id}`,
 						({ newValue }) => {
 							socket.emit(`next:${token.key}`, newValue)
 						},
-						`expose-family:${family.key}:${socket.id}`,
-						store,
 					)
 					unsubCallbacksByKey.set(token.key, unsubscribe)
 					socket.on(`unsub:${token.key}`, () => {

package/realtime-server/src/realtime-mutable-provider.ts

@@ -34,12 +34,12 @@ export function realtimeMutableProvider({
 		const fillSubRequest = () => {
 			socket.emit(`init:${token.key}`, getFromStore(store, jsonToken))
 			unsubscribeFromStateUpdates = subscribeToState(
+				store,
 				trackerToken,
+				`expose-single:${socket.id}`,
 				({ newValue }) => {
 					socket.emit(`next:${token.key}`, newValue)
 				},
-				`expose-single:${socket.id}`,
-				store,
 			)
 			socket.on(`unsub:${token.key}`, fillUnsubRequest)
 		}

package/realtime-server/src/realtime-server-stores/server-room-external-actions.ts

@@ -1,5 +1,6 @@
+import type { Loadable } from "atom.io"
 import * as AtomIO from "atom.io"
-import { editRelationsInStore, type Loadable } from "atom.io/data"
+import { editRelationsInStore } from "atom.io/internal"
 import type { UserInRoomMeta } from "atom.io/realtime"
 import { roomIndex, usersInRooms } from "atom.io/realtime"
 

package/realtime-server/src/realtime-server-stores/server-room-external-store.ts

@@ -1,8 +1,8 @@
 import type { ChildProcessWithoutNullStreams } from "node:child_process"
 import { spawn } from "node:child_process"
 
+import type { Loadable } from "atom.io"
 import { atomFamily, selectorFamily } from "atom.io"
-import type { Loadable } from "atom.io/data"
 
 import { ChildSocket } from "../ipc-sockets"
 

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

@@ -25,7 +25,13 @@ export function redactTransactionUpdateContent(
 					)
 					return { ...update, updates: redacted }
 				}
-				default:
+				case `atom_update`:
+				case `selector_update`:
+				case `molecule_creation`:
+				case `molecule_disposal`:
+				case `molecule_transfer`:
+				case `state_creation`:
+				case `state_disposal`:
 					return update
 			}
 		})
@@ -35,10 +41,12 @@ export function redactTransactionUpdateContent(
 				case `selector_update`:
 					return visibleStateKeys.includes(update.key)
 				case `state_creation`:
+				case `state_disposal`:
 					return visibleStateKeys.includes(update.token.key)
 				case `molecule_creation`:
-					return true
 				case `transaction_update`:
+				case `molecule_disposal`:
+				case `molecule_transfer`:
 					return true
 			}
 		})

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

@@ -1,6 +1,5 @@
 import type { Hierarchy } from "atom.io"
-import { atom, atomFamily } from "atom.io"
-import { join } from "atom.io/data"
+import { atom, atomFamily, join } from "atom.io"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 

package/realtime-server/src/realtime-state-provider.ts

@@ -18,12 +18,12 @@ export function realtimeStateProvider({
 			socket.emit(`serve:${token.key}`, getFromStore(store, token))
 
 			unsubscribeFromStateUpdates = subscribeToState(
+				store,
 				token,
+				`expose-single:${socket.id}`,
 				({ newValue }) => {
 					socket.emit(`serve:${token.key}`, newValue)
 				},
-				`expose-single:${socket.id}`,
-				store,
 			)
 
 			const fillUnsubRequest = () => {

package/realtime-testing/dist/index.js

@@ -1,15 +1,13 @@
+import { RealtimeProvider } from '../../dist/chunk-KVI5OBF2.js';
+import { myUsernameState } from '../../dist/chunk-3ZFTRSNG.js';
+import { socketAtoms, usersOfSockets, userIndex, socketIndex, roomSelectors } from '../../dist/chunk-UYYKOGZQ.js';
+import { roomIndex } from '../../dist/chunk-X7SD2NXU.js';
+import '../../dist/chunk-4LWKCEW3.js';
+import { StoreProvider } from '../../dist/chunk-3PQTWLQQ.js';
+import { Silo, IMPLICIT, Realm, findInStore, setIntoStore, editRelationsInStore, toEntries, findRelationsInStore, getFromStore, clearStore, AtomIOLogger } from '../../dist/chunk-UQEYZ3OI.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import * as http from 'node:http';
 import { render, prettyDOM } from '@testing-library/react';
-import * as AtomIO from 'atom.io';
-import { editRelationsInStore, findRelationsInStore } from 'atom.io/data';
-import { IMPLICIT, findInStore, setIntoStore, getFromStore, clearStore } from 'atom.io/internal';
-import { toEntries } from 'atom.io/json';
-import * as AR from 'atom.io/react';
-import * as RT from 'atom.io/realtime';
-import * as RTC from 'atom.io/realtime-client';
-import * as RTR from 'atom.io/realtime-react';
-import * as RTS from 'atom.io/realtime-server';
 import * as Happy from 'happy-dom';
 import * as SocketIO from 'socket.io';
 import { io } from 'socket.io-client';
@@ -17,7 +15,7 @@ import { jsx } from 'react/jsx-runtime';
 
 var testNumber = 0;
 function prefixLogger(store, prefix) {
-  store.loggers[0] = new AtomIO.AtomIOLogger(`info`, undefined, {
+  store.loggers[0] = new AtomIOLogger(`info`, void 0, {
     info: (...args) => {
       console.info(prefix, ...args);
     },
@@ -31,14 +29,14 @@ function prefixLogger(store, prefix) {
 }
 var setupRealtimeTestServer = (options) => {
   ++testNumber;
-  const silo = new AtomIO.Silo(
+  const silo = new Silo(
     {
       name: `SERVER-${testNumber}`,
       lifespan: options.immortal?.server ? `immortal` : `ephemeral`
     },
     IMPLICIT.STORE
   );
-  const socketRealm = new AtomIO.Realm(silo.store);
+  const socketRealm = new Realm(silo.store);
   const httpServer = http.createServer((_, res) => res.end(`Hello World!`));
   const address = httpServer.listen(options.port).address();
   const port = typeof address === `string` ? null : address === null ? null : address.port;
@@ -48,19 +46,19 @@ var setupRealtimeTestServer = (options) => {
     if (token === `test` && socket.id) {
       const userClaim = socketRealm.allocate(`root`, `user::${username}`);
       const socketClaim = socketRealm.allocate(`root`, `socket::${socket.id}`);
-      const socketState = findInStore(silo.store, RTS.socketAtoms, socketClaim);
+      const socketState = findInStore(silo.store, socketAtoms, socketClaim);
       setIntoStore(silo.store, socketState, socket);
       editRelationsInStore(
-        RTS.usersOfSockets,
+        usersOfSockets,
         (relations) => {
           relations.set(userClaim, socketClaim);
         },
         silo.store
       );
-      setIntoStore(silo.store, RTS.userIndex, (index) => index.add(userClaim));
+      setIntoStore(silo.store, userIndex, (index) => index.add(userClaim));
       setIntoStore(
         silo.store,
-        RTS.socketIndex,
+        socketIndex,
         (index) => index.add(socketClaim)
       );
       next();
@@ -72,7 +70,7 @@ var setupRealtimeTestServer = (options) => {
     let userKey = null;
     function enableLogging() {
       const userKeyState = findRelationsInStore(
-        RTS.usersOfSockets,
+        usersOfSockets,
         `socket::${socket.id}`,
         silo.store
       ).userKeyOfSocket;
@@ -92,9 +90,9 @@ var setupRealtimeTestServer = (options) => {
   });
   const dispose = async () => {
     await server.close();
-    const roomKeys = getFromStore(silo.store, RT.roomIndex);
+    const roomKeys = getFromStore(silo.store, roomIndex);
     for (const roomKey of roomKeys) {
-      const roomState = findInStore(silo.store, RTS.roomSelectors, roomKey);
+      const roomState = findInStore(silo.store, roomSelectors, roomKey);
       const room = getFromStore(silo.store, roomState);
       if (room && !(room instanceof Promise)) {
         room.process.kill();
@@ -116,17 +114,17 @@ var setupRealtimeTestClient = (options, name, port) => {
     const socket = io(`http://localhost:${port}/`, {
       auth: { token: `test`, username: `${name}-${testNumber}` }
     });
-    const silo = new AtomIO.Silo({ name, lifespan: `ephemeral` }, IMPLICIT.STORE);
+    const silo = new Silo({ name, lifespan: `ephemeral` }, IMPLICIT.STORE);
     for (const [key, value] of silo.store.valueMap.entries()) {
       if (Array.isArray(value)) {
         silo.store.valueMap.set(key, [...value]);
       }
     }
-    silo.setState(RTC.myUsernameState, `${name}-${testNumber}`);
+    silo.setState(myUsernameState, `${name}-${testNumber}`);
     const { document } = new Happy.Window();
     document.body.innerHTML = `<div id="app"></div>`;
     const renderResult = render(
-      /* @__PURE__ */ jsx(AR.StoreProvider, { store: silo.store, children: /* @__PURE__ */ jsx(RTR.RealtimeProvider, { socket, children: /* @__PURE__ */ jsx(options.client, {}) }) }),
+      /* @__PURE__ */ jsx(StoreProvider, { store: silo.store, children: /* @__PURE__ */ jsx(RealtimeProvider, { socket, children: /* @__PURE__ */ jsx(options.client, {}) }) }),
       {
         container: document.querySelector(`#app`)
       }

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

@@ -3,11 +3,12 @@ import * as http from "node:http"
 import type { RenderResult } from "@testing-library/react"
 import { prettyDOM, render } from "@testing-library/react"
 import * as AtomIO from "atom.io"
-import { editRelationsInStore, findRelationsInStore } from "atom.io/data"
 import type { Store } from "atom.io/internal"
 import {
 	clearStore,
+	editRelationsInStore,
 	findInStore,
+	findRelationsInStore,
 	getFromStore,
 	IMPLICIT,
 	setIntoStore,

package/src/index.ts

@@ -17,7 +17,9 @@ import type {
 
 export * from "./atom"
 export * from "./dispose-state"
+export * from "./find-state"
 export * from "./get-state"
+export * from "./join"
 export * from "./logger"
 export * from "./realm"
 export * from "./selector"
@@ -146,3 +148,5 @@ export type FamilyMetadata<K extends Canonical = any> = {
 	/** The family member's unique identifier, in the form of a string. */
 	subKey: stringified<K>
 }
+
+export type Loadable<T> = Promise<T> | T

package/src/join.ts

@@ -0,0 +1,218 @@
+import type { MutableAtomFamilyToken, ReadonlySelectorToken } from "atom.io"
+import type {
+	Junction,
+	JunctionEntriesBase,
+	JunctionSchemaBase,
+	Refinement,
+	Store,
+} from "atom.io/internal"
+import {
+	editRelationsInStore,
+	findRelationsInStore,
+	getInternalRelationsFromStore,
+	IMPLICIT,
+	Join,
+} from "atom.io/internal"
+import type { Json } from "atom.io/json"
+import type { SetRTX, SetRTXJson } from "atom.io/transceivers/set-rtx"
+
+export interface JoinOptions<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null,
+> extends JunctionSchemaBase<ASide, BSide>,
+		Partial<JunctionEntriesBase<AType, BType, Content>> {
+	readonly key: string
+	readonly cardinality: Cardinality
+	readonly isAType: Refinement<string, AType>
+	readonly isBType: Refinement<string, BType>
+}
+
+export type JoinToken<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null = null,
+> = {
+	key: string
+	type: `join`
+	cardinality: Cardinality
+	a: ASide
+	b: BSide
+	__aType?: AType
+	__bType?: BType
+	__content?: Content
+}
+
+export function join<
+	const ASide extends string,
+	const AType extends string,
+	const BSide extends string,
+	const BType extends string,
+	const Cardinality extends `1:1` | `1:n` | `n:n`,
+>(
+	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, null>,
+	defaultContent?: undefined,
+	store?: Store,
+): JoinToken<ASide, AType, BSide, BType, Cardinality, null>
+export function join<
+	const ASide extends string,
+	const AType extends string,
+	const BSide extends string,
+	const BType extends string,
+	const Cardinality extends `1:1` | `1:n` | `n:n`,
+	const Content extends Json.Object,
+>(
+	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>,
+	defaultContent: Content,
+	store?: Store,
+): JoinToken<ASide, AType, BSide, BType, Cardinality, Content>
+export function join<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object,
+>(
+	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>,
+	defaultContent: Content | undefined,
+	store: Store = IMPLICIT.STORE,
+): JoinToken<ASide, AType, BSide, BType, Cardinality, Content> {
+	store.joins.set(options.key, new Join(options, defaultContent, store))
+	const token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content> = {
+		key: options.key,
+		type: `join`,
+		a: options.between[0],
+		b: options.between[1],
+		cardinality: options.cardinality,
+	}
+	return token
+}
+
+export type JoinStates<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null,
+> = Cardinality extends `1:1`
+	? (Content extends Json.Object
+			? {
+					readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+						[AType, Content] | null,
+						BType
+					>
+				} & {
+					readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+						[BType, Content] | null,
+						AType
+					>
+				}
+			: {}) & {
+			readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+				AType | null,
+				BType
+			>
+		} & {
+			readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+				BType | null,
+				AType
+			>
+		}
+	: Cardinality extends `1:n`
+		? (Content extends Json.Object
+				? {
+						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+							[AType, Content] | null,
+							BType
+						>
+					} & {
+						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+							[BType, Content][],
+							AType
+						>
+					}
+				: {}) & {
+				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+					AType | null,
+					BType
+				>
+			} & {
+				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+					BType[],
+					AType
+				>
+			}
+		: Cardinality extends `n:n`
+			? (Content extends Json.Object
+					? {
+							readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+								[AType, Content][],
+								BType
+							>
+						} & {
+							readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+								[BType, Content][],
+								AType
+							>
+						}
+					: {}) & {
+					readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+						AType[],
+						BType
+					>
+				} & {
+					readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+						BType[],
+						AType
+					>
+				}
+			: never
+
+export function findRelations<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null,
+>(
+	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
+	key: AType | BType,
+): JoinStates<ASide, AType, BSide, BType, Cardinality, Content> {
+	return findRelationsInStore(token, key, IMPLICIT.STORE)
+}
+
+export function editRelations<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null,
+>(
+	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
+	change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void,
+): void {
+	editRelationsInStore(token, change, IMPLICIT.STORE)
+}
+
+export function getInternalRelations<
+	ASide extends string,
+	AType extends string,
+	BSide extends string,
+	BType extends string,
+	Cardinality extends `1:1` | `1:n` | `n:n`,
+	Content extends Json.Object | null,
+>(
+	token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>,
+): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string> {
+	return getInternalRelationsFromStore(token, IMPLICIT.STORE)
+}

package/src/silo.ts

@@ -1,4 +1,4 @@
-import type { findState } from "atom.io/ephemeral"
+import type { findState } from "atom.io"
 import {
 	actUponStore,
 	arbitrary,
@@ -61,8 +61,8 @@ export class Silo {
 			createStandaloneSelector(s, options)) as typeof selector
 		this.selectorFamily = ((options: Parameters<typeof selectorFamily>[0]) =>
 			createSelectorFamily(s, options)) as typeof selectorFamily
-		this.transaction = (options) => createTransaction(options, s)
-		this.timeline = (options) => createTimeline(options, s)
+		this.transaction = (options) => createTransaction(s, options)
+		this.timeline = (options) => createTimeline(s, options)
 		this.findState = ((...params: Parameters<typeof findState>) =>
 			findInStore(s, ...params)) as typeof findState
 		this.getState = ((...params: Parameters<typeof getState>) =>
@@ -81,7 +81,7 @@ export class Silo {
 		this.redo = (token) => {
 			timeTravel(s, `redo`, token)
 		}
-		this.runTransaction = (token, id = arbitrary()) => actUponStore(token, id, s)
+		this.runTransaction = (token, id = arbitrary()) => actUponStore(s, token, id)
 		this.install = (tokens, source = IMPLICIT.STORE) => {
 			installIntoStore(tokens, s, source)
 		}

package/src/timeline.ts

@@ -49,7 +49,7 @@ export type TimelineUpdate<ManagedAtom extends TimelineManageable> =
 export const timeline = <ManagedAtom extends TimelineManageable>(
 	options: TimelineOptions<ManagedAtom>,
 ): TimelineToken<ManagedAtom> => {
-	return createTimeline(options, IMPLICIT.STORE)
+	return createTimeline(IMPLICIT.STORE, options)
 }
 
 export const redo = (tl: TimelineToken<any>): void => {

package/src/transaction.ts

@@ -1,6 +1,4 @@
-import type { getState, setState } from "atom.io"
-import type { findState } from "atom.io/ephemeral"
-import type { seekState } from "atom.io/immortal"
+import type { findState, getState, setState } from "atom.io"
 import type { EnvironmentData, Func, Transceiver } from "atom.io/internal"
 import {
 	actUponStore,
@@ -83,12 +81,11 @@ export type TransactionUpdate<F extends Func> = {
 	output: ReturnType<F>
 }
 
-export type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json` | `seek`>
+export type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json`>
 export type SetterToolkit = Readonly<{
 	get: typeof getState
 	set: typeof setState
 	find: typeof findState
-	seek: typeof seekState
 	json: <T extends Transceiver<any>, J extends Json.Serializable>(
 		state: MutableAtomToken<T, J>,
 	) => WritableSelectorToken<J>
@@ -97,7 +94,6 @@ export type ActorToolkit = Readonly<{
 	get: typeof getState
 	set: typeof setState
 	find: typeof findState
-	seek: typeof seekState
 	json: <T extends Transceiver<any>, J extends Json.Serializable>(
 		state: MutableAtomToken<T, J>,
 	) => WritableSelectorToken<J>
@@ -132,12 +128,12 @@ export type TransactionIO<Token extends TransactionToken<any>> =
 export function transaction<F extends Func>(
 	options: TransactionOptions<F>,
 ): TransactionToken<F> {
-	return createTransaction(options, IMPLICIT.STORE)
+	return createTransaction(IMPLICIT.STORE, options)
 }
 
 export function runTransaction<F extends Func>(
 	token: TransactionToken<F>,
 	id = arbitrary(),
 ): (...parameters: Parameters<F>) => ReturnType<F> {
-	return actUponStore(token, id, IMPLICIT.STORE)
+	return actUponStore(IMPLICIT.STORE, token, id)
 }