atom.io 0.30.0 → 0.30.2

package/internal/src/junction.ts

@@ -1,23 +1,35 @@
 import type { Refinement } from "atom.io/introspection"
 import type { Json } from "atom.io/json"
 
-export interface JunctionEntries<Content extends Json.Object | null>
-	extends Json.Object {
-	readonly relations: [string, string[]][]
+export type JunctionEntriesBase<
+	AType extends string,
+	BType extends string,
+	Content extends Json.Object | null,
+> = {
+	readonly relations: ([AType, BType[]] | [BType, AType[]])[]
 	readonly contents: [string, Content][]
 }
-export interface JunctionSchema<ASide extends string, BSide extends string>
-	extends Json.Object {
+export interface JunctionEntries<
+	AType extends string,
+	BType extends string,
+	Content extends Json.Object | null,
+> extends Json.Object,
+		JunctionEntriesBase<AType, BType, Content> {}
+
+export type JunctionSchemaBase<ASide extends string, BSide extends string> = {
 	readonly between: [a: ASide, b: BSide]
 	readonly cardinality: `1:1` | `1:n` | `n:n`
 }
+export interface JunctionSchema<ASide extends string, BSide extends string>
+	extends Json.Object,
+		JunctionSchemaBase<ASide, BSide> {}
 
 export type BaseExternalStoreConfiguration = {
 	addRelation: (a: string, b: string) => void
 	deleteRelation: (a: string, b: string) => void
 	replaceRelationsSafely: (a: string, bs: string[]) => void
 	replaceRelationsUnsafely: (a: string, bs: string[]) => void
-	getRelatedKeys: (key: string) => Set<string> | undefined
+	getRelatedKeys(key: string): Set<string> | undefined
 	has: (a: string, b?: string) => boolean
 }
 
@@ -39,41 +51,58 @@ export type ExternalStoreConfiguration<Content extends Json.Object | null> =
 		: BaseExternalStoreConfiguration &
 				Empty<ExternalStoreWithContentConfiguration<Json.Object>>
 
-export type JunctionAdvancedConfiguration<Content extends Json.Object | null> = {
+export type JunctionAdvancedConfiguration<
+	AType extends string,
+	BType extends string,
+	Content extends Json.Object | null,
+> = {
 	warn?: (...args: any[]) => void
 	externalStore?: ExternalStoreConfiguration<Content>
+	isAType?: Refinement<string, AType>
+	isBType?: Refinement<string, BType>
 	isContent?: Refinement<unknown, Content>
-	makeContentKey?: (a: string, b: string) => string
+	makeContentKey?: (a: AType, b: BType) => string
 }
 
 export type JunctionJSON<
 	ASide extends string,
+	AType extends string,
 	BSide extends string,
+	BType extends string,
 	Content extends Json.Object | null,
-> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>
+> = JunctionEntries<AType, BType, Content> & JunctionSchema<ASide, BSide>
 
 export class Junction<
 	const ASide extends string,
+	const AType extends string,
 	const BSide extends string,
+	const BType extends string,
 	const Content extends Json.Object | null = null,
 > {
 	public readonly a: ASide
 	public readonly b: BSide
 	public readonly cardinality: `1:1` | `1:n` | `n:n`
-	public readonly relations = new Map<string, Set<string>>()
+	public readonly relations = new Map<AType | BType, Set<AType> | Set<BType>>()
 	public readonly contents = new Map<string, Content>()
 
+	public isAType?: Refinement<string, AType> | null
+	public isBType?: Refinement<string, BType> | null
 	public isContent: Refinement<unknown, Content> | null
-	public makeContentKey = (a: string, b: string): string => `${a}:${b}`
+	public makeContentKey = (a: AType, b: BType): string => `${a}:${b}`
 
 	public warn?: (...args: any[]) => void
 
-	public getRelatedKeys(key: string): Set<string> | undefined {
+	public getRelatedKeys(key: AType): Set<BType> | undefined
+	public getRelatedKeys(key: BType): Set<AType> | undefined
+	public getRelatedKeys(key: AType | BType): Set<AType> | Set<BType> | undefined
+	public getRelatedKeys(
+		key: AType | BType,
+	): Set<AType> | Set<BType> | undefined {
 		return this.relations.get(key)
 	}
-	protected addRelation(a: string, b: string): void {
-		let aRelations = this.relations.get(a)
-		let bRelations = this.relations.get(b)
+	protected addRelation(a: AType, b: BType): void {
+		let aRelations = this.relations.get(a) as Set<BType> | undefined
+		let bRelations = this.relations.get(b) as Set<AType> | undefined
 		if (aRelations) {
 			aRelations.add(b)
 		} else {
@@ -87,14 +116,14 @@ export class Junction<
 			this.relations.set(b, bRelations)
 		}
 	}
-	protected deleteRelation(a: string, b: string): void {
-		const aRelations = this.relations.get(a)
+	protected deleteRelation(a: AType, b: BType): void {
+		const aRelations = this.relations.get(a) as Set<BType> | undefined
 		if (aRelations) {
 			aRelations.delete(b)
 			if (aRelations.size === 0) {
 				this.relations.delete(a)
 			}
-			const bRelations = this.relations.get(b)
+			const bRelations = this.relations.get(b) as Set<AType> | undefined
 			if (bRelations) {
 				bRelations.delete(a)
 				if (bRelations.size === 0) {
@@ -104,36 +133,50 @@ export class Junction<
 		}
 	}
 
-	protected replaceRelationsUnsafely(a: string, bs: string[]): void {
-		this.relations.set(a, new Set(bs))
-		for (const b of bs) {
-			const bRelations = new Set([a])
-			this.relations.set(b, bRelations)
+	protected replaceRelationsUnsafely(a: AType, bs: BType[]): void
+	protected replaceRelationsUnsafely(b: BType, as: AType[]): void
+	protected replaceRelationsUnsafely(
+		x: AType | BType,
+		ys: AType[] | BType[],
+	): void {
+		this.relations.set(x as AType, new Set(ys as BType[]))
+		for (const y of ys) {
+			const yRelations = new Set<AType>().add(x as AType)
+			this.relations.set(y, yRelations)
 		}
 	}
-	protected replaceRelationsSafely(a: string, bs: string[]): void {
-		const aRelationsPrev = this.relations.get(a)
-		if (aRelationsPrev) {
-			for (const b of aRelationsPrev) {
-				const bRelations = this.relations.get(b)
-				if (bRelations) {
-					if (bRelations.size === 1) {
-						this.relations.delete(b)
+	protected replaceRelationsSafely(a: AType, bs: BType[]): void
+	protected replaceRelationsSafely(b: BType, as: AType[]): void
+	protected replaceRelationsSafely<
+		XType extends AType | BType,
+		YType extends XType extends AType ? BType : AType,
+	>(x: XType, ys: YType[]): void {
+		const xRelationsPrev = this.relations.get(x)
+		let a: AType | undefined = this.isAType?.(x) ? x : undefined
+		let b: BType | undefined = a === undefined ? (x as BType) : undefined
+		if (xRelationsPrev) {
+			for (const y of xRelationsPrev) {
+				a ??= y as AType
+				b ??= y as BType
+				const yRelations = this.relations.get(y) as Set<XType> | undefined
+				if (yRelations) {
+					if (yRelations.size === 1) {
+						this.relations.delete(y)
 					} else {
-						bRelations.delete(a)
+						yRelations.delete(x)
 					}
 					this.contents.delete(this.makeContentKey(a, b))
 				}
 			}
 		}
-		this.relations.set(a, new Set(bs))
-		for (const b of bs) {
-			let bRelations = this.relations.get(b)
-			if (bRelations) {
-				bRelations.add(a)
+		this.relations.set(x, new Set(ys) as any)
+		for (const y of ys) {
+			let yRelations = this.relations.get(y) as Set<XType> | undefined
+			if (yRelations) {
+				yRelations.add(x)
 			} else {
-				bRelations = new Set([a])
-				this.relations.set(b, bRelations)
+				yRelations = new Set<XType>().add(x)
+				this.relations.set(y, yRelations as any)
 			}
 		}
 	}
@@ -149,17 +192,22 @@ export class Junction<
 	}
 
 	public constructor(
-		data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>,
-		config?: JunctionAdvancedConfiguration<Content>,
+		data: JunctionSchema<ASide, BSide> &
+			Partial<JunctionEntries<NoInfer<AType>, NoInfer<BType>, Content>>,
+		config?: JunctionAdvancedConfiguration<AType, BType, Content>,
 	) {
 		this.a = data.between[0]
 		this.b = data.between[1]
 
 		this.cardinality = data.cardinality
 		if (!config?.externalStore) {
-			this.relations = new Map(data.relations?.map(([a, b]) => [a, new Set(b)]))
+			this.relations = new Map(
+				data.relations?.map(([x, ys]) => [x, new Set(ys as AType[])]),
+			)
 			this.contents = new Map(data.contents)
 		}
+		this.isAType = config?.isAType ?? null
+		this.isBType = config?.isBType ?? null
 		this.isContent = config?.isContent ?? null
 		if (config?.makeContentKey) {
 			this.makeContentKey = config.makeContentKey
@@ -179,7 +227,10 @@ export class Junction<
 			this.replaceRelationsUnsafely = (a, bs) => {
 				externalStore.replaceRelationsUnsafely(a, bs)
 			}
-			this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key)
+			this.getRelatedKeys = ((key) =>
+				externalStore.getRelatedKeys(
+					key,
+				)) as typeof Junction.prototype.getRelatedKeys
 			if (externalStore.getContent) {
 				this.getContentInternal = (contentKey) => {
 					return externalStore.getContent(contentKey) as any
@@ -192,7 +243,13 @@ export class Junction<
 				}
 			}
 			for (const [x, ys] of data.relations ?? []) {
-				for (const y of ys) this.addRelation(x, y)
+				let a = this.isAType?.(x) ? x : undefined
+				let b = a === undefined ? (x as BType) : undefined
+				for (const y of ys) {
+					a ??= y as AType
+					b ??= y as BType
+					this.addRelation(a, b)
+				}
 			}
 			for (const [contentKey, content] of data.contents ?? []) {
 				this.setContent(contentKey, content)
@@ -202,33 +259,35 @@ export class Junction<
 			this.warn = config.warn
 		}
 	}
-	public toJSON(): JunctionJSON<ASide, BSide, Content> {
+	public toJSON(): JunctionJSON<ASide, AType, BSide, BType, Content> {
 		return {
 			between: [this.a, this.b],
 			cardinality: this.cardinality,
-			relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
+			relations: [...this.relations.entries()].map(
+				([a, b]) => [a, [...b]] as [AType, BType[]],
+			),
 			contents: [...this.contents.entries()],
 		}
 	}
 
 	public set(
-		a: string,
-		...rest: Content extends null ? [b: string] : [b: string, content: Content]
+		a: AType,
+		...rest: Content extends null ? [b: BType] : [b: BType, content: Content]
 	): this
 	public set(
-		relation: { [Key in ASide | BSide]: string },
-		...rest: Content extends null ? [] | [b?: undefined] : [content: Content]
+		relation: { [Key in ASide]: AType } & { [Key in BSide]: BType },
+		...rest: Content extends null ? [] | [void?: undefined] : [content: Content]
 	): this
 	public set(
-		a: string | { [Key in ASide | BSide]: string },
+		a: AType | ({ [Key in ASide]: AType } & { [Key in BSide]: BType }),
 		...rest: Content extends null
-			? [] | [b?: string | undefined]
-			: [b: string, content: Content] | [content: Content]
+			? [] | [b?: BType | undefined]
+			: [b: BType, content: Content] | [content: Content]
 	): this {
-		const b: string =
+		const b: BType =
 			typeof rest[0] === `string`
 				? rest[0]
-				: (a[this.b as keyof typeof a] as string)
+				: (a[this.b as keyof typeof a] as BType)
 		const content: Content | undefined =
 			(rest[1] ?? typeof rest[0] === `string`) ? undefined : (rest[0] as Content)
 		a = typeof a === `string` ? a : a[this.a]
@@ -236,7 +295,7 @@ export class Junction<
 			// biome-ignore lint/suspicious/noFallthroughSwitchClause: perfect here
 			case `1:1`: {
 				const bPrev = this.getRelatedKey(a)
-				if (bPrev && bPrev !== b) this.delete(bPrev, a)
+				if (bPrev && bPrev !== b) this.delete(a, bPrev)
 			}
 			case `1:n`: {
 				const aPrev = this.getRelatedKey(b)
@@ -251,29 +310,32 @@ export class Junction<
 		return this
 	}
 
-	public delete(a: string, b?: string): this
+	public delete(a: AType, b?: BType): this
+	public delete(b: BType, a?: AType): this
 	public delete(
 		relation:
-			| Record<ASide | BSide, string>
-			| Record<ASide, string>
-			| Record<BSide, string>,
+			| { [Key in ASide]: AType }
+			| { [Key in BSide]: BType }
+			| ({ [Key in ASide]: AType } & { [Key in BSide]: BType }),
 		b?: undefined,
 	): this
 	public delete(
 		x:
+			| AType
+			| BType
 			| Record<ASide | BSide, string>
 			| Record<ASide, string>
-			| Record<BSide, string>
-			| string,
-		b?: string,
+			| Record<BSide, string>,
+		b?: AType | BType,
 	): this {
 		// @ts-expect-error we deduce that this.b may index x
-		b = typeof b === `string` ? b : (x[this.b] as string | undefined)
-		// @ts-expect-error we deduce that this.a may index x
-		const a = typeof x === `string` ? x : (x[this.a] as string | undefined)
+		b = typeof b === `string` ? (b as BType) : (x[this.b] as BType | undefined)
+		const a =
+			// @ts-expect-error we deduce that this.a may index x
+			typeof x === `string` ? (x as AType) : (x[this.a] as AType | undefined)
 
 		if (a === undefined && typeof b === `string`) {
-			const bRelations = this.getRelatedKeys(b)
+			const bRelations = this.getRelatedKeys(b) as Set<AType>
 			if (bRelations) {
 				for (const bRelation of bRelations) {
 					this.delete(bRelation, b)
@@ -296,7 +358,9 @@ export class Junction<
 		return this
 	}
 
-	public getRelatedKey(key: string): string | undefined {
+	public getRelatedKey(key: AType): BType | undefined
+	public getRelatedKey(key: BType): AType | undefined
+	public getRelatedKey(key: AType | BType): AType | BType | undefined {
 		const relations = this.getRelatedKeys(key)
 		if (relations) {
 			if (relations.size > 1) {
@@ -308,49 +372,67 @@ export class Junction<
 						.join(`, `)}). Only one related key was expected.`,
 				)
 			}
+			let singleRelation: AType | BType | undefined
 			for (const relation of relations) {
-				return relation
+				singleRelation = relation
+				break
 			}
+			return singleRelation
 		}
 	}
 
 	public replaceRelations(
-		a: string,
-		relations: Content extends null ? string[] : Record<string, Content>,
+		a: AType,
+		relations: Content extends null ? BType[] : Record<BType, Content>,
+		config?: { reckless: boolean },
+	): this
+	public replaceRelations(
+		b: BType,
+		relations: Content extends null ? AType[] : Record<AType, Content>,
+		config?: { reckless: boolean },
+	): this
+	public replaceRelations<
+		XType extends AType | BType,
+		YType extends XType extends AType ? BType : AType,
+	>(
+		x: XType,
+		relations: Content extends null ? YType[] : Record<YType, Content>,
 		config?: { reckless: boolean },
 	): this {
 		const hasContent = !Array.isArray(relations)
-		const bs = hasContent ? Object.keys(relations) : relations
+		const ys = (hasContent ? Object.keys(relations) : relations) as YType[]
 		if (config?.reckless) {
-			this.replaceRelationsUnsafely(a, bs)
+			this.replaceRelationsUnsafely(x as any, ys as any)
 		} else {
-			this.replaceRelationsSafely(a, bs)
+			this.replaceRelationsSafely(x as any, ys as any)
 		}
 		if (hasContent) {
-			for (const b of bs) {
-				const contentKey = this.makeContentKey(a, b)
-				const content = relations[b] as Content
+			for (const y of ys) {
+				const contentKey = this.makeContentKey(x as any, y as any) // sort XY to AB ❗
+				const content = (relations as Record<YType, Content>)[y]
 				this.setContent(contentKey, content)
 			}
 		}
 		return this
 	}
 
-	public getContent(a: string, b: string): Content | undefined {
+	public getContent(a: AType, b: BType): Content | undefined {
 		const contentKey = this.makeContentKey(a, b)
 		return this.getContentInternal(contentKey)
 	}
 
+	public getRelationEntries(input: Record<ASide, AType>): [BType, Content][]
+	public getRelationEntries(input: Record<BSide, BType>): [AType, Content][]
 	public getRelationEntries(
-		input: Record<ASide, string> | Record<BSide, string>,
-	): [string, Content][] {
-		const a: string | undefined = (input as any)[this.a]
-		const b: string | undefined = (input as any)[this.b]
+		input: Record<ASide, AType> | Record<BSide, BType>,
+	): [AType | BType, Content][] {
+		const a: AType | undefined = (input as any)[this.a]
+		const b: BType | undefined = (input as any)[this.b]
 		if (a !== undefined && b === undefined) {
 			const aRelations = this.getRelatedKeys(a)
 			if (aRelations) {
 				return [...aRelations].map((aRelation) => {
-					return [aRelation, this.getContent(a, aRelation) ?? (null as Content)]
+					return [aRelation, this.getContent(a, aRelation) as Content]
 				})
 			}
 		}
@@ -358,17 +440,19 @@ export class Junction<
 			const bRelations = this.getRelatedKeys(b)
 			if (bRelations) {
 				return [...bRelations].map((bRelation) => {
-					return [bRelation, this.getContent(bRelation, b) ?? (null as Content)]
+					return [bRelation, this.getContent(bRelation, b) as Content]
 				})
 			}
 		}
 		return []
 	}
 
-	public has(a: string, b?: string): boolean {
+	public has(a: AType, b?: BType): boolean
+	public has(b: BType, a?: AType): boolean
+	public has(a: AType | BType, b?: AType | BType): boolean {
 		if (b) {
 			const setA = this.getRelatedKeys(a)
-			return setA?.has(b) ?? false
+			return setA?.has(b as any) ?? false
 		}
 		return this.relations.has(a)
 	}

package/internal/src/molecule/make-molecule-in-store.ts

@@ -82,7 +82,9 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 		},
 		env: () => getEnvironmentData(newest(rootStore)),
 		bond: ((
-			token: JoinToken<any, any, any, any> | ReadableFamilyToken<any, any>,
+			token:
+				| JoinToken<any, any, any, any, any, any>
+				| ReadableFamilyToken<any, any>,
 			maybeRole,
 		) => {
 			if (token.type === `join`) {

package/internal/src/molecule/molecule-internal.ts

@@ -31,7 +31,7 @@ export class Molecule<M extends MoleculeConstructor>
 	public tokens = new Map<string, ReadableToken<any>>()
 	public above = new Map<string, Molecule<any>>()
 	public below = new Map<string, Molecule<any>>()
-	public joins = new Map<string, Join<any, any, any, any>>()
+	public joins = new Map<string, Join<any, any, any, any, any, any>>()
 	public instance: InstanceType<M>
 	public constructor(
 		ctx: Molecule<any>[] | undefined,

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

@@ -7,7 +7,7 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 import { selectJsonFamily, stringifyJson } from "atom.io/json"
 
 import { type MutableAtomFamily, prettyPrintTokenType } from ".."
@@ -21,7 +21,7 @@ import type { Transceiver } from "./transceiver"
 export function createMutableAtomFamily<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends string,
+	K extends Canonical,
 >(
 	store: Store,
 	options: MutableAtomFamilyOptions<T, J, K>,

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

@@ -1,5 +1,5 @@
 import type { MutableAtomFamilyToken } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import type { WritableSelectorFamily } from ".."
 import { newest } from "../lineage"
@@ -9,7 +9,7 @@ import type { Transceiver } from "./transceiver"
 export const getJsonFamily = <
 	Core extends Transceiver<Json.Serializable>,
 	SerializableCore extends Json.Serializable,
-	Key extends string,
+	Key extends Canonical,
 >(
 	mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>,
 	store: Store,

package/internal/src/store/store.ts

@@ -56,7 +56,9 @@ export class Store implements Lineage {
 	})
 	public selectorGraph = new Junction<
 		`upstreamSelectorKey`,
+		string,
 		`downstreamSelectorKey`,
+		string,
 		{ source: string }
 	>(
 		{
@@ -88,7 +90,9 @@ export class Store implements Lineage {
 	public timelines = new Map<string, Timeline<any>>()
 	public timelineTopics = new Junction<
 		`timelineKey`,
+		string,
 		`topicKey`,
+		string,
 		{ topicType: `atom_family` | `atom` | `molecule_family` | `molecule` }
 	>({
 		between: [`timelineKey`, `topicKey`],

package/internal/src/transaction/index.ts

@@ -24,5 +24,5 @@ export type TransactionProgress<F extends Func> = {
 
 export type TransactionEpoch = {
 	epoch: Map<string, number>
-	actionContinuities: Junction<`continuity`, `action`>
+	actionContinuities: Junction<`continuity`, string, `action`, string>
 }

package/json/dist/index.js

@@ -1,5 +1,5 @@
-import { createWritableSelectorFamily } from '../../dist/chunk-7PUUHSXC.js';
-import '../../dist/chunk-ZKG6ZA4I.js';
+import { createWritableSelectorFamily } from '../../dist/chunk-LSCRHXLI.js';
+import '../../dist/chunk-ADMEAXYU.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.30.0",
+  "version": "0.30.2",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -57,34 +57,34 @@
     "@types/estree": "1.0.6",
     "@types/http-proxy": "1.17.15",
     "@types/npmlog": "7.0.0",
-    "@types/react": "18.3.11",
+    "@types/react": "18.3.12",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.8.0",
-    "@typescript-eslint/rule-tester": "8.8.0",
-    "@vitest/coverage-v8": "2.1.2",
-    "@vitest/ui": "2.1.2",
+    "@typescript-eslint/parser": "8.10.0",
+    "@typescript-eslint/rule-tester": "8.10.0",
+    "@vitest/coverage-v8": "2.1.3",
+    "@vitest/ui": "2.1.3",
     "concurrently": "9.0.1",
-    "drizzle-kit": "0.24.2",
-    "drizzle-orm": "0.33.0",
-    "eslint": "9.11.1",
-    "framer-motion": "11.11.0",
+    "drizzle-kit": "0.26.2",
+    "drizzle-orm": "0.35.3",
+    "eslint": "9.13.0",
+    "framer-motion": "11.11.9",
     "happy-dom": "15.7.4",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
-    "preact": "10.24.2",
+    "preact": "10.24.3",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "react-router-dom": "6.26.2",
+    "react-router-dom": "6.27.0",
     "socket.io": "4.8.0",
     "socket.io-client": "4.8.0",
     "tmp": "0.2.3",
     "tsup": "8.3.0",
     "tsx": "4.19.1",
-    "typescript": "5.6.2",
-    "vite": "5.4.8",
+    "typescript": "5.6.3",
+    "vite": "5.4.10",
     "vite-tsconfig-paths": "5.0.1",
-    "vitest": "2.1.2",
+    "vitest": "2.1.3",
     "zod": "3.23.8"
   },
   "main": "dist/index.js",

package/realtime/dist/index.d.ts

@@ -45,7 +45,7 @@ type UserInRoomMeta = {
     enteredAtEpoch: number;
 };
 declare const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta;
-declare const usersInRooms: atom_io_data.JoinToken<"room", "user", "1:n", UserInRoomMeta>;
+declare const usersInRooms: atom_io_data.JoinToken<"room", string, "user", string, "1:n", UserInRoomMeta>;
 declare const usersInMyRoomView: atom_io.ReadonlySelectorFamilyToken<MutableAtomToken<SetRTX<string>, SetRTXJson<string>>[], string>;
 
 export { type ContinuityOptions, type ContinuityToken, DEFAULT_USER_IN_ROOM_META, InvariantMap, type PerspectiveToken, SyncGroup, type UserInRoomMeta, continuity, roomIndex, usersInMyRoomView, usersInRooms, usersInThisRoomIndex };

package/realtime/dist/index.js

@@ -90,7 +90,9 @@ var usersInRooms = join(
   {
     key: `usersInRooms`,
     between: [`room`, `user`],
-    cardinality: `1:n`
+    cardinality: `1:n`,
+    isAType: (input) => typeof input === `string`,
+    isBType: (input) => typeof input === `string`
   },
   DEFAULT_USER_IN_ROOM_META
 );

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

@@ -31,6 +31,8 @@ export const usersInRooms = 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,
 )