atom.io 0.31.0 → 0.31.1

package/ephemeral/dist/index.d.ts

@@ -3,54 +3,64 @@ import { Transceiver } from 'atom.io/internal';
 import { Json, Canonical } from 'atom.io/json';
 
 /**
- * @overload Mutable Atom
- * Finds a {@link MutableAtomToken} in the store.
- * @param token - A {@link MutableAtomFamilyToken}.
- * @param key - The key of the state.
+ * @public
+ * Finds a {@link MutableAtomToken} in the store
+ * @param token - A {@link MutableAtomFamilyToken}
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Mutable Atom
  */
 declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Regular Atom
  */
 declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Writable Selector
  */
 declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K>;
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Readonly Selector
  */
 declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K>;
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Writable State
  */
 declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
 /**
  * @public
- * Finds a {@link ReadableToken} in the store.
- * @param token - A {@link ReadableFamilyToken}.
- * @param key - The key of the state.
+ * Finds a {@link ReadableToken} in the store
+ * @param token - A {@link ReadableFamilyToken}
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
  * @overload Unknown
+ * @default
  */
 declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
 

package/ephemeral/src/find-state.ts

@@ -17,12 +17,13 @@ import { findInStore, IMPLICIT } from "atom.io/internal"
 import type { Canonical, Json } from "atom.io/json"
 
 /**
- * @overload Mutable Atom
- * Finds a {@link MutableAtomToken} in the store.
- * @param token - A {@link MutableAtomFamilyToken}.
- * @param key - The key of the state.
+ * @public
+ * Finds a {@link MutableAtomToken} in the store
+ * @param token - A {@link MutableAtomFamilyToken}
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Mutable Atom
  */
 export function findState<
 	T extends Transceiver<any>,
@@ -31,44 +32,52 @@ export function findState<
 	Key extends K,
 >(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Regular Atom
  */
 export function findState<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 ): RegularAtomToken<T, K>
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Writable Selector
  */
 export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 ): WritableSelectorToken<T, K>
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Readonly Selector
  */
 export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 ): ReadonlySelectorToken<T, K>
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Writable State
  */
 export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
@@ -76,12 +85,13 @@ export function findState<T, K extends Canonical, Key extends K>(
 ): WritableToken<T, K>
 /**
  * @public
- * Finds a {@link ReadableToken} in the store.
- * @param token - A {@link ReadableFamilyToken}.
- * @param key - The key of the state.
+ * Finds a {@link ReadableToken} in the store
+ * @param token - A {@link ReadableFamilyToken}
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
  * @overload Unknown
+ * @default
  */
 export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,

package/internal/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, AtomFamilyToken, AtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, SelectorFamilyToken, SelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, MoleculeTransfer, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, AtomFamilyToken, AtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, SelectorFamilyToken, SelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, TimelineManageable, TimelineToken, AtomIOToken, Hierarchy, Vassal, Above, Claim, CompoundFrom, CompoundTypedKey, SingularTypedKey, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, MoleculeTransfer, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json, Canonical, stringified, JsonInterface } from 'atom.io/json';
 import { Join } from 'atom.io/data';
 import { Store as Store$1, Func as Func$1 } from 'atom.io/internal';
@@ -221,8 +221,8 @@ declare function deposit<T>(state: SelectorFamily<T, any>): SelectorFamilyToken<
 declare function deposit<T>(state: WritableFamily<T, any>): WritableFamilyToken<T, any>;
 declare function deposit<T>(state: ReadableFamily<T, any>): ReadableFamilyToken<T, any>;
 declare function deposit<T extends Func>(state: Transaction<T>): TransactionToken<T>;
