atom.io 0.27.1 → 0.27.3

package/internal/src/mutable/create-mutable-atom-family.ts

@@ -1,7 +1,7 @@
 import type {
 	FamilyMetadata,
-	MutableAtomFamily,
 	MutableAtomFamilyOptions,
+	MutableAtomFamilyToken,
 	MutableAtomOptions,
 	MutableAtomToken,
 	StateCreation,
@@ -10,6 +10,8 @@ import type {
 import type { Json } from "atom.io/json"
 import { selectJsonFamily, stringifyJson } from "atom.io/json"
 
+import type { MutableAtomFamily } from ".."
+import { throwInCaseOfConflictingFamily } from "../families/throw-in-case-of-conflicting-family"
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
 import type { Store } from "../store"
@@ -24,45 +26,52 @@ export function createMutableAtomFamily<
 >(
 	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
-): MutableAtomFamily<T, J, K> {
+	internalRoles?: string[],
+): MutableAtomFamilyToken<T, J, K> {
+	const familyToken = {
+		key: options.key,
+		type: `mutable_atom_family`,
+	} as const satisfies MutableAtomFamilyToken<T, J, K>
+
+	throwInCaseOfConflictingFamily(familyToken, store)
+
 	const subject = new Subject<
 		StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>
 	>()
 
-	const atomFamily = Object.assign(
-		(key: K): MutableAtomToken<T, J> => {
-			const subKey = stringifyJson(key)
-			const family: FamilyMetadata = { key: options.key, subKey }
-			const fullKey = `${options.key}(${subKey})`
-			const target = newest(store)
-
-			const individualOptions: MutableAtomOptions<T, J> = {
-				key: fullKey,
-				default: () => options.default(key),
-				toJson: options.toJson,
-				fromJson: options.fromJson,
-				mutable: true,
-			}
-			if (options.effects) {
-				individualOptions.effects = options.effects(key)
-			}
-
-			const token = createMutableAtom(individualOptions, family, target)
+	const familyFunction = (key: K): MutableAtomToken<T, J> => {
+		const subKey = stringifyJson(key)
+		const family: FamilyMetadata = { key: options.key, subKey }
+		const fullKey = `${options.key}(${subKey})`
+		const target = newest(store)
 
-			subject.next({ type: `state_creation`, token })
-			return token
-		},
-		{
-			key: options.key,
-			type: `mutable_atom_family`,
-			subject,
-			install: (s: Store) => createMutableAtomFamily(options, s),
+		const individualOptions: MutableAtomOptions<T, J> = {
+			key: fullKey,
+			default: () => options.default(key),
 			toJson: options.toJson,
 			fromJson: options.fromJson,
-		} as const,
-	) satisfies MutableAtomFamily<T, J, K>
+			mutable: true,
+		}
+		if (options.effects) {
+			individualOptions.effects = options.effects(key)
+		}
+
+		const token = createMutableAtom(individualOptions, family, target)
+
+		subject.next({ type: `state_creation`, token })
+		return token
+	}
+
+	const atomFamily = Object.assign(familyFunction, familyToken, {
+		subject,
+		install: (s: Store) => createMutableAtomFamily(options, s),
+		toJson: options.toJson,
+		fromJson: options.fromJson,
+		internalRoles,
+	}) satisfies MutableAtomFamily<T, J, K>
+
 	store.families.set(options.key, atomFamily)
 	selectJsonFamily(atomFamily, options, store)
 	new FamilyTracker(atomFamily, store)
-	return atomFamily
+	return familyToken
 }

package/internal/src/mutable/get-json-family.ts

@@ -1,6 +1,7 @@
-import type { MutableAtomFamilyToken, WritableSelectorFamily } from "atom.io"
+import type { MutableAtomFamilyToken } from "atom.io"
 import type { Json } from "atom.io/json"
 
+import type { WritableSelectorFamily } from ".."
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import type { Transceiver } from "./transceiver"

package/internal/src/mutable/get-update-family.ts

@@ -0,0 +1,23 @@
+import type { MutableAtomFamilyToken } from "atom.io"
+import type { Json } from "atom.io/json"
+
+import type { AtomFamily } from ".."
+import { newest } from "../lineage"
+import type { Store } from "../store"
+import type { Signal, Transceiver } from "./transceiver"
+
+export const getUpdateFamily = <
+	Core extends Transceiver<Json.Serializable>,
+	SerializableCore extends Json.Serializable,
+	Key extends string,
+>(
+	mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>,
+	store: Store,
+): AtomFamily<Signal<Core>, Key> => {
+	const target = newest(store)
+	const key = `*${mutableAtomFamily.key}`
+	const updateFamily: AtomFamily<Signal<Core>, Key> = target.families.get(
+		key,
+	) as AtomFamily<Signal<Core>, Key>
+	return updateFamily
+}

package/internal/src/mutable/index.ts

@@ -2,6 +2,7 @@ export * from "./create-mutable-atom"
 export * from "./create-mutable-atom-family"
 export * from "./get-json-family"
 export * from "./get-json-token"
+export * from "./get-update-family"
 export * from "./get-update-token"
 export * from "./tracker"
 export * from "./tracker-family"

package/internal/src/mutable/tracker-family.ts

@@ -1,9 +1,9 @@
-import type { MutableAtomFamily, RegularAtomFamily } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
+import type { MutableAtomFamily, RegularAtomFamily } from ".."
 import { createRegularAtomFamily, seekInStore } from "../families"
-import type { Store } from "../store"
+import { type Store, withdraw } from "../store"
 import { Tracker } from "./tracker"
 import type { Transceiver } from "./transceiver"
 
@@ -25,7 +25,7 @@ export class FamilyTracker<
 		mutableAtoms: MutableAtomFamily<Core, any, FamilyMemberKey>,
 		store: Store,
 	) {
-		this.latestUpdateAtoms = createRegularAtomFamily<
+		const updateAtoms = createRegularAtomFamily<
 			typeof this.Update | null,
 			FamilyMemberKey
 		>(
@@ -34,7 +34,9 @@ export class FamilyTracker<
 				default: null,
 			},
 			store,
+			[`mutable`, `updates`],
 		)
+		this.latestUpdateAtoms = withdraw(updateAtoms, store)
 		this.mutableAtoms = mutableAtoms
 		this.mutableAtoms.subject.subscribe(
 			`store=${store.config.name}::tracker-atom-family`,

package/internal/src/not-found-error.ts

@@ -1,42 +1,9 @@
-import type {
-	MoleculeFamilyToken,
-	MoleculeToken,
-	ReadableFamilyToken,
-	ReadableToken,
-	TimelineToken,
-	TransactionToken,
-} from "atom.io"
 import { type Json, stringifyJson } from "atom.io/json"
 
+import type { AtomIOToken } from "./pretty-print"
+import { prettyPrintTokenType } from "./pretty-print"
 import type { Store } from "./store"
 
-const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
-
-type AtomIOToken =
-	| MoleculeFamilyToken<any>
-	| MoleculeToken<any>
-	| ReadableFamilyToken<any, any>
-	| ReadableToken<any>
-	| TimelineToken<any>
-	| TransactionToken<any>
-
-function prettyPrintTokenType(token: AtomIOToken) {
-	switch (token.type) {
-		case `atom_family`:
-			return `Atom Family`
-		case `molecule_family`:
-			return `Molecule Family`
-		case `readonly_selector`:
-			return `Readonly Selector`
-		case `readonly_selector_family`:
-			return `Readonly Selector Family`
-		case `selector_family`:
-			return `Selector Family`
-		default:
-			return capitalize(token.type)
-	}
-}
-
 export class NotFoundError extends Error {
 	public constructor(token: AtomIOToken, store: Store)
 	public constructor(

package/internal/src/pretty-print.ts

@@ -0,0 +1,37 @@
+import type {
+	MoleculeFamilyToken,
+	MoleculeToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	TimelineToken,
+	TransactionToken,
+} from "atom.io"
+
+const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
+
+export type AtomIOToken =
+	| MoleculeFamilyToken<any>
+	| MoleculeToken<any>
+	| ReadableFamilyToken<any, any>
+	| ReadableToken<any>
+	| TimelineToken<any>
+	| TransactionToken<any>
+
+export function prettyPrintTokenType(token: AtomIOToken): string {
+	switch (token.type) {
+		case `atom_family`:
+			return `Atom Family`
+		case `molecule_family`:
+			return `Molecule Family`
+		case `mutable_atom_family`:
+			return `Mutable Atom Family`
+		case `readonly_selector`:
+			return `Readonly Selector`
+		case `readonly_selector_family`:
+			return `Readonly Selector Family`
+		case `selector_family`:
+			return `Selector Family`
+		default:
+			return capitalize(token.type)
+	}
+}

package/internal/src/store/store.ts

@@ -3,13 +3,9 @@ import type {
 	Logger,
 	MoleculeFamily,
 	MoleculeToken,
-	MutableAtomFamily,
-	ReadonlySelectorFamily,
 	ReadonlySelectorToken,
-	RegularAtomFamily,
 	TimelineToken,
 	TransactionToken,
-	WritableSelectorFamily,
 	WritableSelectorToken,
 } from "atom.io"
 import { AtomIOLogger } from "atom.io"
@@ -20,10 +16,14 @@ import type {
 	Atom,
 	Func,
 	Molecule,
+	MutableAtomFamily,
 	ReadonlySelector,
+	ReadonlySelectorFamily,
+	RegularAtomFamily,
 	Tracker,
 	Transceiver,
 	WritableSelector,
+	WritableSelectorFamily,
 } from ".."
 import type { Lineage } from "../lineage"
 import { getJsonToken, getUpdateToken } from "../mutable"
@@ -160,6 +160,12 @@ export class Store implements Lineage {
 			}
 
 			for (const [, family] of store.families) {
+				if (
+					family.internalRoles?.includes(`mutable`) ||
+					family.internalRoles?.includes(`join`)
+				) {
+					continue
+				}
 				family.install(this)
 			}
 			const mutableHelpers = new Set<string>()

package/internal/src/store/withdraw.ts

@@ -1,32 +1,24 @@
 import type {
-	AtomFamily,
 	AtomFamilyToken,
 	AtomToken,
 	MoleculeConstructor,
 	MoleculeFamily,
 	MoleculeFamilyToken,
 	MoleculeToken,
-	MutableAtomFamily,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
-	ReadableFamily,
 	ReadableFamilyToken,
 	ReadableToken,
-	ReadonlySelectorFamily,
 	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
-	RegularAtomFamily,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
-	SelectorFamily,
 	SelectorFamilyToken,
 	SelectorToken,
 	TimelineManageable,
 	TimelineToken,
 	TransactionToken,
-	WritableFamily,
 	WritableFamilyToken,
-	WritableSelectorFamily,
 	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
@@ -36,15 +28,23 @@ import { stringifyJson } from "atom.io/json"
 
 import type {
 	Atom,
+	AtomFamily,
 	Func,
 	Molecule,
 	MutableAtom,
+	MutableAtomFamily,
+	ReadableFamily,
 	ReadableState,
 	ReadonlySelector,
+	ReadonlySelectorFamily,
 	RegularAtom,
+	RegularAtomFamily,
 	Selector,
+	SelectorFamily,
 	Transceiver,
+	WritableFamily,
 	WritableSelector,
+	WritableSelectorFamily,
 	WritableState,
 } from ".."
 import { NotFoundError } from ".."

package/introspection/dist/index.js

@@ -204,7 +204,7 @@ var attachTimelineFamily = (store = IMPLICIT.STORE) => {
   const findTimelineLogState = createSelectorFamily(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log`,
-      get: (key) => ({ get }) => get(findTimelineLogState__INTERNAL(key))
+      get: (key) => ({ get }) => get(findTimelineLogState__INTERNAL, key)
     },
     store
   );
@@ -271,7 +271,7 @@ var attachTransactionIndex = (store = IMPLICIT.STORE) => {
   return transactionTokenIndex;
 };
 var attachTransactionLogs = (store = IMPLICIT.STORE) => {
-  const findTransactionUpdateLog = createRegularAtomFamily(
+  const transactionUpdateLogAtoms = createRegularAtomFamily(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log (Internal)`,
       default: () => [],
@@ -291,7 +291,7 @@ var attachTransactionLogs = (store = IMPLICIT.STORE) => {
   const findTransactionUpdateLogState = createSelectorFamily(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log`,
-      get: (key) => ({ get }) => get(findTransactionUpdateLog(key))
+      get: (key) => ({ get }) => get(transactionUpdateLogAtoms, key)
     },
     store
   );

package/introspection/src/attach-timeline-family.ts

@@ -46,7 +46,7 @@ export const attachTimelineFamily = (
 			get:
 				(key) =>
 				({ get }) =>
-					get(findTimelineLogState__INTERNAL(key)),
+					get(findTimelineLogState__INTERNAL, key),
 		},
 		store,
 	)

package/introspection/src/attach-transaction-logs.ts

@@ -9,7 +9,7 @@ import {
 export const attachTransactionLogs = (
 	store: Store = IMPLICIT.STORE,
 ): ReadonlySelectorFamilyToken<TransactionUpdate<Func>[], string> => {
-	const findTransactionUpdateLog = createRegularAtomFamily<
+	const transactionUpdateLogAtoms = createRegularAtomFamily<
 		TransactionUpdate<Func>[],
 		string
 	>(
@@ -38,7 +38,7 @@ export const attachTransactionLogs = (
 			get:
 				(key) =>
 				({ get }) =>
-					get(findTransactionUpdateLog(key)),
+					get(transactionUpdateLogAtoms, key),
 		},
 		store,
 	)

package/json/dist/index.d.ts

@@ -38,8 +38,8 @@ declare function fromEntries<E extends Entries>(entries: E): FromEntries<E>;
 
 declare const selectJson: <T, J extends Serializable>(atom: AtomIO.AtomToken<T>, transform: JsonInterface<T, J>, store?: Store) => AtomIO.WritableSelectorToken<J>;
 
-declare function selectJsonFamily<T extends Transceiver<any>, J extends Serializable, K extends Canonical>(atomFamily: AtomIO.MutableAtomFamily<T, J, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamily<J, K>;
-declare function selectJsonFamily<T, J extends Serializable, K extends Canonical>(atomFamily: AtomIO.RegularAtomFamily<T, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamily<J, K>;
+declare function selectJsonFamily<T extends Transceiver<any>, J extends Serializable, K extends Canonical>(atomFamilyToken: AtomIO.MutableAtomFamilyToken<T, J, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamilyToken<J, K>;
+declare function selectJsonFamily<T, J extends Serializable, K extends Canonical>(atomFamilyToken: AtomIO.RegularAtomFamilyToken<T, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamilyToken<J, K>;
 
 type Canonical = primitive | ReadonlyArray<Canonical>;
 type JsonIO = (...params: Serializable[]) => Serializable | void;

package/json/dist/index.js

@@ -1,7 +1,9 @@
 import { stringifyJson, parseJson } from '../../dist/chunk-AK23DRMD.js';
 export { parseJson, stringifyJson } from '../../dist/chunk-AK23DRMD.js';
+import { createWritableSelectorFamily } from '../../dist/chunk-ETCFHO7J.js';
+import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { createStandaloneSelector, IMPLICIT, createSelectorFamily, growMoleculeInStore, initFamilyMemberInStore, seekInStore } from 'atom.io/internal';
+import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';
 
 // json/src/entries.ts
 function fromEntries(entries) {
@@ -19,52 +21,54 @@ var selectJson = (atom, transform, store = IMPLICIT.STORE) => {
     store
   );
 };
-function selectJsonFamily(family, transform, store = IMPLICIT.STORE) {
-  const jsonFamily = createSelectorFamily(
+function selectJsonFamily(atomFamilyToken, transform, store = IMPLICIT.STORE) {
+  const jsonFamily = createWritableSelectorFamily(
     {
-      key: `${family.key}:JSON`,
+      key: `${atomFamilyToken.key}:JSON`,
       get: (key) => ({ seek, get }) => {
-        const existingState = seek(family, key);
+        const existingState = seek(atomFamilyToken, key);
         if (existingState) {
           return transform.toJson(get(existingState));
         }
         const stringKey = stringifyJson(key);
         const molecule = store.molecules.get(stringKey);
         if (molecule) {
-          const atom = growMoleculeInStore(molecule, family, store);
+          const atom = growMoleculeInStore(molecule, atomFamilyToken, store);
           return transform.toJson(get(atom));
         }
         if (store.config.lifespan === `immortal`) {
           throw new Error(`No molecule found for key "${stringKey}"`);
         }
-        const newToken = initFamilyMemberInStore(family, key, store);
+        const newToken = initFamilyMemberInStore(atomFamilyToken, key, store);
         return transform.toJson(get(newToken));
       },
       set: (key) => ({ seek, set }, newValue) => {
-        const existingState = seek(family, key);
+        const existingState = seek(atomFamilyToken, key);
         if (existingState) {
           set(existingState, transform.fromJson(newValue));
         } else {
           const stringKey = stringifyJson(key);
           const molecule = store.molecules.get(stringKey);
           if (molecule) {
-            const atom = growMoleculeInStore(molecule, family, store);
+            const atom = growMoleculeInStore(molecule, atomFamilyToken, store);
             set(atom, transform.fromJson(newValue));
           } else {
             if (store.config.lifespan === `immortal`) {
               throw new Error(`No molecule found for key "${stringKey}"`);
             }
             set(
-              initFamilyMemberInStore(family, key, store),
+              initFamilyMemberInStore(atomFamilyToken, key, store),
               transform.fromJson(newValue)
             );
           }
         }
       }
     },
-    store
+    store,
+    [`mutable`, `json`]
   );
-  family.subject.subscribe(
+  const atomFamily = withdraw(atomFamilyToken, store);
+  atomFamily.subject.subscribe(
     `store=${store.config.name}::json-selector-family`,
     (event) => {
       if (event.token.family) {

package/json/src/select-json-family.ts

@@ -1,13 +1,14 @@
 import type * as AtomIO from "atom.io"
 import type { Store, Transceiver } from "atom.io/internal"
 import {
-	createSelectorFamily,
 	growMoleculeInStore,
 	IMPLICIT,
 	initFamilyMemberInStore,
 	seekInStore,
+	withdraw,
 } from "atom.io/internal"
 
+import { createWritableSelectorFamily } from "../../internal/src/families/create-writable-selector-family"
 import type { Canonical, Json, JsonInterface } from "."
 import { parseJson, stringifyJson } from "."
 
@@ -16,70 +17,70 @@ export function selectJsonFamily<
 	J extends Json.Serializable,
 	K extends Canonical,
 >(
-	atomFamily: AtomIO.MutableAtomFamily<T, J, K>,
+	atomFamilyToken: AtomIO.MutableAtomFamilyToken<T, J, K>,
 	transform: JsonInterface<T, J>,
 	store: Store,
-): AtomIO.WritableSelectorFamily<J, K>
+): AtomIO.WritableSelectorFamilyToken<J, K>
 export function selectJsonFamily<
 	T,
 	J extends Json.Serializable,
 	K extends Canonical,
 >(
-	atomFamily: AtomIO.RegularAtomFamily<T, K>,
+	atomFamilyToken: AtomIO.RegularAtomFamilyToken<T, K>,
 	transform: JsonInterface<T, J>,
 	store: Store,
-): AtomIO.WritableSelectorFamily<J, K>
+): AtomIO.WritableSelectorFamilyToken<J, K>
 export function selectJsonFamily<
 	T,
 	J extends Json.Serializable,
 	K extends Canonical,
 >(
-	family:
-		| AtomIO.MutableAtomFamily<T extends Transceiver<any> ? T : never, J, K>
-		| AtomIO.RegularAtomFamily<T, K>,
+	atomFamilyToken:
+		| AtomIO.MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, J, K>
+		| AtomIO.RegularAtomFamilyToken<T, K>,
 	transform: JsonInterface<T, J>,
 	store: Store = IMPLICIT.STORE,
-): AtomIO.WritableSelectorFamily<J, K> {
-	const jsonFamily = createSelectorFamily<J, K>(
+): AtomIO.WritableSelectorFamilyToken<J, K> {
+	const jsonFamily = createWritableSelectorFamily<J, K>(
 		{
-			key: `${family.key}:JSON`,
+			key: `${atomFamilyToken.key}:JSON`,
 			get:
 				(key) =>
 				({ seek, get }) => {
-					const existingState = seek(family, key)
+					const existingState = seek(atomFamilyToken, key)
 					if (existingState) {
 						return transform.toJson(get(existingState))
 					}
 					const stringKey = stringifyJson(key)
 					const molecule = store.molecules.get(stringKey)
 					if (molecule) {
-						const atom = growMoleculeInStore(molecule, family, store)
+						const atom = growMoleculeInStore(molecule, atomFamilyToken, store)
 						return transform.toJson(get(atom))
 					}
 					if (store.config.lifespan === `immortal`) {
 						throw new Error(`No molecule found for key "${stringKey}"`)
 					}
-					const newToken = initFamilyMemberInStore(family, key, store)
+					const newToken = initFamilyMemberInStore(atomFamilyToken, key, store)
 					return transform.toJson(get(newToken))
 				},
 			set:
 				(key) =>
 				({ seek, set }, newValue) => {
-					const existingState = seek(family, key)
+					const existingState = seek(atomFamilyToken, key)
 					if (existingState) {
 						set(existingState, transform.fromJson(newValue))
 					} else {
 						const stringKey = stringifyJson(key)
 						const molecule = store.molecules.get(stringKey)
 						if (molecule) {
-							const atom = growMoleculeInStore(molecule, family, store)
+							const atom = growMoleculeInStore(molecule, atomFamilyToken, store)
 							set(atom, transform.fromJson(newValue))
 						} else {
 							if (store.config.lifespan === `immortal`) {
 								throw new Error(`No molecule found for key "${stringKey}"`)
 							}
 							set(
-								initFamilyMemberInStore(family, key, store),
+								initFamilyMemberInStore(atomFamilyToken, key, store),
 								transform.fromJson(newValue),
 							)
 						}
@@ -87,8 +88,10 @@ export function selectJsonFamily<
 				},
 		},
 		store,
+		[`mutable`, `json`],
 	)
-	family.subject.subscribe(
+	const atomFamily = withdraw(atomFamilyToken, store)
+	atomFamily.subject.subscribe(
 		`store=${store.config.name}::json-selector-family`,
 		(event) => {
 			if (event.token.family) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.27.1",
+  "version": "0.27.3",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -59,8 +59,8 @@
     "@types/npmlog": "7.0.0",
     "@types/react": "18.3.3",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.0.1",
-    "@typescript-eslint/rule-tester": "8.0.1",
+    "@typescript-eslint/parser": "8.1.0",
+    "@typescript-eslint/rule-tester": "8.1.0",
     "@vitest/coverage-v8": "2.0.5",
     "@vitest/ui": "2.0.5",
     "concurrently": "8.2.2",
@@ -72,7 +72,7 @@
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
-    "preact": "10.23.1",
+    "preact": "10.23.2",
     "react": "18.3.1",
     "react-dom": "18.3.1",
     "react-router-dom": "6.26.0",

package/realtime-server/dist/index.d.ts

@@ -112,7 +112,7 @@ declare function redactTransactionUpdateContent(visibleStateKeys: string[], upda
 declare const actionOcclusionAtoms: AtomIO.RegularAtomFamilyToken<{
     occlude: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[];
 }, string>;
-declare const userUnacknowledgedQueues: AtomIO.RegularAtomFamilyToken<Pick<TransactionUpdate<any>, "key" | "id" | "epoch" | "updates" | "output">[], string>;
+declare const userUnacknowledgedQueues: AtomIO.RegularAtomFamilyToken<Pick<TransactionUpdate<any>, "key" | "epoch" | "id" | "updates" | "output">[], string>;
 
 declare const socketAtoms: AtomIO.RegularAtomFamilyToken<Socket | null, string>;
 declare const socketIndex: AtomIO.MutableAtomToken<SetRTX<string>, SetRTXJson<string>>;