atom.io 0.25.6 → 0.27.0

package/internal/package.json

@@ -2,14 +2,11 @@
 	"name": "atom.io-internal",
 	"type": "module",
 	"private": true,
-	"main": "dist/index.cjs",
-	"module": "dist/index.js",
+	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"exports": {
 		".": {
 			"import": "./dist/index.js",
-			"browser": "./dist/index.js",
-			"require": "./dist/index.cjs",
 			"types": "./dist/index.d.ts"
 		}
 	}

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

@@ -4,7 +4,7 @@ import type {
 	RegularAtomFamily,
 	RegularAtomFamilyOptions,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import { createMutableAtomFamily, type Transceiver } from "../mutable"
 import type { Store } from "../store"
@@ -13,16 +13,16 @@ import { createRegularAtomFamily } from "./create-regular-atom-family"
 export function createAtomFamily<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 >(
 	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
 ): MutableAtomFamily<T, J, K>
-export function createAtomFamily<T, K extends Json.Serializable>(
+export function createAtomFamily<T, K extends Canonical>(
 	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
 ): RegularAtomFamily<T, K>
-export function createAtomFamily<T, K extends Json.Serializable>(
+export function createAtomFamily<T, K extends Canonical>(
 	options:
 		| MutableAtomFamilyOptions<any, any, any>
 		| RegularAtomFamilyOptions<T, K>,

package/internal/src/families/create-readonly-selector-family.ts

@@ -6,7 +6,7 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
@@ -14,7 +14,7 @@ import { createReadonlySelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 
-export function createReadonlySelectorFamily<T, K extends Json.Serializable>(
+export function createReadonlySelectorFamily<T, K extends Canonical>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
 ): ReadonlySelectorFamily<T, K> {

package/internal/src/families/create-regular-atom-family.ts

@@ -7,7 +7,7 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import { createRegularAtom } from "../atom"
@@ -15,7 +15,7 @@ import { newest } from "../lineage"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 
-export function createRegularAtomFamily<T, K extends Json.Serializable>(
+export function createRegularAtomFamily<T, K extends Canonical>(
 	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
 ): RegularAtomFamily<T, K> {

package/internal/src/families/create-selector-family.ts

@@ -4,21 +4,21 @@ import type {
 	WritableSelectorFamily,
 	WritableSelectorFamilyOptions,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 
 import type { Store } from "../store"
 import { createReadonlySelectorFamily } from "./create-readonly-selector-family"
 import { createWritableSelectorFamily } from "./create-writable-selector-family"
 
-export function createSelectorFamily<T, K extends Json.Serializable>(
+export function createSelectorFamily<T, K extends Canonical>(
 	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
 ): WritableSelectorFamily<T, K>
-export function createSelectorFamily<T, K extends Json.Serializable>(
+export function createSelectorFamily<T, K extends Canonical>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 	store: Store,
 ): ReadonlySelectorFamily<T, K>
-export function createSelectorFamily<T, K extends Json.Serializable>(
+export function createSelectorFamily<T, K extends Canonical>(
 	options:
 		| ReadonlySelectorFamilyOptions<T, K>
 		| WritableSelectorFamilyOptions<T, K>,

package/internal/src/families/create-writable-selector-family.ts

@@ -6,7 +6,7 @@ import type {
 	WritableSelectorFamilyOptions,
 	WritableSelectorToken,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
@@ -14,7 +14,7 @@ import { createWritableSelector } from "../selector"
 import type { Store } from "../store"
 import { Subject } from "../subject"
 
-export function createWritableSelectorFamily<T, K extends Json.Serializable>(
+export function createWritableSelectorFamily<T, K extends Canonical>(
 	options: WritableSelectorFamilyOptions<T, K>,
 	store: Store,
 ): WritableSelectorFamily<T, K> {

package/internal/src/families/dispose-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 { disposeAtom } from "../atom"
 import { disposeMolecule } from "../molecule/dispose-molecule"
@@ -21,7 +21,7 @@ export function disposeFromStore(
 	store: Store,
 ): void
 
-export function disposeFromStore<K extends Json.Serializable>(
+export function disposeFromStore<K extends Canonical>(
 	token: ReadableFamilyToken<any, K>,
 	key: K,
 	store: Store,
@@ -35,13 +35,9 @@ export function disposeFromStore<M extends MoleculeConstructor>(
 
 export function disposeFromStore(
 	...params:
-		| [
-				token: ReadableFamilyToken<any, any>,
-				key: Json.Serializable,
-				store: Store,
-		  ]
 		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>, store: Store]
 		| [token: MoleculeToken<any> | ReadableToken<any>, store: Store]
+		| [token: ReadableFamilyToken<any, any>, key: Canonical, store: Store]
 ): void {
 	let token: MoleculeToken<any> | ReadableToken<any>
 	let store: Store

package/internal/src/families/find-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 type { Transceiver } from "../mutable"
 import type { Store } from "../store"
@@ -26,7 +26,7 @@ import { seekInStore } from "./seek-in-store"
 export function findInStore<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 	Key extends K,
 >(
 	token: MutableAtomFamilyToken<T, J, K>,
@@ -34,43 +34,43 @@ export function findInStore<
 	store: Store,
 ): MutableAtomToken<T, J>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): RegularAtomToken<T>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: AtomFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): AtomToken<T>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): WritableSelectorToken<T>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): ReadonlySelectorToken<T>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): SelectorToken<T>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): WritableToken<T>
 
-export function findInStore<T, K extends Json.Serializable, Key extends K>(
+export function findInStore<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
 	store: Store,

package/internal/src/families/init-family-member.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 { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
@@ -27,7 +27,7 @@ import { isChildStore, isRootStore } from "../transaction"
 export function initFamilyMemberInStore<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 	Key extends K,
 >(
 	token: MutableAtomFamilyToken<T, J, K>,
@@ -35,59 +35,47 @@ export function initFamilyMemberInStore<
 	store: Store,
 ): MutableAtomToken<T, J>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): RegularAtomToken<T>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	token: AtomFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): AtomToken<T>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): WritableSelectorToken<T>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 	store: Store,
 ): ReadonlySelectorToken<T>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	token: SelectorFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): SelectorToken<T>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	token: WritableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): WritableToken<T>
 
-export function initFamilyMemberInStore<
-	T,
-	K extends Json.Serializable,
-	Key extends K,
->(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>
+export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
+	token: ReadableFamilyToken<T, K>,
+	key: Key,
+	store: Store,
+): ReadableToken<T>
 
 export function initFamilyMemberInStore(
 	token: ReadableFamilyToken<any, any>,

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>