atom.io 0.41.1 → 0.42.1

package/src/main/join.ts

@@ -13,39 +13,36 @@ import {
 	getInternalRelationsFromStore,
 	IMPLICIT,
 } from "atom.io/internal"
-import type { Json } from "atom.io/json"
-import type { SetRTX } from "atom.io/transceivers/set-rtx"
+import type { UList } from "atom.io/transceivers/u-list"
 
 // biome-ignore format: intersection
 export type JoinOptions<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B extends string,
 	Cardinality extends `1:1` | `1:n` | `n:n`,
-	Content extends Json.Object | null,
 > =
 	Flat<
-		& JunctionSchemaBase<ASide, BSide>
+		& JunctionSchemaBase<AName, BName>
 		& {
 			/** Unique identifier of the join */
 			readonly key: string
 			/** How many relations are allowed in each direction? */
 			readonly cardinality: Cardinality
 			/** Type guard for the type of the left side */
-			readonly isAType: Refinement<string, AType>
+			readonly isAType: Refinement<string, A>
 			/** Type guard for the type of the right side */
-			readonly isBType: Refinement<string, BType>
+			readonly isBType: Refinement<string, B>
 		}
-	> & Partial<JunctionEntriesBase<AType, BType, Content>>
+	> & Partial<JunctionEntriesBase<A, B, null>>
 
 export type JoinToken<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B extends string,
 	Cardinality extends `1:1` | `1:n` | `n:n`,
-	Content extends Json.Object | null = null,
 > = {
 	/** Unique identifier of the join */
 	key: string
@@ -54,15 +51,13 @@ export type JoinToken<
 	/** How many relations are allowed in each direction? */
 	cardinality: Cardinality
 	/** Name of the join's left side */
-	a: ASide
+	a: AName
 	/** Name of the join's right side */
-	b: BSide
+	b: BName
 	/** Never present. This is a marker that preserves the type of the left side's keys */
-	__aType?: AType
+	__aType?: A
 	/** Never present. This is a marker that preserves the type of the right side's keys */
-	__bType?: BType
-	/** Never present. This is a marker that preserves the type of the data present for each relation */
-	__content?: Content
+	__bType?: B
 }
 
 /**
@@ -73,136 +68,61 @@ export type JoinToken<
  * Under the hood, joins coordinate changes of multiple atoms to support that the desired relationships stay consistent.
  *
  * @param options - {@link JoinOptions}
- * @param defaultContent - (undefined)
  * @returns
  * A reference to the join created: a {@link JoinToken}
- * @overload No Content
  */
 export function join<
