atom.io 0.4.1 → 0.5.0

package/src/internal/subscribe-internal.ts

@@ -59,6 +59,11 @@ export const subscribeToRootAtoms = <T>(
       ? null
       : traceAllSelectorAtoms(state.key, store).map((atomToken) => {
           const atom = withdraw(atomToken, store)
+          if (atom === null) {
+            throw new Error(
+              `Atom "${atomToken.key}", a dependency of selector "${state.key}", not found in store "${store.config.name}".`
+            )
+          }
           return atom.subject.subscribe((atomChange) => {
             store.config.logger?.info(
               `📢 selector "${state.key}" saw root "${atomToken.key}" go (`,

package/src/internal/timeline-internal.ts

@@ -1,8 +1,10 @@
 import HAMT from "hamt_plus"
 
+import type { ƒn } from "~/packages/anvl/src/function"
+
 import type { KeyedStateUpdate, TransactionUpdate, Store } from "."
 import { target, IMPLICIT, withdraw } from "."
-import type { AtomToken, TimelineOptions, TimelineToken, ƒn } from ".."
+import type { AtomToken, TimelineOptions, TimelineToken } from ".."
 
 export type Timeline = {
   key: string
@@ -49,6 +51,11 @@ export function timeline__INTERNAL(
 
   const subscribeToAtom = (token: AtomToken<any>) => {
     const state = withdraw(token, store)
+    if (state === null) {
+      throw new Error(
+        `Cannot subscribe to atom "${token.key}" because it has not been initialized in store "${store.config.name}"`
+      )
+    }
     state.subject.subscribe((update) => {
       const storeCurrentSelectorKey =
         store.operation.open && store.operation.token.type === `selector`
@@ -83,6 +90,11 @@ export function timeline__INTERNAL(
           { key: storeCurrentTransactionKey, type: `transaction` },
           store
         )
+        if (currentTransaction === null) {
+          throw new Error(
+            `Transaction "${storeCurrentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${storeCurrentTransactionKey}".`
+          )
+        }
         if (timelineData.transactionKey !== storeCurrentTransactionKey) {
           if (timelineData.transactionKey) {
             store.config.logger?.error(

package/src/internal/transaction-internal.ts

@@ -1,8 +1,10 @@
 import HAMT from "hamt_plus"
 import * as Rx from "rxjs"
 
+import type { ƒn } from "~/packages/anvl/src/function"
+
 import type { Store, StoreCore } from "."
-import { cacheValue, deposit, withdraw, IMPLICIT } from "."
+import { deposit, withdraw, IMPLICIT } from "."
 import { getState, setState } from ".."
 import type {
   AtomToken,
@@ -10,7 +12,6 @@ import type {
   Transaction,
   TransactionOptions,
   TransactionToken,
-  ƒn,
 } from ".."
 
 export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
@@ -84,19 +85,22 @@ export const applyTransaction = <ƒ extends ƒn>(
   for (const { key, newValue } of atomUpdates) {
     const token: AtomToken<unknown> = { key, type: `atom` }
     if (!HAMT.has(token.key, store.valueMap)) {
-      const atom = HAMT.get(token.key, store.transactionStatus.core.atoms)
-      store.atoms = HAMT.set(atom.key, atom, store.atoms)
-      store.valueMap = HAMT.set(atom.key, atom.default, store.valueMap)
-      store.config.logger?.info(`🔧`, `add atom "${atom.key}"`)
+      const newAtom = HAMT.get(token.key, store.transactionStatus.core.atoms)
+      store.atoms = HAMT.set(newAtom.key, newAtom, store.atoms)
+      store.valueMap = HAMT.set(newAtom.key, newAtom.default, store.valueMap)
+      store.config.logger?.info(`🔧`, `add atom "${newAtom.key}"`)
     }
-    const state = withdraw(token, store)
-
-    setState(state, newValue, store)
+    setState(token, newValue, store)
   }
   const myTransaction = withdraw<ƒ>(
     { key: store.transactionStatus.key, type: `transaction` },
     store
   )
+  if (myTransaction === null) {
+    throw new Error(
+      `Transaction "${store.transactionStatus.key}" not found. Absurd. How is this running?`
+    )
+  }
   myTransaction.subject.next({
     key: store.transactionStatus.key,
     atomUpdates,
@@ -114,6 +118,12 @@ export const undoTransactionUpdate = <ƒ extends ƒn>(
   for (const { key, oldValue } of update.atomUpdates) {
     const token: AtomToken<unknown> = { key, type: `atom` }
     const state = withdraw(token, store)
+    if (state === null) {
+      throw new Error(
+        `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
+      )
+    }
+
     setState(state, oldValue, store)
   }
 }
@@ -125,6 +135,11 @@ export const redoTransactionUpdate = <ƒ extends ƒn>(
   for (const { key, newValue } of update.atomUpdates) {
     const token: AtomToken<unknown> = { key, type: `atom` }
     const state = withdraw(token, store)
+    if (state === null) {
+      throw new Error(
+        `State "${token.key}" not found in this store. This is surprising, because we are navigating the history of the store.`
+      )
+    }
     setState(state, newValue, store)
   }
 }

package/src/json/index.ts

@@ -0,0 +1 @@
+export * from "./select-json"

package/src/json/select-json.ts

@@ -0,0 +1,18 @@
+import * as AtomIO from "atom.io"
+
+import type { Json, JsonInterface } from "~/packages/anvl/src/json"
+
+export const selectJson = <T, J extends Json>(
+  atom: AtomIO.AtomToken<T>,
+  transform: JsonInterface<T, J>,
+  store: AtomIO.Store = AtomIO.__INTERNAL__.IMPLICIT.STORE
+): AtomIO.SelectorToken<J> =>
+  AtomIO.__INTERNAL__.selector__INTERNAL(
+    {
+      key: `${atom.key}JSON`,
+      get: ({ get }) => transform.toJson(get(atom)),
+      set: ({ set }, newValue) => set(atom, transform.fromJson(newValue)),
+    },
+    undefined,
+    store
+  )

package/src/react-explorer/explorer-states.ts

@@ -2,7 +2,6 @@ import { lastOf } from "~/packages/anvl/src/array"
 import { now } from "~/packages/anvl/src/id"
 import { Join } from "~/packages/anvl/src/join"
 import type { Entries } from "~/packages/anvl/src/object"
-import { cannotExist } from "~/packages/anvl/src/refinement"
 
 import { addToIndex, removeFromIndex } from "."
 import {
@@ -21,9 +20,7 @@ import type {
   AtomFamily,
   AtomToken,
   ReadonlySelectorFamily,
-  ReadonlySelectorToken,
   SelectorFamily,
-  TransactionToken,
   Write,
 } from ".."
 import { selectorFamily, selector, transaction, atom } from ".."
@@ -39,14 +36,17 @@ export const makeViewsPerSpaceState = (
       persistAtom<Join<null, `viewId`, `spaceId`>>(localStorage)({
         stringify: (index) => JSON.stringify(index.toJSON()),
         parse: (json) =>
-          Join.fromJSON(JSON.parse(json), cannotExist, `viewId`, `spaceId`),
+          Join.fromJSON(JSON.parse(json), {
+            from: `viewId`,
+            to: `spaceId`,
+          }),
       })(`${key}:views_per_space`),
     ],
   })
 
 export const makeSpaceViewsFamily = (
   key: string,
-  viewsPerSpaceState: AtomToken<Join>
+  viewsPerSpaceState: AtomToken<Join<null, `viewId`, `spaceId`>>
 ): ReadonlySelectorFamily<string[], string> =>
   selectorFamily<string[], string>({
     key: `${key}:space_views`,

package/src/react-explorer/index.ts

@@ -1,4 +1,4 @@
-import type { AtomToken, Write } from ".."
+import type { AtomToken, Write } from "atom.io"
 
 export * from "./AtomIOExplorer"
 

package/src/react-explorer/space-states.ts

@@ -30,12 +30,11 @@ export const makeSpaceLayoutState = (
         parse: (string) => {
           try {
             const json = parseJson(string)
-            const join = Join.fromJSON(
-              json,
-              hasExactProperties({ size: isNumber }),
-              `parent`,
-              `child`
-            )
+            const join = Join.fromJSON(json, {
+              isContent: hasExactProperties({ size: isNumber }),
+              from: `parent`,
+              to: `child`,
+            })
             return join
           } catch (thrown) {
             console.error(`Error parsing spaceLayoutState from localStorage`)
@@ -48,7 +47,7 @@ export const makeSpaceLayoutState = (
 
 export const makeSpaceLayoutNodeFamily = (
   key: string,
-  spaceLayoutState: AtomToken<Join<{ size: number }>>
+  spaceLayoutState: AtomToken<Join<{ size: number }, `parent`, `child`>>
 ): ReadonlySelectorFamily<{ childSpaceIds: string[]; size: number }, string> =>
   selectorFamily<{ childSpaceIds: string[]; size: number }, string>({
     key: `${key}:explorer_space`,

package/src/realtime/hook-composition/expose-family.ts

@@ -0,0 +1,101 @@
+import type { Json } from "anvl/json"
+import { parseJson } from "anvl/json"
+import * as AtomIO from "atom.io"
+
+import type { ServerConfig } from ".."
+
+const subscribeToTokenCreation = <T>(
+  family: AtomIO.AtomFamily<T> | AtomIO.SelectorFamily<T>,
+  handleTokenCreation: (token: AtomIO.StateToken<T>) => void
+): (() => void) => {
+  const subscription =
+    family.type === `atom_family`
+      ? family.subject.subscribe(handleTokenCreation)
+      : family.subject.subscribe(handleTokenCreation)
+  return () => subscription.unsubscribe()
+}
+
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+export const useExposeFamily = ({ socket, store }: ServerConfig) => {
+  return function exposeFamily<J extends Json>(
+    family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
+    index: AtomIO.StateToken<Set<string>>
+  ): () => void {
+    const unsubSingleCallbacksByKey = new Map<string, () => void>()
+    const unsubFamilyCallbacksByKey = new Map<string, () => void>()
+
+    const fillFamilyUnsubRequest = () => {
+      unsubFamilyCallbacksByKey.forEach((unsub) => unsub())
+      unsubFamilyCallbacksByKey.clear()
+      socket.off(`unsub:${family.key}`, fillFamilyUnsubRequest)
+    }
+
+    const fillSingleUnsubRequest = (key: string) => {
+      socket.off(`unsub:${key}`, fillSingleUnsubRequest)
+      const unsub = unsubSingleCallbacksByKey.get(key)
+      if (unsub) {
+        unsub()
+        unsubSingleCallbacksByKey.delete(key)
+      }
+    }
+
+    const fillSubRequest = (subKey?: AtomIO.Serializable) => {
+      if (subKey === undefined) {
+        const keys = AtomIO.getState(index, store)
+        keys.forEach((key) => {
+          const token = family(key)
+          socket.emit(
+            `serve:${family.key}`,
+            parseJson(token.family?.subKey || `null`),
+            AtomIO.getState(token, store)
+          )
+        })
+
+        const unsubscribeFromTokenCreation = subscribeToTokenCreation(
+          family,
+          (token) => {
+            const unsub = AtomIO.subscribe(
+              token,
+              ({ newValue }) => {
+                socket.emit(
+                  `serve:${family.key}`,
+                  parseJson(token.family?.subKey || `null`),
+                  newValue
+                )
+              },
+              store
+            )
+            unsubFamilyCallbacksByKey.set(token.key, unsub)
+          }
+        )
+        unsubFamilyCallbacksByKey.set(family.key, unsubscribeFromTokenCreation)
+
+        socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest)
+      } else {
+        const token = family(subKey)
+        socket.emit(`serve:${token.key}`, AtomIO.getState(token, store))
+        const unsubscribe = AtomIO.subscribe(
+          token,
+          ({ newValue }) => {
+            socket.emit(`serve:${token.key}`, newValue)
+          },
+          store
+        )
+        unsubSingleCallbacksByKey.set(token.key, unsubscribe)
+        socket.on(`unsub:${token.key}`, () => {
+          fillSingleUnsubRequest(token.key)
+        })
+      }
+    }
+
+    socket.on(`sub:${family.key}`, fillSubRequest)
+
+    return () => {
+      socket.off(`sub:${family.key}`, fillSubRequest)
+      unsubFamilyCallbacksByKey.forEach((unsub) => unsub())
+      unsubSingleCallbacksByKey.forEach((unsub) => unsub())
+      unsubFamilyCallbacksByKey.clear()
+      unsubSingleCallbacksByKey.clear()
+    }
+  }
+}

package/src/realtime/hook-composition/expose-single.ts

@@ -0,0 +1,38 @@
+import type { Json } from "anvl/json"
+import * as AtomIO from "atom.io"
+
+import type { ServerConfig } from ".."
+
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+export const useExposeSingle = ({ socket, store }: ServerConfig) => {
+  return function exposeSingle<J extends Json>(
+    token: AtomIO.StateToken<J>
+  ): () => void {
+    let unsubscribeFromStateUpdates: (() => void) | null = null
+
+    const fillUnsubRequest = () => {
+      socket.off(`unsub:${token.key}`, fillUnsubRequest)
+      unsubscribeFromStateUpdates?.()
+      unsubscribeFromStateUpdates = null
+    }
+
+    const fillSubRequest = () => {
+      socket.emit(`serve:${token.key}`, AtomIO.getState(token, store))
+      unsubscribeFromStateUpdates = AtomIO.subscribe(
+        token,
+        ({ newValue }) => {
+          socket.emit(`serve:${token.key}`, newValue)
+        },
+        store
+      )
+      socket.on(`unsub:${token.key}`, fillUnsubRequest)
+    }
+
+    socket.on(`sub:${token.key}`, fillSubRequest)
+
+    return () => {
+      socket.off(`sub:${token.key}`, fillSubRequest)
+      unsubscribeFromStateUpdates?.()
+    }
+  }
+}

package/src/realtime/hook-composition/index.ts

@@ -0,0 +1,11 @@
+import type * as AtomIO from "atom.io"
+import type * as SocketIO from "socket.io"
+
+export * from "./expose-single"
+export * from "./expose-family"
+export * from "./receive-transaction"
+
+export type ServerConfig = {
+  socket: SocketIO.Socket
+  store?: AtomIO.__INTERNAL__.Store
+}

package/src/realtime/hook-composition/receive-transaction.ts

@@ -0,0 +1,19 @@
+import * as AtomIO from "atom.io"
+
+import type { ƒn } from "~/packages/anvl/src/function"
+
+import type { ServerConfig } from "."
+
+export const useReceiveTransaction = ({ socket, store }: ServerConfig) => {
+  return function receiveTransaction<ƒ extends ƒn>(
+    tx: AtomIO.TransactionToken<ƒ>
+  ): () => void {
+    const fillTransactionRequest = (
+      update: AtomIO.__INTERNAL__.TransactionUpdate<ƒ>
+    ) => AtomIO.runTransaction<ƒ>(tx, store)(...update.params)
+
+    socket.on(`tx:${tx.key}`, fillTransactionRequest)
+
+    return () => socket.off(`tx:${tx.key}`, fillTransactionRequest)
+  }
+}

package/src/realtime/index.ts

@@ -0,0 +1 @@
+export * from "./hook-composition"

package/src/realtime-client/hook-composition/compose-realtime-hooks.ts

@@ -0,0 +1,62 @@
+import { atom, selector } from "atom.io"
+import * as AtomIO from "atom.io"
+import type * as SocketIO from "socket.io-client"
+
+import type { ƒn } from "~/packages/anvl/src/function"
+import type { Json } from "~/packages/anvl/src/json"
+
+import { realtimeClientFamilyHook } from "./realtime-client-family"
+import { realtimeClientFamilyMemberHook } from "./realtime-client-family-member"
+import { realtimeClientSingleHook } from "./realtime-client-single"
+import { realtimeClientTransactionHook } from "./realtime-client-transaction"
+import { atom__INTERNAL, selector__INTERNAL } from "../../internal"
+
+export type RealtimeClientHooks = {
+  socketIdState: AtomIO.ReadonlySelectorToken<string | null>
+  useRemoteState: <J extends Json>(token: AtomIO.StateToken<J>) => void
+  useRemoteFamily: <J extends Json>(
+    family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>
+  ) => void
+  useRemoteFamilyMember: <J extends Json>(
+    family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
+    subKey: string
+  ) => void
+  useRemoteTransaction: <ƒ extends ƒn>(
+    token: AtomIO.TransactionToken<ƒ>
+  ) => (...parameters: Parameters<ƒ>) => ReturnType<ƒ>
+}
+
+export const composeRealtimeHooks = (
+  socket: SocketIO.Socket,
+  store: AtomIO.Store = AtomIO.__INTERNAL__.IMPLICIT.STORE
+): RealtimeClientHooks => {
+  const socketIdState_INTERNAL = atom__INTERNAL<string | null>(
+    {
+      key: `socketIdState_INTERNAL`,
+      default: null,
+      effects: [
+        ({ setSelf }) => {
+          socket.on(`connection`, () => {
+            setSelf(socket.id)
+          })
+        },
+      ],
+    },
+    undefined,
+    store
+  )
+  return {
+    socketIdState: selector__INTERNAL<string | null>(
+      {
+        key: `socketIdState`,
+        get: ({ get }) => get(socketIdState_INTERNAL),
+      },
+      undefined,
+      store
+    ),
+    useRemoteState: realtimeClientSingleHook(socket, store),
+    useRemoteFamily: realtimeClientFamilyHook(socket, store),
+    useRemoteFamilyMember: realtimeClientFamilyMemberHook(socket, store),
+    useRemoteTransaction: realtimeClientTransactionHook(socket, store),
+  }
+}

package/src/realtime-client/hook-composition/realtime-client-family-member.ts

@@ -0,0 +1,28 @@
+import { useEffect } from "react"
+
+import * as AtomIO from "atom.io"
+import type * as SocketIO from "socket.io-client"
+
+import type { Json } from "~/packages/anvl/src/json"
+
+export const realtimeClientFamilyMemberHook =
+  (
+    socket: SocketIO.Socket,
+    store: AtomIO.Store = AtomIO.__INTERNAL__.IMPLICIT.STORE
+  ) =>
+  <J extends Json>(
+    family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>,
+    subKey: AtomIO.Serializable
+  ): void => {
+    const token = family(subKey)
+    useEffect(() => {
+      socket.on(`serve:${token.key}`, (data: J) => {
+        AtomIO.setState(family(subKey), data, store)
+      })
+      socket.emit(`sub:${family.key}`, subKey)
+      return () => {
+        socket.off(`serve:${token.key}`)
+        socket.emit(`unsub:${token.key}`)
+      }
+    }, [family.key])
+  }

package/src/realtime-client/hook-composition/realtime-client-family.ts

@@ -0,0 +1,26 @@
+import { useEffect } from "react"
+
+import * as AtomIO from "atom.io"
+import type * as SocketIO from "socket.io-client"
+
+import type { Json } from "~/packages/anvl/src/json"
+
+export const realtimeClientFamilyHook =
+  (
+    socket: SocketIO.Socket,
+    store: AtomIO.Store = AtomIO.__INTERNAL__.IMPLICIT.STORE
+  ) =>
+  <J extends Json>(
+    family: AtomIO.AtomFamily<J> | AtomIO.SelectorFamily<J>
+  ): void => {
+    useEffect(() => {
+      socket.on(`serve:${family.key}`, (key: Json, data: J) => {
+        AtomIO.setState(family(key), data, store)
+      })
+      socket.emit(`sub:${family.key}`)
+      return () => {
+        socket.off(`serve:${family.key}`)
+        socket.emit(`unsub:${family.key}`)
+      }
+    }, [family.key])
+  }

package/src/realtime-client/hook-composition/realtime-client-single.ts

@@ -0,0 +1,24 @@
+import * as React from "react"
+
+import * as AtomIO from "atom.io"
+import type * as SocketIO from "socket.io-client"
+
+import type { Json } from "~/packages/anvl/src/json"
+
+export const realtimeClientSingleHook =
+  (
+    socket: SocketIO.Socket,
+    store: AtomIO.Store = AtomIO.__INTERNAL__.IMPLICIT.STORE
+  ) =>
+  <J extends Json>(token: AtomIO.StateToken<J>): void => {
+    React.useEffect(() => {
+      socket.on(`serve:${token.key}`, (data: J) => {
+        AtomIO.setState(token, data, store)
+      })
+      socket.emit(`sub:${token.key}`)
+      return () => {
+        socket.off(`serve:${token.key}`)
+        socket.emit(`unsub:${token.key}`)
+      }
+    }, [token.key])
+  }

package/src/realtime-client/hook-composition/realtime-client-transaction.ts

@@ -0,0 +1,35 @@
+import { useEffect } from "react"
+
+import * as AtomIO from "atom.io"
+import type * as SocketIO from "socket.io-client"
+
+import type { ƒn } from "~/packages/anvl/src/function"
+
+const TX_SUBS = new Map<string, number>()
+export const realtimeClientTransactionHook =
+  (
+    socket: SocketIO.Socket,
+    store: AtomIO.Store = AtomIO.__INTERNAL__.IMPLICIT.STORE
+  ) =>
+  <ƒ extends ƒn>(
+    token: AtomIO.TransactionToken<ƒ>
+  ): ((...parameters: Parameters<ƒ>) => ReturnType<ƒ>) => {
+    useEffect(() => {
+      const count = TX_SUBS.get(token.key) ?? 0
+      TX_SUBS.set(token.key, count + 1)
+      const unsubscribe =
+        count === 0
+          ? AtomIO.subscribeToTransaction(
+              token,
+              (update) => socket.emit(`tx:${token.key}`, update),
+              store
+            )
+          : () => null
+      return () => {
+        const newCount = TX_SUBS.get(token.key) ?? 0
+        TX_SUBS.set(token.key, newCount - 1)
+        unsubscribe()
+      }
+    }, [token.key])
+    return AtomIO.runTransaction(token, store)
+  }

package/src/realtime-client/index.ts

@@ -0,0 +1 @@
+export * from "./hook-composition/compose-realtime-hooks"

package/src/selector.ts

@@ -11,12 +11,15 @@ export type SelectorOptions<T> = {
   get: Read<() => T>
   set: Write<(newValue: T) => void>
 }
-export type ReadonlySelectorOptions<T> = Omit<SelectorOptions<T>, `set`>
+export type ReadonlySelectorOptions<T> = {
+  key: string
+  get: Read<() => T>
+}
 
+export function selector<T>(options: SelectorOptions<T>): SelectorToken<T>
 export function selector<T>(
   options: ReadonlySelectorOptions<T>
 ): ReadonlySelectorToken<T>
-export function selector<T>(options: SelectorOptions<T>): SelectorToken<T>
 export function selector<T>(
   options: ReadonlySelectorOptions<T> | SelectorOptions<T>
 ): ReadonlySelectorToken<T> | SelectorToken<T> {
@@ -28,10 +31,10 @@ export type SelectorFamilyOptions<T, K extends Serializable> = {
   get: (key: K) => Read<() => T>
   set: (key: K) => Write<(newValue: T) => void>
 }
-export type ReadonlySelectorFamilyOptions<T, K extends Serializable> = Omit<
-  SelectorFamilyOptions<T, K>,
-  `set`
->
+export type ReadonlySelectorFamilyOptions<T, K extends Serializable> = {
+  key: string
+  get: (key: K) => Read<() => T>
+}
 
 export type SelectorFamily<T, K extends Serializable = Serializable> = ((
   key: K

package/src/silo.ts

@@ -0,0 +1,45 @@
+import { type timeline, getState, setState, subscribe } from "."
+import type { atom, atomFamily } from "./atom"
+import {
+  type Store,
+  atomFamily__INTERNAL,
+  atom__INTERNAL,
+  createStore,
+  selectorFamily__INTERNAL,
+  selector__INTERNAL,
+  timeline__INTERNAL,
+  transaction__INTERNAL,
+} from "./internal"
+import type { selector, selectorFamily } from "./selector"
+import type { transaction } from "./transaction"
+
+export type Silo = ReturnType<typeof silo>
+
+export const silo = (
+  name: string
+): {
+  store: Store
+  atom: typeof atom
+  atomFamily: typeof atomFamily
+  selector: typeof selector
+  selectorFamily: typeof selectorFamily
+  transaction: typeof transaction
+  timeline: typeof timeline
+  getState: typeof getState
+  setState: typeof setState
+  subscribe: typeof subscribe
+} => {
+  const store = createStore(name)
+  return {
+    store,
+    atom: (options) => atom__INTERNAL(options, undefined, store),
+    atomFamily: (options) => atomFamily__INTERNAL(options, store),
+    selector: (options) => selector__INTERNAL(options, undefined, store) as any,
+    selectorFamily: (options) => selectorFamily__INTERNAL(options, store) as any,
+    transaction: (options) => transaction__INTERNAL(options, store),
+    timeline: (options) => timeline__INTERNAL(options, store),
+    getState: (token) => getState(token, store),
+    setState: (token, newValue) => setState(token, newValue, store),
+    subscribe: (token, handler) => subscribe(token, handler, store),
+  }
+}