atom.io 0.27.4 → 0.28.0

package/introspection/src/attach-type-selectors.ts

@@ -0,0 +1,26 @@
+import type { ReadonlySelectorFamilyToken } from "atom.io"
+import type { Store } from "atom.io/internal"
+import { createReadonlySelectorFamily, IMPLICIT } from "atom.io/internal"
+
+import { discoverType } from "./refinery"
+
+export const attachTypeSelectors = (
+	store: Store = IMPLICIT.STORE,
+): ReadonlySelectorFamilyToken<string, string> => {
+	const typeSelectors = createReadonlySelectorFamily<string, string>(store, {
+		key: `👁‍🗨 State Type`,
+		get:
+			(token) =>
+			({ get }) => {
+				let state: unknown
+				try {
+					state = get(token as any)
+				} catch (error) {
+					return `error`
+				}
+				const typeOfState = discoverType(state)
+				return typeOfState
+			},
+	})
+	return typeSelectors
+}

package/introspection/src/differ.ts

@@ -0,0 +1,167 @@
+import { sprawl } from "anvl/object"
+import type { Json } from "atom.io/json"
+
+import type { Refinery, Supported } from "./refinery"
+import { discoverType, jsonTreeRefinery, primitiveRefinery } from "./refinery"
+
+export function diffNumber(a: number, b: number): Delta {
+	const sign = a < b ? `+` : `-`
+	return {
+		summary: `${sign}${Math.abs(a - b)} (${a} → ${b})`,
+	}
+}
+
+export function diffString(a: string, b: string): Delta {
+	const sign = a.length < b.length ? `+` : `-`
+	return {
+		summary: `${sign}${Math.abs(a.length - b.length)} ("${a}" → "${b}")`,
+	}
+}
+
+export function diffBoolean(a: boolean, b: boolean): Delta {
+	return {
+		summary: `${a} → ${b}`,
+	}
+}
+
+export function diffObject(
+	a: Json.Tree.Object,
+	b: Json.Tree.Object,
+	recurse: Diff<unknown>,
+): Delta {
+	let summary = ``
+	const added: Delta[`added`] = []
+	const removed: Delta[`removed`] = []
+	const changed: Delta[`changed`] = []
+
+	sprawl(a, (path, nodeA) => {
+		let key: string
+		for (key of path) {
+			const nodeB = b[key]
+			if (nodeB === undefined) {
+				removed.push([key, JSON.stringify(nodeA)])
+			} else {
+				const delta = recurse(nodeA, nodeB)
+				if (delta.summary !== `No Change`) {
+					changed.push([key, delta])
+				}
+			}
+		}
+	})
+
+	sprawl(b, (path, nodeB) => {
+		let key: string
+		for (key of path) {
+			const nodeA = a[key]
+			if (nodeA === undefined) {
+				added.push([key, JSON.stringify(nodeB)])
+			}
+		}
+	})
+
+	summary = `～${changed.length} ＋${added.length} －${removed.length}`
+
+	return {
+		summary,
+		added,
+		removed,
+		changed,
+	}
+}
+
+export function diffArray(
+	a: Json.Tree.Array,
+	b: Json.Tree.Array,
+	recurse: Diff<unknown>,
+): Delta {
+	return diffObject(a as any, b as any, recurse)
+}
+
+type Delta = {
+	summary: string
+	added?: [path: string, addedStringifiedValue: string][]
+	removed?: [path: string, removedStringifiedValue: string][]
+	changed?: [path: string, delta: Delta][]
+}
+
+type Diff<T> = (a: T, b: T) => Delta
+type DiffTree<T> = (a: T, b: T, recurse: Differ<any, any>[`diff`]) => Delta
+
+export class Differ<
+	Leaf extends Record<string, any>,
+	Tree extends Record<string, any>,
+> {
+	public leafRefinery: Refinery<Leaf>
+	public treeRefinery: Refinery<Tree>
+	public leafDiffers: { [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>> }
+	public treeDiffers: { [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>> }
+
+	public constructor(
+		leafRefinery: Refinery<Leaf>,
+		treeRefinery: Refinery<Tree>,
+		diffFunctions: {
+			[KT in keyof Tree]: DiffTree<Supported<Tree[KT]>>
+		} & { [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>> },
+	) {
+		this.leafRefinery = leafRefinery
+		this.treeRefinery = treeRefinery
+		this.leafDiffers = {} as any
+		this.treeDiffers = {} as any
+		for (const key of Object.keys(leafRefinery.supported)) {
+			const diffFunction = diffFunctions[key]
+			this.leafDiffers[key as keyof Leaf] = diffFunction
+		}
+		for (const key of Object.keys(treeRefinery.supported)) {
+			const diffFunction = diffFunctions[key]
+			this.treeDiffers[key as keyof Tree] = diffFunction
+		}
+	}
+
+	public diff(a: unknown, b: unknown): Delta {
+		if (a === b) {
+			return { summary: `No Change` }
+		}
+
+		const aRefined = this.leafRefinery.refine(a) ?? this.treeRefinery.refine(a)
+		const bRefined = this.leafRefinery.refine(b) ?? this.treeRefinery.refine(b)
+
+		if (aRefined !== null && bRefined !== null) {
+			if (aRefined.type === bRefined.type) {
+				if (aRefined.type in this.leafDiffers) {
+					const delta = this.leafDiffers[aRefined.type](
+						aRefined.data,
+						bRefined.data,
+					)
+					return delta
+				}
+				if (aRefined.type in this.treeDiffers) {
+					const delta = this.treeDiffers[aRefined.type](
+						aRefined.data,
+						bRefined.data,
+						(x, y) => this.diff(x, y),
+					)
+					return delta
+				}
+			}
+		}
+		const typeA = discoverType(a)
+		const typeB = discoverType(b)
+		if (typeA === typeB) {
+			return {
+				summary: `${typeA} → ${typeB}`,
+			}
+		}
+		return {
+			summary: `Type change: ${typeA} → ${typeB}`,
+		}
+	}
+}
+
+export const prettyJson = new Differ(primitiveRefinery, jsonTreeRefinery, {
+	number: diffNumber,
+	string: diffString,
+	boolean: diffBoolean,
+	null: () => ({ summary: `No Change` }),
+	object: diffObject,
+	array: diffArray,
+})

package/introspection/src/index.ts

@@ -2,6 +2,8 @@ import type { ReadableToken } from "atom.io"
 
 export * from "./attach-introspection-states"
 export * from "./auditor"
+export * from "./differ"
+export * from "./refinery"
 
 export type FamilyNode<Token extends ReadableToken<unknown>> = {
 	key: string

package/introspection/src/refinery.ts

@@ -0,0 +1,100 @@
+import type { Flat } from "atom.io/internal"
+import type { Json } from "atom.io/json"
+
+export type Refinement<A, B extends A> = (a: A) => a is B
+
+export type ClassSignature = abstract new (...args: any) => any
+
+export type RefinementStrategy = ClassSignature | Refinement<unknown, any>
+
+export type Supported<Refine extends RefinementStrategy> =
+	Refine extends Refinement<unknown, infer T>
+		? T
+		: Refine extends ClassSignature
+			? InstanceType<Refine>
+			: never
+
+export type RefinementSupport = Record<string, RefinementStrategy>
+
+export class Refinery<SupportedTypes extends RefinementSupport> {
+	public supported: SupportedTypes
+
+	public constructor(supported: SupportedTypes) {
+		this.supported = supported
+	}
+
+	public refine<T>(input: T):
+		| Flat<{
+				[K in keyof SupportedTypes]: T extends Supported<SupportedTypes[K]>
+					? {
+							type: K
+							data: Supported<SupportedTypes[K]>
+						}
+					: Supported<SupportedTypes[K]> extends T
+						? {
+								type: K
+								data: Supported<SupportedTypes[K]>
+							}
+						: never
+		  }>[keyof SupportedTypes]
+		| (T extends Supported<SupportedTypes[keyof SupportedTypes]>
+				? never
+				: null) {
+		for (const [key, refiner] of Object.entries(this.supported)) {
+			try {
+				if (
+					// @ts-expect-error that's the point
+					refiner(input) === true &&
+					refiner !== Boolean
+				) {
+					return { type: key, data: input } as any
+				}
+			} catch (_) {
+				try {
+					if (input instanceof refiner) {
+						return { type: key, data: input } as any
+					}
+				} catch (__) {}
+			}
+		}
+		return null as any
+	}
+}
+
+export const primitiveRefinery = new Refinery({
+	number: (input: unknown): input is number => typeof input === `number`,
+	string: (input: unknown): input is string => typeof input === `string`,
+	boolean: (input: unknown): input is boolean => typeof input === `boolean`,
+	null: (input: unknown): input is null => input === null,
+})
+
+export const jsonTreeRefinery = new Refinery({
+	object: (input: unknown): input is Json.Tree.Object => {
+		if (!input) {
+			return false
+		}
+		const prototype = Object.getPrototypeOf(input)
+		return prototype === Object.prototype
+	},
+	array: (input: unknown): input is Json.Tree.Array => Array.isArray(input),
+})
+
+export const jsonRefinery = new Refinery({
+	...primitiveRefinery.supported,
+	...jsonTreeRefinery.supported,
+})
+
+export type JsonType = keyof typeof jsonRefinery.supported
+
+export const discoverType = (
+	input: unknown,
+): JsonType | `Map` | `Set` | `undefined` | (string & {}) => {
+	if (input === undefined) {
+		return `undefined`
+	}
+	const refined = jsonRefinery.refine(input)
+	if (refined) {
+		return refined.type
+	}
+	return Object.getPrototypeOf(input).constructor.name
+}

package/json/dist/index.d.ts

@@ -1,31 +1,6 @@
 import { Range, Flat, Store, Transceiver } from 'atom.io/internal';
 import * as AtomIO from 'atom.io';
 
-type JsonInterface<T, J extends Serializable = Serializable> = {
-    toJson: (t: T) => J;
-    fromJson: (json: J) => T;
-};
-
-type primitive = boolean | number | string | null;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
-type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
-
-type json_Array<Element extends Serializable = Serializable> = Array<Element>;
-type json_Serializable = Serializable;
-declare namespace json {
-  export type { json_Array as Array, Object$1 as Object, json_Serializable as Serializable };
-}
-
-declare const parseJson: <S extends stringified<Serializable>>(str: S | string) => S extends stringified<infer J> ? J : Serializable;
-type stringified<J extends Serializable> = string & {
-    __json: J;
-};
-declare const stringifyJson: <J extends Serializable>(json: J) => stringified<J>;
-
 type Entries<K extends keyof any = keyof any, V = any> = [K, V][];
 type KeyOfEntries<E extends Entries> = E extends [infer K, any][] ? K : never;
 type ValueOfEntry<E extends Entries, K extends KeyOfEntries<E>> = {
@@ -35,13 +10,39 @@ type FromEntries<E extends Entries> = Flat<{
     [K in KeyOfEntries<E>]: ValueOfEntry<E, K>;
 }>;
 declare function fromEntries<E extends Entries>(entries: E): FromEntries<E>;
+declare function toEntries<T extends object>(obj: T): Entries<keyof T, T[keyof T]>;
 
-declare const selectJson: <T, J extends Serializable>(atom: AtomIO.AtomToken<T>, transform: JsonInterface<T, J>, store?: Store) => AtomIO.WritableSelectorToken<J>;
+declare const selectJson: <T, J extends Json.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>(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>;
+declare function selectJsonFamily<T extends Transceiver<any>, J extends Json.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 Json.Serializable, K extends Canonical>(atomFamilyToken: AtomIO.RegularAtomFamilyToken<T, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamilyToken<J, K>;
 
+type primitive = boolean | number | string | null;
+declare namespace Json {
+    namespace Tree {
+        type Array<Element = unknown> = ReadonlyArray<Element>;
+        type Object<K extends string = string, V = unknown> = Record<K, V>;
+        type Fork = Array | Object;
+        type Leaf = primitive;
+        type Node = Fork | Leaf;
+    }
+    type Serializable = primitive | Readonly<{
+        [key: string]: Serializable;
+    }> | ReadonlyArray<Serializable>;
+    type Object<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
+    type Array<Element extends Serializable = Serializable> = ReadonlyArray<Element>;
+}
+type stringified<J extends Json.Serializable> = string & {
+    __json: J;
+};
+declare const parseJson: <S extends stringified<Json.Serializable>>(str: S | string) => S extends stringified<infer J> ? J : Json.Serializable;
+declare const stringifyJson: <J extends Json.Serializable>(json: J) => stringified<J>;
 type Canonical = primitive | ReadonlyArray<Canonical>;
-type JsonIO = (...params: Serializable[]) => Serializable | void;
+type JsonIO = (...params: Json.Serializable[]) => Json.Serializable | void;
+type JsonInterface<T, J extends Json.Serializable = Json.Serializable> = {
+    toJson: (t: T) => J;
+    fromJson: (json: J) => T;
+};
+declare const isJson: (input: unknown) => input is Json.Tree.Node;
 
-export { type Canonical, type Entries, type FromEntries, json as Json, type JsonIO, type JsonInterface, type KeyOfEntries, type ValueOfEntry, fromEntries, parseJson, type primitive, selectJson, selectJsonFamily, type stringified, stringifyJson };
+export { type Canonical, type Entries, type FromEntries, Json, type JsonIO, type JsonInterface, type KeyOfEntries, type ValueOfEntry, fromEntries, isJson, parseJson, type primitive, selectJson, selectJsonFamily, type stringified, stringifyJson, toEntries };

package/json/dist/index.js

@@ -1,82 +1,4 @@
-import { stringifyJson, parseJson } from '../../dist/chunk-AK23DRMD.js';
-export { parseJson, stringifyJson } from '../../dist/chunk-AK23DRMD.js';
-import { createWritableSelectorFamily } from '../../dist/chunk-JRENM6KL.js';
+export { fromEntries, isJson, parseJson, selectJson, selectJsonFamily, stringifyJson, toEntries } from '../../dist/chunk-EUVKUTW3.js';
+import '../../dist/chunk-BX3MTH2Z.js';
 import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';
-import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';
-
-// json/src/entries.ts
-function fromEntries(entries) {
-  return Object.fromEntries(entries);
-}
-var selectJson = (atom, transform, store = IMPLICIT.STORE) => {
-  return createStandaloneSelector(
-    {
-      key: `${atom.key}:JSON`,
-      get: ({ get }) => transform.toJson(get(atom)),
-      set: ({ set }, newValue) => {
-        set(atom, transform.fromJson(newValue));
-      }
-    },
-    store
-  );
-};
-function selectJsonFamily(atomFamilyToken, transform, store = IMPLICIT.STORE) {
-  const jsonFamily = createWritableSelectorFamily(
-    {
-      key: `${atomFamilyToken.key}:JSON`,
-      get: (key) => ({ seek, get }) => {
-        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, atomFamilyToken, store);
-          return transform.toJson(get(atom));
-        }
-        if (store.config.lifespan === `immortal`) {
-          throw new Error(`No molecule found for key "${stringKey}"`);
-        }
-        const newToken = initFamilyMemberInStore(atomFamilyToken, key, store);
-        return transform.toJson(get(newToken));
-      },
-      set: (key) => ({ seek, set }, newValue) => {
-        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, atomFamilyToken, store);
-            set(atom, transform.fromJson(newValue));
-          } else {
-            if (store.config.lifespan === `immortal`) {
-              throw new Error(`No molecule found for key "${stringKey}"`);
-            }
-            set(
-              initFamilyMemberInStore(atomFamilyToken, key, store),
-              transform.fromJson(newValue)
-            );
-          }
-        }
-      }
-    },
-    store,
-    [`mutable`, `json`]
-  );
-  const atomFamily = withdraw(atomFamilyToken, store);
-  atomFamily.subject.subscribe(
-    `store=${store.config.name}::json-selector-family`,
-    (event) => {
-      if (event.token.family) {
-        seekInStore(jsonFamily, parseJson(event.token.family.subKey), store);
-      }
-    }
-  );
-  return jsonFamily;
-}
-
-export { fromEntries, selectJson, selectJsonFamily };

package/json/src/entries.ts

@@ -17,3 +17,9 @@ export type FromEntries<E extends Entries> = Flat<{
 export function fromEntries<E extends Entries>(entries: E): FromEntries<E> {
 	return Object.fromEntries(entries) as FromEntries<E>
 }
+
+export function toEntries<T extends object>(
+	obj: T,
+): Entries<keyof T, T[keyof T]> {
+	return Object.entries(obj) as Entries<keyof T, T[keyof T]>
+}

package/json/src/index.ts

@@ -1,14 +1,55 @@
-import type { Json, JsonInterface, stringified } from "~/packages/anvl/src/json"
-import { parseJson, stringifyJson } from "~/packages/anvl/src/json"
-import type { primitive } from "~/packages/anvl/src/primitive"
-
 export * from "./entries"
 export * from "./select-json"
 export * from "./select-json-family"
 
-export type { Json, JsonInterface, primitive, stringified }
-export { parseJson, stringifyJson }
+export type primitive = boolean | number | string | null
+
+export namespace Json {
+	export namespace Tree {
+		export type Array<Element = unknown> = ReadonlyArray<Element>
+		export type Object<K extends string = string, V = unknown> = Record<K, V>
+		export type Fork = Array | Object
+		export type Leaf = primitive
+		export type Node = Fork | Leaf
+	}
+
+	export type Serializable =
+		| primitive
+		| Readonly<{ [key: string]: Serializable }>
+		| ReadonlyArray<Serializable>
+
+	export type Object<
+		Key extends string = string,
+		Value extends Serializable = Serializable,
+	> = Record<Key, Value>
+
+	export type Array<Element extends Serializable = Serializable> =
+		ReadonlyArray<Element>
+}
+
+export type stringified<J extends Json.Serializable> = string & { __json: J }
+
+export const parseJson = <S extends stringified<Json.Serializable>>(
+	str: S | string,
+): S extends stringified<infer J> ? J : Json.Serializable => JSON.parse(str)
+
+export const stringifyJson = <J extends Json.Serializable>(
+	json: J,
+): stringified<J> => JSON.stringify(json) as stringified<J>
 
 export type Canonical = primitive | ReadonlyArray<Canonical>
 
 export type JsonIO = (...params: Json.Serializable[]) => Json.Serializable | void
+
+export type JsonInterface<T, J extends Json.Serializable = Json.Serializable> = {
+	toJson: (t: T) => J
+	fromJson: (json: J) => T
+}
+
+const JSON_PROTOTYPES = [Array, Boolean, Number, Object, String] as const
+export const isJson = (input: unknown): input is Json.Tree.Node => {
+	if (input === null) return true
+	if (input === undefined) return false
+	const prototype = Object.getPrototypeOf(input)
+	return JSON_PROTOTYPES.includes(prototype)
+}

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

@@ -42,6 +42,7 @@ export function selectJsonFamily<
 	store: Store = IMPLICIT.STORE,
 ): AtomIO.WritableSelectorFamilyToken<J, K> {
 	const jsonFamily = createWritableSelectorFamily<J, K>(
+		store,
 		{
 			key: `${atomFamilyToken.key}:JSON`,
 			get:
@@ -60,7 +61,7 @@ export function selectJsonFamily<
 					if (store.config.lifespan === `immortal`) {
 						throw new Error(`No molecule found for key "${stringKey}"`)
 					}
-					const newToken = initFamilyMemberInStore(atomFamilyToken, key, store)
+					const newToken = initFamilyMemberInStore(store, atomFamilyToken, key)
 					return transform.toJson(get(newToken))
 				},
 			set:
@@ -80,14 +81,13 @@ export function selectJsonFamily<
 								throw new Error(`No molecule found for key "${stringKey}"`)
 							}
 							set(
-								initFamilyMemberInStore(atomFamilyToken, key, store),
+								initFamilyMemberInStore(store, atomFamilyToken, key),
 								transform.fromJson(newValue),
 							)
 						}
 					}
 				},
 		},