-	const ASide extends string,
-	const AType extends string,
-	const BSide extends string,
-	const BType extends string,
+	const AName extends string,
+	const A extends string,
+	const BName extends string,
+	const B extends string,
 	const Cardinality extends `1:1` | `1:n` | `n:n`,
 >(
-	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, null>,
-	defaultContent?: undefined,
-): JoinToken<ASide, AType, BSide, BType, Cardinality, null>
-/**
- * Create a join, an interface for managing relations between two sets of keys.
- *
- * Use joins when it is important to view relationships from either side.
- *
- * Under the hood, joins coordinate changes of multiple atoms to support that the desired relationships stay consistent.
- *
- * @param options - {@link JoinOptions}
- * @param defaultContent - The default value for the content of each relation
- * @returns
- * A reference to the join created: a {@link JoinToken}
- * @overload With 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`,
-	const Content extends Json.Object,
->(
-	options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>,
-	defaultContent: Content,
-): 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,
-): JoinToken<ASide, AType, BSide, BType, Cardinality, Content> {
-	return createJoin(IMPLICIT.STORE, options, defaultContent)
+	options: JoinOptions<AName, A, BName, B, Cardinality>,
+): JoinToken<AName, A, BName, B, Cardinality> {
+	return createJoin(IMPLICIT.STORE, options)
 }
 
 export type JoinStates<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B 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>}`]: ReadonlyPureSelectorToken<
-						[AType, Content] | null,
-						BType
-					>
-				} & {
-					readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
-						[BType, Content] | null,
-						AType
-					>
-				}
-			: {}) & {
-			readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
-				AType | null,
-				BType
+	? {
+			readonly [N in AName as `${N}KeyOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken<
+				A | null,
+				B
 			>
 		} & {
-			readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
-				BType | null,
-				AType
+			readonly [N in BName as `${N}KeyOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken<
+				B | null,
+				A
 			>
 		}
 	: Cardinality extends `1:n`
-		? (Content extends Json.Object
-				? {
-						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
-							[AType, Content] | null,
-							BType
-						>
-					} & {
-						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
-							[BType, Content][],
-							AType
-						>
-					}
-				: {}) & {
-				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
-					AType | null,
-					BType
+		? {
+				readonly [N in AName as `${N}KeyOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken<
+					A | null,
+					B
 				>
 			} & {
-				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
-					BType[],
-					AType
+				readonly [N in BName as `${N}KeysOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken<
+					B[],
+					A
 				>
 			}
 		: Cardinality extends `n:n`
-			? (Content extends Json.Object
-					? {
-							readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
-								[AType, Content][],
-								BType
-							>
-						} & {
-							readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
-								[BType, Content][],
-								AType
-							>
-						}
-					: {}) & {
-					readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlyPureSelectorToken<
-						AType[],
-						BType
+			? {
+					readonly [N in AName as `${N}KeysOf${Capitalize<BName>}`]: ReadonlyPureSelectorToken<
+						A[],
+						B
 					>
 				} & {
-					readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorToken<
-						BType[],
-						AType
+					readonly [N in BName as `${N}KeysOf${Capitalize<AName>}`]: ReadonlyPureSelectorToken<
+						B[],
+						A
 					>
 				}
 			: never
@@ -216,16 +136,15 @@ export type JoinStates<
  * @overload Default
  */
 export function findRelations<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B 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> {
+	token: JoinToken<AName, A, BName, B, Cardinality>,
+	key: A | B,
+): JoinStates<AName, A, BName, B, Cardinality> {
 	return findRelationsInStore(token, key, IMPLICIT.STORE)
 }
 
@@ -235,15 +154,14 @@ export function findRelations<
  * @param change - A function that takes a {@link Junction} interface to edit the relations
  */
 export function editRelations<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B 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,
+	token: JoinToken<AName, A, BName, B, Cardinality>,
+	change: (relations: Junction<AName, A, BName, B>) => void,
 ): void {
 	editRelationsInStore(token, change, IMPLICIT.STORE)
 }
@@ -254,14 +172,13 @@ export function editRelations<
  * A {@link MutableAtomFamilyToken} to access the internal relations
  */
 export function getInternalRelations<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B 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>, string> {
+	token: JoinToken<AName, A, BName, B, Cardinality>,
+): MutableAtomFamilyToken<UList<A> | UList<B>, string> {
 	return getInternalRelationsFromStore(token, IMPLICIT.STORE)
 }

package/src/main/realm.ts

@@ -14,16 +14,20 @@ import type { Canonical } from "atom.io/json"
 
 import type { TransactionToken } from "./tokens"
 
