atom.io 0.13.0 → 0.14.1

package/data/dist/index.d.cts

@@ -1,11 +1,53 @@
-import * as AtomIO from 'atom.io';
-import { SelectorFamily } from 'atom.io';
-import { Store } from 'atom.io/internal';
-import { Json, Stringified } from 'atom.io/json';
+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;
+}
 
-declare function dict<State, Key extends Json.Serializable>(findState: AtomIO.AtomFamily<State, Key> | AtomIO.ReadonlySelectorFamily<State, Key> | AtomIO.SelectorFamily<State, Key>, index: AtomIO.AtomToken<Key[]> | AtomIO.ReadonlySelectorToken<Key[]> | AtomIO.SelectorToken<Key[]>, store?: Store): AtomIO.ReadonlySelectorToken<{
-    [K in Stringified<Key>]: State;
-}>;
+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 primitive = boolean | number | string | null;
 
@@ -81,18 +123,275 @@ declare class Junction<const ASide extends string, const BSide extends string, c
     has(a: string, b?: string): boolean;
 }
 
-interface JoinOptions<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Json.Object | null> extends Json.Object, JunctionSchema<ASide, BSide>, Partial<JunctionEntries<Content>> {
+interface Lineage {
+    parent: typeof this | null;
+    child: typeof this | null;
+}
+
+type Stringified<J extends Serializable> = string & {
+    __json: J;
+};
+
+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;
+};
+
+type AtomFamily<T, K extends Serializable = Serializable> = ((key: K) => AtomToken<T>) & {
+    key: string;
+    type: `atom_family`;
+    subject: Subject<AtomToken<T>>;
+};
+
+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 function dict<State, Key extends Serializable>(findState: AtomFamily<State, Key> | ReadonlySelectorFamily<State, Key> | SelectorFamily<State, Key>, index: AtomToken<Key[]> | ReadonlySelectorToken<Key[]> | SelectorToken<Key[]>, store?: Store): ReadonlySelectorToken<{
+    [K in Stringified<Key>]: State;
+}>;
+
+interface JoinOptions<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Object$1 | null> extends Object$1, JunctionSchema<ASide, BSide>, Partial<JunctionEntries<Content>> {
     readonly key: string;
     readonly cardinality: Cardinality;
 }
