atom.io 0.13.0 → 0.14.1

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

@@ -1,21 +1,401 @@
-import { Transceiver, Store } from 'atom.io/internal';
 import * as SocketIO from 'socket.io';
-import * as AtomIO from 'atom.io';
-import { StateToken } from 'atom.io';
-import { Json } from 'atom.io/json';
 
-declare const useExposeSingle: ({ socket, store }: ServerConfig) => <J extends Json.Serializable>(token: AtomIO.StateToken<J>) => () => void;
+type JsonInterface<T, J extends Serializable = Serializable> = {
+    toJson: (t: T) => J;
+    fromJson: (json: J) => T;
+};
+
+type primitive = boolean | number | string | null;
+
+type Serializable = primitive | Readonly<{
+    [key: string]: Serializable;
+}> | ReadonlyArray<Serializable>;
+type Object$1<Key extends string = string, Value extends Serializable = Serializable> = Record<Key, Value>;
+
+type AtomFamily<T, K extends Serializable = Serializable> = ((key: K) => AtomToken<T>) & {
+    key: string;
+    type: `atom_family`;
+    subject: Subject<AtomToken<T>>;
+};
+type MutableAtomFamily<Core extends Transceiver<any>, SerializableCore extends Serializable, Key extends Serializable> = JsonInterface<Core, SerializableCore> & ((key: Key) => MutableAtomToken<Core, SerializableCore>) & {
+    key: `${string}::mutable`;
+    type: `atom_family`;
+    subject: Subject<MutableAtomToken<Core, SerializableCore>>;
+};
+
+declare const LoggerIconDictionary: {
+    readonly "\u231B": "Timeline event fully captured";
+    readonly "\u23E9": "Timeline redo";
+    readonly "\u23EA": "Timeline undo";
+    readonly "\u23ED\uFE0F": "Transaction redo";
+    readonly "\u23EE\uFE0F": "Transaction undo";
+    readonly "\u23F3": "Timeline event partially captured";
+    readonly "\u23F9\uFE0F": "Time-travel complete";
+    readonly "\uD83D\uDC81": "Notice";
+    readonly "\uD83D\uDD04": "Realtime transaction synchronized";
+    readonly "\u2705": "Realtime transaction success";
+    readonly "\u2728": "Computation complete";
+    readonly "\u274C": "Conflict prevents attempted action";
+    readonly "\u2B55": "Operation start";
+    readonly "\uD83D\uDC1E": "Possible bug in AtomIO";
+    readonly "\uD83D\uDC40": "Subscription added";
+    readonly "\uD83D\uDC6A": "Family member added";
+    readonly "\uD83D\uDCC1": "Stow update";
+    readonly "\uD83D\uDCC3": "Copy mutable";
+    readonly "\uD83D\uDCD6": "Read state";
+    readonly "\uD83D\uDCDD": "Write state";
+    readonly "\uD83D\uDCE2": "Notify subscribers";
+    readonly "\uD83D\uDD0C": "Register dependency";
+    readonly "\uD83D\uDD0D": "Discover root";
+    readonly "\uD83D\uDD25": "Delete state";
+    readonly "\uD83D\uDD27": "Create mutable atom";
+    readonly "\uD83D\uDD28": "Create immutable atom";
+    readonly "\uD83D\uDD34": "Operation complete";
+    readonly "\uD83D\uDDD1": "Evict cached value";
+    readonly "\uD83D\uDCA5": "Caught";
+    readonly "\uD83D\uDE48": "Subscription canceled";
+    readonly "\uD83D\uDEC4": "Apply transaction";
+    readonly "\uD83D\uDEE0\uFE0F": "Install atom into store";
+    readonly "\uD83D\uDEEB": "Begin transaction";
+    readonly "\uD83D\uDEEC": "Complete transaction";
+    readonly "\uD83E\uDDEE": "Computing selector";
+    readonly "\uD83E\uDDF9": "Prepare to evict";
+    readonly "\uD83E\uDE82": "Abort transaction";
+};
+type LoggerIcon = keyof typeof LoggerIconDictionary;
+declare const LOG_LEVELS: readonly ["info", "warn", "error"];
+type LogLevel = (typeof LOG_LEVELS)[number];
+type LogFn = (icon: LoggerIcon, tokenType: `atom` | `readonly_selector` | `selector` | `state` | `timeline` | `transaction` | `unknown`, tokenKey: string, message: string, ...rest: unknown[]) => void;
+type LogFilter = (...params: Parameters<LogFn>) => boolean;
+type Logger = Record<LogLevel, LogFn>;
+declare class AtomIOLogger implements Logger {
+    logLevel: `error` | `info` | `warn` | null;
+    private readonly filter?;
+    private readonly logger;
+    constructor(logLevel: `error` | `info` | `warn` | null, filter?: LogFilter | undefined, logger?: Logger);
+    error: LogFn;
+    info: LogFn;
+    warn: LogFn;
+}
+
+type TransactionToken<_> = {
+    key: string;
+    type: `transaction`;
+    __brand?: _;
+};
+type TransactionUpdate<ƒ extends ƒn> = {
+    key: string;
+    updates: (KeyedStateUpdate<unknown> | TransactionUpdate<ƒn>)[];
+    params: Parameters<ƒ>;
+    output: ReturnType<ƒ>;
+};
+
+type SelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => SelectorToken<T>) & {
+    key: string;
+    type: `selector_family`;
+    subject: Subject<SelectorToken<T>>;
+};
+type ReadonlySelectorFamily<T, K extends Serializable = Serializable> = ((key: K) => ReadonlySelectorToken<T>) & {
+    key: string;
+    type: `readonly_selector_family`;
+    subject: Subject<ReadonlySelectorToken<T>>;
+};
+
+type StateUpdate<T> = {
+    newValue: T;
+    oldValue: T;
+};
+type KeyedStateUpdate<T> = StateUpdate<T> & {
+    key: string;
+    family?: FamilyMetadata;
+};
+
+type TimelineToken = {
+    key: string;
+    type: `timeline`;
+};
+type TimelineUpdate = TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate;
+
+type ƒn = (...parameters: any[]) => any;
+type AtomToken<_> = {
+    key: string;
+    type: `atom`;
+    family?: FamilyMetadata;
+    __brand?: _;
+};
+interface MutableAtomToken<T extends Transceiver<any>, J extends Serializable> extends AtomToken<T> {
+    __asJSON?: J;
+    __update?: T extends Transceiver<infer Update> ? Update : never;
+}
+type SelectorToken<_> = {
+    key: string;
+    type: `selector`;
+    family?: FamilyMetadata;
+    __brand?: _;
+};
+type StateToken<T> = AtomToken<T> | SelectorToken<T>;
+type ReadonlySelectorToken<_> = {
+    key: string;
+    type: `readonly_selector`;
+    family?: FamilyMetadata;
+    __brand?: _;
+};
+type FamilyMetadata = {
+    key: string;
+    subKey: string;
+};
+
+declare class Subject<T> {
+    Subscriber: (value: T) => void;
+    subscribers: Map<string, this[`Subscriber`]>;
+    subscribe(key: string, subscriber: this[`Subscriber`]): () => void;
+    private unsubscribe;
+    next(value: T): void;
+}
+declare class StatefulSubject<T> extends Subject<T> {
+    state: T;
+    constructor(initialState: T);
+    next(value: T): void;
+}
+
+type Selector<T> = {
+    key: string;
+    type: `selector`;
+    family?: FamilyMetadata;
+    install: (store: Store) => void;
+    subject: Subject<{
+        newValue: T;
+        oldValue: T;
+    }>;
+    get: () => T;
+    set: (newValue: T | ((oldValue: T) => T)) => void;
+};
+type ReadonlySelector<T> = {
+    key: string;
+    type: `readonly_selector`;
+    family?: FamilyMetadata;
+    install: (store: Store) => void;
+    subject: Subject<{
+        newValue: T;
+        oldValue: T;
+    }>;
+    get: () => T;
+};
+
+type Transaction<ƒ extends ƒn> = {
+    key: string;
+    type: `transaction`;
+    install: (store: Store) => void;
+    subject: Subject<TransactionUpdate<ƒ>>;
+    run: (...parameters: Parameters<ƒ>) => ReturnType<ƒ>;
+};
+
+type TransactionMeta<ƒ extends ƒn> = {
+    phase: `applying` | `building`;
+    time: number;
+    update: TransactionUpdate<ƒ>;
+};
+
+type Refinement<Unrefined, Refined extends Unrefined> = (value: Unrefined) => value is Refined;
+type Cardinality = `1:1` | `1:n` | `n:n`;
+
+interface JunctionEntries<Content extends Object$1 | null> extends Object$1 {
+    readonly relations: [string, string[]][];
+    readonly contents: [string, Content][];
+}
+interface JunctionSchema<ASide extends string, BSide extends string> extends Object$1 {
+    readonly between: [a: ASide, b: BSide];
+    readonly cardinality: Cardinality;
+}
+type BaseExternalStoreConfiguration = {
+    addRelation: (a: string, b: string) => void;
+    deleteRelation: (a: string, b: string) => void;
+    replaceRelationsSafely: (a: string, bs: string[]) => void;
+    replaceRelationsUnsafely: (a: string, bs: string[]) => void;
+    getRelatedKeys: (key: string) => Set<string> | undefined;
+    has: (a: string, b?: string) => boolean;
+};
+type ExternalStoreWithContentConfiguration<Content extends Object$1> = {
+    getContent: (contentKey: string) => Content | undefined;
+    setContent: (contentKey: string, content: Content) => void;
+    deleteContent: (contentKey: string) => void;
+};
+type Empty<Obj extends object> = {
+    [Key in keyof Obj]?: undefined;
+};
+type ExternalStoreConfiguration<Content extends Object$1 | null> = Content extends Object$1 ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Object$1>>;
+type JunctionAdvancedConfiguration<Content extends Object$1 | null> = {
+    externalStore?: ExternalStoreConfiguration<Content>;
+    isContent?: Refinement<unknown, Content>;
+    makeContentKey?: (a: string, b: string) => string;
+};
+type JunctionJSON<ASide extends string, BSide extends string, Content extends Object$1 | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
+declare class Junction<const ASide extends string, const BSide extends string, const Content extends Object$1 | null = null> {
+    readonly a: ASide;
+    readonly b: BSide;
+    readonly cardinality: Cardinality;
+    readonly relations: Map<string, Set<string>>;
+    readonly contents: Map<string, Content>;
+    isContent: Refinement<unknown, Content> | null;
+    makeContentKey: (a: string, b: string) => string;
+    getRelatedKeys(key: string): Set<string> | undefined;
+    protected addRelation(a: string, b: string): void;
+    protected deleteRelation(a: string, b: string): void;
+    protected replaceRelationsUnsafely(a: string, bs: string[]): void;
+    protected replaceRelationsSafely(a: string, bs: string[]): void;
+    protected getContentInternal(contentKey: string): Content | undefined;
+    protected setContent(contentKey: string, content: Content): void;
+    protected deleteContent(contentKey: string): void;
+    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>, config?: JunctionAdvancedConfiguration<Content>);
+    toJSON(): JunctionJSON<ASide, BSide, Content>;
+    set(a: string, ...rest: Content extends null ? [b: string] : [b: string, content: Content]): this;
+    set(relation: {
+        [Key in ASide | BSide]: string;
+    }, ...rest: Content extends null ? [] | [b?: undefined] : [content: Content]): this;
+    delete(a: string, b?: string): this;
+    delete(relation: Record<ASide | BSide, string> | Record<ASide, string> | Record<BSide, string>, b?: undefined): this;
+    getRelatedKey(key: string): string | undefined;
+    replaceRelations(a: string, relations: Content extends null ? string[] : Record<string, Content>, config?: {
+        reckless: boolean;
+    }): this;
+    getContent(a: string, b: string): Content | undefined;
+    getRelationEntries(input: Record<ASide, string> | Record<BSide, string>): [string, Content][];
+    has(a: string, b?: string): boolean;
+}
+
+interface Lineage {
+    parent: typeof this | null;
+    child: typeof this | null;
+}
+
+interface Transceiver<Signal extends Serializable> {
+    do: (update: Signal) => void;
+    undo: (update: Signal) => void;
+    subscribe: (key: string, fn: (update: Signal) => void) => () => void;
+    cacheUpdateNumber: number;
+    getUpdateNumber: (update: Signal) => number;
+}
+
+/**
+ * @internal Give the tracker a transceiver state and a store, and it will
+ * subscribe to the transceiver's inner value. When the inner value changes,
+ * the tracker will update its own state to reflect the change.
+ */
+declare class Tracker<Mutable extends Transceiver<any>> {
+    private Update;
+    private initializeState;
+    private unsubscribeFromInnerValue;
+    private observeCore;
+    private updateCore;
+    mutableState: MutableAtomToken<Mutable, Serializable>;
+    latestUpdateState: AtomToken<typeof this.Update | null>;
+    constructor(mutableState: MutableAtomToken<Mutable, Serializable>, store: Store);
+}
+
+interface MutableAtom<T> extends Atom<T> {
+    mutable: true;
+}
+
+type OperationProgress = {
+    open: false;
+} | {
+    open: true;
+    done: Set<string>;
+    prev: Map<string, any>;
+    time: number;
+    token: StateToken<any>;
+};
+
+type TimelineAtomUpdate = StateUpdate<unknown> & {
+    key: string;
+    type: `atom_update`;
+    timestamp: number;
+    family?: FamilyMetadata;
+};
+type TimelineSelectorUpdate = {
+    key: string;
+    type: `selector_update`;
+    timestamp: number;
+    atomUpdates: Omit<TimelineAtomUpdate, `timestamp`>[];
+};
+type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
+    key: string;
+    type: `transaction_update`;
+    timestamp: number;
+};
+type Timeline = {
+    type: `timeline`;
+    key: string;
+    at: number;
+    shouldCapture?: (update: TimelineUpdate, timeline: Timeline) => boolean;
+    timeTraveling: `into_future` | `into_past` | null;
+    history: TimelineUpdate[];
+    selectorTime: number | null;
+    transactionKey: string | null;
+    install: (store: Store) => void;
+    subject: Subject<TimelineAtomUpdate | TimelineSelectorUpdate | TimelineTransactionUpdate | `redo` | `undo`>;
+};
+
+declare class Store implements Lineage {
+    parent: Store | null;
+    child: Store | null;
+    valueMap: Map<string, any>;
+    atoms: Map<string, Atom<any> | MutableAtom<any>>;
+    selectors: Map<string, Selector<any>>;
+    readonlySelectors: Map<string, ReadonlySelector<any>>;
+    trackers: Map<string, Tracker<Transceiver<any>>>;
+    families: Map<string, AtomFamily<any, any> | ReadonlySelectorFamily<any, any> | SelectorFamily<any, any>>;
+    timelines: Map<string, Timeline>;
+    transactions: Map<string, Transaction<ƒn>>;
+    atomsThatAreDefault: Set<string>;
+    timelineAtoms: Junction<"timelineKey", "atomKey", null>;
+    selectorAtoms: Junction<"selectorKey", "atomKey", null>;
+    selectorGraph: Junction<"upstreamSelectorKey", "downstreamSelectorKey", {
+        source: string;
+    }>;
+    subject: {
+        atomCreation: Subject<AtomToken<unknown>>;
+        selectorCreation: Subject<ReadonlySelectorToken<unknown> | SelectorToken<unknown>>;
+        transactionCreation: Subject<TransactionToken<ƒn>>;
+        timelineCreation: Subject<TimelineToken>;
+        transactionApplying: StatefulSubject<TransactionMeta<ƒn> | null>;
+        operationStatus: Subject<OperationProgress>;
+    };
+    operation: OperationProgress;
+    transactionMeta: TransactionMeta<ƒn> | null;
+    config: {
+        name: string;
+    };
+    loggers: AtomIOLogger[];
+    logger: Logger;
+    constructor(name: string, store?: Store | null);
+}
+
+type Atom<T> = {
+    key: string;
+    type: `atom`;
+    family?: FamilyMetadata;
+    install: (store: Store) => void;
+    subject: Subject<{
+        newValue: T;
+        oldValue: T;
+    }>;
+    default: T | (() => T);
+    cleanup?: () => void;
+};
+
+declare const useExposeSingle: ({ socket, store, }: ServerConfig) => <J extends Serializable>(token: StateToken<J>) => () => void;
 
