atom.io 0.28.2 → 0.29.1

package/internal/src/families/init-family-member.ts

@@ -33,57 +33,56 @@ export function initFamilyMemberInStore<
 	store: Store,
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
-): MutableAtomToken<T, J>
+): MutableAtomToken<T, J, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-): RegularAtomToken<T>
+): RegularAtomToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: AtomFamilyToken<T, K>,
 	key: Key,
-): AtomToken<T>
+): AtomToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T>
+): WritableSelectorToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T>
+): ReadonlySelectorToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
-): SelectorToken<T>
+): SelectorToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-): WritableToken<T>
+): WritableToken<T, K>
 
 export function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-): ReadableToken<T>
+): ReadableToken<T, K>
 
 export function initFamilyMemberInStore(
 	store: Store,
 	token: ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
 ): ReadableToken<any> {
-	const familyKey = token.key
-	const family = store.families.get(familyKey)
+	const family = store.families.get(token.key)
 	if (family === undefined) {
 		throw new NotFoundError(token, store)
 	}

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

@@ -37,49 +37,49 @@ export function seekInStore<
 	store: Store,
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
-): MutableAtomToken<T, J> | undefined
+): MutableAtomToken<T, J, K> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
-): RegularAtomToken<T> | undefined
+): RegularAtomToken<T, K> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: AtomFamilyToken<T, K>,
 	key: Key,
-): AtomToken<T> | undefined
+): AtomToken<T, K> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
-): WritableSelectorToken<T> | undefined
+): WritableSelectorToken<T, K> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
-): ReadonlySelectorToken<T> | undefined
+): ReadonlySelectorToken<T, K> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: SelectorFamilyToken<T, K>,
 	key: Key,
-): SelectorToken<T> | undefined
+): SelectorToken<T, K> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: WritableFamilyToken<T, K>,
 	key: Key,
-): WritableToken<T> | undefined
+): WritableToken<T, K> | undefined
 
 export function seekInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
