atom.io 0.27.3 → 0.27.4

package/dist/{chunk-ETCFHO7J.js → chunk-JRENM6KL.js}

@@ -202,7 +202,7 @@ var readOrComputeValue = (state, target) => {
     target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
     return readCachedValue(state, target);
   }
-  if (state.type !== `atom` && state.type !== `mutable_atom`) {
+  if (state.type === `selector` || state.type === `readonly_selector`) {
     target.logger.info(`\u{1F9EE}`, state.type, state.key, `computing value`);
     return state.get();
   }
@@ -481,6 +481,7 @@ function createRegularAtomFamily(options, store, internalRoles) {
     internalRoles
   });
   store.families.set(options.key, atomFamily);
+  store.defaults.set(options.key, options.default);
   return familyToken;
 }
 
@@ -492,8 +493,6 @@ function createAtomFamily(options, store) {
   }
   return createRegularAtomFamily(options, store);
 }
-
-// internal/src/get-state/get-from-store.ts
 function getFromStore(...params) {
   let token;
   let store;
@@ -506,7 +505,31 @@ function getFromStore(...params) {
     store = params[2];
     const maybeToken = family.type === `molecule_family` ? seekInStore(family, key, store) : store.config.lifespan === `immortal` ? seekInStore(family, key, store) : findInStore(family, key, store);
     if (!maybeToken) {
-      throw new NotFoundError(family, key, store);
+      store.logger.error(
+        `\u2757`,
+        family.type,
+        family.key,
+        `tried to get member`,
+        stringifyJson(key),
+        `but it was not found in store`,
+        store.config.name
+      );
+      switch (family.type) {
+        case `atom_family`:
+        case `mutable_atom_family`:
+          return store.defaults.get(family.key);
+        case `selector_family`:
+        case `readonly_selector_family`: {
+          if (store.defaults.has(family.key)) {
+            return store.defaults.get(family.key);
+          }
+          const defaultValue = withdraw(family, store).default(key);
+          store.defaults.set(family.key, defaultValue);
+          return defaultValue;
+        }
+        case `molecule_family`:
+          throw new NotFoundError(family, key, store);
+      }
     }
     token = maybeToken;
   }
@@ -720,18 +743,18 @@ var createWritableSelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
   const covered = /* @__PURE__ */ new Set();
-  const toolkit = registerSelector(options.key, covered, target);
-  const { find, get, seek, json } = toolkit;
+  const setterToolkit = registerSelector(options.key, covered, target);
+  const { find, get, seek, json } = setterToolkit;
   const getterToolkit = { find, get, seek, json };
-  const getSelf = (innerTarget = newest(store)) => {
-    const value = options.get(getterToolkit);
+  const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
+    const value = getFn(getterToolkit);
     cacheValue(options.key, value, subject, innerTarget);
     covered.clear();
     return value;
   };
   const setSelf = (next) => {
     const innerTarget = newest(store);
-    const oldValue = getSelf(innerTarget);
+    const oldValue = getSelf(options.get, innerTarget);
     const newValue = become(next)(oldValue);
     store.logger.info(
       `\u{1F4DD}`,
@@ -748,7 +771,7 @@ var createWritableSelector = (options, family, store) => {
     if (isRootStore(innerTarget)) {
       subject.next({ newValue, oldValue });
     }
-    options.set(toolkit, newValue);
+    options.set(setterToolkit, newValue);
   };
   const mySelector = {
     ...options,
@@ -885,9 +908,18 @@ function createReadonlySelectorFamily(options, store, internalRoles) {
     return token;
   };
   const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+    internalRoles,
     subject,
     install: (s) => createReadonlySelectorFamily(options, s),
-    internalRoles
+    default: (key) => {
+      const getFn = options.get(key);
+      return getFn({
+        get: (token) => getFromStore(token, store),
+        find: (token, k) => findInStore(token, k, store),
+        seek: (token, k) => seekInStore(token, k, store),
+        json: (token) => getJsonToken(token, store)
+      });
+    }
   });
   store.families.set(options.key, readonlySelectorFamily);
   return familyToken;
@@ -917,9 +949,19 @@ function createWritableSelectorFamily(options, store, internalRoles) {
     return token;
   };
   const selectorFamily = Object.assign(familyFunction, familyToken, {
+    internalRoles,
     subject,
     install: (s) => createWritableSelectorFamily(options, s),
-    internalRoles
+    default: (key) => {
+      const getFn = options.get(key);
+      return getFn({
+        get: (...params) => getFromStore(...params, store),
+        // TODO: make store zero-arg
+        find: (token, k) => findInStore(token, k, store),
+        seek: (token, k) => seekInStore(token, k, store),
+        json: (token) => getJsonToken(token, store)
+      });
+    }
   });
   store.families.set(options.key, selectorFamily);
   return familyToken;
@@ -1051,9 +1093,6 @@ function seekInStore(token, key, store) {
       break;
     case `molecule_family`:
       state = target.molecules.get(stringifyJson(key));
-      if (state) {
-        return deposit(state);
-      }
   }
   if (state) {
     return deposit(state);
@@ -1089,7 +1128,16 @@ function disposeFromStore(...params) {
     store = params[2];
     const maybeToken = family.type === `molecule_family` ? seekInStore(family, key, store) : store.config.lifespan === `immortal` ? seekInStore(family, key, store) : findInStore(family, key, store);
     if (!maybeToken) {
-      throw new NotFoundError(family, key, store);
+      store.logger.error(
+        `\u2757`,
+        family.type,
+        family.key,
+        `tried to dispose of member`,
+        stringifyJson(key),
+        `but it was not found in store`,
+        store.config.name
+      );
+      return;
     }
     token = maybeToken;
   }
@@ -1124,7 +1172,18 @@ function setIntoStore(...params) {
     store = params[3];
     const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(family, key, store) : seekInStore(family, key, store);
     if (!maybeToken) {
-      throw new NotFoundError(family, key, store);
+      store.logger.error(
+        `\u2757`,
+        family.type,
+        family.key,
+        `tried to set member`,
+        stringifyJson(key),
+        `to`,
+        value,
+        `but it was not found in store`,
+        store.config.name
+      );
+      return;
     }
     token = maybeToken;
   }
@@ -1609,6 +1668,7 @@ var buildTransaction = (key, params, store, id) => {
     }),
     selectors: new LazyMap(parent.selectors),
     valueMap: new LazyMap(parent.valueMap),
+    defaults: parent.defaults,
     molecules: new LazyMap(parent.molecules),
     moleculeFamilies: new LazyMap(parent.moleculeFamilies),
     moleculeInProgress: parent.moleculeInProgress,
@@ -1711,6 +1771,7 @@ var Store = class {
   parent = null;
   child = null;
   valueMap = /* @__PURE__ */ new Map();
+  defaults = /* @__PURE__ */ new Map();
   atoms = /* @__PURE__ */ new Map();
   selectors = /* @__PURE__ */ new Map();
   readonlySelectors = /* @__PURE__ */ new Map();

package/dist/index.d.ts

@@ -287,7 +287,7 @@ declare const LoggerIconDictionary: {
     readonly "\uD83D\uDC41": "Determining perspective";
 };
 type LoggerIcon = keyof typeof LoggerIconDictionary;
-type TokenDenomination = `atom` | `continuity` | `molecule_family` | `molecule` | `mutable_atom` | `readonly_selector` | `selector` | `state` | `timeline` | `transaction` | `unknown`;
+type TokenDenomination = `atom_family` | `atom` | `continuity` | `molecule_family` | `molecule` | `mutable_atom_family` | `mutable_atom` | `readonly_selector_family` | `readonly_selector` | `selector_family` | `selector` | `state` | `timeline` | `transaction` | `unknown`;
 declare const LOG_LEVELS: readonly ["info", "warn", "error"];
 type LogLevel = (typeof LOG_LEVELS)[number];
 type LogFn = (icon: LoggerIcon, denomination: TokenDenomination, tokenKey: string, message: string, ...rest: unknown[]) => void;

package/internal/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as atom_io from 'atom.io';
-import { TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, MoleculeToken, MoleculeFamily, MoleculeFamilyToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeConstructor, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, AtomIOLogger, Logger, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, ReadableFamilyToken, WritableFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MoleculeKey, KeyedStateUpdate, MoleculeFamilyOptions, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, MoleculeConstructor, MoleculeFamily, MoleculeFamilyToken, MoleculeToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, AtomIOLogger, Logger, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, ReadableFamilyToken, WritableFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MoleculeKey, KeyedStateUpdate, MoleculeFamilyOptions, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Canonical, Json, JsonInterface } from 'atom.io/json';
 import { Join } from 'atom.io/data';
 
@@ -156,14 +156,11 @@ declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T
 declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
 declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
 declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
-declare function deposit<K extends Canonical, S extends {
-    [key: string]: any;
-}, P extends any[]>(state: Molecule<any>): MoleculeToken<any>;
-declare function deposit<K extends Canonical, S extends {
-    [key: string]: any;
-}, P extends any[]>(state: MoleculeFamily<any>): MoleculeFamilyToken<any>;
+declare function deposit<M extends MoleculeConstructor>(state: MoleculeFamily<M>): MoleculeFamilyToken<M>;
+declare function deposit<M extends MoleculeConstructor>(state: Molecule<M>): MoleculeToken<M>;
 declare function deposit<T extends Func>(state: Transaction<T>): TransactionToken<T>;
 declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
+declare function deposit(state: Molecule<any> | ReadableState<any>): MoleculeToken<any> | ReadableToken<any>;
 
 interface Lineage {
     parent: typeof this | null;
@@ -236,6 +233,7 @@ declare class Store implements Lineage {
     parent: Store | null;
     child: Store | null;
     valueMap: Map<string, any>;
+    defaults: Map<string, any>;
     atoms: Map<string, Atom<any>>;
     selectors: Map<string, WritableSelector<any>>;
     readonlySelectors: Map<string, ReadonlySelector<any>>;
@@ -604,15 +602,14 @@ type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable,
     internalRoles: string[] | undefined;
 };
 type AtomFamily<T, K extends Canonical = Canonical> = MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamily<T, K>;
-type WritableSelectorFamily<T, K extends Canonical> = WritableSelectorFamilyToken<T, K> & {
-    (key: K): WritableSelectorToken<T>;
+type WritableSelectorFamily<T, K extends Canonical> = WritableSelectorFamilyToken<T, K> & ((key: K) => WritableSelectorToken<T>) & {
+    default: (key: K) => T;
     subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>;
     install: (store: Store) => void;
     internalRoles: string[] | undefined;
 };
-type ReadonlySelectorFamily<T, K extends Canonical> = ((key: K) => ReadonlySelectorToken<T>) & {
-    key: string;
-    type: `readonly_selector_family`;
+type ReadonlySelectorFamily<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> & ((key: K) => ReadonlySelectorToken<T>) & {
+    default: (key: K) => T;
     subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>;
     install: (store: Store) => void;
     internalRoles: string[] | undefined;

package/internal/dist/index.js

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

package/internal/src/families/create-readonly-selector-family.ts

@@ -6,10 +6,18 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
+import type { findState } from "atom.io/ephemeral"
+import type { seekState } from "atom.io/immortal"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { ReadonlySelectorFamily } from ".."
+import {
+	findInStore,
+	getFromStore,
+	getJsonToken,
+	type ReadonlySelectorFamily,
+	seekInStore,
+} from ".."
 import { newest } from "../lineage"
 import { createReadonlySelector } from "../selector"
 import type { Store } from "../store"
@@ -53,9 +61,18 @@ export function createReadonlySelectorFamily<T, K extends Canonical>(
 	}
 
 	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+		internalRoles,
 		subject,
 		install: (s: Store) => createReadonlySelectorFamily(options, s),
-		internalRoles,
+		default: (key: K) => {
+			const getFn = options.get(key)
+			return getFn({
+				get: (token) => getFromStore(token, store),
+				find: ((token, k) => findInStore(token, k, store)) as typeof findState,
+				seek: ((token, k) => seekInStore(token, k, store)) as typeof seekState,
+				json: (token) => getJsonToken(token, store),
+			})
+		},
 	}) satisfies ReadonlySelectorFamily<T, K>
 
 	store.families.set(options.key, readonlySelectorFamily)

package/internal/src/families/create-regular-atom-family.ts

@@ -61,5 +61,6 @@ export function createRegularAtomFamily<T, K extends Canonical>(
 	}) satisfies RegularAtomFamily<T, K>
 
 	store.families.set(options.key, atomFamily)
+	store.defaults.set(options.key, options.default)
 	return familyToken
 }

package/internal/src/families/create-writable-selector-family.ts

@@ -6,10 +6,18 @@ import type {
 	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 } from "atom.io"
+import type { findState } from "atom.io/ephemeral"
+import type { seekState } from "atom.io/immortal"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { WritableSelectorFamily } from ".."
+import {
+	findInStore,
+	getFromStore,
+	getJsonToken,
+	seekInStore,
+	type WritableSelectorFamily,
+} from ".."
 import { newest } from "../lineage"
 import { createWritableSelector } from "../selector"
 import type { Store } from "../store"
@@ -54,9 +62,18 @@ export function createWritableSelectorFamily<T, K extends Canonical>(
 	}
 
 	const selectorFamily = Object.assign(familyFunction, familyToken, {
+		internalRoles,
 		subject,
 		install: (s: Store) => createWritableSelectorFamily(options, s),
-		internalRoles,
+		default: (key: K) => {
+			const getFn = options.get(key)
+			return getFn({
+				get: (...params: [any]) => getFromStore(...params, store), // TODO: make store zero-arg
+				find: ((token, k) => findInStore(token, k, store)) as typeof findState,
+				seek: ((token, k) => seekInStore(token, k, store)) as typeof seekState,
+				json: (token) => getJsonToken(token, store),
+			})
+		},
 	}) satisfies WritableSelectorFamily<T, K>
 
 	store.families.set(options.key, selectorFamily)

package/internal/src/families/dispose-from-store.ts

@@ -6,7 +6,7 @@ import type {
 	ReadableFamilyToken,
 	ReadableToken,
 } from "atom.io"
-import type { Canonical } from "atom.io/json"
+import { type Canonical, stringifyJson } from "atom.io/json"
 
 import { disposeAtom } from "../atom"
 import { disposeMolecule } from "../molecule/dispose-molecule"
@@ -55,7 +55,16 @@ export function disposeFromStore(
 					? seekInStore(family, key, store)
 					: findInStore(family, key, store)
 		if (!maybeToken) {
-			throw new NotFoundError(family, key, store)
+			store.logger.error(
+				`❗`,
+				family.type,
+				family.key,
+				`tried to dispose of member`,
+				stringifyJson(key),
+				`but it was not found in store`,
+				store.config.name,
+			)
+			return
 		}
 		token = maybeToken
 	}

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

@@ -109,9 +109,6 @@ export function seekInStore(
 			break
 		case `molecule_family`:
 			state = target.molecules.get(stringifyJson(key))
-			if (state) {
-				return deposit(state)
-			}
 	}
 	if (state) {
 		return deposit(state)

package/internal/src/get-state/get-from-store.ts

@@ -6,7 +6,7 @@ import type {
 	ReadableFamilyToken,
 	ReadableToken,
 } from "atom.io"
-import type { Canonical } from "atom.io/json"
+import { type Canonical, stringifyJson } from "atom.io/json"
 
 import { findInStore, seekInStore } from "../families"
 import { NotFoundError } from "../not-found-error"
@@ -56,7 +56,31 @@ export function getFromStore<T>(
 					? seekInStore(family, key, store)
 					: findInStore(family, key, store)
 		if (!maybeToken) {
-			throw new NotFoundError(family, key, store)
+			store.logger.error(
+				`❗`,
+				family.type,
+				family.key,
+				`tried to get member`,
+				stringifyJson(key),
+				`but it was not found in store`,
+				store.config.name,
+			)
+			switch (family.type) {
+				case `atom_family`:
+				case `mutable_atom_family`:
+					return store.defaults.get(family.key)
+				case `selector_family`:
+				case `readonly_selector_family`: {
+					if (store.defaults.has(family.key)) {
+						return store.defaults.get(family.key)
+					}
+					const defaultValue = withdraw(family, store).default(key)
+					store.defaults.set(family.key, defaultValue)
+					return defaultValue
+				}
+				case `molecule_family`:
+					throw new NotFoundError(family, key, store)
+			}
 		}
 		token = maybeToken
 	}

package/internal/src/get-state/read-or-compute-value.ts

@@ -10,7 +10,7 @@ export const readOrComputeValue = <T>(
 		target.logger.info(`📖`, state.type, state.key, `reading cached value`)
 		return readCachedValue(state, target)
 	}
-	if (state.type !== `atom` && state.type !== `mutable_atom`) {
+	if (state.type === `selector` || state.type === `readonly_selector`) {
 		target.logger.info(`🧮`, state.type, state.key, `computing value`)
 		return state.get()
 	}

package/internal/src/index.ts

@@ -3,6 +3,7 @@ import type {
 	FamilyMetadata,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
+	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
@@ -113,8 +114,9 @@ export type AtomFamily<T, K extends Canonical = Canonical> =
 // biome-ignore format: intersection
 export type WritableSelectorFamily<T, K extends Canonical> = 
 	& WritableSelectorFamilyToken<T, K> 
+	& ((key: K) => WritableSelectorToken<T>)
 	& {
-		(key: K): WritableSelectorToken<T>
+		default: (key: K) => T,
 		subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>
 		install: (store: Store) => void
 		internalRoles : string[] | undefined
@@ -122,10 +124,10 @@ export type WritableSelectorFamily<T, K extends Canonical> =
 
 // biome-ignore format: intersection
 export type ReadonlySelectorFamily<T, K extends Canonical> = 
+	& ReadonlySelectorFamilyToken<T, K>
 	& ((key: K) => ReadonlySelectorToken<T>)
 	& {
-		key: string
-		type: `readonly_selector_family`
+		default: (key: K) => T,
 		subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>
 		install: (store: Store) => void
 		internalRoles : string[] | undefined

package/internal/src/selector/create-writable-selector.ts

@@ -22,12 +22,12 @@ export const createWritableSelector = <T>(
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const covered = new Set<string>()
-	const toolkit = registerSelector(options.key, covered, target)
-	const { find, get, seek, json } = toolkit
+	const setterToolkit = registerSelector(options.key, covered, target)
+	const { find, get, seek, json } = setterToolkit
 	const getterToolkit = { find, get, seek, json }
 
-	const getSelf = (innerTarget = newest(store)): T => {
-		const value = options.get(getterToolkit)
+	const getSelf = (getFn = options.get, innerTarget = newest(store)): T => {
+		const value = getFn(getterToolkit)
 		cacheValue(options.key, value, subject, innerTarget)
 		covered.clear()
 		return value
@@ -35,7 +35,7 @@ export const createWritableSelector = <T>(
 
 	const setSelf = (next: T | ((oldValue: T) => T)): void => {
 		const innerTarget = newest(store)
-		const oldValue = getSelf(innerTarget)
+		const oldValue = getSelf(options.get, innerTarget)
 		const newValue = become(next)(oldValue)
 		store.logger.info(
 			`📝`,
@@ -52,7 +52,7 @@ export const createWritableSelector = <T>(
 		if (isRootStore(innerTarget)) {
 			subject.next({ newValue, oldValue })
 		}
-		options.set(toolkit, newValue)
+		options.set(setterToolkit, newValue)
 	}
 	const mySelector: WritableSelector<T> = {
 		...options,

package/internal/src/set-state/set-into-store.ts

@@ -1,5 +1,5 @@
 import type { WritableFamilyToken, WritableToken } from "atom.io"
-import type { Canonical } from "atom.io/json"
+import { type Canonical, stringifyJson } from "atom.io/json"
 
 import { findInStore, seekInStore } from "../families"
 import { NotFoundError } from "../not-found-error"
@@ -52,7 +52,18 @@ export function setIntoStore<T, New extends T>(
 				? findInStore(family, key, store)
 				: seekInStore(family, key, store)
 		if (!maybeToken) {
-			throw new NotFoundError(family, key, store)
+			store.logger.error(
+				`❗`,
+				family.type,
+				family.key,
+				`tried to set member`,
+				stringifyJson(key),
+				`to`,
+				value,
+				`but it was not found in store`,
+				store.config.name,
+			)
+			return
 		}
 		token = maybeToken
 	}

package/internal/src/store/deposit.ts

@@ -1,5 +1,6 @@
 import type {
 	AtomToken,
+	MoleculeConstructor,
 	MoleculeFamily,
 	MoleculeFamilyToken,
 	MoleculeToken,
@@ -38,20 +39,20 @@ export function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>
 export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
 export function deposit<T>(state: Selector<T>): SelectorToken<T>
 export function deposit<T>(state: WritableState<T>): WritableToken<T>
-export function deposit<
-	K extends Canonical,
-	S extends { [key: string]: any },
-	P extends any[],
->(state: Molecule<any>): MoleculeToken<any>
-export function deposit<
-	K extends Canonical,
-	S extends { [key: string]: any },
-	P extends any[],
->(state: MoleculeFamily<any>): MoleculeFamilyToken<any>
+export function deposit<M extends MoleculeConstructor>(
+	state: MoleculeFamily<M>,
+): MoleculeFamilyToken<M>
+export function deposit<M extends MoleculeConstructor>(
+	state: Molecule<M>,
+): MoleculeToken<M>
 export function deposit<T extends Func>(
 	state: Transaction<T>,
 ): TransactionToken<T>
 export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
+export function deposit(
+	state: Molecule<any> | ReadableState<any>,
+): MoleculeToken<any> | ReadableToken<any>
+
 export function deposit<T>(
 	state:
 		| Molecule<any>

package/internal/src/store/store.ts

@@ -42,6 +42,7 @@ export class Store implements Lineage {
 	public child: Store | null = null
 
 	public valueMap = new Map<string, any>()
+	public defaults = new Map<string, any>()
 
 	public atoms = new Map<string, Atom<any>>()
 	public selectors = new Map<string, WritableSelector<any>>()

package/internal/src/transaction/build-transaction.ts

@@ -48,6 +48,7 @@ export const buildTransaction = (
 		}),
 		selectors: new LazyMap(parent.selectors),
 		valueMap: new LazyMap(parent.valueMap),
+		defaults: parent.defaults,
 		molecules: new LazyMap(parent.molecules),
 		moleculeFamilies: new LazyMap(parent.moleculeFamilies),
 		moleculeInProgress: parent.moleculeInProgress,

package/json/dist/index.js

@@ -1,6 +1,6 @@
 import { stringifyJson, parseJson } from '../../dist/chunk-AK23DRMD.js';
 export { parseJson, stringifyJson } from '../../dist/chunk-AK23DRMD.js';
-import { createWritableSelectorFamily } from '../../dist/chunk-ETCFHO7J.js';
+import { createWritableSelectorFamily } from '../../dist/chunk-JRENM6KL.js';
 import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.27.3",
+  "version": "0.27.4",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -67,7 +67,7 @@
     "drizzle-kit": "0.24.0",
     "drizzle-orm": "0.33.0",
     "eslint": "9.9.0",
-    "framer-motion": "11.3.24",
+    "framer-motion": "11.3.28",
     "happy-dom": "14.12.3",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
@@ -75,14 +75,14 @@
     "preact": "10.23.2",
     "react": "18.3.1",
     "react-dom": "18.3.1",
-    "react-router-dom": "6.26.0",
+    "react-router-dom": "6.26.1",
     "socket.io": "4.7.5",
     "socket.io-client": "4.7.5",
     "tmp": "0.2.3",
     "tsup": "8.2.4",
     "tsx": "4.17.0",
     "typescript": "5.5.4",
-    "vite": "5.4.0",
+    "vite": "5.4.1",
     "vite-tsconfig-paths": "5.0.1",
     "vitest": "2.0.5"
   },

package/src/logger.ts

@@ -52,12 +52,16 @@ const LoggerIconDictionary = {
 } as const
 export type LoggerIcon = keyof typeof LoggerIconDictionary
 export type TokenDenomination =
+	| `atom_family`
 	| `atom`
 	| `continuity`
 	| `molecule_family`
 	| `molecule`
+	| `mutable_atom_family`
 	| `mutable_atom`
+	| `readonly_selector_family`
 	| `readonly_selector`
+	| `selector_family`
 	| `selector`
 	| `state`
 	| `timeline`