atom.io 0.26.0 → 0.27.1

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;

package/react-devtools/dist/index.js

@@ -1,6 +1,6 @@
 import { lazyLocalStorageEffect } from '../../dist/chunk-H6EDLPKH.js';
 import { pipe, ifDefined, isArray, isRecord, doesExtend, isPlainObject, raiseError, sprawl, fallback, doNothing, become, mapObject, delve } from '../../dist/chunk-IW6WYRS7.js';
-import { JSON_TYPE_NAMES, isString, isNumber, isBoolean, stringifyJson, JSON_DEFAULTS } from '../../dist/chunk-BF4MVQF6.js';
+import { JSON_TYPE_NAMES, stringifyJson, JSON_DEFAULTS } from '../../dist/chunk-AK23DRMD.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import { selectorFamily, atom, atomFamily, undo, redo, getState } from 'atom.io';
 import { attachIntrospectionStates } from 'atom.io/introspection';
@@ -61,6 +61,17 @@ var mustSatisfyOneOfTheFollowing = (isTypeA, logging = false, refinements = [isT
 };
 var isUnion = mustSatisfyOneOfTheFollowing(cannotExist);
 
+// ../anvl/src/primitive/index.ts
+var isString = (input) => {
+  return typeof input === `string`;
+};
+var isNumber = (input) => {
+  return typeof input === `number`;
+};
+var isBoolean = (input) => {
+  return typeof input === `boolean`;
+};
+
 // ../anvl/src/refinement/refine-json.ts
 var JSON_PROTOTYPES = [
   `Array`,
@@ -1496,7 +1507,7 @@ var StateIndexTreeNode = ({ node, isOpenState }) => {
   const isOpen = useO(isOpenState);
   for (const [key, childNode] of node.familyMembers) {
     findState(findViewIsOpenState, key);
-    findState(findStateTypeState, childNode);
+    findState(findStateTypeState, childNode.key);
   }
   return /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsxs("header", { children: [
@@ -1518,7 +1529,7 @@ var StateIndexTreeNode = ({ node, isOpenState }) => {
       {
         node: childNode,
         isOpenState: findState(findViewIsOpenState, childNode.key),
-        typeState: findState(findStateTypeState, childNode)
+        typeState: findState(findStateTypeState, childNode.key)
       },
       key
     )) : null
@@ -1542,7 +1553,7 @@ var StateIndex = ({ tokenIndex }) => {
       {
         node,
         isOpenState: findState(findViewIsOpenState, node.key),
-        typeState: findState(findStateTypeState, node)
+        typeState: findState(findStateTypeState, node.key)
       },
       key
     );

package/react-devtools/src/StateIndex.tsx

@@ -6,6 +6,7 @@ import type {
 import { getState, selectorFamily } from "atom.io"
 import { findState } from "atom.io/ephemeral"
 import type { FamilyNode, WritableTokenIndex } from "atom.io/introspection"
+import type { Canonical } from "atom.io/json"
 import { useI, useO } from "atom.io/react"
 import type { FC } from "react"
 
@@ -15,7 +16,7 @@ import { findViewIsOpenState, primitiveRefinery } from "."
 import { button } from "./Button"
 import { StoreEditor } from "./StateEditor"
 
-const findStateTypeState = selectorFamily<string, { key: string }>({
+const findStateTypeState = selectorFamily<string, Canonical>({
 	key: `👁‍🗨 State Type`,
 	get:
 		(token) =>
@@ -83,7 +84,7 @@ export const StateIndexTreeNode: FC<{
 	const isOpen = useO(isOpenState)
 	for (const [key, childNode] of node.familyMembers) {
 		findState(findViewIsOpenState, key)
-		findState(findStateTypeState, childNode)
+		findState(findStateTypeState, childNode.key)
 	}
 	return (
 		<>
@@ -104,7 +105,7 @@ export const StateIndexTreeNode: FC<{
 							key={key}
 							node={childNode}
 							isOpenState={findState(findViewIsOpenState, childNode.key)}
-							typeState={findState(findStateTypeState, childNode)}
+							typeState={findState(findStateTypeState, childNode.key)}
 						/>
 					))
 				: null}
@@ -147,7 +148,7 @@ export const StateIndex: FC<{
 							key={key}
 							node={node}
 							isOpenState={findState(findViewIsOpenState, node.key)}
-							typeState={findState(findStateTypeState, node)}
+							typeState={findState(findStateTypeState, node.key)}
 						/>
 					)
 				})}

package/realtime/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as atom_io from 'atom.io';
 import { AtomFamilyToken, ReadableFamilyToken, ReadableToken, AtomToken, TransactionToken, MutableAtomToken } from 'atom.io';
-import { Json } from 'atom.io/json';
+import { Canonical, Json } from 'atom.io/json';
 import * as atom_io_data from 'atom.io/data';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
@@ -18,7 +18,7 @@ type ContinuityToken = {
     readonly key: string;
     readonly globals: AtomToken<any>[];
     readonly actions: TransactionToken<any>[];
-    readonly perspectives: PerspectiveToken<AtomFamilyToken<any, Json.Serializable>, Json.Serializable>[];
+    readonly perspectives: PerspectiveToken<AtomFamilyToken<any, Canonical>, Json.Serializable>[];
 };
 declare class SyncGroup {
     protected readonly key: string;
@@ -46,6 +46,6 @@ type UserInRoomMeta = {
 };
 declare const DEFAULT_USER_IN_ROOM_META: UserInRoomMeta;
 declare const usersInRooms: atom_io_data.JoinToken<"room", "user", "1:n", UserInRoomMeta>;
-declare const usersInMyRoomView: atom_io.ReadonlySelectorFamilyTokenWithCall<MutableAtomToken<SetRTX<string>, SetRTXJson<string>>[], string>;
+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/src/realtime-continuity.ts

@@ -11,7 +11,7 @@ import {
 	IMPLICIT,
 	setEpochNumberOfContinuity,
 } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 export class InvariantMap<K, V> extends Map<K, V> {
 	public set(key: K, value: V): this {
@@ -45,7 +45,7 @@ export type ContinuityToken = {
 	readonly globals: AtomToken<any>[]
 	readonly actions: TransactionToken<any>[]
 	readonly perspectives: PerspectiveToken<
-		AtomFamilyToken<any, Json.Serializable>,
+		AtomFamilyToken<any, Canonical>,
 		Json.Serializable
 	>[]
 }

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

@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { Socket } from 'socket.io-client';
 import * as AtomIO from 'atom.io';
-import { Json } from 'atom.io/json';
+import { Json, Canonical } from 'atom.io/json';
 import { Transceiver, Func } from 'atom.io/internal';
 import { ContinuityToken } from 'atom.io/realtime';
 
@@ -20,15 +20,15 @@ declare const RealtimeProvider: React.FC<{
 
 declare function usePullAtom<J extends Json.Serializable>(token: AtomIO.RegularAtomToken<J>): J;
 
-declare function usePullAtomFamilyMember<J extends Json.Serializable, K extends Json.Serializable, Key extends K>(family: AtomIO.RegularAtomFamilyToken<J, K>, subKey: Key): J;
+declare function usePullAtomFamilyMember<J extends Json.Serializable, K extends Canonical, Key extends K>(family: AtomIO.RegularAtomFamilyToken<J, K>, subKey: Key): J;
 
 declare function usePullMutable<T extends Transceiver<any>, J extends Json.Serializable>(token: AtomIO.MutableAtomToken<T, J>): T;
 
-declare function usePullMutableAtomFamilyMember<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(familyToken: AtomIO.MutableAtomFamilyToken<T, J, K>, key: Key): T;
+declare function usePullMutableAtomFamilyMember<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(familyToken: AtomIO.MutableAtomFamilyToken<T, J, K>, key: Key): T;
 
 declare function usePullSelector<J extends Json.Serializable>(token: AtomIO.SelectorToken<J>): J;
 
-declare function usePullSelectorFamilyMember<T, K extends Json.Serializable, Key extends K>(familyToken: AtomIO.SelectorFamilyToken<T, K>, key: Key): T;
+declare function usePullSelectorFamilyMember<T, K extends Canonical, Key extends K>(familyToken: AtomIO.SelectorFamilyToken<T, K>, key: Key): T;
 
 declare function usePush<J extends Json.Serializable>(token: AtomIO.WritableToken<J>): <New extends J>(next: New | ((old: J) => New)) => void;
 

package/realtime-react/src/use-pull-atom-family-member.ts

@@ -1,6 +1,6 @@
 import type * as AtomIO from "atom.io"
 import { findInStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 import { StoreContext, useO } from "atom.io/react"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
@@ -9,7 +9,7 @@ import { useRealtimeService } from "./use-realtime-service"
 
 export function usePullAtomFamilyMember<
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 	Key extends K,
 >(family: AtomIO.RegularAtomFamilyToken<J, K>, subKey: Key): J {
 	const store = React.useContext(StoreContext)

package/realtime-react/src/use-pull-mutable-family-member.ts

@@ -1,7 +1,7 @@
 import type * as AtomIO from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import { findInStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 import { StoreContext, useO } from "atom.io/react"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
@@ -11,7 +11,7 @@ import { useRealtimeService } from "./use-realtime-service"
 export function usePullMutableAtomFamilyMember<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 	Key extends K,
 >(familyToken: AtomIO.MutableAtomFamilyToken<T, J, K>, key: Key): T {
 	const store = React.useContext(StoreContext)

package/realtime-react/src/use-pull-selector-family-member.ts

@@ -1,6 +1,6 @@
 import type * as AtomIO from "atom.io"
 import { findInStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { StoreContext, useO } from "atom.io/react"
 import * as RTC from "atom.io/realtime-client"
 import * as React from "react"
@@ -9,7 +9,7 @@ import { useRealtimeService } from "./use-realtime-service"
 
 export function usePullSelectorFamilyMember<
 	T,
-	K extends Json.Serializable,
+	K extends Canonical,
 	Key extends K,
 >(familyToken: AtomIO.SelectorFamilyToken<T, K>, key: Key): T {
 	const store = React.useContext(StoreContext)

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

@@ -1,5 +1,5 @@
 import { Subject, Transceiver, Store } from 'atom.io/internal';
-import { Json, Stringified, JsonIO } from 'atom.io/json';
+import { Json, stringified, JsonIO, Canonical } from 'atom.io/json';
 import { ChildProcessWithoutNullStreams } from 'node:child_process';
 import * as AtomIO from 'atom.io';
 import { TransactionUpdateContent, TransactionUpdate, WritableToken } from 'atom.io';
@@ -9,7 +9,7 @@ import { Loadable } from 'atom.io/data';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
 type Events = Json.Object<string, Json.Serializable[]>;
-type StringifiedEvent<Key extends string, Params extends Json.Serializable[]> = Stringified<[Key, ...Params]>;
+type StringifiedEvent<Key extends string, Params extends Json.Serializable[]> = stringified<[Key, ...Params]>;
 interface EventBuffer<Key extends string, Params extends Json.Serializable[]> extends Buffer {
     toString(): StringifiedEvent<Key, Params>;
 }
@@ -88,10 +88,10 @@ type RealtimeContinuitySynchronizer = ReturnType<typeof realtimeContinuitySynchr
 declare function realtimeContinuitySynchronizer({ socket: initialSocket, store, }: ServerConfig): (continuity: ContinuityToken) => () => void;
 
 type FamilyProvider = ReturnType<typeof realtimeAtomFamilyProvider>;
-declare function realtimeAtomFamilyProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable, K extends Json.Serializable>(family: AtomIO.RegularAtomFamilyToken<J, K>, index: AtomIO.ReadableToken<Iterable<K>>) => () => void;
+declare function realtimeAtomFamilyProvider({ socket, store, }: ServerConfig): <J extends Json.Serializable, K extends Canonical>(family: AtomIO.RegularAtomFamilyToken<J, K>, index: AtomIO.ReadableToken<Iterable<K>>) => () => void;
 
 type MutableFamilyProvider = ReturnType<typeof realtimeMutableFamilyProvider>;
-declare function realtimeMutableFamilyProvider({ socket, store, }: ServerConfig): <T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(family: AtomIO.MutableAtomFamilyToken<T, J, K>, index: AtomIO.ReadableToken<Iterable<K>>) => () => void;
+declare function realtimeMutableFamilyProvider({ socket, store, }: ServerConfig): <T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(family: AtomIO.MutableAtomFamilyToken<T, J, K>, index: AtomIO.ReadableToken<Iterable<K>>) => () => void;
 
 type MutableProvider = ReturnType<typeof realtimeMutableProvider>;
 declare function realtimeMutableProvider({ socket, store, }: ServerConfig): <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable>(token: AtomIO.MutableAtomToken<Core, SerializableCore>) => () => void;
@@ -105,16 +105,16 @@ type LeaveRoomIO = AtomIO.TransactionIO<typeof leaveRoomTX>;
 declare const destroyRoomTX: AtomIO.TransactionToken<(roomId: string) => void>;
 
 type RoomArguments = [script: string, options: string[]] | [script: string];
-declare const roomArgumentsAtoms: AtomIO.RegularAtomFamilyTokenWithCall<RoomArguments, string>;
-declare const roomSelectors: AtomIO.ReadonlySelectorFamilyTokenWithCall<Loadable<ChildSocket<any, any>>, string>;
+declare const roomArgumentsAtoms: AtomIO.RegularAtomFamilyToken<RoomArguments, string>;
+declare const roomSelectors: AtomIO.ReadonlySelectorFamilyToken<Loadable<ChildSocket<any, any>>, string>;
 
 declare function redactTransactionUpdateContent(visibleStateKeys: string[], updates: TransactionUpdateContent[]): TransactionUpdateContent[];
-declare const actionOcclusionAtoms: AtomIO.RegularAtomFamilyTokenWithCall<{
+declare const actionOcclusionAtoms: AtomIO.RegularAtomFamilyToken<{
     occlude: (updates: TransactionUpdateContent[]) => TransactionUpdateContent[];
 }, string>;
-declare const userUnacknowledgedQueues: AtomIO.RegularAtomFamilyTokenWithCall<Pick<TransactionUpdate<any>, "key" | "id" | "epoch" | "updates" | "output">[], string>;
+declare const userUnacknowledgedQueues: AtomIO.RegularAtomFamilyToken<Pick<TransactionUpdate<any>, "key" | "id" | "epoch" | "updates" | "output">[], string>;
 
-declare const socketAtoms: AtomIO.RegularAtomFamilyTokenWithCall<Socket | null, string>;
+declare const socketAtoms: AtomIO.RegularAtomFamilyToken<Socket | null, string>;
 declare const socketIndex: AtomIO.MutableAtomToken<SetRTX<string>, SetRTXJson<string>>;
 declare const userIndex: AtomIO.MutableAtomToken<SetRTX<string>, SetRTXJson<string>>;
 declare const usersOfSockets: atom_io_data.JoinToken<"user", "socket", "1:1", null>;

package/realtime-server/src/ipc-sockets/custom-socket.ts

@@ -1,4 +1,4 @@
-import type { Json, Stringified } from "atom.io/json"
+import type { Json, stringified } from "atom.io/json"
 
 import type { Socket } from ".."
 
@@ -7,7 +7,7 @@ export type Events = Json.Object<string, Json.Serializable[]>
 export type StringifiedEvent<
 	Key extends string,
 	Params extends Json.Serializable[],
-> = Stringified<[Key, ...Params]>
+> = stringified<[Key, ...Params]>
 
 export interface EventBuffer<
 	Key extends string,

package/realtime-server/src/realtime-family-provider.ts

@@ -5,7 +5,8 @@ import {
 	IMPLICIT,
 	subscribeToState,
 } from "atom.io/internal"
-import { type Json, stringifyJson } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
 
 import type { ServerConfig } from "."
 
@@ -16,7 +17,7 @@ export function realtimeAtomFamilyProvider({
 }: ServerConfig) {
 	return function familyProvider<
 		J extends Json.Serializable,
-		K extends Json.Serializable,
+		K extends Canonical,
 	>(
 		family: AtomIO.RegularAtomFamilyToken<J, K>,
 		index: AtomIO.ReadableToken<Iterable<K>>,

package/realtime-server/src/realtime-mutable-family-provider.ts

@@ -8,7 +8,7 @@ import {
 	IMPLICIT,
 	subscribeToState,
 } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import type { ServerConfig } from "."
@@ -23,7 +23,7 @@ export function realtimeMutableFamilyProvider({
 	return function mutableFamilyProvider<
 		T extends Transceiver<any>,
 		J extends Json.Serializable,
-		K extends Json.Serializable,
+		K extends Canonical,
 	>(
 		family: AtomIO.MutableAtomFamilyToken<T, J, K>,
 		index: AtomIO.ReadableToken<Iterable<K>>,

package/src/atom.ts

@@ -4,7 +4,7 @@ import {
 	createStandaloneAtom,
 	IMPLICIT,
 } from "atom.io/internal"
-import type { Json, JsonInterface } from "atom.io/json"
+import type { Canonical, Json, JsonInterface } from "atom.io/json"
 
 import type {
 	AtomToken,
@@ -62,31 +62,20 @@ export function atom(
 	return createStandaloneAtom(options, IMPLICIT.STORE)
 }
 
-export type RegularAtomFamilyOptions<T, K extends Json.Serializable> = {
+export type RegularAtomFamilyOptions<T, K extends Canonical> = {
 	key: string
 	default: T | ((key: K) => T)
 	effects?: (key: K) => AtomEffect<T>[]
 }
 
-export type RegularAtomFamilyToken<T, K extends Json.Serializable> = {
+export type RegularAtomFamilyToken<T, K extends Canonical> = {
 	key: string
 	type: `atom_family`
 	__T?: T
 	__K?: K
 }
 // biome-ignore format: intersection
-export type RegularAtomFamilyTokenWithCall<
-	T,
-	K extends Json.Serializable,
-> = 
-	& RegularAtomFamilyToken<T, K>
-	& {
-		/** @deprecated In ephemeral stores, prefer the `findState`, `findInStore`, or `find` functions. In immortal stores, prefer the `seekState`, `seekInStore`, or `seek` functions. */
-		/* eslint-disable-next-line @typescript-eslint/prefer-function-type */
-		(key: K): RegularAtomToken<T>
-	}
-// biome-ignore format: intersection
-export type RegularAtomFamily<T, K extends Json.Serializable> = 
+export type RegularAtomFamily<T, K extends Canonical> = 
 	& RegularAtomFamilyToken<T, K>
 	& {
 		(key: K): RegularAtomToken<T>
@@ -98,7 +87,7 @@ export type RegularAtomFamily<T, K extends Json.Serializable> =
 export type MutableAtomFamilyOptions<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 > = 
 	& JsonInterface<T, J>
 	& { 
@@ -111,7 +100,7 @@ export type MutableAtomFamilyOptions<
 export type MutableAtomFamilyToken<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 > = {
 	key: string
 	type: `mutable_atom_family`
@@ -120,22 +109,10 @@ export type MutableAtomFamilyToken<
 	__K?: K
 }
 // biome-ignore format: intersection
-export type MutableAtomFamilyTokenWithCall<
-	T extends Transceiver<any>,
-	J extends Json.Serializable,
-	K extends Json.Serializable,
-> = 
-	& MutableAtomFamilyToken<T, J, K>
-	& {
-		/** @deprecated In ephemeral stores, prefer the `findState`, `findInStore`, or `find` functions. In immortal stores, prefer the `seekState`, `seekInStore`, or `seek` functions. */
-		/* eslint-disable-next-line @typescript-eslint/prefer-function-type */	
-		(key: K): MutableAtomToken<T, J>
-	}
-// biome-ignore format: intersection
 export type MutableAtomFamily<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 > = 
 	& JsonInterface<T, J>
 	& MutableAtomFamilyToken<T, J, K>
@@ -145,29 +122,25 @@ export type MutableAtomFamily<
 			install: (store: Store) => void
 		}
 
-export type AtomFamily<T, K extends Json.Serializable = Json.Serializable> =
+export type AtomFamily<T, K extends Canonical = Canonical> =
 	| MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K>
 	| RegularAtomFamily<T, K>
-export type AtomFamilyToken<T, K extends Json.Serializable = Json.Serializable> =
+export type AtomFamilyToken<T, K extends Canonical = Canonical> =
 	| MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K>
 	| RegularAtomFamilyToken<T, K>
 
 export function atomFamily<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
->(
-	options: MutableAtomFamilyOptions<T, J, K>,
-): MutableAtomFamilyTokenWithCall<T, J, K>
-export function atomFamily<T, K extends Json.Serializable>(
+	K extends Canonical,
+>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>
+export function atomFamily<T, K extends Canonical>(
 	options: RegularAtomFamilyOptions<T, K>,
-): RegularAtomFamilyTokenWithCall<T, K>
-export function atomFamily<T, K extends Json.Serializable>(
+): RegularAtomFamilyToken<T, K>
+export function atomFamily<T, K extends Canonical>(
 	options:
 		| MutableAtomFamilyOptions<any, any, any>
 		| RegularAtomFamilyOptions<T, K>,
-):
-	| MutableAtomFamilyTokenWithCall<any, any, any>
-	| RegularAtomFamilyTokenWithCall<T, K> {
+): MutableAtomFamilyToken<any, any, any> | RegularAtomFamilyToken<T, K> {
 	return createAtomFamily(options, IMPLICIT.STORE)
 }

package/src/dispose-state.ts

@@ -1,5 +1,5 @@
 import * as Internal from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import type { ReadableFamilyToken, ReadableToken } from "."
 import type {
@@ -13,7 +13,7 @@ export function disposeState(
 	token: MoleculeToken<any> | ReadableToken<any>,
 ): void
 
-export function disposeState<K extends Json.Serializable>(
+export function disposeState<K extends Canonical>(
 	token: ReadableFamilyToken<any, K>,
 	key: K,
 ): void

package/src/get-state.ts

@@ -1,5 +1,5 @@
 import * as Internal from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type {
 	MoleculeConstructor,
@@ -15,14 +15,14 @@ export function getState<M extends MoleculeConstructor>(
 	token: MoleculeToken<M>,
 ): InstanceType<M>
 
-export function getState<T, K extends Json.Serializable>(
+export function getState<T, K extends Canonical>(
 	token: ReadableFamilyToken<T, K>,
 	key: K,
 ): T
 
 export function getState<M extends MoleculeConstructor>(
 	token: MoleculeFamilyToken<M>,
-	key: Json.Serializable,
+	key: Canonical,
 ): InstanceType<M>
 
 export function getState(
@@ -31,7 +31,7 @@ export function getState(
 		| MoleculeToken<any>
 		| ReadableFamilyToken<any, any>
 		| ReadableToken<any>,
-	key?: Json.Serializable,
+	key?: Canonical,
 ): any {
 	if (key) {
 		return Internal.getFromStore(

package/src/index.ts

@@ -1,5 +1,5 @@
 import type { Transceiver } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import type { AtomFamily, AtomFamilyToken } from "./atom"
 import type {
@@ -61,17 +61,17 @@ export type SelectorToken<T> =
 export type WritableToken<T> = AtomToken<T> | WritableSelectorToken<T>
 export type ReadableToken<T> = AtomToken<T> | SelectorToken<T>
 
-export type WritableFamily<T, K extends Json.Serializable> =
+export type WritableFamily<T, K extends Canonical> =
 	| AtomFamily<T, K>
 	| WritableSelectorFamily<T, K>
-export type ReadableFamily<T, K extends Json.Serializable> =
+export type ReadableFamily<T, K extends Canonical> =
 	| AtomFamily<T, K>
 	| SelectorFamily<T, K>
 
-export type WritableFamilyToken<T, K extends Json.Serializable> =
+export type WritableFamilyToken<T, K extends Canonical> =
 	| AtomFamilyToken<T, K>
 	| WritableSelectorFamilyToken<T, K>
-export type ReadableFamilyToken<T, K extends Json.Serializable> =
+export type ReadableFamilyToken<T, K extends Canonical> =
 	| AtomFamilyToken<T, K>
 	| SelectorFamilyToken<T, K>
 

package/src/molecule.ts

@@ -23,9 +23,10 @@ import {
 	makeMoleculeInStore,
 	Molecule,
 } from "atom.io/internal"
-import { type Json, stringifyJson } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
 
-export type CtorToolkit<K extends Json.Serializable> = Flat<
+export type CtorToolkit<K extends Canonical> = Flat<
 	Omit<ActorToolkit, `find`> & {
 		bond<T extends Transceiver<any>, J extends Json.Serializable>(
 			family: MutableAtomFamilyToken<T, J, K>,
@@ -53,7 +54,7 @@ export type CtorToolkit<K extends Json.Serializable> = Flat<
 
 		claim(below: MoleculeToken<any>, options: { exclusive: boolean }): void
 
-		spawn<Key extends Json.Serializable, Ctor extends MoleculeConstructor>(
+		spawn<Key extends Canonical, Ctor extends MoleculeConstructor>(
 			family: MoleculeFamilyToken<Ctor>,
 			key: Key,
 			...params: MoleculeParams<Ctor>