-declare function deposit(state: ReadableState<any>): ReadableToken<any>;
-declare function deposit(state: ReadableFamily<any, any> | ReadableState<any> | Transaction<Func>): ReadableFamilyToken<any, any> | ReadableToken<any> | TransactionToken<Func>;
+declare function deposit<M extends TimelineManageable>(state: Timeline<M>): TimelineToken<M>;
+declare function deposit(resource: AtomIOInternalResource): AtomIOToken;
 
 interface Lineage {
     parent: typeof this | null;
@@ -235,6 +235,11 @@ type Molecule<K extends Canonical> = {
     readonly stringKey: stringified<K>;
     readonly dependsOn: `all` | `any`;
 };
+declare function makeRootMoleculeInStore<S extends string>(key: S, store?: Store): S;
+declare function allocateIntoStore<H extends Hierarchy, V extends Vassal<H>, A extends Above<V, H>>(store: Store, provenance: A, key: V, dependsOn?: `all` | `any`): Claim<V>;
+declare function fuseWithinStore<H extends Hierarchy, C extends CompoundFrom<H>, T extends C extends CompoundTypedKey<infer t, any, any> ? t : never, A extends C extends CompoundTypedKey<any, infer a, any> ? a : never, B extends C extends CompoundTypedKey<any, any, infer b> ? b : never>(store: Store, type: T, sideA: SingularTypedKey<A>, sideB: SingularTypedKey<B>): Claim<CompoundTypedKey<T, A, B>>;
+declare function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(store: Store, claim: Claim<V>): void;
+declare function claimWithinStore<H extends Hierarchy, V extends Exclude<Vassal<H>, CompoundTypedKey>, A extends Above<V, H>>(store: Store, newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V>;
 
 type OperationProgress = {
     open: false;
@@ -310,7 +315,7 @@ declare class Store implements Lineage {
         source: string;
     }>;
     trackers: Map<string, Tracker<Transceiver<any>>>;
-    families: Map<string, MutableAtomFamily<any, any, any> | ReadonlySelectorFamily<any, any> | RegularAtomFamily<any, any> | WritableSelectorFamily<any, any>>;
+    families: Map<string, MutableAtomFamily<any, any, any> | RegularAtomFamily<any, any> | ReadonlySelectorFamily<any, any> | WritableSelectorFamily<any, any>>;
     joins: Map<string, Join<any, any, any, any, any, any, `T$--content==${any}::${string}++${any}::${string}`>>;
     transactions: Map<string, Transaction<Func>>;
     transactionMeta: TransactionEpoch | TransactionProgress<Func>;
@@ -355,7 +360,6 @@ declare const IMPLICIT: {
 };
 declare const clearStore: (store: Store) => void;
 
-type Withdrawable = Atom<any> | AtomFamily<any, any> | Molecule<any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableFamily<any, any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableFamily<any, any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
 declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T>;
 declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any>;
 declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
@@ -374,7 +378,9 @@ declare function withdraw<T, K extends Canonical>(token: ReadableFamilyToken<T,
 declare function withdraw<T, K extends Canonical>(token: WritableFamilyToken<T, K>, store: Store): WritableFamily<T, any>;
 declare function withdraw<T extends Func>(token: TransactionToken<T>, store: Store): Transaction<T extends Func ? T : never>;
 declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never>;
+declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T>;
 declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T>;
+declare function withdraw(token: AtomIOToken, store: Store): AtomIOInternalResource;
 
 interface Transceiver<S extends Json.Serializable> {
     do: (update: S) => number | `OUT_OF_RANGE` | null;
@@ -555,14 +561,12 @@ declare class LazyMap<K, V> extends Map<K, V> {
     delete(key: K): boolean;
 }
 
-type AtomIOToken = ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
-declare function prettyPrintTokenType(token: AtomIOToken): string;
-
 declare class NotFoundError extends Error {
     constructor(token: AtomIOToken, store: Store);
-    constructor(familyToken: AtomIOToken, key: Json.Serializable, store: Store);
 }
 
+declare function prettyPrintTokenType(token: AtomIOToken): string;
+
 declare const createReadonlySelector: <T>(store: Store, options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined) => ReadonlySelectorToken<T>;
 
 declare function createStandaloneSelector<T>(store: Store, options: WritableSelectorOptions<T>): WritableSelectorToken<T>;
@@ -664,5 +668,6 @@ type ReadonlySelectorFamily<T, K extends Canonical> = ReadonlySelectorFamilyToke
 type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K>;
 type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelectorFamily<T, K>;
 type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
+type AtomIOInternalResource = ReadableFamily<any, any> | ReadableState<any> | Timeline<any> | Transaction<any>;
 
-export { type Atom, type AtomFamily, type AtomIOState, type AtomIOToken, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, CircularBuffer, type Count, type Each, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionEntriesBase, type JunctionJSON, type JunctionSchema, type JunctionSchemaBase, LazyMap, type Lineage, type Modify, type Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type Refinement, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { type Atom, type AtomFamily, type AtomIOInternalResource, type AtomIOState, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, CircularBuffer, type Count, type Each, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionEntriesBase, type JunctionJSON, type JunctionSchema, type JunctionSchemaBase, LazyMap, type Lineage, type Modify, type Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type Refinement, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };

package/internal/dist/index.js

@@ -1,3 +1,2 @@
-export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-42UH5F5Q.js';
-import '../../dist/chunk-ICGFFQ3H.js';
+export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, evictCachedValue, findInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-Y5MBNTVU.js';
 import '../../dist/chunk-XWL6SNVU.js';

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

@@ -16,12 +16,7 @@ import type {
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import {
-	type Canonical,
-	type Json,
-	stringified,
-	stringifyJson,
-} from "atom.io/json"
+import { type Canonical, type Json, stringifyJson } from "atom.io/json"
 
 import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"

package/internal/src/index.ts

@@ -17,6 +17,8 @@ import type { Canonical, Json, JsonInterface } from "atom.io/json"
 import type { Transceiver } from "./mutable"
 import type { Store } from "./store"
 import type { Subject } from "./subject"
+import type { Timeline } from "./timeline"
+import type { Transaction } from "./transaction"
 
 export * from "./arbitrary"
 export * from "./atom"
@@ -31,7 +33,7 @@ export * from "./junction"
 export * from "./keys"
 export * from "./lazy-map"
 export * from "./lineage"
-export type * from "./molecule"
+export * from "./molecule"
 export * from "./mutable"
 export * from "./not-found-error"
 export * from "./operation"
@@ -100,14 +102,14 @@ T extends Transceiver<any>,
 J extends Json.Serializable,
 K extends Canonical,
 > = 
-& JsonInterface<T, J>
-& MutableAtomFamilyToken<T, J, K>
-& {
-		(key: K): MutableAtomToken<T, J>
-		subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>
-		install: (store: Store) => void
-		internalRoles: string[] | undefined
-	}
+	& JsonInterface<T, J>
+	& MutableAtomFamilyToken<T, J, K>
+	& {
+			(key: K): MutableAtomToken<T, J>
+			subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>
+			install: (store: Store) => void
+			internalRoles: string[] | undefined
+		}
 
 export type AtomFamily<T, K extends Canonical = Canonical> =
 	| MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K>
@@ -145,3 +147,9 @@ export type WritableFamily<T, K extends Canonical> =
 export type ReadableFamily<T, K extends Canonical> =
 	| AtomFamily<T, K>
 	| SelectorFamily<T, K>
+
+export type AtomIOInternalResource =
+	| ReadableFamily<any, any>
+	| ReadableState<any>
+	| Timeline<any>
+	| Transaction<any>

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

@@ -8,13 +8,12 @@ import type {
 } from "atom.io"
 import { parseJson, stringifyJson } from "atom.io/json"
 
+import { disposeFromStore, findInStore } from "../families"
 import {
 	allocateIntoStore,
 	claimWithinStore,
 	deallocateFromStore,
-} from "~/packages/atom.io/src/allocate"
-
-import { disposeFromStore, findInStore } from "../families"
+} from "../molecule"
 import type { Store } from "../store"
 
 export function ingestCreationEvent(

package/internal/src/install-into-store.ts

@@ -0,0 +1,48 @@
+import type { AtomIOToken } from "atom.io"
+
+import { newest } from "./lineage"
+import { type Store, withdraw } from "./store"
+import { isChildStore } from "./transaction"
+
+/**
+ * @public
+ * Install the given tokens into the target store
+ * @param tokens - States, families, transactions, and timelines to install into the target store
+ * @param target - The store to install the tokens into
+ * @param source - The store to install the tokens from
+ *
+ */
+export function installIntoStore(
+	tokens: AtomIOToken[],
+	target: Store,
+	source: Store,
+): void {
+	const sourceNewest = newest(source)
+	if (isChildStore(sourceNewest)) {
+		source.logger.error(
+			`❌`,
+			`transaction`,
+			sourceNewest.transactionMeta.update.key,
+			`could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
+			tokens,
+			`${sourceNewest.config.name} is undergoing a transaction.`,
+		)
+		return
+	}
+	const targetNewest = newest(target)
+	if (isChildStore(targetNewest)) {
+		target.logger.error(
+			`❌`,
+			`transaction`,
+			targetNewest.transactionMeta.update.key,
+			`could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
+			tokens,
+			`${targetNewest.config.name} is undergoing a transaction.`,
+		)
+		return
+	}
+	for (const token of tokens) {
+		const resource = withdraw(token, source)
+		resource.install(target)
+	}
+}