-): ReadableToken<T> | undefined
+): ReadableToken<T, K> | undefined
 
 export function seekInStore<M extends MoleculeConstructor>(
 	store: Store,

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

@@ -6,9 +6,11 @@ import type {
 	ReadableFamilyToken,
 	ReadableToken,
 } from "atom.io"
-import { type Canonical, stringifyJson } from "atom.io/json"
+import { type Canonical, parseJson } from "atom.io/json"
+import { M } from "vitest/dist/chunks/environment.0M5R1SX_.js"
 
 import { findInStore, seekInStore } from "../families"
+import { getFamilyOfToken } from "../families/get-family-of-token"
 import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
 import { counterfeit, withdraw } from "../store"
@@ -58,11 +60,23 @@ export function getFromStore(
 		| [token: ReadableToken<any>]
 ): any {
 	let token: MoleculeToken<any> | ReadableToken<any>
+	let family:
+		| MoleculeFamilyToken<any>
+		| ReadableFamilyToken<any, Canonical>
+		| null
+	let key: Canonical | null
 	if (params.length === 1) {
 		token = params[0]
+		if (token.type !== `molecule`) {
+			family = getFamilyOfToken(store, token) ?? null
+			if (family) {
+				key = token.family ? parseJson(token.family.subKey) : null
+				token = findInStore(store, family, key)
+			}
+		}
 	} else {
-		const family = params[0]
-		const key = params[1]
+		family = params[0]
+		key = params[1]
 		let maybeToken: MoleculeToken<any> | ReadableToken<any>
 		if (family.type === `molecule_family`) {
 			maybeToken = seekInStore(store, family, key) ?? counterfeit(family, key)
@@ -72,7 +86,7 @@ export function getFromStore(
 		token = maybeToken
 	}
 	if (`counterfeit` in token && `family` in token) {
-		const family =
+		family =
 			token.type === `molecule`
 				? withdraw(token.family, store)
 				: // biome-ignore lint/style/noNonNullAssertion: family must be present

package/internal/src/ingest-updates/ingest-creation-disposal.ts

@@ -7,7 +7,11 @@ import type {
 } from "atom.io"
 import { parseJson, stringifyJson } from "atom.io/json"
 
-import { disposeFromStore, initFamilyMemberInStore } from "../families"
+import {
+	disposeFromStore,
+	findInStore,
+	initFamilyMemberInStore,
+} from "../families"
 import { growMoleculeInStore, makeMoleculeInStore } from "../molecule"
 import { type Store, withdraw } from "../store"
 
@@ -18,7 +22,7 @@ export function ingestCreationEvent(
 ): void {
 	switch (applying) {
 		case `newValue`: {
-			createInStore(update.token, store)
+			createInStore(update, store)
 			break
 		}
 		case `oldValue`: {
@@ -29,7 +33,7 @@ export function ingestCreationEvent(
 }
 
 export function ingestDisposalEvent(
-	update: StateDisposal<any>,
+	update: StateDisposal<ReadableToken<any>>,
 	applying: `newValue` | `oldValue`,
 	store: Store,
 ): void {
@@ -39,35 +43,22 @@ export function ingestDisposalEvent(
 			break
 		}
 		case `oldValue`: {
-			createInStore(update.token, store)
+			createInStore(update, store)
 			store.valueMap.set(update.token.key, update.value)
 			break
 		}
 	}
 }
 
-function createInStore(token: ReadableToken<any>, store: Store): void {
-	if (token.family) {
-		const family = store.families.get(token.family.key)
+function createInStore(
+	update: StateCreation<any> | StateDisposal<any>,
+	store: Store,
+): void {
+	const { family: familyMeta } = update.token
+	if (familyMeta) {
+		const family = store.families.get(familyMeta.key)
 		if (family) {
-			const molecule = store.molecules.get(token.family.subKey)
-			if (molecule) {
-				growMoleculeInStore(molecule, family, store)
-				return
-			}
-			if (store.config.lifespan === `immortal`) {
-				store.logger.error(
-					`🐞`,
-					`atom`,
-					token.family.key,
-					`tried to create member`,
-					`"${token.family.subKey}"`,
-					`but a molecule with that key was not found in store`,
-					`"${store.config.name}"`,
-				)
-				return
-			}
-			initFamilyMemberInStore(store, family, parseJson(token.family.subKey))
+			findInStore(store, family, parseJson(familyMeta.subKey))
 		}
 	}
 }

package/internal/src/selector/dispose-selector.ts

@@ -52,19 +52,6 @@ export function disposeSelector(
 		}
 		target.valueMap.delete(key)
 		target.selectorAtoms.delete(key)
-		const downstreamTokens = target.selectorGraph
-			.getRelationEntries({ upstreamSelectorKey: key })
-			.filter(([_, { source }]) => source === key)
-			.map(
-				([downstreamSelectorKey]) =>
-					target.selectors.get(downstreamSelectorKey) ??
-					target.readonlySelectors.get(downstreamSelectorKey),
-			)
-		for (const downstreamToken of downstreamTokens) {
-			if (downstreamToken) {
-				disposeSelector(downstreamToken, store)
-			}
-		}
 		target.selectorGraph.delete(key)
 		store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
 		if (isChildStore(target) && target.transactionMeta.phase === `building`) {

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

@@ -1,7 +1,8 @@
 import type { WritableFamilyToken, WritableToken } from "atom.io"
-import { type Canonical, stringifyJson } from "atom.io/json"
+import { type Canonical, parseJson, stringifyJson } from "atom.io/json"
 
 import { findInStore } from "../families"
+import { getFamilyOfToken } from "../families/get-family-of-token"
 import { closeOperation, openOperation } from "../operation"
 import type { Store } from "../store"
 import { withdraw } from "../store"
@@ -31,17 +32,24 @@ export function setIntoStore<T, New extends T>(
 		| [token: WritableToken<T>, value: New | ((oldValue: T) => New)]
 ): void {
 	let token: WritableToken<T>
+	let family: WritableFamilyToken<T, Canonical> | null
+	let key: Canonical | null
 	let value: New | ((oldValue: T) => New)
 	if (params.length === 2) {
 		token = params[0]
 		value = params[1]
+		family = getFamilyOfToken(store, token) ?? null
+		if (family) {
+			key = token.family ? parseJson(token.family.subKey) : null
+			token = findInStore(store, family, key)
+		}
 	} else {
-		const family = params[0]
-		const key = params[1]
+		family = params[0]
+		key = params[1]
 		value = params[2]
-		const maybeToken = findInStore(store, family, key)
-		token = maybeToken
+		token = findInStore(store, family, key)
 	}
+
 	if (`counterfeit` in token) {
 		const disposal = store.disposalTraces.buffer.find(
 			(item) => item?.key === token.key,

package/json/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { Range, Flat, Store, Transceiver } from 'atom.io/internal';
 import * as AtomIO from 'atom.io';
 
-type Entries<K extends keyof any = keyof any, V = any> = [K, V][];
+type Entries<K extends PropertyKey = 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>> = {
     [P in Range<E[`length`]>]: E[P] extends [K, infer V] ? V : never;
@@ -32,8 +32,8 @@ declare namespace Json {
     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;
+type stringified<J extends Json.Serializable> = J extends string ? `"${J}"` : J extends number ? `${J}` : J extends true ? `true` : J extends false ? `false` : J extends boolean ? `false` | `true` : J extends null ? `null` : 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>;

package/json/dist/index.js

@@ -1,4 +1,4 @@
-import { createWritableSelectorFamily } from '../../dist/chunk-D3ZPRYEW.js';
+import { createWritableSelectorFamily } from '../../dist/chunk-4WXELLFT.js';
 import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';

package/json/src/entries.ts

@@ -1,6 +1,6 @@
 import type { Flat, Range } from "atom.io/internal"
 
-export type Entries<K extends keyof any = keyof any, V = any> = [K, V][]
+export type Entries<K extends PropertyKey = keyof any, V = any> = [K, V][]
 
 export type KeyOfEntries<E extends Entries> = E extends [infer K, any][]
 	? K

package/json/src/index.ts

@@ -27,7 +27,19 @@ export namespace Json {
 		ReadonlyArray<Element>
 }
 
-export type stringified<J extends Json.Serializable> = string & { __json: J }
+export type stringified<J extends Json.Serializable> = J extends string
+	? `"${J}"`
+	: J extends number
+		? `${J}`
+		: J extends true
+			? `true`
+			: J extends false
+				? `false`
+				: J extends boolean
+					? `false` | `true`
+					: J extends null
+						? `null`
+						: string & { __json?: J }
 
 export const parseJson = <S extends stringified<Json.Serializable>>(
 	str: S | string,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.28.2",
+  "version": "0.29.1",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -52,37 +52,37 @@
     }
   },
   "devDependencies": {
-    "@testing-library/react": "16.0.0",
+    "@testing-library/react": "16.0.1",
     "@types/eslint": "9.6.1",
     "@types/estree": "1.0.5",
     "@types/http-proxy": "1.17.15",
     "@types/npmlog": "7.0.0",
-    "@types/react": "18.3.4",
+    "@types/react": "18.3.5",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.3.0",
-    "@typescript-eslint/rule-tester": "8.3.0",
+    "@typescript-eslint/parser": "8.5.0",
+    "@typescript-eslint/rule-tester": "8.5.0",
     "@vitest/coverage-v8": "2.0.5",
     "@vitest/ui": "2.0.5",
-    "concurrently": "8.2.2",
+    "concurrently": "9.0.1",
     "drizzle-kit": "0.24.2",
     "drizzle-orm": "0.33.0",
-    "eslint": "9.9.1",
-    "framer-motion": "11.3.30",
-    "happy-dom": "15.0.0",
+    "eslint": "9.10.0",
+    "framer-motion": "11.5.4",
+    "happy-dom": "15.7.4",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",
     "preact": "10.23.2",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "react-router-dom": "6.26.1",
+    "react-router-dom": "6.26.2",
     "socket.io": "4.7.5",
     "socket.io-client": "4.7.5",
     "tmp": "0.2.3",
     "tsup": "8.2.4",
-    "tsx": "4.19.0",
-    "typescript": "5.5.4",
-    "vite": "5.4.2",
+    "tsx": "4.19.1",
+    "typescript": "5.6.2",
+    "vite": "5.4.4",
     "vite-tsconfig-paths": "5.0.1",
     "vitest": "2.0.5"
   },

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

@@ -14,21 +14,19 @@ interface EventBuffer<Key extends string, Params extends Json.Serializable[]> ex
     toString(): StringifiedEvent<Key, Params>;
 }
 declare class CustomSocket<I extends Events, O extends Events> implements Socket {
-    emit: <Event extends keyof O>(event: Event, ...args: O[Event]) => CustomSocket<I, O>;
-    protected listeners: Map<keyof I, Set<(...args: Json.Array) => void>>;
+    emit: <Event extends keyof I>(event: Event, ...args: I[Event]) => CustomSocket<I, O>;
+    protected listeners: Map<keyof O, Set<(...args: Json.Array) => void>>;
     protected globalListeners: Set<(event: string, ...args: Json.Array) => void>;
     protected handleEvent<Event extends keyof I>(event: string, ...args: I[Event]): void;
     id: string;
-    constructor(emit: <Event extends keyof O>(event: Event, ...args: O[Event]) => CustomSocket<I, O>);
-    on<Event extends keyof I>(event: Event, listener: (...args: I[Event]) => void): this;
+    constructor(emit: <Event extends keyof I>(event: Event, ...args: I[Event]) => CustomSocket<I, O>);
+    on<Event extends keyof O>(event: Event, listener: (...args: O[Event]) => void): this;
     onAny(listener: (event: string, ...args: Json.Array) => void): this;
-    off<Event extends keyof I>(event: Event, listener?: (...args: I[Event]) => void): this;
+    off<Event extends keyof O>(event: Event, listener?: (...args: O[Event]) => void): this;
     offAny(listener: (event: string, ...args: Json.Array) => void): this;
 }
 
-declare class ChildSocket<I extends Events, O extends Events & {
-    "setup-relay": [string];
-}> extends CustomSocket<I, O> {
+declare class ChildSocket<I extends Events, O extends Events> extends CustomSocket<I, O> {
     process: ChildProcessWithoutNullStreams;
     key: string;
     logger: {
@@ -58,12 +56,12 @@ declare class SubjectSocket<I extends Events, O extends Events> extends CustomSo
     dispose(): void;
 }
 declare class ParentSocket<I extends Events & {
+    [id in string as `relay:${id}`]: [string, ...Json.Serializable[]];
+}, O extends Events & {
     [id in string as `user:${id}`]: [string, ...Json.Serializable[]];
 } & {
     "user-joins": [string];
     "user-leaves": [string];
-}, O extends Events & {
-    [id in string as `relay:${id}`]: [string, ...Json.Serializable[]];
 }> extends CustomSocket<I, O> {
     protected incompleteData: string;
     protected unprocessedEvents: string[];

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

@@ -10,11 +10,7 @@ import { CustomSocket } from "./custom-socket"
 
 export class ChildSocket<
 	I extends Events,
-	O extends Events & {
-		/* eslint-disable quotes */
-		"setup-relay": [string]
-		/* eslint-enable quotes */
-	},
+	O extends Events,
 > extends CustomSocket<I, O> {
 	protected incompleteData = ``
 	protected unprocessedEvents: string[] = []

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

@@ -17,7 +17,7 @@ export interface EventBuffer<
 }
 
 export class CustomSocket<I extends Events, O extends Events> implements Socket {
-	protected listeners: Map<keyof I, Set<(...args: Json.Array) => void>>
+	protected listeners: Map<keyof O, Set<(...args: Json.Array) => void>>
 	protected globalListeners: Set<(event: string, ...args: Json.Array) => void>
 	protected handleEvent<Event extends keyof I>(
 		event: string,
@@ -37,18 +37,18 @@ export class CustomSocket<I extends Events, O extends Events> implements Socket
 	public id = `no_id_retrieved`
 
 	public constructor(
-		public emit: <Event extends keyof O>(
+		public emit: <Event extends keyof I>(
 			event: Event,
-			...args: O[Event]
+			...args: I[Event]
 		) => CustomSocket<I, O>,
 	) {
 		this.listeners = new Map()
 		this.globalListeners = new Set()
 	}
 
-	public on<Event extends keyof I>(
+	public on<Event extends keyof O>(
 		event: Event,
-		listener: (...args: I[Event]) => void,
+		listener: (...args: O[Event]) => void,
 	): this {
 		const listeners = this.listeners.get(event)
 		if (listeners) {
@@ -64,9 +64,9 @@ export class CustomSocket<I extends Events, O extends Events> implements Socket
 		return this
 	}
 
-	public off<Event extends keyof I>(
+	public off<Event extends keyof O>(
 		event: Event,
-		listener?: (...args: I[Event]) => void,
+		listener?: (...args: O[Event]) => void,
 	): this {
 		const listeners = this.listeners.get(event)
 		if (listeners) {

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

@@ -37,6 +37,9 @@ export class SubjectSocket<
 
 export class ParentSocket<
 	I extends Events & {
+		[id in string as `relay:${id}`]: [string, ...Json.Serializable[]]
+	},
+	O extends Events & {
 		[id in string as `user:${id}`]: [string, ...Json.Serializable[]]
 	} & {
 		/* eslint-disable quotes */
@@ -44,9 +47,6 @@ export class ParentSocket<
 		"user-leaves": [string]
 		/* eslint-enable quotes */
 	},
-	O extends Events & {
-		[id in string as `relay:${id}`]: [string, ...Json.Serializable[]]
-	},
 > extends CustomSocket<I, O> {
 	protected incompleteData = ``
 	protected unprocessedEvents: string[] = []
@@ -167,7 +167,7 @@ export class ParentSocket<
 				relay.in.next(data)
 			})
 			relay.out.subscribe(`socket`, (data) => {
-				this.emit(...(data as [string, ...O[keyof O]]))
+				this.emit(...(data as [string, ...I[keyof I]]))
 			})
 		})
 

package/src/index.ts

@@ -1,5 +1,5 @@
 import type { Transceiver } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical, Json, stringified } from "atom.io/json"
 
 import type { AtomFamilyToken } from "./atom"
 import type {
@@ -20,44 +20,49 @@ export * from "./timeline"
 export * from "./transaction"
 export * from "./validators"
 
-export type RegularAtomToken<T> = {
+export type RegularAtomToken<T, K extends Canonical = any> = {
 	key: string
 	type: `atom`
-	family?: FamilyMetadata
+	family?: FamilyMetadata<K>
 	__T?: T
 }
 export type MutableAtomToken<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
+	K extends Canonical = any,
 > = {
 	key: string
 	type: `mutable_atom`
-	family?: FamilyMetadata
+	family?: FamilyMetadata<K>
 	__J?: J
 	__U?: T extends Transceiver<infer Update> ? Update : never
 }
-export type AtomToken<T> =
-	| MutableAtomToken<T extends Transceiver<any> ? T : never, any>
-	| RegularAtomToken<T>
+export type AtomToken<T, K extends Canonical = any> =
+	| MutableAtomToken<T extends Transceiver<any> ? T : never, any, K>
+	| RegularAtomToken<T, K>
 
-export type WritableSelectorToken<T> = {
+export type WritableSelectorToken<T, K extends Canonical = any> = {
 	key: string
 	type: `selector`
-	family?: FamilyMetadata
+	family?: FamilyMetadata<K>
 	__T?: T
 }
-export type ReadonlySelectorToken<T> = {
+export type ReadonlySelectorToken<T, K extends Canonical = any> = {
 	key: string
 	type: `readonly_selector`
-	family?: FamilyMetadata
+	family?: FamilyMetadata<K>
 	__T?: T
 }
-export type SelectorToken<T> =
-	| ReadonlySelectorToken<T>
-	| WritableSelectorToken<T>
+export type SelectorToken<T, K extends Canonical = any> =
+	| ReadonlySelectorToken<T, K>
+	| WritableSelectorToken<T, K>
 
-export type WritableToken<T> = AtomToken<T> | WritableSelectorToken<T>
-export type ReadableToken<T> = AtomToken<T> | SelectorToken<T>
+export type WritableToken<T, K extends Canonical = any> =
+	| AtomToken<T, K>
+	| WritableSelectorToken<T, K>
+export type ReadableToken<T, K extends Canonical = any> =
+	| AtomToken<T, K>
+	| SelectorToken<T, K>
 
 export type WritableFamilyToken<T, K extends Canonical> =
 	| AtomFamilyToken<T, K>
@@ -66,4 +71,7 @@ export type ReadableFamilyToken<T, K extends Canonical> =
 	| AtomFamilyToken<T, K>
 	| SelectorFamilyToken<T, K>
 
-export type FamilyMetadata = { key: string; subKey: string }
+export type FamilyMetadata<K extends Canonical = any> = {
+	key: string
+	subKey: stringified<K>
+}