-declare const useExposeFamily: ({ socket, store }: ServerConfig) => <J extends Json.Serializable>(family: AtomIO.AtomFamily<J, Json.Serializable> | AtomIO.SelectorFamily<J, Json.Serializable>, index: AtomIO.StateToken<Set<string>>) => () => void;
+declare const useExposeFamily: ({ socket, store, }: ServerConfig) => <J extends Serializable>(family: AtomFamily<J, Serializable> | SelectorFamily<J, Serializable>, index: StateToken<Set<string>>) => () => void;
 
-declare const useExposeMutable: ({ socket, store }: ServerConfig) => <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable>(token: AtomIO.MutableAtomToken<Core, SerializableCore>) => () => void;
+declare const useExposeMutable: ({ socket, store, }: ServerConfig) => <Core extends Transceiver<Serializable>, SerializableCore extends Serializable>(token: MutableAtomToken<Core, SerializableCore>) => () => void;
 
-declare const useExposeMutableFamily: ({ socket, store }: ServerConfig) => <Family extends AtomIO.MutableAtomFamily<Transceiver<Json.Serializable>, Json.Serializable, Json.Serializable>>(family: Family, index: AtomIO.StateToken<Set<string>>) => () => void;
+declare const useExposeMutableFamily: ({ socket, store, }: ServerConfig) => <Family extends MutableAtomFamily<Transceiver<Serializable>, Serializable, Serializable>>(family: Family, index: StateToken<Set<string>>) => () => void;
 