-export const $claim: unique symbol = Symbol.for(`claim`)
-export type Claim<K extends Canonical> = K & { [$claim]?: true }
+export const $validatedKey: unique symbol = Symbol.for(`claim`)
+export type ValidKey<K extends Canonical> = K & { [$validatedKey]?: true }
+
+export function simpleCompound(a: string, b: string): string {
+	return [a, b].sort().join(`\u001F`)
+}
 
 export class Realm<H extends Hierarchy> {
 	public store: RootStore
-	public deallocateTX: TransactionToken<(claim: Claim<Vassal<H>>) => void>
+	public deallocateTX: TransactionToken<(claim: ValidKey<Vassal<H>>) => void>
 	public claimTX: TransactionToken<
 		<V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(
 			newProvenance: A,
-			claim: Claim<V>,
+			claim: ValidKey<V>,
 			exclusive?: `exclusive`,
 		) => void
 	>
@@ -42,13 +46,13 @@ export class Realm<H extends Hierarchy> {
 	 * @param key - A unique identifier for the new subject
 	 * @param attachmentStyle - The attachment style of new subject to its owner(s). `any` means that if any owners remain, the subject will be retained. `all` means that the subject be retained only if all owners remain .
 	 * @returns
-	 * The subject's key, given status as a true {@link Claim}
+	 * The subject's key, given status as a true {@link ValidKey}
 	 */
 	public allocate<V extends Vassal<H>, A extends Above<V, H>>(
 		provenance: A,
 		key: V,
 		attachmentStyle?: `all` | `any`,
-	): Claim<V> {
+	): ValidKey<V> {
 		return allocateIntoStore<H, V, A>(
 			this.store,
 			provenance,
@@ -62,7 +66,7 @@ export class Realm<H extends Hierarchy> {
 	 * @param reagentA - the left reagent of the compound
 	 * @param reagentB - the right reagent of the compound
 	 * @returns
-	 * The compound's key, given status as a true {@link Claim}
+	 * The compound's key, given status as a {@link ValidKey}
 	 */
 	public fuse<
 		C extends CompoundFrom<H>,
@@ -73,14 +77,14 @@ export class Realm<H extends Hierarchy> {
 		type: T,
 		reagentA: SingularTypedKey<A>,
 		reagentB: SingularTypedKey<B>,
-	): Claim<CompoundTypedKey<T, A, B>> {
+	): ValidKey<CompoundTypedKey<T, A, B>> {
 		return fuseWithinStore<H, C, T, A, B>(this.store, type, reagentA, reagentB)
 	}
 	/**
 	 * Remove a subject from the realm
 	 * @param claim - The subject to be deallocated
 	 */
-	public deallocate<V extends Vassal<H>>(claim: Claim<V>): void {
+	public deallocate<V extends Vassal<H>>(claim: ValidKey<V>): void {
 		actUponStore(this.store, this.deallocateTX, arbitrary())(claim)
 	}
 	/**
@@ -89,12 +93,12 @@ export class Realm<H extends Hierarchy> {
 	 * @param claim - The subject to be claimed
 	 * @param exclusive - Whether the subjects previous owners should be detached from it
 	 * @returns
-	 * The subject's key, given status as a true {@link Claim}
+	 * The subject's key, given status as a true {@link ValidKey}
 	 */
 	public claim<
 		V extends Exclude<Vassal<H>, CompoundTypedKey>,
 		A extends Above<V, H>,
-	>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): void {
+	>(newProvenance: A, claim: ValidKey<V>, exclusive?: `exclusive`): void {
 		actUponStore(this.store, this.claimTX, arbitrary())(
 			newProvenance,
 			claim,
@@ -157,22 +161,59 @@ export class Anarchy {
 	): void {
 		claimWithinStore<any, any, any>(this.store, newProvenance, key, exclusive)
 	}
+	/**
+	 * Fuse two reagents into a compound
+	 * @param type - the name of the compound that is being fused
+	 * @param reagentA - the left reagent of the compound
+	 * @param reagentB - the right reagent of the compound
+	 * @returns
+	 * The compound's key, given status as a {@link ValidKey}
+	 */
+	public fuse<T extends string, A extends string, B extends string>(
+		type: T,
+		reagentA: SingularTypedKey<A>,
+		reagentB: SingularTypedKey<B>,
+	): ValidKey<CompoundTypedKey<T, A, B>> {
+		return fuseWithinStore<any, any, T, A, B>(
+			this.store,
+			type,
+			reagentA,
+			reagentB,
+		)
+	}
+}
+
+export function decomposeCompound(
+	compound: Canonical,
+): [type: string, a: string, b: string] | null {
+	if ((typeof compound === `string`) === false) {
+		return null
+	}
+	const [typeTag, components] = compound.split(`==`)
+	if (!components) {
+		return null
+	}
+	const type = typeTag.slice(4)
+	const [a, b] = components.split(`++`)
+	if (type && a && b) {
+		return [type, a, b]
+	}
+	return null
 }
 
-export const T$ = `T$`
-export type T$ = typeof T$
+export type T$ = `T$`
 export type TypeTag<T extends string> = `${T$}--${T}`
 export type SingularTypedKey<T extends string = string> = `${T}::${string}`
 export type CompoundTypedKey<
+	T extends string = string,
 	A extends string = string,
 	B extends string = string,
-	C extends string = string,
-> = `${TypeTag<A>}==${SingularTypedKey<B>}++${SingularTypedKey<C>}`
+> = `${TypeTag<T>}==${SingularTypedKey<A>}++${SingularTypedKey<B>}`
 export type TypedKey<
+	T extends string = string,
 	A extends string = string,
 	B extends string = string,
-	C extends string = string,
-> = CompoundTypedKey<A, B, C> | SingularTypedKey<A>
+> = CompoundTypedKey<T, A, B> | SingularTypedKey<T>
 type Scope = SingularTypedKey[]
 type MutualFealty = {
 	above: Scope

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

@@ -4,7 +4,6 @@ import type {
 	ReadonlyPureSelectorFamilyToken,
 } from "atom.io"
 import { getInternalRelations, join, mutableAtom, selectorFamily } from "atom.io"
-import type { SetRTX } from "atom.io/transceivers/set-rtx"
 import { UList } from "atom.io/transceivers/u-list"
 
 export const usersInThisRoomIndex: MutableAtomToken<UList<string>> = mutableAtom<
@@ -27,28 +26,19 @@ export type UserInRoomMeta = {
 export const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta = {
 	enteredAtEpoch: 0,
 }
-export const usersInRooms: JoinToken<
-	`room`,
-	string,
-	`user`,
-	string,
-	`1:n`,
-	UserInRoomMeta
-> = join(
-	{
+export const usersInRooms: JoinToken<`room`, string, `user`, string, `1:n`> =
+	join({
 		key: `usersInRooms`,
 		between: [`room`, `user`],
 		cardinality: `1:n`,
 		isAType: (input): input is string => typeof input === `string`,
 		isBType: (input): input is string => typeof input === `string`,
-	},
-	DEFAULT_USER_IN_ROOM_META,
-)
+	})
 
 export const usersInMyRoomView: ReadonlyPureSelectorFamilyToken<
-	MutableAtomToken<SetRTX<string>>[],
+	MutableAtomToken<UList<string>>[],
 	string
-> = selectorFamily<MutableAtomToken<SetRTX<string>>[], string>({
+> = selectorFamily<MutableAtomToken<UList<string>>[], string>({
 	key: `usersInMyRoomView`,
 	get:
 		(myUsername) =>

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

@@ -43,7 +43,7 @@ export const joinRoomTX: TransactionToken<
 		editRelationsInStore(
 			usersInRooms,
 			(relations) => {
-				relations.set({ room: roomId, user: userId }, meta)
+				relations.set({ room: roomId, user: userId })
 			},
 			tools.env().store,
 		)

package/src/struct/index.ts

@@ -0,0 +1 @@
+export * from "./micro"

package/src/{internal → struct}/micro.ts

@@ -1,6 +1,6 @@
 import type { primitive } from "atom.io/json"
 
-import type { Flat } from "./utility-types"
+import type { Flat } from "../internal/utility-types"
 
 export type IndexOf<
 	T extends readonly unknown[],

package/src/transceivers/o-list/o-list.ts

@@ -1,11 +1,8 @@
-import type {
-	Enumeration,
-	Fn,
-	Transceiver,
-	TransceiverMode,
-} from "atom.io/internal"
-import { enumeration, packValue, Subject, unpackValue } from "atom.io/internal"
+import type { Fn, Transceiver, TransceiverMode } from "atom.io/internal"
+import { Subject } from "atom.io/internal"
 import type { primitive } from "atom.io/json"
+import type { Enumeration } from "atom.io/struct"
+import { enumeration, packValue, unpackValue } from "atom.io/struct"
 
 export type ArrayMutations = Exclude<keyof Array<any>, keyof ReadonlyArray<any>>
 export type ArrayUpdate<P extends primitive> =
@@ -99,16 +96,23 @@ export type ArrayMutationHandler = {
 	[K in Exclude<OListUpdateType, `extend` | `set` | `truncate`>]: Fn
 }
 
+export type OListView<P extends primitive> = ReadonlyArray<P> & {
+	subscribe: (
+		key: string,
+		fn: (update: PackedArrayUpdate<P>) => void,
+	) => () => void
+}
+
 export class OList<P extends primitive>
 	extends Array<P>
 	implements
-		Transceiver<ReadonlyArray<P>, PackedArrayUpdate<P>, ReadonlyArray<P>>,
+		Transceiver<OListView<P>, PackedArrayUpdate<P>, ReadonlyArray<P>>,
 		ArrayMutationHandler
 {
 	public mode: TransceiverMode = `record`
 	public readonly subject: Subject<PackedArrayUpdate<P>> = new Subject()
 
-	public readonly READONLY_VIEW: ReadonlyArray<P> = this
+	public readonly READONLY_VIEW: OListView<P> = this
 
 	public constructor(arrayLength?: number)
 	public constructor(...items: P[])

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

@@ -12,6 +12,10 @@ export interface SetRTXView<P extends primitive> extends ReadonlySet<P> {
 	readonly cacheLimit: number
 	readonly cacheIdx: number
 	readonly cacheUpdateNumber: number
+	readonly subscribe: (
+		key: string,
+		fn: (update: NumberedSetUpdateString) => void,
+	) => () => void
 }
 
 export interface SetRTXJson<P extends primitive> extends Json.Object {

package/src/transceivers/u-list/index.ts

@@ -1 +1,2 @@
 export * from "./u-list"
+export * from "./u-list-disposed-key-cleanup-effect"

package/src/transceivers/u-list/u-list-disposed-key-cleanup-effect.ts

@@ -0,0 +1,47 @@
+import type { AtomEffect } from "atom.io"
+import { getUpdateToken, subscribeInStore } from "atom.io/internal"
+import { type primitive, stringifyJson } from "atom.io/json"
+
+import { UList } from "./u-list"
+
+export const uListDisposedKeyCleanupEffect: AtomEffect<UList<primitive>> = ({
+	token,
+	setSelf,
+	store,
+}) => {
+	const disposalSubscriptions = new Map<primitive, () => void>()
+	const updateToken = getUpdateToken(token)
+	subscribeInStore(
+		store,
+		updateToken,
+		function setAutoDeletionTriggers({ newValue }) {
+			const unpacked = UList.unpackUpdate(newValue)
+			switch (unpacked.type) {
+				case `add`:
+					{
+						const molecule = store.molecules.get(stringifyJson(unpacked.value))
+						if (molecule) {
+							disposalSubscriptions.set(
+								unpacked.value,
+								molecule.subject.subscribe(token.key, () => {
+									setSelf((self) => {
+										self.delete(unpacked.value)
+										return self
+									})
+								}),
+							)
+						}
+					}
+					break
+				case `delete`:
+					disposalSubscriptions.get(unpacked.value)?.()
+					disposalSubscriptions.delete(unpacked.value)
+					break
+				case `clear`:
+					for (const unsub of disposalSubscriptions.values()) unsub()
+					disposalSubscriptions.clear()
+			}
+		},
+		`set-auto-deletion-triggers`,
+	)
+}

package/src/transceivers/u-list/u-list.ts

@@ -1,11 +1,8 @@
-import type {
-	Enumeration,
-	Fn,
-	Transceiver,
-	TransceiverMode,
-} from "atom.io/internal"
-import { enumeration, packValue, Subject, unpackValue } from "atom.io/internal"
+import type { Fn, Transceiver, TransceiverMode } from "atom.io/internal"
+import { Subject } from "atom.io/internal"
 import type { primitive } from "atom.io/json"
+import type { Enumeration } from "atom.io/struct"
+import { enumeration, packValue, unpackValue } from "atom.io/struct"
 
 export type SetMutations = Exclude<
 	keyof Set<any>,
@@ -34,10 +31,17 @@ export const SET_UPDATE_ENUM: Enumeration<[`add`, `delete`, `clear`]> =
 
 export type SetMutationHandler = { [K in UListUpdateType]: Fn }
 
+export type UListView<P extends primitive> = ReadonlySet<P> & {
+	subscribe: (
+		key: string,
+		fn: (update: PackedSetUpdate<P>) => void,
+	) => () => void
+}
+
 export class UList<P extends primitive>
 	extends Set<P>
 	implements
-		Transceiver<ReadonlySet<P>, PackedSetUpdate<P>, ReadonlyArray<P>>,
+		Transceiver<UListView<P>, PackedSetUpdate<P>, ReadonlyArray<P>>,
 		SetMutationHandler
 {
 	public mode: TransceiverMode = `record`
@@ -49,7 +53,7 @@ export class UList<P extends primitive>
 		}
 	}
 
-	public readonly READONLY_VIEW: ReadonlySet<P> = this
+	public readonly READONLY_VIEW: UListView<P> = this
 
 	public toJSON(): ReadonlyArray<P> {
 		return [...this]