-		store,
 		[`mutable`, `json`],
 	)
 	const atomFamily = withdraw(atomFamilyToken, store)
@@ -95,7 +95,7 @@ export function selectJsonFamily<
 		`store=${store.config.name}::json-selector-family`,
 		(event) => {
 			if (event.token.family) {
-				seekInStore(jsonFamily, parseJson(event.token.family.subKey) as K, store)
+				seekInStore(store, jsonFamily, parseJson(event.token.family.subKey) as K)
 			}
 		},
 	)

package/json/src/select-json.ts

@@ -9,14 +9,11 @@ export const selectJson = <T, J extends Json.Serializable>(
 	transform: JsonInterface<T, J>,
 	store: Store = IMPLICIT.STORE,
 ): AtomIO.WritableSelectorToken<J> => {
-	return createStandaloneSelector(
-		{
-			key: `${atom.key}:JSON`,
-			get: ({ get }) => transform.toJson(get(atom)),
-			set: ({ set }, newValue) => {
-				set(atom, transform.fromJson(newValue))
-			},
+	return createStandaloneSelector(store, {
+		key: `${atom.key}:JSON`,
+		get: ({ get }) => transform.toJson(get(atom)),
+		set: ({ set }, newValue) => {
+			set(atom, transform.fromJson(newValue))
 		},
-		store,
-	)
+	})
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.27.4",
+  "version": "0.28.0",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -57,18 +57,18 @@
     "@types/estree": "1.0.5",
     "@types/http-proxy": "1.17.15",
     "@types/npmlog": "7.0.0",
-    "@types/react": "18.3.3",
+    "@types/react": "18.3.4",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.1.0",
-    "@typescript-eslint/rule-tester": "8.1.0",
+    "@typescript-eslint/parser": "8.2.0",
+    "@typescript-eslint/rule-tester": "8.2.0",
     "@vitest/coverage-v8": "2.0.5",
     "@vitest/ui": "2.0.5",
     "concurrently": "8.2.2",
     "drizzle-kit": "0.24.0",
     "drizzle-orm": "0.33.0",
     "eslint": "9.9.0",
-    "framer-motion": "11.3.28",
-    "happy-dom": "14.12.3",
+    "framer-motion": "11.3.29",
+    "happy-dom": "15.0.0",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
@@ -82,7 +82,7 @@
     "tsup": "8.2.4",
     "tsx": "4.17.0",
     "typescript": "5.5.4",
-    "vite": "5.4.1",
+    "vite": "5.4.2",
     "vite-tsconfig-paths": "5.0.1",
     "vitest": "2.0.5"
   },
@@ -135,7 +135,10 @@
     "realtime-testing/src",
     "transceivers/set-rtx/dist",
     "transceivers/set-rtx/package.json",
-    "transceivers/set-rtx/src"
+    "transceivers/set-rtx/src",
+    "web/dist",
+    "web/package.json",
+    "web/src"
   ],
   "exports": {
     "./package.json": "./package.json",
@@ -217,6 +220,11 @@
     "./transceivers/set-rtx": {
       "import": "./transceivers/set-rtx/dist/index.js",
       "types": "./transceivers/set-rtx/dist/index.d.ts"
+    },
+    "./web/package.json": "./web/package.json",
+    "./web": {
+      "import": "./web/dist/index.js",
+      "types": "./web/dist/index.d.ts"
     }
   },
   "scripts": {
@@ -240,6 +248,7 @@
     "build:realtime-server": "cd realtime-server && tsup",
     "build:realtime-testing": "cd realtime-testing && tsup",
     "build:transceivers:set-rtx": "cd transceivers/set-rtx && tsup",
+    "build:web": "cd web && tsup",
     "lint:biome": "biome check -- .",
     "lint:eslint": "eslint --flag unstable_ts_config -- .",
     "lint:eslint:build": "bun run build:main",