atom.io 0.19.1 → 0.19.3

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

@@ -76,12 +76,12 @@ export class ChildSocket<
 				// console.log(`🤓`, this.unprocessedEvents.length)
 				// console.log(`🤓`, ...this.unprocessedEvents.map((x) => x.length))
 				const newInput = this.unprocessedEvents.shift()
-				this.incompleteData += newInput || ``
+				this.incompleteData += newInput ?? ``
 				try {
 					if (this.incompleteData.startsWith(`error`)) {
 						console.log(`❗`, this.incompleteData)
 					}
-					const parsedEvent = parseJson(this.incompleteData)
+					let parsedEvent = parseJson(this.incompleteData)
 					this.handleEvent(...(parsedEvent as [string, ...I[keyof I]]))
 					while (this.unprocessedEvents.length > 0) {
 						const event = this.unprocessedEvents.shift()
@@ -89,7 +89,7 @@ export class ChildSocket<
 							if (this.unprocessedEvents.length === 0) {
 								this.incompleteData = event
 							}
-							const parsedEvent = parseJson(event)
+							parsedEvent = parseJson(event)
 							this.handleEvent(...(parsedEvent as [string, ...I[keyof I]]))
 						}
 					}
@@ -109,15 +109,15 @@ export class ChildSocket<
 			// console.log(`🤫`, this.unprocessedLogs.length)
 			// console.log(`🤫`, ...this.unprocessedLogs.map((x) => x.length))
 			const newInput = this.unprocessedLogs.shift()