-type JoinState<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
+type JoinState<ASide extends string, BSide extends string, Cardinality extends Cardinality, Content extends Object$1 | null> = Cardinality extends `1:1` ? (Content extends Object$1 ? {
     readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntryOf${Capitalize<BSide>}` : `${AB}EntryOf${Capitalize<ASide>}`]: SelectorFamily<[
         string,
         Content
     ] | undefined, string>;
 } : {}) & {
     readonly [AB in ASide | BSide as AB extends ASide ? `${AB}KeyOf${Capitalize<BSide>}` : `${AB}KeyOf${Capitalize<ASide>}`]: SelectorFamily<string | undefined, string>;
-} : Cardinality extends `1:n` ? (Content extends Json.Object ? {
+} : Cardinality extends `1:n` ? (Content extends Object$1 ? {
     readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: SelectorFamily<[
         string,
         Content
@@ -106,7 +405,7 @@ type JoinState<ASide extends string, BSide extends string, Cardinality extends C
     readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: SelectorFamily<string | undefined, string>;
 } & {
     readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: SelectorFamily<string[], string>;
-} : Cardinality extends `n:n` ? (Content extends Json.Object ? {
+} : Cardinality extends `n:n` ? (Content extends Object$1 ? {
     readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntriesOf${Capitalize<BSide>}` : `${AB}EntriesOf${Capitalize<ASide>}`]: SelectorFamily<[
         string,
         Content
@@ -118,7 +417,7 @@ declare function join<const ASide extends string, const BSide extends string, co
     relations: Junction<ASide, BSide>;
     findState: JoinState<ASide, BSide, Cardinality, null>;
 };
-declare function join<const ASide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const BSide extends string, const Content extends Json.Object>(options: JoinOptions<ASide, BSide, Cardinality, Content>, defaultContent: Content, store?: Store): {
+declare function join<const ASide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const BSide extends string, const Content extends Object$1>(options: JoinOptions<ASide, BSide, Cardinality, Content>, defaultContent: Content, store?: Store): {
     relations: Junction<ASide, BSide, Content>;
     findState: JoinState<ASide, BSide, Cardinality, Content>;
 };
@@ -130,9 +429,9 @@ declare function struct<Struct extends {
     default: Struct;
 }, store?: Store): [
     {
-        [K in keyof Struct as `${Key}${Capitalize<K & string>}State`]: AtomIO.AtomToken<Struct[K]>;
+        [K in keyof Struct as `${Key}${Capitalize<K & string>}State`]: AtomToken<Struct[K]>;
     },
-    AtomIO.ReadonlySelectorToken<Struct>
+    ReadonlySelectorToken<Struct>
 ];
 
 declare function structFamily<Struct extends object, Key extends string>(options: {
@@ -140,9 +439,9 @@ declare function structFamily<Struct extends object, Key extends string>(options
     default: Struct;
 }): [
     {
-        [K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<K & string>}State`]: AtomIO.AtomFamily<Struct[K], string>;
+        [K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<K & string>}State`]: AtomFamily<Struct[K], string>;
     },
-    AtomIO.ReadonlySelectorFamily<Struct>
+    ReadonlySelectorFamily<Struct>
 ];
 
 type Loadable<T> = Promise<T> | T;

package/data/dist/index.js

@@ -1,8 +1,7 @@
-import { createSelector, IMPLICIT, createMutableAtomFamily, createAtomFamily, createAtom, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
-import { getState, setState } from 'atom.io';
+import { createSelector, IMPLICIT, createMutableAtomFamily, createAtomFamily, Junction, createAtom, createSelectorFamily, getJsonFamily, getState, setState } from '../../dist/chunk-TE3ZSTQ6.js';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
-// src/dict.ts
+// data/src/dict.ts
 function dict(findState, index, store = IMPLICIT.STORE) {
   return createSelector(
     {
@@ -19,266 +18,6 @@ function dict(findState, index, store = IMPLICIT.STORE) {
     store
   );
 }
-
-// ../../rel8/junction/src/junction.ts
-var Junction = class {
-  constructor(data, config) {
-    this.relations = /* @__PURE__ */ new Map();
-    this.contents = /* @__PURE__ */ new Map();
-    this.makeContentKey = (a, b) => `${a}:${b}`;
-    var _a, _b, _c, _d;
-    this.a = data.between[0];
-    this.b = data.between[1];
-    this.cardinality = data.cardinality;
-    if (!(config == null ? void 0 : config.externalStore)) {
-      this.relations = new Map((_a = data.relations) == null ? void 0 : _a.map(([a, b]) => [a, new Set(b)]));
-      this.contents = new Map(data.contents);
-    }
-    this.isContent = (_b = config == null ? void 0 : config.isContent) != null ? _b : null;
-    if (config == null ? void 0 : config.makeContentKey) {
-      this.makeContentKey = config.makeContentKey;
-    }
-    if (config == null ? void 0 : config.externalStore) {
-      const externalStore = config.externalStore;
-      this.has = (a, b) => externalStore.has(a, b);
-      this.addRelation = (a, b) => {
-        externalStore.addRelation(a, b);
-      };
-      this.deleteRelation = (a, b) => {
-        externalStore.deleteRelation(a, b);
-      };
-      this.replaceRelationsSafely = (a, bs) => {
-        externalStore.replaceRelationsSafely(a, bs);
-      };
-      this.replaceRelationsUnsafely = (a, bs) => {
-        externalStore.replaceRelationsUnsafely(a, bs);
-      };
-      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
-      if (externalStore.getContent) {
-        this.getContentInternal = (contentKey) => {
-          return externalStore.getContent(contentKey);
-        };
-        this.setContent = (contentKey, content) => {
-          externalStore.setContent(contentKey, content);
-        };
-        this.deleteContent = (contentKey) => {
-          externalStore.deleteContent(contentKey);
-        };
-      }
-      for (const [x, ys] of (_c = data.relations) != null ? _c : []) {
-        for (const y of ys)
-          this.addRelation(x, y);
-      }
-      for (const [contentKey, content] of (_d = data.contents) != null ? _d : []) {
-        this.setContent(contentKey, content);
-      }
-    }
-  }
-  getRelatedKeys(key) {
-    return this.relations.get(key);
-  }
-  addRelation(a, b) {
-    let aRelations = this.relations.get(a);
-    let bRelations = this.relations.get(b);
-    if (aRelations) {
-      aRelations.add(b);
-    } else {
-      aRelations = /* @__PURE__ */ new Set([b]);
-      this.relations.set(a, aRelations);
-    }
-    if (bRelations) {
-      bRelations.add(a);
-    } else {
-      bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
-    }
-  }
-  deleteRelation(a, b) {
-    const aRelations = this.relations.get(a);
-    if (aRelations) {
-      aRelations.delete(b);
-      if (aRelations.size === 0) {
-        this.relations.delete(a);
-      }
-      const bRelations = this.relations.get(b);
-      if (bRelations) {
-        bRelations.delete(a);
-        if (bRelations.size === 0) {
-          this.relations.delete(b);
-        }
-      }
-    }
-  }
-  replaceRelationsUnsafely(a, bs) {
-    this.relations.set(a, new Set(bs));
-    for (const b of bs) {
-      const bRelations = /* @__PURE__ */ new Set([a]);
-      this.relations.set(b, bRelations);
-    }
-  }
-  replaceRelationsSafely(a, bs) {
-    const aRelationsPrev = this.relations.get(a);
-    if (aRelationsPrev) {
-      for (const b of aRelationsPrev) {
-        const bRelations = this.relations.get(b);
-        if (bRelations) {
-          if (bRelations.size === 1) {
-            this.relations.delete(b);
-          } else {
-            bRelations.delete(a);
-          }
-          this.contents.delete(this.makeContentKey(a, b));
-        }
-      }
-    }
-    this.relations.set(a, new Set(bs));
-    for (const b of bs) {
-      let bRelations = this.relations.get(b);
-      if (bRelations) {
-        bRelations.add(a);
-      } else {
-        bRelations = /* @__PURE__ */ new Set([a]);
-        this.relations.set(b, bRelations);
-      }
-    }
-  }
-  getContentInternal(contentKey) {
-    return this.contents.get(contentKey);
-  }
-  setContent(contentKey, content) {
-    this.contents.set(contentKey, content);
-  }
-  deleteContent(contentKey) {
-    this.contents.delete(contentKey);
-  }
-  toJSON() {
-    return {
-      between: [this.a, this.b],
-      cardinality: this.cardinality,
-      relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
-      contents: [...this.contents.entries()]
-    };
-  }
-  set(a, ...rest) {
-    var _a;
-    const b = typeof rest[0] === `string` ? rest[0] : a[this.b];
-    const content = ((_a = rest[1]) != null ? _a : typeof rest[0] === `string`) ? void 0 : rest[0];
-    a = typeof a === `string` ? a : a[this.a];
-    switch (this.cardinality) {
-      case `1:1`: {
-        const bPrev = this.getRelatedKey(a);
-        if (bPrev && bPrev !== b)
-          this.delete(bPrev, a);
-      }
-      case `1:n`: {
-        const aPrev = this.getRelatedKey(b);
-        if (aPrev && aPrev !== a)
-          this.delete(aPrev, b);
-      }
-    }
-    if (content) {
-      const contentKey = this.makeContentKey(a, b);
-      this.setContent(contentKey, content);
-    }
-    this.addRelation(a, b);
-    return this;
-  }
-  delete(x, b) {
-    b = typeof b === `string` ? b : x[this.b];
-    const a = typeof x === `string` ? x : x[this.a];
-    if (a === void 0 && typeof b === `string`) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) {
-        for (const a2 of bRelations) {
-          this.delete(a2, b);
-        }
-      }
-    }
-    if (typeof a === `string` && b === void 0) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) {
-        for (const b2 of aRelations) {
-          this.delete(a, b2);
-        }
-      }
-    }
-    if (typeof a === `string` && typeof b === `string`) {
-      this.deleteRelation(a, b);
-      const contentKey = this.makeContentKey(a, b);
-      this.deleteContent(contentKey);
-    }
-    return this;
-  }
-  getRelatedKey(key) {
-    const relations = this.getRelatedKeys(key);
-    if (relations) {
-      if (relations.size > 1) {
-        console.warn(
-          `${relations.size} related keys were found for key "${key}": (${[
-            ...relations
-          ].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`
-        );
-      }
-      for (const relation of relations) {
-        return relation;
-      }
-    }
-  }
-  replaceRelations(a, relations, config) {
-    const hasContent = !Array.isArray(relations);
-    const bs = hasContent ? Object.keys(relations) : relations;
-    if (config == null ? void 0 : config.reckless) {
-      this.replaceRelationsUnsafely(a, bs);
-    } else {
-      this.replaceRelationsSafely(a, bs);
-    }
-    if (hasContent) {
-      for (const b of bs) {
-        const contentKey = this.makeContentKey(a, b);
-        const content = relations[b];
-        this.setContent(contentKey, content);
-      }
-    }
-    return this;
-  }
-  getContent(a, b) {
-    const contentKey = this.makeContentKey(a, b);
-    return this.getContentInternal(contentKey);
-  }
-  getRelationEntries(input) {
-    const a = input[this.a];
-    const b = input[this.b];
-    if (a !== void 0 && b === void 0) {
-      const aRelations = this.getRelatedKeys(a);
-      if (aRelations) {
-        return [...aRelations].map((b2) => {
-          var _a;
-          return [b2, (_a = this.getContent(a, b2)) != null ? _a : null];
-        });
-      }
-    }
-    if (a === void 0 && b !== void 0) {
-      const bRelations = this.getRelatedKeys(b);
-      if (bRelations) {
-        return [...bRelations].map((a2) => {
-          var _a;
-          return [a2, (_a = this.getContent(a2, b)) != null ? _a : null];
-        });
-      }
-    }
-    return [];
-  }
-  has(a, b) {
-    var _a;
-    if (b) {
-      const setA = this.getRelatedKeys(a);
-      return (_a = setA == null ? void 0 : setA.has(b)) != null ? _a : false;
-    }
-    return this.relations.has(a);
-  }
-};
-
-// src/join.ts
 var TRANSACTORS = { get: getState, set: setState };
 function capitalize(string) {
   return string[0].toUpperCase() + string.slice(1);
@@ -328,9 +67,9 @@ function join(options, defaultContent, store = IMPLICIT.STORE) {
     }
   };
   const replaceRelationsSafely = (transactors, a2, bs) => {
-    const aKeys = getRelatedKeys(transactors, a2);
-    if (aKeys) {
-      for (const b2 of aKeys) {
+    const aRelations = getRelatedKeys(transactors, a2);
+    if (aRelations) {
+      for (const b2 of aRelations) {
         const bKeys = getRelatedKeys(transactors, b2);
         if (bKeys) {
           bKeys.delete(a2);
@@ -535,6 +274,8 @@ function join(options, defaultContent, store = IMPLICIT.STORE) {
       throw new Error(`Invalid cardinality: ${options.cardinality}`);
   }
 }
+
+// data/src/struct.ts
 var capitalize2 = (str) => str[0].toUpperCase() + str.slice(1);
 function struct(options, store = IMPLICIT.STORE) {
   const atoms = Object.keys(options.default).reduce((acc, key) => {
@@ -564,6 +305,8 @@ function struct(options, store = IMPLICIT.STORE) {
   );
   return [atoms, structState];
 }
+
+// data/src/struct-family.ts
 var capitalize3 = (str) => str[0].toUpperCase() + str.slice(1);
 var nameFamily = (topKey, subKey) => `find` + capitalize3(topKey) + capitalize3(subKey) + `State`;
 function structFamily(options) {
@@ -595,7 +338,7 @@ function structFamily(options) {
   return [atoms, findStructState];
 }
 
-// src/until.ts
+// data/src/until.ts
 function until(loadable, fallback) {
   if (loadable instanceof Promise) {
     return fallback;