atom.io 0.15.6 → 0.16.0

package/realtime-server/src/{hook-composition/expose-single.ts → realtime-state-provider.ts}

@@ -1,15 +1,14 @@
 import * as AtomIO from "atom.io"
-import * as Internal from "atom.io/internal"
+import { IMPLICIT, subscribeToState } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
-import type { ServerConfig } from ".."
+import type { ServerConfig } from "."
 
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-export const useExposeSingle = ({
+export function realtimeStateProvider({
 	socket,
-	store = Internal.IMPLICIT.STORE,
-}: ServerConfig) => {
-	return function exposeSingle<J extends Json.Serializable>(
+	store = IMPLICIT.STORE,
+}: ServerConfig) {
+	return function stateProvider<J extends Json.Serializable>(
 		token: AtomIO.WritableToken<J>,
 	): () => void {
 		let unsubscribeFromStateUpdates: (() => void) | null = null
@@ -22,7 +21,7 @@ export const useExposeSingle = ({
 
 		const fillSubRequest = () => {
 			socket.emit(`serve:${token.key}`, AtomIO.getState(token, store))
-			unsubscribeFromStateUpdates = Internal.subscribeToState(
+			unsubscribeFromStateUpdates = subscribeToState(
 				token,
 				({ newValue }) => {
 					socket.emit(`serve:${token.key}`, newValue)

package/realtime-server/src/{hook-composition/receive-state.ts → realtime-state-receiver.ts}

@@ -1,12 +1,15 @@
 import { setState } from "atom.io"
 import type { WritableToken } from "atom.io"
+import { IMPLICIT } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
-import type { ServerConfig } from ".."
+import type { ServerConfig } from "."
 
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-export const useReceiveState = ({ socket, store }: ServerConfig) => {
-	return function receiveState<J extends Json.Serializable>(
+export function realtimeStateReceiver({
+	socket,
+	store = IMPLICIT.STORE,
+}: ServerConfig) {
+	return function stateReceiver<J extends Json.Serializable>(
 		token: WritableToken<J>,
 	): () => void {
 		const publish = (newValue: J) => setState(token, newValue, store)

package/src/atom.ts

@@ -1,8 +1,12 @@
 import type { Store, Subject, Transceiver } from "atom.io/internal"
-import { IMPLICIT, createAtom, createAtomFamily } from "atom.io/internal"
+import {
+	IMPLICIT,
+	createAtomFamily,
+	createStandaloneAtom,
+} from "atom.io/internal"
 import type { Json, JsonInterface } from "atom.io/json"
 
-import type { AtomToken, MutableAtomToken } from "."
+import type { AtomToken, MutableAtomToken, RegularAtomToken } from "."
 
 export type Effectors<T> = {
 	setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void
@@ -11,7 +15,7 @@ export type Effectors<T> = {
 
 export type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void
 
-export type AtomOptions<T> = {
+export type RegularAtomOptions<T> = {
 	key: string
 	default: T | (() => T)
 	effects?: AtomEffect<T>[]
@@ -19,7 +23,7 @@ export type AtomOptions<T> = {
 // biome-ignore format: complex intersection
 export type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serializable> = 
 	& JsonInterface<T, J>
-	& Omit<AtomOptions<T>, `default`> 
+	& Omit<RegularAtomOptions<T>, `default`> 
 	& { 
 			default: ()	=> T
 			mutable: true
@@ -28,31 +32,31 @@ export type MutableAtomOptions<T extends Transceiver<any>, J extends Json.Serial
 export function atom<T extends Transceiver<any>, J extends Json.Serializable>(
 	options: MutableAtomOptions<T, J>,
 ): MutableAtomToken<T, J>
-export function atom<T>(options: AtomOptions<T>): AtomToken<T>
+export function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>
 export function atom(
-	options: AtomOptions<any> | MutableAtomOptions<any, any>,
+	options: MutableAtomOptions<any, any> | RegularAtomOptions<any>,
 ): AtomToken<any> {
-	return createAtom(options, undefined, IMPLICIT.STORE)
+	return createStandaloneAtom(options, IMPLICIT.STORE)
 }
 
-export type AtomFamilyOptions<T, K extends Json.Serializable> = {
+export type RegularAtomFamilyOptions<T, K extends Json.Serializable> = {
 	key: string
 	default: T | ((key: K) => T)
 	effects?: (key: K) => AtomEffect<T>[]
 }
 
-export type AtomFamily<T, K extends Json.Serializable = Json.Serializable> = ((
-	key: K,
-) => AtomToken<T>) & {
+export type RegularAtomFamily<
+	T,
+	K extends Json.Serializable = Json.Serializable,
+> = ((key: K) => RegularAtomToken<T>) & {
 	key: string
 	type: `atom_family`
-	subject: Subject<AtomToken<T>>
-	mutable?: boolean
+	subject: Subject<RegularAtomToken<T>>
 	install: (store: Store) => void
 	__T?: T
 	__K?: K
 }
-export type AtomFamilyToken<T, K extends Json.Serializable> = {
+export type RegularAtomFamilyToken<T, K extends Json.Serializable> = {
 	key: string
 	type: `atom_family`
 	__T?: T
@@ -65,9 +69,13 @@ export type MutableAtomFamilyOptions<
 	J extends Json.Serializable,
 	K extends Json.Serializable,
 > = 
-	& AtomFamilyOptions<T, K>
 	& JsonInterface<T, J>
-	& { mutable: true }
+	& { 
+		key: string
+		default: (key: K) => T
+		effects?: (key: K) => AtomEffect<T>[]
+		mutable: true,
+	}
 
 // biome-ignore format: intersection
 export type MutableAtomFamily<
@@ -79,9 +87,8 @@ export type MutableAtomFamily<
 	& ((key: K) => MutableAtomToken<T, J>) 
 	& {
 			key: string
-			type: `atom_family`
+			type: `mutable_atom_family`
 			subject: Subject<MutableAtomToken<T, J>>
-			mutable: true
 			install: (store: Store) => void
 			__T?: T
 			__J?: J
@@ -93,23 +100,31 @@ export type MutableAtomFamilyToken<
 	K extends Json.Serializable,
 > = {
 	key: string
-	type: `atom_family`
-	mutable: true
+	type: `mutable_atom_family`
 	__T?: T
 	__J?: J
 	__K?: K
 }
 
+export type AtomFamily<T, K extends Json.Serializable = Json.Serializable> =
+	| MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K>
+	| RegularAtomFamily<T, K>
+export type AtomFamilyToken<T, K extends Json.Serializable = Json.Serializable> =
+	| 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>): MutableAtomFamily<T, J, K>
 export function atomFamily<T, K extends Json.Serializable>(
-	options: AtomFamilyOptions<T, K>,
-): AtomFamily<T, K>
+	options: RegularAtomFamilyOptions<T, K>,
+): RegularAtomFamily<T, K>
 export function atomFamily<T, K extends Json.Serializable>(
-	options: AtomFamilyOptions<T, K> | MutableAtomFamilyOptions<any, any, any>,
-): AtomFamily<T, K> | MutableAtomFamily<any, any, any> {
+	options:
+		| MutableAtomFamilyOptions<any, any, any>
+		| RegularAtomFamilyOptions<T, K>,
+): MutableAtomFamily<any, any, any> | RegularAtomFamily<T, K> {
 	return createAtomFamily(options, IMPLICIT.STORE)
 }

package/src/find-state.ts

@@ -1,15 +1,15 @@
 import type {
-	AtomFamilyToken,
-	AtomToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
 	ReadableToken,
 	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
-	SelectorFamilyToken,
-	SelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
 	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
 import type { Store, Transceiver } from "atom.io/internal"
@@ -34,26 +34,27 @@ export function findState<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
 	K extends Json.Serializable,
->(token: MutableAtomFamilyToken<T, J, K>, key: K): MutableAtomToken<T, J>
-export function findState<T, K extends Json.Serializable>(
-	token: AtomFamilyToken<T, K>,
-	key: K,
-): AtomToken<T>
-export function findState<T, K extends Json.Serializable>(
-	token: SelectorFamilyToken<T, K>,
-	key: K,
-): SelectorToken<T>
-export function findState<T, K extends Json.Serializable>(
+	Key extends K,
+>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>
+export function findState<T, K extends Json.Serializable, Key extends K>(
+	token: RegularAtomFamilyToken<T, K>,
+	key: Key,
+): RegularAtomToken<T>
+export function findState<T, K extends Json.Serializable, Key extends K>(
+	token: WritableSelectorFamilyToken<T, K>,
+	key: Key,
+): WritableSelectorToken<T>
+export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
-	key: K,
+	key: Key,
 ): ReadonlySelectorToken<T>
-export function findState<T, K extends Json.Serializable>(
+export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: WritableFamilyToken<T, K>,
-	key: K,
+	key: Key,
 ): WritableToken<T>
-export function findState<T, K extends Json.Serializable>(
+export function findState<T, K extends Json.Serializable, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
-	key: K,
+	key: Key,
 ): ReadableToken<T>
 export function findState(
 	token: ReadableFamilyToken<any, any>,

package/src/index.ts

@@ -1,11 +1,18 @@
 import type { Transceiver } from "atom.io/internal"
 import type { Json } from "atom.io/json"
-import type { AtomFamily, AtomFamilyToken } from "./atom"
+import type {
+	AtomFamily,
+	AtomFamilyToken,
+	RegularAtomFamily,
+	RegularAtomFamilyToken,
+} from "./atom"
 import type {
 	ReadonlySelectorFamily,
 	ReadonlySelectorFamilyToken,
 	SelectorFamily,
 	SelectorFamilyToken,
+	WritableSelectorFamily,
+	WritableSelectorFamilyToken,
 } from "./selector"
 
 export * from "./atom"
@@ -23,51 +30,57 @@ export * from "./validators"
 
 export type ƒn = (...parameters: any[]) => any
 
-export type AtomToken<_> = {
+export type RegularAtomToken<T> = {
 	key: string
 	type: `atom`
 	family?: FamilyMetadata
-	__brand?: _
+	__T?: T
 }
-export interface MutableAtomToken<
+export type MutableAtomToken<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-> extends AtomToken<T> {
-	__asJSON?: J
-	__update?: T extends Transceiver<infer Update> ? Update : never
+> = {
+	key: string
+	type: `mutable_atom`
+	family?: FamilyMetadata
+	__J?: J
+	__U?: T extends Transceiver<infer Update> ? Update : never
 }
-export type SelectorToken<_> = {
+export type AtomToken<T> =
+	| MutableAtomToken<T extends Transceiver<any> ? T : never, any>
+	| RegularAtomToken<T>
+
+export type WritableSelectorToken<T> = {
 	key: string
 	type: `selector`
 	family?: FamilyMetadata
-	__brand?: _
+	__T?: T
+}
+export type ReadonlySelectorToken<T> = {
+	key: string
+	type: `readonly_selector`
+	family?: FamilyMetadata
+	__T?: T
 }
-/**
- * @deprecated Prefer `WritableToken`.
- */
-export type StateToken<T> = AtomToken<T> | SelectorToken<T>
-export type WritableToken<T> = AtomToken<T> | SelectorToken<T>
-export type ReadableToken<T> = ReadonlySelectorToken<T> | WritableToken<T>
+export type SelectorToken<T> =
+	| ReadonlySelectorToken<T>
+	| WritableSelectorToken<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> =
 	| AtomFamily<T, K>
-	| SelectorFamily<T, K>
+	| WritableSelectorFamily<T, K>
 export type ReadableFamily<T, K extends Json.Serializable> =
-	| ReadonlySelectorFamily<T, K>
-	| WritableFamily<T, K>
+	| AtomFamily<T, K>
+	| SelectorFamily<T, K>
 
 export type WritableFamilyToken<T, K extends Json.Serializable> =
 	| AtomFamilyToken<T, K>
-	| SelectorFamilyToken<T, K>
+	| WritableSelectorFamilyToken<T, K>
 export type ReadableFamilyToken<T, K extends Json.Serializable> =
-	| ReadonlySelectorFamilyToken<T, K>
-	| WritableFamilyToken<T, K>
-
-export type ReadonlySelectorToken<_> = {
-	key: string
-	type: `readonly_selector`
-	family?: FamilyMetadata
-	__brand?: _
-}
+	| AtomFamilyToken<T, K>
+	| SelectorFamilyToken<T, K>
 
 export type FamilyMetadata = { key: string; subKey: string }

package/src/logger.ts

@@ -47,6 +47,7 @@ export type LogFn = (
 	icon: LoggerIcon,
 	tokenType:
 		| `atom`
+		| `mutable_atom`
 		| `readonly_selector`
 		| `selector`
 		| `state`

package/src/selector.ts

@@ -1,11 +1,15 @@
 import type { Store, Subject } from "atom.io/internal"
-import { IMPLICIT, createSelector, createSelectorFamily } from "atom.io/internal"
+import {
+	IMPLICIT,
+	createSelectorFamily,
+	createStandaloneSelector,
+} from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
-import type { ReadonlySelectorToken, SelectorToken } from "."
+import type { ReadonlySelectorToken, WritableSelectorToken } from "."
 import type { Read, Write } from "./transaction"
 
-export type SelectorOptions<T> = {
+export type WritableSelectorOptions<T> = {
 	key: string
 	get: Read<() => T>
 	set: Write<(newValue: T) => void>
@@ -15,17 +19,19 @@ export type ReadonlySelectorOptions<T> = {
 	get: Read<() => T>
 }
 
-export function selector<T>(options: SelectorOptions<T>): SelectorToken<T>
+export function selector<T>(
+	options: WritableSelectorOptions<T>,
+): WritableSelectorToken<T>
 export function selector<T>(
 	options: ReadonlySelectorOptions<T>,
 ): ReadonlySelectorToken<T>
 export function selector<T>(
-	options: ReadonlySelectorOptions<T> | SelectorOptions<T>,
-): ReadonlySelectorToken<T> | SelectorToken<T> {
-	return createSelector(options, undefined, IMPLICIT.STORE)
+	options: ReadonlySelectorOptions<T> | WritableSelectorOptions<T>,
+): ReadonlySelectorToken<T> | WritableSelectorToken<T> {
+	return createStandaloneSelector(options, IMPLICIT.STORE)
 }
 
-export type SelectorFamilyOptions<T, K extends Json.Serializable> = {
+export type WritableSelectorFamilyOptions<T, K extends Json.Serializable> = {
 	key: string
 	get: (key: K) => Read<() => T>
 	set: (key: K) => Write<(newValue: T) => void>
@@ -35,18 +41,18 @@ export type ReadonlySelectorFamilyOptions<T, K extends Json.Serializable> = {
 	get: (key: K) => Read<() => T>
 }
 
-export type SelectorFamily<
+export type WritableSelectorFamily<
 	T,
 	K extends Json.Serializable = Json.Serializable,
-> = ((key: K) => SelectorToken<T>) & {
+> = ((key: K) => WritableSelectorToken<T>) & {
 	key: string
 	type: `selector_family`
-	subject: Subject<SelectorToken<T>>
+	subject: Subject<WritableSelectorToken<T>>
 	install: (store: Store) => void
 	__T?: T
 	__K?: K
 }
-export type SelectorFamilyToken<T, K extends Json.Serializable> = {
+export type WritableSelectorFamilyToken<T, K extends Json.Serializable> = {
 	key: string
 	type: `selector_family`
 	__T?: T
@@ -71,14 +77,23 @@ export type ReadonlySelectorFamilyToken<T, K extends Json.Serializable> = {
 	__K?: K
 }
 
+export type SelectorFamily<T, K extends Json.Serializable> =
+	| ReadonlySelectorFamily<T, K>
+	| WritableSelectorFamily<T, K>
+export type SelectorFamilyToken<T, K extends Json.Serializable> =
+	| ReadonlySelectorFamilyToken<T, K>
+	| WritableSelectorFamilyToken<T, K>
+
 export function selectorFamily<T, K extends Json.Serializable>(
-	options: SelectorFamilyOptions<T, K>,
-): SelectorFamily<T, K>
+	options: WritableSelectorFamilyOptions<T, K>,
+): WritableSelectorFamily<T, K>
 export function selectorFamily<T, K extends Json.Serializable>(
 	options: ReadonlySelectorFamilyOptions<T, K>,
 ): ReadonlySelectorFamily<T, K>
 export function selectorFamily<T, K extends Json.Serializable>(
-	options: ReadonlySelectorFamilyOptions<T, K> | SelectorFamilyOptions<T, K>,
-): ReadonlySelectorFamily<T, K> | SelectorFamily<T, K> {
+	options:
+		| ReadonlySelectorFamilyOptions<T, K>
+		| WritableSelectorFamilyOptions<T, K>,
+): ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K> {
 	return createSelectorFamily(options, IMPLICIT.STORE)
 }

package/src/silo.ts

@@ -1,15 +1,30 @@
+import type { Transceiver } from "atom.io/internal"
 import {
 	Store,
-	createAtom,
 	createAtomFamily,
-	createSelector,
 	createSelectorFamily,
+	createStandaloneAtom,
+	createStandaloneSelector,
 	createTimeline,
 	createTransaction,
 	timeTravel,
 } from "atom.io/internal"
+import type { Json } from "atom.io/json"
 
-import type { redo, timeline, undo } from "."
+import type {
+	AtomToken,
+	MutableAtomFamily,
+	MutableAtomFamilyOptions,
+	MutableAtomOptions,
+	MutableAtomToken,
+	RegularAtomFamily,
+	RegularAtomFamilyOptions,
+	RegularAtomOptions,
+	RegularAtomToken,
+	redo,
+	timeline,
+	undo,
+} from "."
 import { getState, setState, subscribe } from "."
 import type { atom, atomFamily } from "./atom"
 import type { selector, selectorFamily } from "./selector"
@@ -30,10 +45,34 @@ export class Silo {
 	public redo: typeof redo
 	public constructor(name: string, fromStore: Store | null = null) {
 		const s = new Store(name, fromStore)
+		function _atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>
+		function _atom<T extends Transceiver<any>, J extends Json.Serializable>(
+			options: MutableAtomOptions<T, J>,
+		): MutableAtomToken<T, J>
+		function _atom<T>(
+			options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
+		): AtomToken<T> {
+			return createStandaloneAtom(options, s)
+		}
+		function _atomFamily<
+			T extends Transceiver<any>,
+			J extends Json.Serializable,
+			K extends Json.Serializable,
+		>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamily<T, J, K>
+		function _atomFamily<T, K extends Json.Serializable>(
+			options: RegularAtomFamilyOptions<T, K>,
+		): RegularAtomFamily<T, K>
+		function _atomFamily<T, K extends Json.Serializable>(
+			options:
+				| MutableAtomFamilyOptions<any, any, any>
+				| RegularAtomFamilyOptions<T, K>,
+		): MutableAtomFamily<any, any, any> | RegularAtomFamily<T, K> {
+			return createAtomFamily(options, s)
+		}
 		this.store = s
-		this.atom = (options) => createAtom(options, undefined, s)
-		this.atomFamily = (options) => createAtomFamily(options, s)
-		this.selector = (options) => createSelector(options, undefined, s) as any
+		this.atom = _atom
+		this.atomFamily = _atomFamily
+		this.selector = (options) => createStandaloneSelector(options, s) as any
 		this.selectorFamily = (options) => createSelectorFamily(options, s) as any
 		this.transaction = (options) => createTransaction(options, s)
 		this.timeline = (options) => createTimeline(options, s)

package/src/subscribe.ts

@@ -54,6 +54,7 @@ export function subscribe(
 ): () => void {
 	switch (token.type) {
 		case `atom`:
+		case `mutable_atom`:
 		case `readonly_selector`:
 		case `selector`:
 			return subscribeToState(token, handleUpdate, key, store)

package/src/validators.ts

@@ -1,13 +1,15 @@
 import type {
-	AtomFamily,
-	AtomToken,
+	MutableAtomFamily,
+	MutableAtomToken,
 	ReadableFamily,
 	ReadableToken,
 	ReadonlySelectorFamily,
 	ReadonlySelectorToken,
-	SelectorFamily,
-	SelectorToken,
+	RegularAtomFamily,
+	RegularAtomToken,
 	WritableFamily,
+	WritableSelectorFamily,
+	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
 
@@ -19,56 +21,64 @@ export type TokenType<
 	  ? RepresentedValue
 	  : never
 
-export function isToken<KnownToken extends AtomToken<any>>(
+export function isToken<KnownToken extends RegularAtomToken<any>>(
 	knownToken: KnownToken,
-	unknownToken: ReadableToken<unknown>,
-): unknownToken is AtomToken<TokenType<KnownToken>>
-export function isToken<KnownToken extends SelectorToken<any>>(
+	unknownToken: ReadableToken<any>,
+): unknownToken is RegularAtomToken<TokenType<KnownToken>>
+export function isToken<KnownToken extends MutableAtomToken<any, any>>(
 	knownToken: KnownToken,
-	unknownToken: ReadableToken<unknown>,
-): unknownToken is SelectorToken<TokenType<KnownToken>>
+	unknownToken: ReadableToken<any>,
+): unknownToken is MutableAtomToken<TokenType<KnownToken>, any>
+export function isToken<KnownToken extends WritableSelectorToken<any>>(
+	knownToken: KnownToken,
+	unknownToken: ReadableToken<any>,
+): unknownToken is WritableSelectorToken<TokenType<KnownToken>>
 export function isToken<KnownToken extends ReadonlySelectorToken<any>>(
 	knownToken: KnownToken,
-	unknownToken: ReadableToken<unknown>,
+	unknownToken: ReadableToken<any>,
 ): unknownToken is ReadonlySelectorToken<TokenType<KnownToken>>
 export function isToken<KnownToken extends WritableToken<any>>(
 	knownToken: KnownToken,
-	unknownToken: ReadableToken<unknown>,
+	unknownToken: ReadableToken<any>,
 ): unknownToken is WritableToken<TokenType<KnownToken>>
-export function isToken<KnownToken extends WritableToken<any>>(
+export function isToken<KnownToken extends ReadableToken<any>>(
 	knownToken: KnownToken,
-	unknownToken: ReadableToken<unknown>,
+	unknownToken: ReadableToken<any>,
 ): unknownToken is ReadableToken<TokenType<KnownToken>>
 export function isToken<KnownToken extends ReadableToken<any>>(
 	knownToken: KnownToken,
-	unknownToken: ReadableToken<unknown>,
+	unknownToken: ReadableToken<any>,
 ): unknownToken is ReadableToken<TokenType<KnownToken>> {
 	return knownToken.key === unknownToken.key
 }
 
-export function belongsTo<Family extends AtomFamily<any, any>>(
+export function belongsTo<Family extends RegularAtomFamily<any, any>>(
+	family: Family,
+	unknownToken: ReadableToken<any>,
+): unknownToken is RegularAtomToken<TokenType<Family>>
+export function belongsTo<Family extends MutableAtomFamily<any, any, any>>(
 	family: Family,
-	unknownToken: ReadableToken<unknown>,
-): unknownToken is AtomToken<TokenType<Family>>
-export function belongsTo<Family extends SelectorFamily<any, any>>(
+	unknownToken: ReadableToken<any>,
+): unknownToken is MutableAtomToken<TokenType<Family>, any>
+export function belongsTo<Family extends WritableSelectorFamily<any, any>>(
 	family: Family,
-	unknownToken: ReadableToken<unknown>,
-): unknownToken is SelectorToken<TokenType<Family>>
+	unknownToken: ReadableToken<any>,
+): unknownToken is WritableSelectorToken<TokenType<Family>>
 export function belongsTo<Family extends ReadonlySelectorFamily<any, any>>(
 	family: Family,
-	unknownToken: ReadableToken<unknown>,
+	unknownToken: ReadableToken<any>,
 ): unknownToken is ReadonlySelectorToken<TokenType<Family>>
 export function belongsTo<Family extends WritableFamily<any, any>>(
 	family: Family,
-	unknownToken: ReadableToken<unknown>,
+	unknownToken: ReadableToken<any>,
 ): unknownToken is WritableToken<TokenType<Family>>
 export function belongsTo<Family extends ReadableFamily<any, any>>(
 	family: Family,
-	unknownToken: ReadableToken<unknown>,
+	unknownToken: ReadableToken<any>,
 ): unknownToken is ReadableToken<TokenType<Family>>
 export function belongsTo<Family extends ReadableFamily<any, any>>(
 	family: Family,
-	unknownToken: ReadableToken<unknown>,
+	unknownToken: ReadableToken<any>,
 ): unknownToken is ReadableToken<TokenType<Family>> {
 	return family.key === unknownToken.family?.key
 }

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

@@ -1,21 +0,0 @@
-import type {
-	AtomOptions,
-	AtomToken,
-	FamilyMetadata,
-	MutableAtomOptions,
-} from "atom.io"
-
-import { createMutableAtom } from "../mutable"
-import type { Store } from "../store"
-import { createRegularAtom } from "./create-regular-atom"
-
-export function createAtom<T>(
-	options: AtomOptions<T> | MutableAtomOptions<any, any>,
-	family: FamilyMetadata | undefined,
-	store: Store,
-): AtomToken<T> {
-	if (`mutable` in options) {
-		return createMutableAtom(options, family, store)
-	}
-	return createRegularAtom<T>(options, family, store)
-}