-			this.incompleteLog += newInput || ``
+			this.incompleteLog += newInput ?? ``
 			try {
-				const parsedLog = parseJson(this.incompleteLog)
+				let parsedLog = parseJson(this.incompleteLog)
 				// console.log(`🤫`, parsedLog)
 				this.handleLog(parsedLog)
 				while (this.unprocessedLogs.length > 0) {
 					this.incompleteLog = this.unprocessedLogs.shift() ?? ``
 					if (this.incompleteLog) {
-						const parsedLog = parseJson(this.incompleteLog)
+						parsedLog = parseJson(this.incompleteLog)
 						this.handleLog(parsedLog)
 					}
 				}

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

@@ -49,7 +49,7 @@ export class CustomSocket<I extends Events, O extends Events> implements Socket
 	public on<Event extends keyof I>(
 		event: Event,
 		listener: (...args: I[Event]) => void,
-	): CustomSocket<I, O> {
+	): this {
 		const listeners = this.listeners.get(event)
 		if (listeners) {
 			listeners.add(listener)
@@ -59,9 +59,7 @@ export class CustomSocket<I extends Events, O extends Events> implements Socket
 		return this
 	}
 
-	public onAny(
-		listener: (event: string, ...args: Json.Array) => void,
-	): CustomSocket<I, O> {
+	public onAny(listener: (event: string, ...args: Json.Array) => void): this {
 		this.globalListeners.add(listener)
 		return this
 	}
@@ -69,7 +67,7 @@ export class CustomSocket<I extends Events, O extends Events> implements Socket
 	public off<Event extends keyof I>(
 		event: Event,
 		listener?: (...args: I[Event]) => void,
-	): CustomSocket<I, O> {
+	): this {
 		const listeners = this.listeners.get(event)
 		if (listeners) {
 			if (listener) {
@@ -81,9 +79,7 @@ export class CustomSocket<I extends Events, O extends Events> implements Socket
 		return this
 	}
 
-	public offAny(
-		listener: (event: string, ...args: Json.Array) => void,
-	): CustomSocket<I, O> {
+	public offAny(listener: (event: string, ...args: Json.Array) => void): this {
 		this.globalListeners.delete(listener)
 		return this
 	}

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

@@ -70,9 +70,15 @@ export class ParentSocket<
 		)
 	}
 	public logger = {
-		info: (...args: any[]): void => this.log(`i`, ...args),
-		warn: (...args: any[]): void => this.log(`w`, ...args),
-		error: (...args: any[]): void => this.log(`e`, ...args),
+		info: (...args: any[]): void => {
+			this.log(`i`, ...args)
+		},
+		warn: (...args: any[]): void => {
+			this.log(`w`, ...args)
+		},
+		error: (...args: any[]): void => {
+			this.log(`e`, ...args)
+		},
 	}
 
 	public constructor() {
@@ -93,12 +99,12 @@ export class ParentSocket<
 				const chunk = buffer.toString()
 				this.unprocessedEvents.push(...chunk.split(`\x03`))
 				const newInput = this.unprocessedEvents.shift()
-				this.incompleteData += newInput || ``
+				this.incompleteData += newInput ?? ``
 
 				try {
-					const parsedEvent = parseJson(this.incompleteData)
-					this.logger.info(`🎰`, `received`, parsedEvent)
-					this.handleEvent(...(parsedEvent as [string, ...I[keyof I]]))
+					const parsedData = parseJson(this.incompleteData)
+					this.logger.info(`🎰`, `received`, parsedData)
+					this.handleEvent(...(parsedData as [string, ...I[keyof I]]))
 					while (this.unprocessedEvents.length > 0) {
 						const event = this.unprocessedEvents.shift()
 						if (event) {

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

@@ -9,17 +9,17 @@ export function realtimeActionReceiver({
 	socket,
 	store = IMPLICIT.STORE,
 }: ServerConfig) {
-	return function actionReceiver<ƒ extends JsonIO>(
-		tx: AtomIO.TransactionToken<ƒ>,
+	return function actionReceiver<F extends JsonIO>(
+		tx: AtomIO.TransactionToken<F>,
 	): () => void {
 		const fillTransactionRequest = (
-			update: Pick<AtomIO.TransactionUpdate<ƒ>, `id` | `params`>,
+			update: Pick<AtomIO.TransactionUpdate<F>, `id` | `params`>,
 		) => {
 			const performanceKey = `tx-run:${tx.key}:${update.id}`
 			const performanceKeyStart = `${performanceKey}:start`
 			const performanceKeyEnd = `${performanceKey}:end`
 			performance.mark(performanceKeyStart)
-			actUponStore<ƒ>(tx, update.id, store)(...update.params)
+			actUponStore<F>(tx, update.id, store)(...update.params)
 			performance.mark(performanceKeyEnd)
 			const metric = performance.measure(
 				performanceKey,
@@ -30,6 +30,8 @@ export function realtimeActionReceiver({
 		}
 		socket.on(`tx-run:${tx.key}`, fillTransactionRequest)
 
-		return () => socket.off(`tx-run:${tx.key}`, fillTransactionRequest)
+		return () => {
+			socket.off(`tx-run:${tx.key}`, fillTransactionRequest)
+		}
 	}
 }

package/realtime-server/src/realtime-continuity-synchronizer.ts

@@ -91,7 +91,7 @@ export function realtimeContinuitySynchronizer({
 		const unsubscribeFunctions: (() => void)[] = []
 
 		const revealPerspectives = (): (() => void) => {
-			const unsubscribeFunctions: (() => void)[] = []
+			const unsubFns: (() => void)[] = []
 			for (const perspective of continuity.perspectives) {
 				const { viewAtoms } = perspective
 				const userViewState = findInStore(viewAtoms, userKey, store)
@@ -128,10 +128,10 @@ export function realtimeContinuitySynchronizer({
 					`sync-continuity:${continuityKey}:${userKey}:perspective:${perspective.resourceAtoms.key}`,
 					store,
 				)
-				unsubscribeFunctions.push(unsubscribe)
+				unsubFns.push(unsubscribe)
 			}
 			return () => {
-				for (const unsubscribe of unsubscribeFunctions) unsubscribe()
+				for (const unsubscribe of unsubFns) unsubscribe()
 			}
 		}
 		const unsubscribeFromPerspectives = revealPerspectives()

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

@@ -12,7 +12,9 @@ export function realtimeStateReceiver({
 	return function stateReceiver<J extends Json.Serializable>(
 		token: WritableToken<J>,
 	): () => void {
-		const publish = (newValue: J) => setIntoStore(token, newValue, store)
+		const publish = (newValue: J) => {
+			setIntoStore(token, newValue, store)
+		}
 
 		const fillPubUnclaim = () => {
 			socket.off(`pub:${token.key}`, publish)

package/realtime-testing/dist/index.cjs

@@ -74,29 +74,29 @@ function getJoinMap(store) {
 function getJoin(token, store) {
   var _a;
   const joinMap = getJoinMap(store);
-  let join = joinMap.get(token.key);
-  if (join === void 0) {
+  let myJoin = joinMap.get(token.key);
+  if (myJoin === void 0) {
     const rootJoinMap = getJoinMap(internal.IMPLICIT.STORE);
-    join = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
-    if (join === void 0) {
+    myJoin = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
+    if (myJoin === void 0) {
       throw new Error(
         `Join "${token.key}" not found in store "${store.config.name}"`
       );
     }
-    joinMap.set(token.key, join);
+    joinMap.set(token.key, myJoin);
   }
-  return join;
+  return myJoin;
 }
 function editRelationsInStore(token, change, store) {
-  const join = getJoin(token, store);
+  const myJoin = getJoin(token, store);
   const target = internal.newest(store);
   if (internal.isChildStore(target)) {
     const { transactors } = target.transactionMeta;
-    join.transact(transactors, ({ relations }) => {
+    myJoin.transact(transactors, ({ relations }) => {
       change(relations);
     });
   } else {
-    change(join.relations);
+    change(myJoin.relations);
   }
 }
 
@@ -213,7 +213,9 @@ var setupRealtimeTestClient = (options, name, port) => {
         container: document.querySelector(`#app`)
       }
     );
-    const prettyPrint = () => console.log(react.prettyDOM(renderResult.container));
+    const prettyPrint = () => {
+      console.log(react.prettyDOM(renderResult.container));
+    };
     const dispose2 = () => {
       renderResult.unmount();
       socket.disconnect();
@@ -245,13 +247,13 @@ var singleClient = (options) => {
 var multiClient = (options) => {
   const server = setupRealtimeTestServer(options);
   const clients = recordToEntries(options.clients).reduce(
-    (clients2, [name, client]) => {
-      clients2[name] = setupRealtimeTestClient(
+    (clientRecord, [name, client]) => {
+      clientRecord[name] = setupRealtimeTestClient(
         __spreadProps(__spreadValues({}, options), { client }),
         name,
         server.port
       );
-      return clients2;
+      return clientRecord;
     },
     {}
   );

package/realtime-testing/dist/index.js

@@ -1,9 +1,9 @@
 import { myUsernameState } from '../../dist/chunk-O47EQUM6.js';
-import { editRelationsInStore } from '../../dist/chunk-7ZR244C2.js';
-import '../../dist/chunk-WX2NCOZR.js';
-import { recordToEntries } from '../../dist/chunk-7VCCW45K.js';
+import { editRelationsInStore } from '../../dist/chunk-MSCJWACE.js';
+import '../../dist/chunk-FTONNX2R.js';
+import { recordToEntries } from '../../dist/chunk-CC7IF7QF.js';
 import '../../dist/chunk-BWWVY5O5.js';
-import { __spreadProps, __spreadValues } from '../../dist/chunk-U2IICNHQ.js';
+import { __spreadProps, __spreadValues } from '../../dist/chunk-F2X4B4VY.js';
 import * as http from 'http';
 import { render, prettyDOM } from '@testing-library/react';
 import * as AtomIO from 'atom.io';
@@ -90,7 +90,9 @@ var setupRealtimeTestClient = (options, name, port) => {
         container: document.querySelector(`#app`)
       }
     );
-    const prettyPrint = () => console.log(prettyDOM(renderResult.container));
+    const prettyPrint = () => {
+      console.log(prettyDOM(renderResult.container));
+    };
     const dispose = () => {
       renderResult.unmount();
       socket.disconnect();
@@ -122,13 +124,13 @@ var singleClient = (options) => {
 var multiClient = (options) => {
   const server = setupRealtimeTestServer(options);
   const clients = recordToEntries(options.clients).reduce(
-    (clients2, [name, client]) => {
-      clients2[name] = setupRealtimeTestClient(
+    (clientRecord, [name, client]) => {
+      clientRecord[name] = setupRealtimeTestClient(
         __spreadProps(__spreadValues({}, options), { client }),
         name,
         server.port
       );
-      return clients2;
+      return clientRecord;
     },
     {}
   );

package/realtime-testing/package.json

@@ -3,7 +3,7 @@
 	"type": "module",
 	"private": true,
 	"main": "dist/index.cjs",
-	"module": "dist/index.mjs",
+	"module": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"exports": {
 		".": {

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

@@ -159,7 +159,9 @@ export const setupRealtimeTestClient = (
 			},
 		)
 
-		const prettyPrint = () => console.log(prettyDOM(renderResult.container))
+		const prettyPrint = () => {
+			console.log(prettyDOM(renderResult.container))
+		}
 
 		const dispose = () => {
 			renderResult.unmount()
@@ -200,13 +202,13 @@ export const multiClient = <ClientNames extends string>(
 ): RealtimeTestAPI__MultiClient<ClientNames> => {
 	const server = setupRealtimeTestServer(options)
 	const clients = recordToEntries(options.clients).reduce(
-		(clients, [name, client]) => {
-			clients[name] = setupRealtimeTestClient(
+		(clientRecord, [name, client]) => {
+			clientRecord[name] = setupRealtimeTestClient(
 				{ ...options, client },
 				name,
 				server.port,
 			)
-			return clients
+			return clientRecord
 		},
 		{} as Record<ClientNames, RealtimeTestClientBuilder>,
 	)

package/src/atom.ts

@@ -57,10 +57,8 @@ export type RegularAtomFamilyTokenWithCall<
 	K extends Json.Serializable,
 > = 
 	& RegularAtomFamilyToken<T, K>
-	& {
-		/** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
-		(key: K): RegularAtomToken<T>
-	}
+	& /** @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>
@@ -102,10 +100,8 @@ export type MutableAtomFamilyTokenWithCall<
 	K extends Json.Serializable,
 > = 
 	& MutableAtomFamilyToken<T, J, K>
-	& {
-		/** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
-		(key: K): MutableAtomToken<T, J>
-	}
+	& /** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
+((key: K) => MutableAtomToken<T, J>)
 // biome-ignore format: intersection
 export type MutableAtomFamily<
 	T extends Transceiver<any>,

package/src/dispose.ts

@@ -8,6 +8,7 @@ export function dispose(
 ): void {
 	switch (token.type) {
 		case `atom`:
+		case `mutable_atom`:
 			Internal.deleteAtom(token, store)
 			break
 		case `selector`:

package/src/index.ts

@@ -1,14 +1,7 @@
 import type { Transceiver } from "atom.io/internal"
 import type { Json } from "atom.io/json"
+import type { AtomFamily, AtomFamilyToken } from "./atom"
 import type {
-	AtomFamily,
-	AtomFamilyToken,
-	RegularAtomFamily,
-	RegularAtomFamilyToken,
-} from "./atom"
-import type {
-	ReadonlySelectorFamily,
-	ReadonlySelectorFamilyToken,
 	SelectorFamily,
 	SelectorFamilyToken,
 	WritableSelectorFamily,
@@ -28,7 +21,7 @@ export * from "./timeline"
 export * from "./transaction"
 export * from "./validators"
 
-export type ƒn = (...parameters: any[]) => any
+export type Func = (...parameters: any[]) => any
 
 export type RegularAtomToken<T> = {
 	key: string

package/src/selector.ts

@@ -53,10 +53,8 @@ export type WritableSelectorFamilyTokenWithCall<
 	K extends Json.Serializable,
 > = 
 	& WritableSelectorFamilyToken<T, K>
-	& {
-		/** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
-		(key: K): WritableSelectorToken<T>
-	}
+	& /** @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> 
@@ -78,10 +76,8 @@ export type ReadonlySelectorFamilyTokenWithCall<
 	K extends Json.Serializable,
 > = 
 	& ReadonlySelectorFamilyToken<T, K>
-	& {
-		/** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */
-		(key: K): ReadonlySelectorToken<T>
-	}
+	& /** @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>)

package/src/silo.ts

@@ -85,9 +85,15 @@ export class Silo {
 		this.timeline = (options) => createTimeline(options, s)
 		this.findState = (token, key) => findInStore(token, key, s) as any
 		this.getState = (token) => getFromStore(token, s)
-		this.setState = (token, newValue) => setIntoStore(token, newValue, s)
+		this.setState = (token, newValue) => {
+			setIntoStore(token, newValue, s)
+		}
 		this.subscribe = (token, handler, key) => subscribe(token, handler, key, s)
-		this.undo = (token) => timeTravel(`undo`, token, s)
-		this.redo = (token) => timeTravel(`redo`, token, s)
+		this.undo = (token) => {
+			timeTravel(`undo`, token, s)
+		}
+		this.redo = (token) => {
+			timeTravel(`redo`, token, s)
+		}
 	}
 }

package/src/subscribe.ts

@@ -15,7 +15,7 @@ import type {
 	TimelineUpdate,
 	TransactionToken,
 	TransactionUpdate,
-	ƒn,
+	Func,
 } from "."
 
 export type StateUpdate<T> = { newValue: T; oldValue: T }
@@ -25,8 +25,8 @@ export type KeyedStateUpdate<T> = StateUpdate<T> & {
 }
 export type UpdateHandler<T> = (update: StateUpdate<T>) => void
 
-export type TransactionUpdateHandler<ƒ extends ƒn> = (
-	data: TransactionUpdate<ƒ>,
+export type TransactionUpdateHandler<F extends Func> = (
+	data: TransactionUpdate<F>,
 ) => void
 
 export function subscribe<T>(
@@ -35,9 +35,9 @@ export function subscribe<T>(
 	key?: string,
 	store?: Store,
 ): () => void
-export function subscribe<ƒ extends ƒn>(
-	token: TransactionToken<ƒ>,
-	handleUpdate: TransactionUpdateHandler<ƒ>,
+export function subscribe<F extends Func>(
+	token: TransactionToken<F>,
+	handleUpdate: TransactionUpdateHandler<F>,
 	key?: string,
 	store?: Store,
 ): () => void

package/src/timeline.ts

@@ -36,10 +36,10 @@ export const timeline = <ManagedAtom extends TimelineManageable>(
 	return createTimeline(options, IMPLICIT.STORE)
 }
 
-export const redo = (timeline: TimelineToken<any>): void => {
-	timeTravel(`redo`, timeline, IMPLICIT.STORE)
+export const redo = (tl: TimelineToken<any>): void => {
+	timeTravel(`redo`, tl, IMPLICIT.STORE)
 }
 
-export const undo = (timeline: TimelineToken<any>): void => {
-	timeTravel(`undo`, timeline, IMPLICIT.STORE)
+export const undo = (tl: TimelineToken<any>): void => {
+	timeTravel(`undo`, tl, IMPLICIT.STORE)
 }

package/src/transaction.ts

@@ -11,10 +11,10 @@ import type {
 	ReadonlySelectorToken,
 	WritableToken,
 	findState,
-	ƒn,
+	Func,
 } from "."
 
-export type TransactionToken<F> = {
+export type TransactionToken<F extends Func> = {
 	key: string
 	type: `transaction`
 	__F?: F
@@ -22,15 +22,15 @@ export type TransactionToken<F> = {
 
 export type TransactionUpdateContent =
 	| KeyedStateUpdate<unknown>
-	| TransactionUpdate<ƒn>
+	| TransactionUpdate<Func>
 
-export type TransactionUpdate<ƒ extends ƒn> = {
+export type TransactionUpdate<F extends Func> = {
 	key: string
 	id: string
 	epoch: number
 	updates: TransactionUpdateContent[]
-	params: Parameters<ƒ>
-	output: ReturnType<ƒ>
+	params: Parameters<F>
+	output: ReturnType<F>
 }
 
 export type Transactors = Readonly<{
@@ -53,38 +53,38 @@ export type TransactorsWithRunAndEnv = Readonly<{
 }>
 export type ReadonlyTransactors = Pick<Transactors, `find` | `get`>
 
-export type Read<ƒ extends ƒn> = (
+export type Read<F extends Func> = (
 	transactors: ReadonlyTransactors,
-	...parameters: Parameters<ƒ>
-) => ReturnType<ƒ>
+	...parameters: Parameters<F>
+) => ReturnType<F>
 
-export type Write<ƒ extends ƒn> = (
+export type Write<F extends Func> = (
 	transactors: Transactors,
-	...parameters: Parameters<ƒ>
-) => ReturnType<ƒ>
+	...parameters: Parameters<F>
+) => ReturnType<F>
 
-export type Transact<ƒ extends ƒn> = (
+export type Transact<F extends Func> = (
 	transactors: TransactorsWithRunAndEnv,
-	...parameters: Parameters<ƒ>
-) => ReturnType<ƒ>
+	...parameters: Parameters<F>
+) => ReturnType<F>
 
-export type TransactionOptions<ƒ extends ƒn> = {
+export type TransactionOptions<F extends Func> = {
 	key: string
-	do: Transact<ƒ>
+	do: Transact<F>
 }
 
 export type TransactionIO<Token extends TransactionToken<any>> =
-	Token extends TransactionToken<infer ƒ> ? ƒ : never
+	Token extends TransactionToken<infer F> ? F : never
 
-export function transaction<ƒ extends ƒn>(
-	options: TransactionOptions<ƒ>,
-): TransactionToken<ƒ> {
+export function transaction<F extends Func>(
+	options: TransactionOptions<F>,
+): TransactionToken<F> {
 	return createTransaction(options, IMPLICIT.STORE)
 }
 
-export function runTransaction<ƒ extends ƒn>(
-	token: TransactionToken<ƒ>,
+export function runTransaction<F extends Func>(
+	token: TransactionToken<F>,
 	id = arbitrary(),
-): (...parameters: Parameters<ƒ>) => ReturnType<ƒ> {
+): (...parameters: Parameters<F>) => ReturnType<F> {
 	return actUponStore(token, id, IMPLICIT.STORE)
 }

package/transceivers/set-rtx/dist/index.cjs

@@ -87,7 +87,7 @@ var SetRTX = class _SetRTX extends Set {
         this.emit(`tx:${this.transactionUpdates.join(`;`)}`);
       }
     } catch (thrown) {
-      console.error(`Failed to apply transaction to SetRTX: ${thrown}`);
+      console.error(`Failed to apply transaction to SetRTX:`, thrown);
       throw thrown;
     } finally {
       unsubscribe();
@@ -100,10 +100,9 @@ var SetRTX = class _SetRTX extends Set {
     return this.subject.subscribe(key, fn);
   }
   subscribe(key, fn) {
-    return this.subject.subscribe(
-      key,
-      (update) => fn(`${this.cacheUpdateNumber}=${update}`)
-    );
+    return this.subject.subscribe(key, (update) => {
+      fn(`${this.cacheUpdateNumber}=${update}`);
+    });
   }
   emit(update) {
     this.subject.next(update);
@@ -123,8 +122,8 @@ var SetRTX = class _SetRTX extends Set {
         this.delete(json.parseJson(value));
         break;
       case `tx`:
-        for (const update2 of value.split(`;`)) {
-          this.doStep(update2);
+        for (const subUpdate of value.split(`;`)) {
+          this.doStep(subUpdate);
         }
     }
   }
@@ -158,12 +157,12 @@ var SetRTX = class _SetRTX extends Set {
       let done = false;
       while (!done) {
         this.cacheIdx %= this.cacheLimit;
-        const update2 = this.cache[this.cacheIdx];
+        const u = this.cache[this.cacheIdx];
         this.cacheIdx--;
-        if (!update2) {
+        if (!u) {
           return `OUT_OF_RANGE`;
         }
-        this.undo(update2);
+        this.undo(u);
         done = this.cacheIdx === eventIdx - 1;
       }
       const innerUpdate = update.substring(breakpoint + 1);
@@ -187,8 +186,8 @@ var SetRTX = class _SetRTX extends Set {
         break;
       case `clear`: {
         const values = JSON.parse(value);
-        for (const value2 of values)
-          this.add(value2);
+        for (const v of values)
+          this.add(v);
         break;
       }
       case `tx`: {