atom.io 0.26.0 → 0.27.0

package/internal/src/families/seek-in-store.ts

@@ -20,7 +20,8 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import { type Json, stringifyJson } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
 
 import type { Molecule, ReadableState } from ".."
 import { newest } from "../lineage"
@@ -30,7 +31,7 @@ import { deposit, type Store } from "../store"
 export function seekInStore<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 	Key extends K,
 >(
 	token: MutableAtomFamilyToken<T, J, K>,
@@ -38,43 +39,43 @@ export function seekInStore<
 	store: Store,
 ): MutableAtomToken<T, J> | undefined
 
-export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): RegularAtomToken<T> | undefined
 
-export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K>(
 	token: AtomFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): AtomToken<T> | undefined
 
-export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): WritableSelectorToken<T> | undefined
 
-export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): ReadonlySelectorToken<T> | undefined
 
-export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K>(
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): SelectorToken<T> | undefined
 
-export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): WritableToken<T> | undefined
 
-export function seekInStore<T, K extends Json.Serializable, Key extends K>(
+export function seekInStore<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
 	store: Store,
@@ -88,7 +89,7 @@ export function seekInStore<M extends MoleculeConstructor>(
 
 export function seekInStore(
 	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
-	key: Json.Serializable,
+	key: Canonical,
 	store: Store,
 ): MoleculeToken<any> | ReadableToken<any> | undefined {
 	const subKey = stringifyJson(key)

package/internal/src/get-state/get-from-store.ts

@@ -6,7 +6,7 @@ import type {
 	ReadableFamilyToken,
 	ReadableToken,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import { findInStore, seekInStore } from "../families"
 import { NotFoundError } from "../not-found-error"
@@ -21,7 +21,7 @@ export function getFromStore<M extends MoleculeConstructor>(
 	store: Store,
 ): InstanceType<M> | undefined
 
-export function getFromStore<T, K extends Json.Serializable>(
+export function getFromStore<T, K extends Canonical>(
 	token: ReadableFamilyToken<T, K>,
 	key: K,
 	store: Store,
@@ -37,7 +37,7 @@ export function getFromStore<T>(
 	...params:
 		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>, store: Store]
 		| [token: MoleculeToken<any>, store: Store]
-		| [token: ReadableFamilyToken<T, any>, key: Json.Serializable, store: Store]
+		| [token: ReadableFamilyToken<T, any>, key: Canonical, store: Store]
 		| [token: ReadableToken<T>, store: Store]
 ): any {
 	let token: MoleculeToken<any> | ReadableToken<T>

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

@@ -16,7 +16,7 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import { initFamilyMemberInStore } from "../families"
 import type { Transceiver } from "../mutable"
@@ -27,43 +27,43 @@ import type { Molecule } from "./molecule-internal"
 export function growMoleculeInStore<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 >(
 	molecule: Molecule<any>,
 	family: MutableAtomFamily<T, J, K>,
 	store: Store,
 ): MutableAtomToken<T, J>
-export function growMoleculeInStore<T, K extends Json.Serializable>(
+export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
 	family: RegularAtomFamily<T, K>,
 	store: Store,
 ): RegularAtomToken<T>
-export function growMoleculeInStore<T, K extends Json.Serializable>(
+export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
 	family: AtomFamily<T, K>,
 	store: Store,
 ): AtomToken<T>
-export function growMoleculeInStore<T, K extends Json.Serializable>(
+export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
 	family: WritableSelectorFamily<T, K>,
 	store: Store,
 ): WritableSelectorToken<T>
-export function growMoleculeInStore<T, K extends Json.Serializable>(
+export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
 	family: ReadonlySelectorFamily<T, K>,
 	store: Store,
 ): ReadonlySelectorToken<T>
-export function growMoleculeInStore<T, K extends Json.Serializable>(
+export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
 	family: SelectorFamily<T, K>,
 	store: Store,
 ): SelectorToken<T>
-export function growMoleculeInStore<T, K extends Json.Serializable>(
+export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
 	family: WritableFamily<T, K>,
 	store: Store,
 ): WritableToken<T>
-export function growMoleculeInStore<T, K extends Json.Serializable>(
+export function growMoleculeInStore<T, K extends Canonical>(
 	molecule: Molecule<any>,
 	family: ReadableFamily<T, K>,
 	store: Store,

package/internal/src/mutable/index.ts

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

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

@@ -1,5 +1,5 @@
 import type { MutableAtomFamily, RegularAtomFamily } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
 import { createRegularAtomFamily, seekInStore } from "../families"
@@ -9,7 +9,7 @@ import type { Transceiver } from "./transceiver"
 
 export class FamilyTracker<
 	Core extends Transceiver<any>,
-	FamilyMemberKey extends Json.Serializable,
+	FamilyMemberKey extends Canonical,
 > {
 	private readonly Update: Core extends Transceiver<infer Signal>
 		? Signal

package/internal/src/set-state/set-into-store.ts

@@ -1,5 +1,5 @@
 import type { WritableFamilyToken, WritableToken } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import { findInStore, seekInStore } from "../families"
 import { NotFoundError } from "../not-found-error"
@@ -14,7 +14,7 @@ export function setIntoStore<T, New extends T>(
 	store: Store,
 ): void
 
-export function setIntoStore<T, K extends Json.Serializable, New extends T>(
+export function setIntoStore<T, K extends Canonical, New extends T>(
 	token: WritableFamilyToken<T, K>,
 	key: K,
 	value: New | ((oldValue: T) => New),
@@ -24,8 +24,8 @@ export function setIntoStore<T, K extends Json.Serializable, New extends T>(
 export function setIntoStore<T, New extends T>(
 	...params:
 		| [
-				token: WritableFamilyToken<T, Json.Serializable>,
-				key: Json.Serializable,
+				token: WritableFamilyToken<T, Canonical>,
+				key: Canonical,
 				value: New | ((oldValue: T) => New),
 				store: Store,
 		  ]

package/internal/src/store/deposit.ts

@@ -12,7 +12,7 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type {
 	Atom,
@@ -39,12 +39,12 @@ export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
 export function deposit<T>(state: Selector<T>): SelectorToken<T>
 export function deposit<T>(state: WritableState<T>): WritableToken<T>
 export function deposit<
-	K extends Json.Serializable,
+	K extends Canonical,
 	S extends { [key: string]: any },
 	P extends any[],
 >(state: Molecule<any>): MoleculeToken<any>
 export function deposit<
-	K extends Json.Serializable,
+	K extends Canonical,
 	S extends { [key: string]: any },
 	P extends any[],
 >(state: MoleculeFamily<any>): MoleculeFamilyToken<any>

package/internal/src/store/withdraw.ts

@@ -31,7 +31,8 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import { type Json, stringifyJson } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
 
 import type {
 	Atom,
@@ -100,39 +101,39 @@ export function withdraw<T>(
 	store: Store,
 ): ReadableState<T>
 
-export function withdraw<T, K extends Json.Serializable>(
+export function withdraw<T, K extends Canonical>(
 	token: RegularAtomFamilyToken<T, K>,
 	store: Store,
 ): RegularAtomFamily<T, K>
 export function withdraw<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 >(
 	token: MutableAtomFamilyToken<T, J, K>,
 	store: Store,
 ): MutableAtomFamily<T, J, K>
-export function withdraw<T, K extends Json.Serializable>(
+export function withdraw<T, K extends Canonical>(
 	token: AtomFamilyToken<T>,
 	store: Store,
 ): AtomFamily<T, any>
-export function withdraw<T, K extends Json.Serializable>(
+export function withdraw<T, K extends Canonical>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	store: Store,
 ): ReadonlySelectorFamily<T, any>
-export function withdraw<T, K extends Json.Serializable>(
+export function withdraw<T, K extends Canonical>(
 	token: WritableSelectorFamilyToken<T, K>,
 	store: Store,
 ): WritableSelectorFamily<T, any>
-export function withdraw<T, K extends Json.Serializable>(
+export function withdraw<T, K extends Canonical>(
 	token: SelectorFamilyToken<T, K>,
 	store: Store,
 ): SelectorFamily<T, any>
-export function withdraw<T, K extends Json.Serializable>(
+export function withdraw<T, K extends Canonical>(
 	token: ReadableFamilyToken<T, K>,
 	store: Store,
 ): ReadableFamily<T, any>
-export function withdraw<T, K extends Json.Serializable>(
+export function withdraw<T, K extends Canonical>(
 	token: WritableFamilyToken<T, K>,
 	store: Store,
 ): WritableFamily<T, any>

package/json/dist/index.d.ts

@@ -1,23 +1,12 @@
 import * as AtomIO from 'atom.io';
 import { Store, Transceiver } from 'atom.io/internal';
 
-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 Serializable>(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 Serializable>(atomFamily: AtomIO.RegularAtomFamily<T, K>, transform: JsonInterface<T, J>, store: Store): AtomIO.WritableSelectorFamily<J, K>;
-
 type JsonInterface<T, J extends Serializable = Serializable> = {
     toJson: (t: T) => J;
     fromJson: (json: J) => T;
 };
-declare const stringSetJsonInterface: JsonInterface<Set<string>, Array<string>>;
 
 type primitive = boolean | number | string | null;
-declare const isString: (input: unknown) => input is string;
-declare const isNumber: (input: unknown) => input is number;
-declare const isBoolean: (input: unknown) => input is boolean;
-declare const isNull: (input: unknown) => input is null;
-declare const isPrimitive: (input: unknown) => input is primitive;
 
 type Serializable = primitive | Readonly<{
     [key: string]: Serializable;
@@ -31,24 +20,18 @@ 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 & {
+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 Empty = Record<string, never>;
-declare const JSON_TYPE_NAMES: readonly ["array", "boolean", "null", "number", "object", "string"];
-type JsonTypeName = (typeof JSON_TYPE_NAMES)[number];
-interface JsonTypes extends Record<JsonTypeName, Serializable> {
-    array: Array;
-    boolean: boolean;
-    null: null;
-    number: number;
-    object: Object$1;
-    string: string;
-}
-declare const JSON_DEFAULTS: JsonTypes;
+declare const stringifyJson: <J extends Serializable>(json: J) => stringified<J>;
+
+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>;
 
+type Canonical = primitive | ReadonlyArray<Canonical>;
 type JsonIO = (...params: Serializable[]) => Serializable | void;
 
-export { type Empty, JSON_DEFAULTS, JSON_TYPE_NAMES, json as Json, type JsonIO, type JsonInterface, type JsonTypeName, type JsonTypes, type Stringified, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, type primitive, selectJson, selectJsonFamily, stringSetJsonInterface, stringifyJson };
+export { type Canonical, json as Json, type JsonIO, type JsonInterface, parseJson, type primitive, selectJson, selectJsonFamily, type stringified, stringifyJson };

package/json/dist/index.js

@@ -1,5 +1,5 @@
-import { stringifyJson, parseJson } from '../../dist/chunk-BF4MVQF6.js';
-export { JSON_DEFAULTS, JSON_TYPE_NAMES, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, stringSetJsonInterface, stringifyJson } from '../../dist/chunk-BF4MVQF6.js';
+import { stringifyJson, parseJson } from '../../dist/chunk-AK23DRMD.js';
+export { parseJson, stringifyJson } from '../../dist/chunk-AK23DRMD.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import { createStandaloneSelector, IMPLICIT, createSelectorFamily, growMoleculeInStore, initFamilyMemberInStore, seekInStore } from 'atom.io/internal';
 

package/json/src/index.ts

@@ -1,8 +1,13 @@
+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 "./select-json"
 export * from "./select-json-family"
-export * from "~/packages/anvl/src/json"
-export * from "~/packages/anvl/src/primitive"
 
-import type { Json } from "~/packages/anvl/src/json"
+export type { Json, JsonInterface, primitive, stringified }
+export { parseJson, stringifyJson }
+
+export type Canonical = primitive | ReadonlyArray<Canonical>
 
 export type JsonIO = (...params: Json.Serializable[]) => Json.Serializable | void

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

@@ -8,13 +8,13 @@ import {
 	seekInStore,
 } from "atom.io/internal"
 
-import type { Json, JsonInterface } from "."
+import type { Canonical, Json, JsonInterface } from "."
 import { parseJson, stringifyJson } from "."
 
 export function selectJsonFamily<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 >(
 	atomFamily: AtomIO.MutableAtomFamily<T, J, K>,
 	transform: JsonInterface<T, J>,
@@ -23,7 +23,7 @@ export function selectJsonFamily<
 export function selectJsonFamily<
 	T,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 >(
 	atomFamily: AtomIO.RegularAtomFamily<T, K>,
 	transform: JsonInterface<T, J>,
@@ -32,7 +32,7 @@ export function selectJsonFamily<
 export function selectJsonFamily<
 	T,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 >(
 	family:
 		| AtomIO.MutableAtomFamily<T extends Transceiver<any> ? T : never, J, K>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -19,6 +19,7 @@
     "@floating-ui/react": ">=0.25.0",
     "@floating-ui/react-dom": ">=2.0.0",
     "@testing-library/react": ">=14.0.0",
+    "eslint": ">=9.0.0",
     "framer-motion": ">=10.0.0",
     "react": ">=18.0.0",
     "socket.io": ">=4.0.0",
@@ -37,6 +38,9 @@
     "@floating-ui/react-dom": {
       "optional": true
     },
+    "eslint": {
+      "optional": true
+    },
     "framer-motion": {
       "optional": true
     },
@@ -49,23 +53,21 @@
   },
   "devDependencies": {
     "@testing-library/react": "16.0.0",
-    "@types/eslint": "npm:@types/eslint@9.6.0",
-    "@types/eslint-v9": "npm:@types/eslint@9.6.0",
+    "@types/eslint": "9.6.0",
     "@types/estree": "1.0.5",
-    "@types/http-proxy": "1.17.14",
+    "@types/http-proxy": "1.17.15",
     "@types/npmlog": "7.0.0",
     "@types/react": "18.3.3",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.0.0",
-    "@typescript-eslint/rule-tester": "8.0.0",
+    "@typescript-eslint/parser": "8.0.1",
+    "@typescript-eslint/rule-tester": "8.0.1",
     "@vitest/coverage-v8": "2.0.5",
     "@vitest/ui": "2.0.5",
     "concurrently": "8.2.2",
-    "drizzle-kit": "0.23.1",
-    "drizzle-orm": "0.32.1",
-    "eslint": "npm:eslint@8.57.0",
-    "eslint-v9": "npm:eslint@9.8.0",
-    "framer-motion": "11.3.19",
+    "drizzle-kit": "0.24.0",
+    "drizzle-orm": "0.33.0",
+    "eslint": "9.9.0",
+    "framer-motion": "11.3.24",
     "happy-dom": "14.12.3",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
@@ -73,15 +75,15 @@
     "preact": "10.23.1",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "react-router-dom": "6.25.1",
+    "react-router-dom": "6.26.0",
     "socket.io": "4.7.5",
     "socket.io-client": "4.7.5",
     "tmp": "0.2.3",
-    "tsup": "8.2.3",
-    "tsx": "4.16.4",
+    "tsup": "8.2.4",
+    "tsx": "4.17.0",
     "typescript": "5.5.4",
-    "vite": "5.3.5",
-    "vite-tsconfig-paths": "4.3.2",
+    "vite": "5.4.0",
+    "vite-tsconfig-paths": "5.0.1",
     "vitest": "2.0.5"
   },
   "main": "dist/index.js",
@@ -239,9 +241,10 @@
     "build:realtime-testing": "cd realtime-testing && tsup",
     "build:transceivers:set-rtx": "cd transceivers/set-rtx && tsup",
     "lint:biome": "biome check -- .",
-    "lint:eslint": "eslint .",
+    "lint:eslint": "eslint --flag unstable_ts_config -- .",
     "lint:eslint:build": "bun run build:main",
     "lint:types": "tsc --noEmit",
+    "lint:types:watch": "tsc --watch --noEmit",
     "lint": "bun run lint:biome && bun run lint:eslint && bun run lint:types",
     "test": "vitest",
     "test:coverage": "vitest run --coverage",

package/react/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Store } from 'atom.io/internal';
 import * as React from 'react';
 import { WritableToken, WritableFamilyToken, MutableAtomToken, MutableAtomFamilyToken, ReadableToken, ReadableFamilyToken, TimelineToken } from 'atom.io';
-import { Json } from 'atom.io/json';
+import { Canonical, Json } from 'atom.io/json';
 
 declare const StoreContext: React.Context<Store>;
 declare const StoreProvider: React.FC<{
@@ -10,13 +10,13 @@ declare const StoreProvider: React.FC<{
 }>;
 
 declare function useI<T>(token: WritableToken<T>): <New extends T>(next: New | ((old: T) => New)) => void;
-declare function useI<T, K extends Json.Serializable>(token: WritableFamilyToken<T, K>, key: K): <New extends T>(next: New | ((old: T) => New)) => void;
+declare function useI<T, K extends Canonical>(token: WritableFamilyToken<T, K>, key: K): <New extends T>(next: New | ((old: T) => New)) => void;
 
 declare function useJSON<Serializable extends Json.Serializable>(token: MutableAtomToken<any, Serializable>): Serializable;
-declare function useJSON<Serializable extends Json.Serializable, Key extends Json.Serializable>(token: MutableAtomFamilyToken<any, Serializable, Key>, key: Key): Serializable;
+declare function useJSON<Serializable extends Json.Serializable, Key extends Canonical>(token: MutableAtomFamilyToken<any, Serializable, Key>, key: Key): Serializable;
 
 declare function useO<T>(token: ReadableToken<T>): T;
-declare function useO<T, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>, key: K): T;
+declare function useO<T, K extends Canonical>(token: ReadableFamilyToken<T, K>, key: K): T;
 
 type TimelineMeta = {
     at: number;

package/react/src/parse-state-overloads.ts

@@ -6,19 +6,19 @@ import type {
 } from "atom.io"
 import type { Store } from "atom.io/internal"
 import { findInStore, NotFoundError, seekInStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
-export function parseStateOverloads<T, K extends Json.Serializable>(
+export function parseStateOverloads<T, K extends Canonical>(
 	store: Store,
 	...rest: [WritableFamilyToken<T, K>, K] | [WritableToken<T>]
 ): WritableToken<T>
 
-export function parseStateOverloads<T, K extends Json.Serializable>(
+export function parseStateOverloads<T, K extends Canonical>(
 	store: Store,
 	...rest: [ReadableFamilyToken<T, K>, K] | [ReadableToken<T>]
 ): ReadableToken<T>
 
-export function parseStateOverloads<T, K extends Json.Serializable>(
+export function parseStateOverloads<T, K extends Canonical>(
 	store: Store,
 	...rest: [ReadableFamilyToken<T, K>, K] | [ReadableToken<T>]
 ): ReadableToken<T> {

package/react/src/use-i.ts

@@ -1,6 +1,6 @@
 import type { WritableFamilyToken, WritableToken } from "atom.io"
 import { setIntoStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import * as React from "react"
 
 import { parseStateOverloads } from "./parse-state-overloads"
@@ -10,12 +10,12 @@ export function useI<T>(
 	token: WritableToken<T>,
 ): <New extends T>(next: New | ((old: T) => New)) => void
 
-export function useI<T, K extends Json.Serializable>(
+export function useI<T, K extends Canonical>(
 	token: WritableFamilyToken<T, K>,
 	key: K,
 ): <New extends T>(next: New | ((old: T) => New)) => void
 
-export function useI<T, K extends Json.Serializable>(
+export function useI<T, K extends Canonical>(
 	...params: [WritableFamilyToken<T, K>, K] | [WritableToken<T>]
 ): <New extends T>(next: New | ((old: T) => New)) => void {
 	const store = React.useContext(StoreContext)

package/react/src/use-json.ts

@@ -4,7 +4,7 @@ import type {
 	ReadableToken,
 } from "atom.io"
 import { findInStore, getJsonToken } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 import * as React from "react"
 
 import { StoreContext } from "./store-context"
@@ -16,12 +16,12 @@ export function useJSON<Serializable extends Json.Serializable>(
 
 export function useJSON<
 	Serializable extends Json.Serializable,
-	Key extends Json.Serializable,
+	Key extends Canonical,
 >(token: MutableAtomFamilyToken<any, Serializable, Key>, key: Key): Serializable
 
 export function useJSON<
 	Serializable extends Json.Serializable,
-	Key extends Serializable,
+	Key extends Canonical,
 >(
 	token:
 		| MutableAtomFamilyToken<any, Serializable, Key>

package/react/src/use-o.ts

@@ -1,6 +1,6 @@
 import type { ReadableFamilyToken, ReadableToken } from "atom.io"
 import { getFromStore, subscribeToState } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import * as React from "react"
 
 import { parseStateOverloads } from "./parse-state-overloads"
@@ -8,12 +8,12 @@ import { StoreContext } from "./store-context"
 
 export function useO<T>(token: ReadableToken<T>): T
 
-export function useO<T, K extends Json.Serializable>(
+export function useO<T, K extends Canonical>(
 	token: ReadableFamilyToken<T, K>,
 	key: K,
 ): T
 
-export function useO<T, K extends Json.Serializable>(
+export function useO<T, K extends Canonical>(
 	...params: [ReadableFamilyToken<T, K>, K] | [ReadableToken<T>]
 ): T {
 	const store = React.useContext(StoreContext)

package/react-devtools/dist/index.d.ts

@@ -69,7 +69,7 @@ declare const devtoolsAreOpenState: atom_io.RegularAtomToken<boolean>;
 type DevtoolsView = `atoms` | `selectors` | `timelines` | `transactions`;
 declare const devtoolsViewSelectionState: atom_io.RegularAtomToken<DevtoolsView>;
 declare const devtoolsViewOptionsState: atom_io.RegularAtomToken<DevtoolsView[]>;
-declare const findViewIsOpenState: atom_io.RegularAtomFamilyTokenWithCall<boolean, string>;
+declare const findViewIsOpenState: atom_io.RegularAtomFamilyToken<boolean, string>;
 declare const primitiveRefinery: Refinery<{
     number: (input: unknown) => input is number;
     string: (input: unknown) => input is string;