-declare const useReceiveTransaction: ({ socket, store }: ServerConfig) => <ƒ extends AtomIO.ƒn>(tx: AtomIO.TransactionToken<ƒ>) => () => void;
-declare function useSyncTransaction({ socket, store }: ServerConfig): <ƒ extends AtomIO.ƒn>(tx: AtomIO.TransactionToken<ƒ>) => () => void;
+declare const useReceiveTransaction: ({ socket, store }: ServerConfig) => <ƒ extends ƒn>(tx: TransactionToken<ƒ>) => () => void;
+declare function useSyncTransaction({ socket, store, }: ServerConfig): <ƒ extends ƒn>(tx: TransactionToken<ƒ>) => () => void;
 
-declare const useReceiveState: ({ socket, store }: ServerConfig) => <J extends Json.Serializable>(token: StateToken<J>) => () => void;
+declare const useReceiveState: ({ socket, store }: ServerConfig) => <J extends Serializable>(token: StateToken<J>) => () => void;
 
 type ServerConfig = {
     socket: SocketIO.Socket;

package/realtime-server/dist/index.js

@@ -1,10 +1,10 @@
-import * as AtomIO4 from 'atom.io';
-import { setState } from 'atom.io';
-import { parseJson } from 'atom.io/json';
-import { getJsonToken, getUpdateToken } from 'atom.io/internal';
+import { IMPLICIT, getJsonToken, getUpdateToken, getState, subscribeToState, parseJson, runTransaction, subscribeToTransaction, setState } from '../../dist/chunk-TE3ZSTQ6.js';
 
-// src/hook-composition/expose-single.ts
-var useExposeSingle = ({ socket, store }) => {
+// realtime-server/src/hook-composition/expose-single.ts
+var useExposeSingle = ({
+  socket,
+  store = IMPLICIT.STORE
+}) => {
   return function exposeSingle(token) {
     let unsubscribeFromStateUpdates = null;
     const fillUnsubRequest = () => {
@@ -13,8 +13,8 @@ var useExposeSingle = ({ socket, store }) => {
       unsubscribeFromStateUpdates = null;
     };
     const fillSubRequest = () => {
-      socket.emit(`serve:${token.key}`, AtomIO4.getState(token, store));
-      unsubscribeFromStateUpdates = AtomIO4.subscribe(
+      socket.emit(`serve:${token.key}`, getState(token, store));
+      unsubscribeFromStateUpdates = subscribeToState(
         token,
         ({ newValue }) => {
           socket.emit(`serve:${token.key}`, newValue);
@@ -31,11 +31,16 @@ var useExposeSingle = ({ socket, store }) => {
     };
   };
 };
+
+// realtime-server/src/hook-composition/expose-family.ts
 var subscribeToTokenCreation = (family, key, handleTokenCreation) => {
   const unsubscribe = family.type === `atom_family` ? family.subject.subscribe(key, handleTokenCreation) : family.subject.subscribe(key, handleTokenCreation);
   return unsubscribe;
 };
-var useExposeFamily = ({ socket, store }) => {
+var useExposeFamily = ({
+  socket,
+  store = IMPLICIT.STORE
+}) => {
   return function exposeFamily(family, index) {
     const unsubSingleCallbacksByKey = /* @__PURE__ */ new Map();
     const unsubFamilyCallbacksByKey = /* @__PURE__ */ new Map();
@@ -57,20 +62,20 @@ var useExposeFamily = ({ socket, store }) => {
     const fillSubRequest = (subKey) => {
       var _a;
       if (subKey === void 0) {
-        const keys = AtomIO4.getState(index, store);
+        const keys = getState(index, store);
         for (const key of keys) {
           const token = family(key);
           socket.emit(
             `serve:${family.key}`,
             parseJson(((_a = token.family) == null ? void 0 : _a.subKey) || `null`),
-            AtomIO4.getState(token, store)
+            getState(token, store)
           );
         }
         const unsubscribeFromTokenCreation = subscribeToTokenCreation(
           family,
           `expose-family:${socket.id}`,
           (token) => {
-            const unsub = AtomIO4.subscribe(
+            const unsub = subscribeToState(
               token,
               ({ newValue }) => {
                 var _a2;
@@ -90,8 +95,8 @@ var useExposeFamily = ({ socket, store }) => {
         socket.on(`unsub:${family.key}`, fillFamilyUnsubRequest);
       } else {
         const token = family(subKey);
-        socket.emit(`serve:${token.key}`, AtomIO4.getState(token, store));
-        const unsubscribe = AtomIO4.subscribe(
+        socket.emit(`serve:${token.key}`, getState(token, store));
+        const unsubscribe = subscribeToState(
           token,
           ({ newValue }) => {
             socket.emit(`serve:${token.key}`, newValue);
@@ -119,7 +124,12 @@ var useExposeFamily = ({ socket, store }) => {
     };
   };
 };
-var useExposeMutable = ({ socket, store }) => {
+
+// realtime-server/src/hook-composition/expose-mutable.ts
+var useExposeMutable = ({
+  socket,
+  store = IMPLICIT.STORE
+}) => {
   return function exposeMutable(token) {
     let unsubscribeFromStateUpdates = null;
     const jsonToken = getJsonToken(token);
@@ -130,8 +140,8 @@ var useExposeMutable = ({ socket, store }) => {
       unsubscribeFromStateUpdates = null;
     };
     const fillSubRequest = () => {
-      socket.emit(`init:${token.key}`, AtomIO4.getState(jsonToken, store));
-      unsubscribeFromStateUpdates = AtomIO4.subscribe(
+      socket.emit(`init:${token.key}`, getState(jsonToken, store));
+      unsubscribeFromStateUpdates = subscribeToState(
         trackerToken,
         ({ newValue }) => {
           socket.emit(`next:${token.key}`, newValue);
@@ -148,7 +158,12 @@ var useExposeMutable = ({ socket, store }) => {
     };
   };
 };
-var useExposeMutableFamily = ({ socket, store }) => {
+
+// realtime-server/src/hook-composition/expose-mutable-family.ts
+var useExposeMutableFamily = ({
+  socket,
+  store = IMPLICIT.STORE
+}) => {
   return function exposeMutableFamily(family, index) {
     const unsubSingleCallbacksByKey = /* @__PURE__ */ new Map();
     const unsubFamilyCallbacksByKey = /* @__PURE__ */ new Map();
@@ -170,7 +185,7 @@ var useExposeMutableFamily = ({ socket, store }) => {
     const fillSubRequest = (subKey) => {
       var _a;
       if (subKey === void 0) {
-        const keys = AtomIO4.getState(index, store);
+        const keys = getState(index, store);
         for (const key of keys) {
           const token = family(key);
           const jsonToken = getJsonToken(token);
@@ -178,9 +193,9 @@ var useExposeMutableFamily = ({ socket, store }) => {
           socket.emit(
             `init:${family.key}`,
             parseJson(((_a = jsonToken.family) == null ? void 0 : _a.subKey) || `null`),
-            AtomIO4.getState(jsonToken, store)
+            getState(jsonToken, store)
           );
-          const unsubFromUpdates = AtomIO4.subscribe(
+          const unsubFromUpdates = subscribeToState(
             trackerToken,
             ({ newValue }) => {
               var _a2;
@@ -204,9 +219,9 @@ var useExposeMutableFamily = ({ socket, store }) => {
             socket.emit(
               `init:${family.key}`,
               parseJson(((_a2 = jsonToken.family) == null ? void 0 : _a2.subKey) || `null`),
-              AtomIO4.getState(jsonToken, store)
+              getState(jsonToken, store)
             );
-            const unsubFromUpdates = AtomIO4.subscribe(
+            const unsubFromUpdates = subscribeToState(
               trackerToken,
               ({ newValue }) => {
                 var _a3;
@@ -228,8 +243,8 @@ var useExposeMutableFamily = ({ socket, store }) => {
         const token = family(subKey);
         const jsonToken = getJsonToken(token);
         const updateToken = getUpdateToken(token);
-        socket.emit(`init:${token.key}`, AtomIO4.getState(jsonToken, store));
-        const unsubscribe = AtomIO4.subscribe(
+        socket.emit(`init:${token.key}`, getState(jsonToken, store));
+        const unsubscribe = subscribeToState(
           updateToken,
           ({ newValue }) => {
             socket.emit(`next:${token.key}`, newValue);
@@ -257,26 +272,38 @@ var useExposeMutableFamily = ({ socket, store }) => {
     };
   };
 };
+
+// realtime-server/src/hook-composition/receive-transaction.ts
 var useReceiveTransaction = ({ socket, store }) => {
   return function receiveTransaction(tx) {
-    const fillTransactionRequest = (update) => AtomIO4.runTransaction(tx, store)(...update.params);
+    const fillTransactionRequest = (update) => runTransaction(tx, store)(...update.params);
     socket.on(`tx:${tx.key}`, fillTransactionRequest);
     return () => socket.off(`tx:${tx.key}`, fillTransactionRequest);
   };
 };
-function useSyncTransaction({ socket, store }) {
+function useSyncTransaction({
+  socket,
+  store = IMPLICIT.STORE
+}) {
   return function receiveTransaction(tx) {
     const fillTransactionRequest = (update, transactionId) => {
-      const unsubscribe = AtomIO4.subscribeToTransaction(tx, (update2) => {
-        unsubscribe();
-        socket.emit(`tx:sync:${transactionId}`, update2);
-      });
-      AtomIO4.runTransaction(tx, store)(...update.params);
+      const unsubscribe = subscribeToTransaction(
+        tx,
+        (update2) => {
+          unsubscribe();
+          socket.emit(`tx:sync:${transactionId}`, update2);
+        },
+        `sync:${transactionId}`,
+        store
+      );
+      runTransaction(tx, store)(...update.params);
     };
     socket.on(`tx:${tx.key}`, fillTransactionRequest);
     return () => socket.off(`tx:${tx.key}`, fillTransactionRequest);
   };
 }
+
+// realtime-server/src/hook-composition/receive-state.ts
 var useReceiveState = ({ socket, store }) => {
   return function receiveState(token) {
     const publish = (newValue) => setState(token, newValue, store);