atom.io 0.35.0 → 0.36.1

package/src/main/validators.ts

@@ -56,7 +56,7 @@ export function belongsTo<Family extends RegularAtomFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is RegularAtomToken<TokenType<Family>>
-export function belongsTo<Family extends MutableAtomFamilyToken<any, any, any>>(
+export function belongsTo<Family extends MutableAtomFamilyToken<any, any>>(
 	family: Family,
 	unknownToken: ReadableToken<any>,
 ): unknownToken is MutableAtomToken<TokenType<Family>, any>

package/src/react/use-json.ts

@@ -1,8 +1,5 @@
-import type {
-	MutableAtomFamilyToken,
-	MutableAtomToken,
-	ReadableToken,
-} from "atom.io"
+import type { MutableAtomFamilyToken, MutableAtomToken } from "atom.io"
+import type { AsJSON, Transceiver } from "atom.io/internal"
 import { findInStore, getJsonToken } from "atom.io/internal"
 import type { Canonical, Json } from "atom.io/json"
 import * as React from "react"
@@ -10,29 +7,22 @@ import * as React from "react"
 import { StoreContext } from "./store-context"
 import { useO } from "./use-o"
 
-export function useJSON<Serializable extends Json.Serializable>(
-	token: MutableAtomToken<any, Serializable>,
-): Serializable
+export function useJSON<T extends Transceiver<any, any, any>>(
+	token: MutableAtomToken<T>,
+): AsJSON<T>
 
 export function useJSON<
-	Serializable extends Json.Serializable,
-	Key extends Canonical,
->(token: MutableAtomFamilyToken<any, Serializable, Key>, key: Key): Serializable
+	T extends Transceiver<any, any, any>,
+	K extends Canonical,
+>(token: MutableAtomFamilyToken<T, K>, key: K): AsJSON<T>
 
-export function useJSON<
-	Serializable extends Json.Serializable,
-	Key extends Canonical,
->(
-	token:
-		| MutableAtomFamilyToken<any, Serializable, Key>
-		| MutableAtomToken<any, Serializable>,
-	key?: Key,
-): Serializable {
+export function useJSON(
+	token: MutableAtomFamilyToken<any, any> | MutableAtomToken<any>,
+	key?: Canonical,
+): Json.Serializable {
 	const store = React.useContext(StoreContext)
-	const stateToken: ReadableToken<any> =
-		token.type === `mutable_atom_family`
-			? findInStore(store, token, key as Key)
-			: token
+	const stateToken: MutableAtomToken<any> =
+		token.type === `mutable_atom_family` ? findInStore(store, token, key) : token
 	const jsonToken = getJsonToken(store, stateToken)
 	return useO(jsonToken)
 }

package/src/react-devtools/TransactionIndex.tsx

@@ -4,7 +4,7 @@ import type {
 	TransactionToken,
 	TransactionUpdate,
 } from "atom.io"
-import { findInStore, type Func } from "atom.io/internal"
+import { findInStore, type Fn } from "atom.io/internal"
 import { useI, useO } from "atom.io/react"
 import { type FC, useContext } from "react"
 
@@ -13,9 +13,9 @@ import { DevtoolsContext } from "./store"
 import { article } from "./Updates"
 
 export const TransactionLog: FC<{
-	token: TransactionToken<Func>
+	token: TransactionToken<Fn>
 	isOpenState: RegularAtomToken<boolean>
-	logState: ReadonlyPureSelectorToken<TransactionUpdate<Func>[]>
+	logState: ReadonlyPureSelectorToken<TransactionUpdate<Fn>[]>
 }> = ({ token, isOpenState, logState }) => {
 	const log = useO(logState)
 	const isOpen = useO(isOpenState)

package/src/react-devtools/Updates.tsx

@@ -3,7 +3,7 @@ import type {
 	TimelineUpdate,
 	TransactionUpdate,
 } from "atom.io"
-import type { Func } from "atom.io/internal"
+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"
@@ -37,7 +37,7 @@ const AtomUpdateFC: React.FC<{
 
 const TransactionUpdateFC: React.FC<{
 	serialNumber: number
-	transactionUpdate: TransactionUpdate<Func>
+	transactionUpdate: TransactionUpdate<Fn>
 }> = ({ serialNumber, transactionUpdate }) => {
 	return (
 		<article

package/src/realtime/shared-room-store.ts

@@ -4,27 +4,19 @@ import type {
 	ReadonlyPureSelectorFamilyToken,
 } from "atom.io"
 import { getInternalRelations, join, mutableAtom, selectorFamily } from "atom.io"
-import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
-export const usersInThisRoomIndex: MutableAtomToken<
-	SetRTX<string>,
-	SetRTXJson<string>
-> = mutableAtom<SetRTX<string>, SetRTXJson<string>>({
-	key: `usersInRoomIndex`,
-	default: () => new SetRTX<string>(),
-	toJson: (set) => set.toJSON(),
-	fromJson: (json) => SetRTX.fromJSON(json),
-})
+export const usersInThisRoomIndex: MutableAtomToken<SetRTX<string>> =
+	mutableAtom<SetRTX<string>>({
+		key: `usersInRoomIndex`,
+		class: SetRTX,
+	})
 
-export const roomIndex: MutableAtomToken<
-	SetRTX<string>,
-	SetRTXJson<string>
-> = mutableAtom<SetRTX<string>, SetRTXJson<string>>({
+export const roomIndex: MutableAtomToken<SetRTX<string>> = mutableAtom<
+	SetRTX<string>
+>({
 	key: `roomIndex`,
-	default: () => new SetRTX<string>(),
-	toJson: (set) => set.toJSON(),
-	fromJson: (json) => SetRTX.fromJSON(json),
+	class: SetRTX,
 })
 
 export type UserInRoomMeta = {
@@ -52,12 +44,9 @@ export const usersInRooms: JoinToken<
 )
 
 export const usersInMyRoomView: ReadonlyPureSelectorFamilyToken<
-	MutableAtomToken<SetRTX<string>, SetRTXJson<string>>[],
+	MutableAtomToken<SetRTX<string>>[],
 	string
-> = selectorFamily<
-	MutableAtomToken<SetRTX<string>, SetRTXJson<string>>[],
-	string
->({
+> = selectorFamily<MutableAtomToken<SetRTX<string>>[], string>({
 	key: `usersInMyRoomView`,
 	get:
 		(myUsername) =>

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

@@ -1,5 +1,5 @@
 import type * as AtomIO from "atom.io"
-import type { Func, Store } from "atom.io/internal"
+import type { Fn, Store } from "atom.io/internal"
 import {
 	actUponStore,
 	getEpochNumberOfContinuity,
@@ -22,7 +22,7 @@ export const useRegisterAndAttemptConfirmedUpdate =
 		optimisticUpdates: AtomIO.TransactionUpdate<any>[],
 		confirmedUpdates: AtomIO.TransactionUpdate<any>[],
 	) =>
-	(confirmed: AtomIO.TransactionUpdate<Func>): void => {
+	(confirmed: AtomIO.TransactionUpdate<Fn>): void => {
 		function reconcileEpoch(
 			optimisticUpdate: AtomIO.TransactionUpdate<any>,
 			confirmedUpdate: AtomIO.TransactionUpdate<any>,

package/src/realtime-client/pull-mutable-atom-family-member.ts

@@ -1,37 +1,28 @@
 import type * as AtomIO from "atom.io"
-import type { Store, Transceiver } from "atom.io/internal"
+import type { AsJSON, SignalFrom, Store, Transceiver } from "atom.io/internal"
 import { getJsonToken, getUpdateToken, setIntoStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
 /* eslint-disable no-console */
 
 export function pullMutableAtomFamilyMember<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(
-	store: Store,
-	socket: Socket,
-	token: AtomIO.MutableAtomToken<T, J>,
-): () => void {
+	T extends Transceiver<any, any, any>,
+>(store: Store, socket: Socket, token: AtomIO.MutableAtomToken<T>): () => void {
 	if (!(`family` in token)) {
 		console.error(`Token is not a family member:`, token)
 		return () => {}
 	}
 	const { key: familyKey, subKey: serializedSubKey } = token.family
 	const subKey = parseJson(serializedSubKey)
-	socket.on(`init:${token.key}`, (data: J) => {
+	socket.on(`init:${token.key}`, (data: AsJSON<T>) => {
 		const jsonToken = getJsonToken(store, token)
 		setIntoStore(store, jsonToken, data)
 	})
-	socket.on(
-		`next:${token.key}`,
-		(data: T extends Transceiver<infer Signal> ? Signal : never) => {
-			const trackerToken = getUpdateToken(token)
-			setIntoStore(store, trackerToken, data)
-		},
-	)
+	socket.on(`next:${token.key}`, (data: SignalFrom<T>) => {
+		const trackerToken = getUpdateToken(token)
+		setIntoStore(store, trackerToken, data)
+	})
 	socket.emit(`sub:${familyKey}`, subKey)
 	return () => {
 		socket.off(`serve:${token.key}`)

package/src/realtime-client/pull-mutable-atom.ts

@@ -1,28 +1,21 @@
 import type * as AtomIO from "atom.io"
-import type { Store, Transceiver } from "atom.io/internal"
+import type { AsJSON, SignalFrom, Store, Transceiver } from "atom.io/internal"
 import { getJsonToken, getUpdateToken, setIntoStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
-export function pullMutableAtom<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(
+export function pullMutableAtom<T extends Transceiver<any, any, any>>(
 	store: Store,
 	socket: Socket,
-	token: AtomIO.MutableAtomToken<T, J>,
+	token: AtomIO.MutableAtomToken<T>,
 ): () => void {
 	const jsonToken = getJsonToken(store, token)
 	const updateToken = getUpdateToken(token)
-	socket.on(`init:${token.key}`, (data: J) => {
+	socket.on(`init:${token.key}`, (data: AsJSON<T>) => {
 		setIntoStore(store, jsonToken, data)
 	})
-	socket.on(
-		`next:${token.key}`,
-		(data: T extends Transceiver<infer Update> ? Update : never) => {
-			setIntoStore(store, updateToken, data)
-		},
-	)
+	socket.on(`next:${token.key}`, (data: SignalFrom<T>) => {
+		setIntoStore(store, updateToken, data)
+	})
 	socket.emit(`sub:${token.key}`)
 	return () => {
 		socket.off(`init:${token.key}`)

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

@@ -1,15 +1,16 @@
-import type * as AtomIO from "atom.io"
-import * as Internal from "atom.io/internal"
+import type { WritableToken } from "atom.io"
+import type { Store } from "atom.io/internal"
+import { subscribeToState } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 import type { Socket } from "socket.io-client"
 
 export function pushState<J extends Json.Serializable>(
-	store: Internal.Store,
+	store: Store,
 	socket: Socket,
-	token: AtomIO.WritableToken<J>,
+	token: WritableToken<J>,
 ): () => void {
 	socket.emit(`claim:${token.key}`)
-	Internal.subscribeToState(store, token, `push`, ({ newValue }) => {
+	subscribeToState(store, token, `push`, ({ newValue }) => {
 		socket.emit(`pub:${token.key}`, newValue)
 	})
 	return () => {

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

@@ -1,13 +1,14 @@
 import type * as AtomIO from "atom.io"
-import * as Internal from "atom.io/internal"
+import type { Fn, Store } from "atom.io/internal"
+import { subscribeToTransaction } from "atom.io/internal"
 import type { Socket } from "socket.io-client"
 
-export function serverAction<F extends Internal.Func>(
-	store: Internal.Store,
+export function serverAction<F extends Fn>(
+	store: Store,
 	socket: Socket,
 	token: AtomIO.TransactionToken<F>,
 ): () => void {
-	const unsubscribeFromLocalUpdates = Internal.subscribeToTransaction(
+	const unsubscribeFromLocalUpdates = subscribeToTransaction(
 		store,
 		token,
 		`tx-run:${token.key}:${socket.id}`,

package/src/realtime-react/use-pull-mutable-atom.ts

@@ -1,16 +1,14 @@
 import type * as AtomIO from "atom.io"
 import type { Transceiver } from "atom.io/internal"
-import type { Json } from "atom.io/json"
 import { StoreContext, useO } 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 usePullMutable<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
->(token: AtomIO.MutableAtomToken<T, J>): T {
+export function usePullMutable<T extends Transceiver<any, any, any>>(
+	token: AtomIO.MutableAtomToken<T>,
+): T {
 	const store = React.useContext(StoreContext)
 	useRealtimeService(`pull:${token.key}`, (socket) =>
 		RTC.pullMutableAtom(store, socket, token),

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

@@ -1,7 +1,7 @@
 import type * as AtomIO from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import { findInStore } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { StoreContext, useO } from "atom.io/react"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
@@ -9,11 +9,10 @@ import * as React from "react"
 import { useRealtimeService } from "./use-realtime-service"
 
 export function usePullMutableAtomFamilyMember<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
+	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 	Key extends K,
->(familyToken: AtomIO.MutableAtomFamilyToken<T, J, K>, key: Key): T {
+>(familyToken: AtomIO.MutableAtomFamilyToken<T, K>, key: Key): T {
 	const store = React.useContext(StoreContext)
 	const token = findInStore(store, familyToken, key)
 	useRealtimeService(`pull:${token.key}`, (socket) =>

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

@@ -1,5 +1,5 @@
 import type * as AtomIO from "atom.io"
-import type { Func } from "atom.io/internal"
+import type { Fn } from "atom.io/internal"
 import { actUponStore, arbitrary } from "atom.io/internal"
 import { StoreContext } from "atom.io/react"
 import * as RTC from "atom.io/realtime-client"
@@ -7,7 +7,7 @@ import * as React from "react"
 
 import { useRealtimeService } from "./use-realtime-service"
 
-export function useServerAction<F extends Func>(
+export function useServerAction<F extends Fn>(
 	token: AtomIO.TransactionToken<F>,
 ): (...parameters: Parameters<F>) => ReturnType<F> {
 	const store = React.useContext(StoreContext)

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

@@ -8,7 +8,7 @@ import {
 	IMPLICIT,
 	subscribeToState,
 } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import type { ServerConfig } from "."
@@ -21,11 +21,10 @@ export function realtimeMutableFamilyProvider({
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	return function mutableFamilyProvider<
-		T extends Transceiver<any>,
-		J extends Json.Serializable,
+		T extends Transceiver<any, any, any>,
 		K extends Canonical,
 	>(
-		family: AtomIO.MutableAtomFamilyToken<T, J, K>,
+		family: AtomIO.MutableAtomFamilyToken<T, K>,
 		index: AtomIO.ReadableToken<Iterable<K>>,
 	): () => void {
 		const unsubCallbacksByKey = new Map<string, () => void>()

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

@@ -17,9 +17,8 @@ export function realtimeMutableProvider({
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
 	return function mutableProvider<
-		Core extends Transceiver<Json.Serializable>,
-		SerializableCore extends Json.Serializable,
-	>(token: AtomIO.MutableAtomToken<Core, SerializableCore>): () => void {
+		Core extends Transceiver<any, Json.Serializable, Json.Serializable>,
+	>(token: AtomIO.MutableAtomToken<Core>): () => void {
 		let unsubscribeFromStateUpdates: (() => void) | null = null
 
 		const jsonToken = getJsonToken(store, token)

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

@@ -7,10 +7,11 @@ import { roomIndex, usersInRooms } from "atom.io/realtime"
 import type { ChildSocket } from "../ipc-sockets"
 import type { RoomArguments } from "./server-room-external-store"
 import { roomArgumentsAtoms, roomSelectors } from "./server-room-external-store"
+import type { RoomKey } from "./server-user-store"
 
 export const createRoomTX: AtomIO.TransactionToken<
 	(
-		roomId: string,
+		roomKey: RoomKey,
 		script: string,
 		options?: string[],
 	) => Loadable<ChildSocket<any, any>>
@@ -62,17 +63,17 @@ export const leaveRoomTX: AtomIO.TransactionToken<
 })
 export type LeaveRoomIO = AtomIO.TransactionIO<typeof leaveRoomTX>
 
-export const destroyRoomTX: AtomIO.TransactionToken<(roomId: string) => void> =
+export const destroyRoomTX: AtomIO.TransactionToken<(roomKey: RoomKey) => void> =
 	AtomIO.transaction({
 		key: `destroyRoom`,
-		do: (tools, roomId) => {
+		do: (tools, roomKey) => {
 			editRelationsInStore(
 				usersInRooms,
 				(relations) => {
-					relations.delete({ room: roomId })
+					relations.delete({ room: roomKey })
 				},
 				tools.env().store,
 			)
-			tools.set(roomIndex, (s) => (s.delete(roomId), s))
+			tools.set(roomIndex, (s) => (s.delete(roomKey), s))
 		},
 	})

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

@@ -5,7 +5,6 @@ import type {
 	RegularAtomFamilyToken,
 } from "atom.io"
 import { atomFamily, join, mutableAtom } from "atom.io"
-import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
 import type { Socket } from ".."
@@ -29,23 +28,17 @@ export const socketAtoms: RegularAtomFamilyToken<Socket | null, SocketKey> =
 		default: null,
 	})
 
-export const socketIndex: MutableAtomToken<
-	SetRTX<SocketKey>,
-	SetRTXJson<SocketKey>
-> = mutableAtom<SetRTX<SocketKey>, SetRTXJson<SocketKey>>({
+export const socketIndex: MutableAtomToken<SetRTX<SocketKey>> = mutableAtom<
+	SetRTX<SocketKey>
+>({
 	key: `socketsIndex`,
-	default: () => new SetRTX(),
-	toJson: (set) => set.toJSON(),
-	fromJson: (json) => SetRTX.fromJSON(json),
+	class: SetRTX,
 })
-export const userIndex: MutableAtomToken<
-	SetRTX<UserKey>,
-	SetRTXJson<UserKey>
-> = mutableAtom<SetRTX<UserKey>, SetRTXJson<UserKey>>({
+export const userIndex: MutableAtomToken<SetRTX<UserKey>> = mutableAtom<
+	SetRTX<UserKey>
+>({
 	key: `usersIndex`,
-	default: () => new SetRTX(),
-	toJson: (set) => set.toJSON(),
-	fromJson: (json) => SetRTX.fromJSON(json),
+	class: SetRTX,
 })
 export const usersOfSockets: JoinToken<
 	`user`,

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

@@ -7,6 +7,13 @@ export type SetUpdateType = `add` | `clear` | `del` | `tx`
 export type SetUpdate = `${SetUpdateType}:${string}`
 export type NumberedSetUpdate = `${number}=${SetUpdate}`
 
+export interface SetRTXView<P extends primitive> extends ReadonlySet<P> {
+	readonly cache: ReadonlyArray<NumberedSetUpdate | null>
+	readonly cacheLimit: number
+	readonly cacheIdx: number
+	readonly cacheUpdateNumber: number
+}
+
 export interface SetRTXJson<P extends primitive> extends Json.Object {
 	members: P[]
 	cache: (NumberedSetUpdate | null)[]
@@ -16,7 +23,9 @@ export interface SetRTXJson<P extends primitive> extends Json.Object {
 }
 export class SetRTX<P extends primitive>
 	extends Set<P>
-	implements Transceiver<NumberedSetUpdate>, Lineage
+	implements
+		Transceiver<SetRTXView<P>, NumberedSetUpdate, SetRTXJson<P>>,
+		Lineage
 {
 	public mode: TransceiverMode = `record`
 	public readonly subject: Subject<SetUpdate> = new Subject<SetUpdate>()
@@ -42,6 +51,10 @@ export class SetRTX<P extends primitive>
 		}
 	}
 
+	public view(): SetRTXView<P> {
+		return this
+	}
+
 	public toJSON(): SetRTXJson<P> {
 		return {
 			members: [...this],

package/src/eslint-plugin/rules/synchronous-selector-dependencies.ts

@@ -1,140 +0,0 @@
-/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
-import type { RuleType } from "@eslint/core"
-import type { Rule } from "eslint"
-import type * as ESTree from "estree"
-
-import { walk } from "../walk"
-
-export const synchronousSelectorDependencies: {
-	meta: {
-		type: RuleType
-		docs: {
-			description: string
-			category: string
-			recommended: boolean
-			url: string
-		}
-		schema: never[]
-	}
-	create(context: Rule.RuleContext): Rule.NodeListener
-} = {
-	meta: {
-		type: `problem`,
-		docs: {
-			description: `disallow await before calling get on the parameter's get method inside selector`,
-			category: `Possible Errors`,
-			recommended: false,
-			url: ``, // URL to documentation page for this rule
-		},
-		schema: [], // no options
-	},
-	create(context) {
-		return {
-			CallExpression(node) {
-				let selectorComputation: ESTree.Node | undefined
-				if (`name` in node.callee && node.callee.name === `selectorFamily`) {
-					if (node.arguments[0].type === `ObjectExpression`) {
-						const selectorLookupProperty = node.arguments[0].properties.find(
-							(prop): prop is ESTree.Property => {
-								return (
-									`key` in prop && `name` in prop.key && prop.key.name === `get`
-								)
-							},
-						)
-						const selectorLookup = selectorLookupProperty?.value
-						if (
-							selectorLookup?.type === `FunctionExpression` ||
-							selectorLookup?.type === `ArrowFunctionExpression`
-						) {
-							if (selectorLookup.body.type === `BlockStatement`) {
-								for (const statement of selectorLookup.body.body) {
-									if (
-										statement.type === `ReturnStatement` &&
-										statement.argument
-									) {
-										selectorComputation = statement.argument
-									}
-								}
-							} else if (
-								selectorLookup.body.type === `FunctionExpression` ||
-								selectorLookup.body.type === `ArrowFunctionExpression`
-							) {
-								selectorComputation = selectorLookup.body
-							}
-						}
-					}
-				}
-				if (`name` in node.callee && node.callee.name === `selector`) {
-					if (node.arguments[0].type === `ObjectExpression`) {
-						const selectorComputationProperty =
-							node.arguments[0].properties.find(
-								(prop): prop is ESTree.Property => {
-									return (
-										`key` in prop &&
-										`name` in prop.key &&
-										prop.key.name === `get`
-									)
-								},
-							)
-						selectorComputation = selectorComputationProperty?.value
-					}
-				}
-				if (
-					selectorComputation?.type === `FunctionExpression` ||
-					selectorComputation?.type === `ArrowFunctionExpression`
-				) {
-					const nonDestructuredTransactorsName =
-						selectorComputation.params[0] &&
-						`name` in selectorComputation.params[0]
-							? selectorComputation.params[0].name
-							: undefined
-					let awaited: number | undefined
-					let awaitNode: ESTree.AwaitExpression | undefined
-					walk(selectorComputation, (n, depth) => {
-						// console.log(`${`\t`.repeat(depth)}${n.type} ${n.name ?? ``}`)
-						if (typeof awaited === `number`) {
-							if (awaited > depth) {
-								awaited = undefined
-								awaitNode = undefined
-							}
-						}
-						switch (n.type) {
-							case `AwaitExpression`:
-								awaited = depth
-								awaitNode = n
-								break
-							case `CallExpression`:
-								if (awaitNode) {
-									let willReport = false
-									switch (n.callee.type) {
-										case `MemberExpression`:
-											if (
-												n.callee.object.type === `Identifier` &&
-												n.callee.object.name ===
-													nonDestructuredTransactorsName &&
-												n.callee.property.type === `Identifier` &&
-												n.callee.property.name === `get`
-											) {
-												willReport = true
-											}
-											break
-										case `Identifier`:
-											if (n.callee.name === `get`) {
-												willReport = true
-											}
-											break
-									}
-									if (willReport) {
-										context.report({
-											node: awaitNode,
-											message: `Using await before calling the 'get' transactor is not allowed.`,
-										})
-									}
-								}
-						}
-					})
-				}
-			},
-		}
-	},
-} satisfies Rule.RuleModule