atom.io 0.33.1 → 0.33.3

package/dist/internal/index.js

@@ -102,10 +102,12 @@ var CircularBuffer = class CircularBuffer {
 //#region src/internal/store/counterfeit.ts
 const FAMILY_MEMBER_TOKEN_TYPES = {
 	atom_family: `atom`,
+	molecule_family: `molecule`,
 	mutable_atom_family: `mutable_atom`,
-	selector_family: `selector`,
-	readonly_selector_family: `readonly_selector`,
-	molecule_family: `molecule`
+	readonly_held_selector_family: `readonly_held_selector`,
+	readonly_pure_selector_family: `readonly_pure_selector`,
+	writable_held_selector_family: `writable_held_selector`,
+	writable_pure_selector_family: `writable_pure_selector`
 };
 function counterfeit(token, key) {
 	const subKey = stringifyJson(key);
@@ -492,8 +494,10 @@ const readOrComputeValue = (target, state) => {
 		return readCachedValue(state, target);
 	}
 	switch (state.type) {
-		case `selector`:
-		case `readonly_selector`:
+		case `readonly_held_selector`:
+		case `readonly_pure_selector`:
+		case `writable_held_selector`:
+		case `writable_pure_selector`:
 			target.logger.info(`🧮`, state.type, state.key, `computing value`);
 			return state.get();
 		case `atom`:
@@ -553,8 +557,10 @@ const emitUpdate = (store, state, update) => {
 			store.logger.info(`📢`, state.type, state.key, `is now (`, update.newValue, `) subscribers:`, state.subject.subscribers);
 			break;
 		case `atom`:
-		case `selector`:
-		case `readonly_selector`: store.logger.info(`📢`, state.type, state.key, `went (`, update.oldValue, `->`, update.newValue, `) subscribers:`, state.subject.subscribers);
+		case `writable_pure_selector`:
+		case `readonly_pure_selector`:
+		case `writable_held_selector`:
+		case `readonly_held_selector`: store.logger.info(`📢`, state.type, state.key, `went (`, update.oldValue, `->`, update.newValue, `) subscribers:`, state.subject.subscribers);
 	}
 	state.subject.next(update);
 };
@@ -632,7 +638,8 @@ const setAtomOrSelector = (store, state, value) => {
 		case `mutable_atom`:
 			setAtom(store, state, value);
 			break;
-		case `selector`:
+		case `writable_pure_selector`:
+		case `writable_held_selector`:
 			state.set(value);
 			break;
 	}
@@ -690,62 +697,63 @@ function createAtomFamily(store, options) {
 //#endregion
 //#region src/internal/keys.ts
 const isAtomKey = (store, key) => newest(store).atoms.has(key);
-const isSelectorKey = (store, key) => newest(store).selectors.has(key);
+const isSelectorKey = (store, key) => newest(store).writableSelectors.has(key);
 const isReadonlySelectorKey = (store, key) => newest(store).readonlySelectors.has(key);
 const isStateKey = (store, key) => isAtomKey(store, key) || isSelectorKey(store, key) || isReadonlySelectorKey(store, key);
 
 //#endregion
 //#region src/internal/selector/get-selector-dependency-keys.ts
-const getSelectorDependencyKeys = (key, store) => {
+const getSelectorDependencyKeys = (store, key) => {
 	const sources = newest(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(store, source));
 	return sources;
 };
 
 //#endregion
 //#region src/internal/selector/trace-selector-atoms.ts
-const traceSelectorAtoms = (directDependencyKey, covered, store) => {
+const traceSelectorAtoms = (store, directDependencyKey, covered) => {
 	const rootKeys = [];
-	const indirectDependencyKeys = getSelectorDependencyKeys(directDependencyKey, store);
+	const indirectDependencyKeys = getSelectorDependencyKeys(store, directDependencyKey);
 	while (indirectDependencyKeys.length > 0) {
 		const indirectDependencyKey = indirectDependencyKeys.shift();
 		if (covered.has(indirectDependencyKey)) continue;
 		covered.add(indirectDependencyKey);
-		if (!isAtomKey(store, indirectDependencyKey)) indirectDependencyKeys.push(...getSelectorDependencyKeys(indirectDependencyKey, store));
+		if (!isAtomKey(store, indirectDependencyKey)) indirectDependencyKeys.push(...getSelectorDependencyKeys(store, indirectDependencyKey));
 		else if (!rootKeys.includes(indirectDependencyKey)) rootKeys.push(indirectDependencyKey);
 	}
 	return rootKeys;
 };
 const traceAllSelectorAtoms = (selector, store) => {
 	const selectorKey = selector.key;
-	const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store);
+	const directDependencyKeys = getSelectorDependencyKeys(store, selectorKey);
 	const covered = new Set();
-	return directDependencyKeys.flatMap((depKey) => isAtomKey(store, depKey) ? depKey : traceSelectorAtoms(depKey, covered, store));
+	return directDependencyKeys.flatMap((depKey) => isAtomKey(store, depKey) ? depKey : traceSelectorAtoms(store, depKey, covered));
 };
 
 //#endregion
 //#region src/internal/selector/update-selector-atoms.ts
-const updateSelectorAtoms = (selectorKey, dependency, covered, store) => {
+const updateSelectorAtoms = (store, selectorType, selectorKey, dependency, covered) => {
 	const target = newest(store);
-	if (dependency.type === `atom` || dependency.type === `mutable_atom`) {
+	const { type: dependencyType, key: dependencyKey } = dependency;
+	if (dependencyType === `atom` || dependencyType === `mutable_atom`) {
 		target.selectorAtoms.set({
 			selectorKey,
-			atomKey: dependency.key
+			atomKey: dependencyKey
 		});
-		store.logger.info(`🔍`, `selector`, selectorKey, `discovers root atom "${dependency.key}"`);
+		store.logger.info(`🔍`, selectorType, selectorKey, `discovers root atom "${dependencyKey}"`);
 	} else {
-		const rootKeys = traceSelectorAtoms(dependency.key, covered, store);
-		store.logger.info(`🔍`, `selector`, selectorKey, `discovers root atoms: [ ${rootKeys.map((key) => `"${key}"`).join(`, `)} ]`);
+		const rootKeys = traceSelectorAtoms(store, dependencyKey, covered);
+		store.logger.info(`🔍`, selectorType, selectorKey, `discovers root atoms: [ ${rootKeys.map((key) => `"${key}"`).join(`, `)} ]`);
 		for (const atomKey of rootKeys) target.selectorAtoms = target.selectorAtoms.set({
 			selectorKey,
 			atomKey
 		});
 	}
-	covered.add(dependency.key);
+	covered.add(dependencyKey);
 };
 
 //#endregion
 //#region src/internal/selector/register-selector.ts
-const registerSelector = (selectorKey, covered, store) => ({
+const registerSelector = (store, selectorType, selectorKey, covered) => ({
 	get: (...params) => {
 		const target = newest(store);
 		let dependency;
@@ -755,12 +763,13 @@ const registerSelector = (selectorKey, covered, store) => ({
 		} else [dependency] = params;
 		const dependencyState = withdraw(store, dependency);
 		const dependencyValue = readOrComputeValue(store, dependencyState);
-		store.logger.info(`🔌`, `selector`, selectorKey, `registers dependency ( "${dependency.key}" =`, dependencyValue, `)`);
+		const dependencyKey = dependency.key;
+		store.logger.info(`🔌`, selectorType, selectorKey, `registers dependency ( "${dependencyKey}" =`, dependencyValue, `)`);
 		target.selectorGraph.set({
-			upstreamSelectorKey: dependency.key,
+			upstreamSelectorKey: dependencyKey,
 			downstreamSelectorKey: selectorKey
 		}, { source: dependency.key });
-		updateSelectorAtoms(selectorKey, dependency, covered, store);
+		updateSelectorAtoms(store, selectorType, selectorKey, dependency, covered);
 		return dependencyValue;
 	},
 	set: (...params) => {
@@ -784,48 +793,143 @@ const registerSelector = (selectorKey, covered, store) => ({
 });
 
 //#endregion
-//#region src/internal/selector/create-readonly-selector.ts
-const createReadonlySelector = (store, options, family) => {
+//#region src/internal/selector/create-readonly-held-selector.ts
+const createReadonlyHeldSelector = (store, options, family) => {
 	const target = newest(store);
 	const subject = new Subject();
 	const covered = new Set();
-	const { get, find, json } = registerSelector(options.key, covered, target);
+	const { key, const: constant } = options;
+	const type = `readonly_held_selector`;
+	const { get, find, json } = registerSelector(target, type, key, covered);
+	const getSelf = () => {
+		options.get({
+			get,
+			find,
+			json
+		}, constant);
+		cacheValue(newest(store), key, constant, subject);
+		covered.clear();
+		return constant;
+	};
+	const readonlySelector = {
+		...options,
+		type,
+		subject,
+		install: (s) => createReadonlyHeldSelector(s, options, family),
+		get: getSelf,
+		...family && { family }
+	};
+	target.readonlySelectors.set(key, readonlySelector);
+	store.logger.info(`✨`, type, key, `=`, constant);
+	const token = {
+		key,
+		type
+	};
+	if (family) token.family = family;
+	return token;
+};
+
+//#endregion
+//#region src/internal/selector/create-readonly-pure-selector.ts
+const createReadonlyPureSelector = (store, options, family) => {
+	const target = newest(store);
+	const subject = new Subject();
+	const covered = new Set();
+	const key = options.key;
+	const type = `readonly_pure_selector`;
+	const { get, find, json } = registerSelector(target, type, key, covered);
 	const getSelf = () => {
 		const value = options.get({
 			get,
 			find,
 			json
 		});
-		cacheValue(newest(store), options.key, value, subject);
+		cacheValue(newest(store), key, value, subject);
 		covered.clear();
 		return value;
 	};
 	const readonlySelector = {
 		...options,
+		type,
 		subject,
-		install: (s) => createReadonlySelector(s, options, family),
+		install: (s) => createReadonlyPureSelector(s, options, family),
 		get: getSelf,
-		type: `readonly_selector`,
 		...family && { family }
 	};
-	target.readonlySelectors.set(options.key, readonlySelector);
+	target.readonlySelectors.set(key, readonlySelector);
 	const initialValue = getSelf();
-	store.logger.info(`✨`, readonlySelector.type, readonlySelector.key, `=`, initialValue);
+	store.logger.info(`✨`, type, key, `=`, initialValue);
 	const token = {
-		key: options.key,
-		type: `readonly_selector`
+		key,
+		type
+	};
+	if (family) token.family = family;
+	return token;
+};
+
+//#endregion
+//#region src/internal/selector/create-writable-held-selector.ts
+const createWritableHeldSelector = (store, options, family) => {
+	const target = newest(store);
+	const subject = new Subject();
+	const covered = new Set();
+	const { key, const: constant } = options;
+	const type = `writable_held_selector`;
+	const setterToolkit = registerSelector(target, type, key, covered);
+	const { find, get, json } = setterToolkit;
+	const getterToolkit = {
+		find,
+		get,
+		json
+	};
+	const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
+		getFn(getterToolkit, constant);
+		cacheValue(innerTarget, key, constant, subject);
+		covered.clear();
+		return constant;
+	};
+	const setSelf = (next) => {
+		const innerTarget = newest(store);
+		const oldValue = getSelf(options.get, innerTarget);
+		const newValue = become(next)(oldValue);
+		store.logger.info(`📝`, type, key, `set (`, oldValue, `->`, newValue, `)`);
+		cacheValue(innerTarget, key, newValue, subject);
+		markDone(innerTarget, key);
+		if (isRootStore(innerTarget)) subject.next({
+			newValue,
+			oldValue
+		});
+		options.set(setterToolkit, newValue);
+	};
+	const mySelector = {
+		...options,
+		type,
+		subject,
+		install: (s) => createWritableHeldSelector(s, options, family),
+		get: getSelf,
+		set: setSelf,
+		...family && { family }
+	};
+	target.writableSelectors.set(key, mySelector);
+	const initialValue = getSelf();
+	store.logger.info(`✨`, type, key, `=`, initialValue);
+	const token = {
+		key,
+		type
 	};
 	if (family) token.family = family;
 	return token;
 };
 
 //#endregion
-//#region src/internal/selector/create-writable-selector.ts
-const createWritableSelector = (store, options, family) => {
+//#region src/internal/selector/create-writable-pure-selector.ts
+const createWritablePureSelector = (store, options, family) => {
 	const target = newest(store);
 	const subject = new Subject();
 	const covered = new Set();
-	const setterToolkit = registerSelector(options.key, covered, target);
+	const key = options.key;
+	const type = `writable_pure_selector`;
+	const setterToolkit = registerSelector(target, type, key, covered);
 	const { find, get, json } = setterToolkit;
 	const getterToolkit = {
 		find,
@@ -834,7 +938,7 @@ const createWritableSelector = (store, options, family) => {
 	};
 	const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
 		const value = getFn(getterToolkit);
-		cacheValue(innerTarget, options.key, value, subject);
+		cacheValue(innerTarget, key, value, subject);
 		covered.clear();
 		return value;
 	};
@@ -842,7 +946,7 @@ const createWritableSelector = (store, options, family) => {
 		const innerTarget = newest(store);
 		const oldValue = getSelf(options.get, innerTarget);
 		const newValue = become(next)(oldValue);
-		store.logger.info(`📝`, `selector`, options.key, `set (`, oldValue, `->`, newValue, `)`);
+		store.logger.info(`📝`, type, key, `set (`, oldValue, `->`, newValue, `)`);
 		cacheValue(innerTarget, options.key, newValue, subject);
 		markDone(innerTarget, options.key);
 		if (isRootStore(innerTarget)) subject.next({
@@ -853,19 +957,19 @@ const createWritableSelector = (store, options, family) => {
 	};
 	const mySelector = {
 		...options,
+		type,
 		subject,
-		install: (s) => createWritableSelector(s, options, family),
+		install: (s) => createWritablePureSelector(s, options, family),
 		get: getSelf,
 		set: setSelf,
-		type: `selector`,
 		...family && { family }
 	};
-	target.selectors.set(options.key, mySelector);
+	target.writableSelectors.set(key, mySelector);
 	const initialValue = getSelf();
 	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue);
 	const token = {
-		key: options.key,
-		type: `selector`
+		key,
+		type
 	};
 	if (family) token.family = family;
 	return token;
@@ -875,12 +979,23 @@ const createWritableSelector = (store, options, family) => {
 //#region src/internal/selector/create-standalone-selector.ts
 function createStandaloneSelector(store, options) {
 	const isWritable = `set` in options;
+	const isHeld = `const` in options;
+	if (isHeld && isWritable) {
+		const state$1 = createWritableHeldSelector(store, options, void 0);
+		store.on.selectorCreation.next(state$1);
+		return state$1;
+	}
+	if (isHeld) {
+		const state$1 = createReadonlyHeldSelector(store, options, void 0);
+		store.on.selectorCreation.next(state$1);
+		return state$1;
+	}
 	if (isWritable) {
-		const state$1 = createWritableSelector(store, options, void 0);
+		const state$1 = createWritablePureSelector(store, options, void 0);
 		store.on.selectorCreation.next(state$1);
 		return state$1;
 	}
-	const state = createReadonlySelector(store, options, void 0);
+	const state = createReadonlyPureSelector(store, options, void 0);
 	store.on.selectorCreation.next(state);
 	return state;
 }
@@ -889,20 +1004,35 @@ function createStandaloneSelector(store, options) {
 //#region src/internal/selector/dispose-selector.ts
 function disposeSelector(store, selectorToken) {
 	const target = newest(store);
-	const { key } = selectorToken;
+	const { key, type } = selectorToken;
 	const selector = withdraw(target, selectorToken);
-	if (!selector.family) store.logger.error(`❌`, `selector`, key, `Standalone selectors cannot be disposed.`);
+	if (!selector.family) store.logger.error(`❌`, type, key, `Standalone selectors cannot be disposed.`);
 	else {
 		const molecule = target.molecules.get(selector.family.subKey);
 		if (molecule) target.moleculeData.delete(selector.family.subKey, selector.family.key);
 		let familyToken;
 		switch (selectorToken.type) {
-			case `selector`:
+			case `writable_held_selector`:
+				{
+					target.writableSelectors.delete(key);
+					familyToken = {
+						key: selector.family.key,
+						type: `writable_held_selector_family`
+					};
+					const family = withdraw(store, familyToken);
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken
+					});
+				}
+				break;
+			case `writable_pure_selector`:
 				{
-					target.selectors.delete(key);
+					target.writableSelectors.delete(key);
 					familyToken = {
 						key: selector.family.key,
-						type: `selector_family`
+						type: `writable_pure_selector_family`
 					};
 					const family = withdraw(store, familyToken);
 					family.subject.next({
@@ -912,12 +1042,27 @@ function disposeSelector(store, selectorToken) {
 					});
 				}
 				break;
-			case `readonly_selector`:
+			case `readonly_held_selector`:
 				{
 					target.readonlySelectors.delete(key);
 					familyToken = {
 						key: selector.family.key,
-						type: `readonly_selector_family`
+						type: `readonly_held_selector_family`
+					};
+					const family = withdraw(store, familyToken);
+					family.subject.next({
+						type: `state_disposal`,
+						subType: `selector`,
+						token: selectorToken
+					});
+				}
+				break;
+			case `readonly_pure_selector`:
+				{
+					target.readonlySelectors.delete(key);
+					familyToken = {
+						key: selector.family.key,
+						type: `readonly_pure_selector_family`
 					};
 					const family = withdraw(store, familyToken);
 					family.subject.next({
@@ -942,24 +1087,26 @@ function disposeSelector(store, selectorToken) {
 }
 
 //#endregion
-//#region src/internal/families/create-readonly-selector-family.ts
-function createReadonlySelectorFamily(store, options, internalRoles) {
+//#region src/internal/families/create-readonly-pure-selector-family.ts
+function createReadonlyPureSelectorFamily(store, options, internalRoles) {
+	const familyKey = options.key;
+	const type = `readonly_pure_selector_family`;
 	const familyToken = {
-		key: options.key,
-		type: `readonly_selector_family`
+		key: familyKey,
+		type
 	};
-	const existing = store.families.get(options.key);
-	if (existing) store.logger.error(`❗`, `readonly_selector_family`, options.key, `Overwriting an existing ${prettyPrintTokenType(existing)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+	const existing = store.families.get(familyKey);
+	if (existing) store.logger.error(`❗`, type, familyKey, `Overwriting an existing ${prettyPrintTokenType(existing)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
 	const subject = new Subject();
 	const familyFunction = (key) => {
 		const subKey = stringifyJson(key);
 		const family = {
-			key: options.key,
+			key: familyKey,
 			subKey
 		};
-		const fullKey = `${options.key}(${subKey})`;
+		const fullKey = `${familyKey}(${subKey})`;
 		const target = newest(store);
-		const token = createReadonlySelector(target, {
+		const token = createReadonlyPureSelector(target, {
 			key: fullKey,
 			get: options.get(key)
 		}, family);
@@ -972,7 +1119,7 @@ function createReadonlySelectorFamily(store, options, internalRoles) {
 	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
 		internalRoles,
 		subject,
-		install: (s) => createReadonlySelectorFamily(s, options),
+		install: (s) => createReadonlyPureSelectorFamily(s, options),
 		default: (key) => {
 			const getFn = options.get(key);
 			return getFn({
@@ -982,29 +1129,114 @@ function createReadonlySelectorFamily(store, options, internalRoles) {
 			});
 		}
 	});
-	store.families.set(options.key, readonlySelectorFamily);
+	store.families.set(familyKey, readonlySelectorFamily);
 	return familyToken;
 }
 
 //#endregion
-//#region src/internal/families/create-writable-selector-family.ts
-function createWritableSelectorFamily(store, options, internalRoles) {
+//#region src/internal/families/create-readonly-held-selector-family.ts
+function createReadonlyHeldSelectorFamily(store, options, internalRoles) {
+	const familyKey = options.key;
+	const type = `readonly_held_selector_family`;
 	const familyToken = {
-		key: options.key,
-		type: `selector_family`
+		key: familyKey,
+		type
 	};
-	const existing = store.families.get(options.key);
-	if (existing) store.logger.error(`❗`, `selector_family`, options.key, `Overwriting an existing ${prettyPrintTokenType(existing)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+	const existing = store.families.get(familyKey);
+	if (existing) store.logger.error(`❗`, type, familyKey, `Overwriting an existing ${prettyPrintTokenType(existing)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
 	const subject = new Subject();
 	const familyFunction = (key) => {
 		const subKey = stringifyJson(key);
 		const family = {
-			key: options.key,
+			key: familyKey,
 			subKey
 		};
-		const fullKey = `${options.key}(${subKey})`;
+		const fullKey = `${familyKey}(${subKey})`;
+		const target = newest(store);
+		const token = createReadonlyHeldSelector(target, {
+			key: fullKey,
+			const: options.const(key),
+			get: options.get(key)
+		}, family);
+		subject.next({
+			type: `state_creation`,
+			token
+		});
+		return token;
+	};
+	const readonlySelectorFamily = Object.assign(familyFunction, familyToken, {
+		internalRoles,
+		subject,
+		install: (s) => createReadonlyHeldSelectorFamily(s, options),
+		default: options.const
+	});
+	store.families.set(familyKey, readonlySelectorFamily);
+	return familyToken;
+}
+
+//#endregion
+//#region src/internal/families/create-writable-held-selector-family.ts
+function createWritableHeldSelectorFamily(store, options, internalRoles) {
+	const familyKey = options.key;
+	const type = `writable_held_selector_family`;
+	const familyToken = {
+		key: familyKey,
+		type
+	};
+	const existing = store.families.get(familyKey);
+	if (existing) store.logger.error(`❗`, type, familyKey, `Overwriting an existing ${prettyPrintTokenType(existing)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+	const subject = new Subject();
+	const familyFunction = (key) => {
+		const subKey = stringifyJson(key);
+		const family = {
+			key: familyKey,
+			subKey
+		};
+		const fullKey = `${familyKey}(${subKey})`;
+		const target = newest(store);
+		const token = createWritableHeldSelector(target, {
+			key: fullKey,
+			const: options.const(key),
+			get: options.get(key),
+			set: options.set(key)
+		}, family);
+		subject.next({
+			type: `state_creation`,
+			token
+		});
+		return token;
+	};
+	const selectorFamily$1 = Object.assign(familyFunction, familyToken, {
+		internalRoles,
+		subject,
+		install: (s) => createWritableHeldSelectorFamily(s, options),
+		default: options.const
+	});
+	store.families.set(familyKey, selectorFamily$1);
+	return familyToken;
+}
+
+//#endregion
+//#region src/internal/families/create-writable-pure-selector-family.ts
+function createWritablePureSelectorFamily(store, options, internalRoles) {
+	const familyKey = options.key;
+	const type = `writable_pure_selector_family`;
+	const familyToken = {
+		key: familyKey,
+		type
+	};
+	const existing = store.families.get(familyKey);
+	if (existing) store.logger.error(`❗`, type, familyKey, `Overwriting an existing ${prettyPrintTokenType(existing)} "${existing.key}" in store "${store.config.name}". You can safely ignore this warning if it is due to hot module replacement.`);
+	const subject = new Subject();
+	const familyFunction = (key) => {
+		const subKey = stringifyJson(key);
+		const family = {
+			key: familyKey,
+			subKey
+		};
+		const fullKey = `${familyKey}(${subKey})`;
 		const target = newest(store);
-		const token = createWritableSelector(target, {
+		const token = createWritablePureSelector(target, {
 			key: fullKey,
 			get: options.get(key),
 			set: options.set(key)
@@ -1018,7 +1250,7 @@ function createWritableSelectorFamily(store, options, internalRoles) {
 	const selectorFamily$1 = Object.assign(familyFunction, familyToken, {
 		internalRoles,
 		subject,
-		install: (s) => createWritableSelectorFamily(s, options),
+		install: (s) => createWritablePureSelectorFamily(s, options),
 		default: (key) => {
 			const getFn = options.get(key);
 			return getFn({
@@ -1028,7 +1260,7 @@ function createWritableSelectorFamily(store, options, internalRoles) {
 			});
 		}
 	});
-	store.families.set(options.key, selectorFamily$1);
+	store.families.set(familyKey, selectorFamily$1);
 	return familyToken;
 }
 
@@ -1036,8 +1268,11 @@ function createWritableSelectorFamily(store, options, internalRoles) {
 //#region src/internal/families/create-selector-family.ts
 function createSelectorFamily(store, options) {
 	const isWritable = `set` in options;
-	if (isWritable) return createWritableSelectorFamily(store, options);
-	return createReadonlySelectorFamily(store, options);
+	const isHeld = `const` in options;
+	if (isHeld && isWritable) return createWritableHeldSelectorFamily(store, options, void 0);
+	if (isHeld) return createReadonlyHeldSelectorFamily(store, options, void 0);
+	if (isWritable) return createWritablePureSelectorFamily(store, options);
+	return createReadonlyPureSelectorFamily(store, options);
 }
 
 //#endregion
@@ -1053,8 +1288,10 @@ function initFamilyMemberInStore(store, token, key) {
 			case `mutable_atom`:
 				store.on.atomCreation.next(state);
 				break;
-			case `selector`:
-			case `readonly_selector`:
+			case `writable_pure_selector`:
+			case `readonly_pure_selector`:
+			case `writable_held_selector`:
+			case `readonly_held_selector`:
 				store.on.selectorCreation.next(state);
 				break;
 		}
@@ -1078,10 +1315,12 @@ function seekInStore(store, token, key) {
 		case `mutable_atom_family`:
 			state = target.atoms.get(fullKey);
 			break;
-		case `selector_family`:
-			state = target.selectors.get(fullKey);
+		case `writable_held_selector_family`:
+		case `writable_pure_selector_family`:
+			state = target.writableSelectors.get(fullKey);
 			break;
-		case `readonly_selector_family`:
+		case `readonly_held_selector_family`:
+		case `readonly_pure_selector_family`:
 			state = target.readonlySelectors.get(fullKey);
 			break;
 	}
@@ -1131,8 +1370,10 @@ function disposeFromStore(store, ...params) {
 		case `mutable_atom`:
 			disposeAtom(store, token);
 			break;
-		case `selector`:
-		case `readonly_selector`:
+		case `writable_pure_selector`:
+		case `readonly_pure_selector`:
+		case `writable_held_selector`:
+		case `readonly_held_selector`:
 			disposeSelector(store, token);
 			break;
 	}
@@ -1561,8 +1802,10 @@ function getFromStore(store, ...params) {
 		switch (family.type) {
 			case `atom_family`:
 			case `mutable_atom_family`: return store.defaults.get(family.key);
-			case `selector_family`:
-			case `readonly_selector_family`: {
+			case `readonly_pure_selector_family`:
+			case `writable_pure_selector_family`:
+			case `readonly_held_selector_family`:
+			case `writable_held_selector_family`: {
 				if (store.defaults.has(family.key)) return store.defaults.get(token.family.key);
 				const defaultValue = withdraw(store, family).default(subKey);
 				store.defaults.set(family.key, defaultValue);
@@ -1630,7 +1873,7 @@ const buildTransaction = (store, key, params, id) => {
 		transactions: new LazyMap(parent.transactions),
 		selectorAtoms: new Junction(parent.selectorAtoms.toJSON()),
 		selectorGraph: new Junction(parent.selectorGraph.toJSON(), { makeContentKey: (...keys) => keys.sort().join(`:`) }),
-		selectors: new LazyMap(parent.selectors),
+		writableSelectors: new LazyMap(parent.writableSelectors),
 		valueMap: new LazyMap(parent.valueMap),
 		defaults: parent.defaults,
 		disposalTraces: store.disposalTraces.copy(),
@@ -1718,7 +1961,7 @@ var Store = class {
 	valueMap = new Map();
 	defaults = new Map();
 	atoms = new Map();
-	selectors = new Map();
+	writableSelectors = new Map();
 	readonlySelectors = new Map();
 	atomsThatAreDefault = new Set();
 	selectorAtoms = new Junction({
@@ -1817,7 +2060,7 @@ var Store = class {
 				}
 			}
 			for (const [, selector] of store.readonlySelectors) selector.install(this);
-			for (const [, selector] of store.selectors) {
+			for (const [, selector] of store.writableSelectors) {
 				if (mutableHelpers.has(selector.key)) continue;
 				selector.install(this);
 			}
@@ -1851,16 +2094,20 @@ function withdraw(store, token) {
 			case `mutable_atom`:
 				withdrawn = target.atoms.get(token.key);
 				break;
-			case `selector`:
-				withdrawn = target.selectors.get(token.key);
+			case `writable_pure_selector`:
+			case `writable_held_selector`:
+				withdrawn = target.writableSelectors.get(token.key);
 				break;
-			case `readonly_selector`:
+			case `readonly_pure_selector`:
+			case `readonly_held_selector`:
 				withdrawn = target.readonlySelectors.get(token.key);
 				break;
 			case `atom_family`:
 			case `mutable_atom_family`:
-			case `selector_family`:
-			case `readonly_selector_family`:
+			case `writable_pure_selector_family`:
+			case `readonly_pure_selector_family`:
+			case `writable_held_selector_family`:
+			case `readonly_held_selector_family`:
 				withdrawn = target.families.get(token.key);
 				break;
 			case `timeline`:
@@ -1890,8 +2137,10 @@ function subscribeInStore(store, token, handleUpdate, key = arbitrary$1()) {
 	switch (token.type) {
 		case `atom`:
 		case `mutable_atom`:
-		case `readonly_selector`:
-		case `selector`: return subscribeToState$1(store, token, key, handleUpdate);
+		case `readonly_pure_selector`:
+		case `readonly_held_selector`:
+		case `writable_pure_selector`:
+		case `writable_held_selector`: return subscribeToState$1(store, token, key, handleUpdate);
 		case `transaction`: return subscribeToTransaction$1(store, token, key, handleUpdate);
 		case `timeline`: return subscribeToTimeline$1(store, token, key, handleUpdate);
 	}
@@ -1931,7 +2180,7 @@ function subscribeToState(store, token, key, handleUpdate) {
 	}
 	const state = withdraw(store, token);
 	store.logger.info(`👀`, state.type, state.key, `Adding subscription "${key}"`);
-	const isSelector = state.type === `selector` || state.type === `readonly_selector`;
+	const isSelector = state.type === `writable_pure_selector` || state.type === `readonly_pure_selector`;
 	let dependencyUnsubFunctions = null;
 	let updateHandler = safelyHandleUpdate;
 	if (isSelector) {
@@ -2074,26 +2323,28 @@ var Tracker = class {
 function createMutableAtom(store, options, family) {
 	store.logger.info(`🔨`, `atom`, options.key, `creating in store "${store.config.name}"`);
 	const target = newest(store);
-	const existing = target.atoms.get(options.key);
-	if (existing && existing.type === `mutable_atom`) {
-		store.logger.error(`❌`, `atom`, options.key, `Tried to create atom, but it already exists in the store.`);
+	const { key, default: def } = options;
+	const existing = target.atoms.get(key);
+	const type = `mutable_atom`;
+	if (existing && existing.type === type) {
+		store.logger.error(`❌`, type, key, `Tried to create atom, but it already exists in the store.`);
 		return deposit(existing);
 	}
 	const subject = new Subject();
 	const newAtom = {
 		...options,
-		type: `mutable_atom`,
+		type,
 		install: (s) => {
-			s.logger.info(`🛠️`, `atom`, options.key, `installing in store "${s.config.name}"`);
+			s.logger.info(`🛠️`, `atom`, key, `installing in store "${s.config.name}"`);
 			return createMutableAtom(s, options, family);
 		},
 		subject
 	};
 	if (family) newAtom.family = family;
-	const initialValue = options.default();
+	const initialValue = def();
 	target.atoms.set(newAtom.key, newAtom);
-	markAtomAsDefault(store, options.key);
-	cacheValue(target, options.key, initialValue, subject);
+	markAtomAsDefault(store, key);
+	cacheValue(target, key, initialValue, subject);
 	const token = deposit(newAtom);
 	if (options.effects) {
 		let effectIndex = 0;
@@ -2216,7 +2467,7 @@ const getJsonToken = (store, mutableAtomToken) => {
 		const jsonFamilyKey = `${mutableAtomToken.family.key}:JSON`;
 		const jsonFamilyToken = {
 			key: jsonFamilyKey,
-			type: `selector_family`
+			type: `writable_pure_selector_family`
 		};
 		const family = withdraw(target, jsonFamilyToken);
 		const subKey = JSON.parse(mutableAtomToken.family.subKey);
@@ -2224,7 +2475,7 @@ const getJsonToken = (store, mutableAtomToken) => {
 		return jsonToken;
 	}
 	const token = {
-		type: `selector`,
+		type: `writable_pure_selector`,
 		key: `${mutableAtomToken.key}:JSON`
 	};
 	return token;
@@ -2313,7 +2564,7 @@ const evictCachedValue = (key, target) => {
 	const currentValue = target.valueMap.get(key);
 	if (currentValue instanceof Future) {
 		const future = currentValue;
-		const selector = target.selectors.get(key) ?? target.readonlySelectors.get(key);
+		const selector = target.writableSelectors.get(key) ?? target.readonlySelectors.get(key);
 		if (selector) future.use(selector.get());
 		return;
 	}
@@ -2341,29 +2592,31 @@ const markAtomAsNotDefault = (store, key) => {
 //#endregion
 //#region src/internal/atom/create-regular-atom.ts
 function createRegularAtom(store, options, family) {
-	store.logger.info(`🔨`, `atom`, options.key, `creating in store "${store.config.name}"`);
+	const type = `atom`;
+	const { key, default: def } = options;
+	store.logger.info(`🔨`, `atom`, key, `creating in store "${store.config.name}"`);
 	const target = newest(store);
-	const existing = target.atoms.get(options.key);
-	if (existing && existing.type === `atom`) {
-		store.logger.error(`❌`, `atom`, options.key, `Tried to create atom, but it already exists in the store.`);
+	const existing = target.atoms.get(key);
+	if (existing && existing.type === type) {
+		store.logger.error(`❌`, `atom`, key, `Tried to create atom, but it already exists in the store.`);
 		return deposit(existing);
 	}
 	const subject = new Subject();
 	const newAtom = {
 		...options,
-		type: `atom`,
+		type,
 		install: (s) => {
-			s.logger.info(`🛠️`, `atom`, options.key, `installing in store "${s.config.name}"`);
+			s.logger.info(`🛠️`, type, key, `installing in store "${s.config.name}"`);
 			return createRegularAtom(s, options, family);
 		},
 		subject
 	};
 	if (family) newAtom.family = family;
-	let initialValue = options.default;
-	if (options.default instanceof Function) initialValue = options.default();
-	target.atoms.set(newAtom.key, newAtom);
-	markAtomAsDefault(store, options.key);
-	cacheValue(target, options.key, initialValue, subject);
+	let initialValue = def;
+	if (def instanceof Function) initialValue = def();
+	target.atoms.set(key, newAtom);
+	markAtomAsDefault(store, key);
+	cacheValue(target, key, initialValue, subject);
 	const token = deposit(newAtom);
 	if (options.effects) {
 		let effectIndex = 0;
@@ -2649,7 +2902,7 @@ var Join = class {
 				return compositeKey;
 			}
 		});
-		const createSingleKeySelectorFamily = () => createReadonlySelectorFamily(store, {
+		const createSingleKeySelectorFamily = () => createReadonlyPureSelectorFamily(store, {
 			key: `${options.key}/singleRelatedKey`,
 			get: (key) => ({ get }) => {
 				const relatedKeys = get(relatedKeysAtoms, key);
@@ -2658,7 +2911,7 @@ var Join = class {
 			}
 		}, [`join`, `keys`]);
 		const getMultipleKeySelectorFamily = () => {
-			return createReadonlySelectorFamily(store, {
+			return createReadonlyPureSelectorFamily(store, {
 				key: `${options.key}/multipleRelatedKeys`,
 				get: (key) => ({ get }) => {
 					const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
@@ -2667,7 +2920,7 @@ var Join = class {
 				}
 			}, [`join`, `keys`]);
 		};
-		const createSingleEntrySelectorFamily = () => createReadonlySelectorFamily(store, {
+		const createSingleEntrySelectorFamily = () => createReadonlyPureSelectorFamily(store, {
 			key: `${options.key}/singleRelatedEntry`,
 			get: (x) => ({ get }) => {
 				const relatedKeys = get(relatedKeysAtoms, x);
@@ -2683,7 +2936,7 @@ var Join = class {
 				return null;
 			}
 		}, [`join`, `entries`]);
-		const getMultipleEntrySelectorFamily = () => createReadonlySelectorFamily(store, {
+		const getMultipleEntrySelectorFamily = () => createReadonlyPureSelectorFamily(store, {
 			key: `${options.key}/multipleRelatedEntries`,
 			get: (x) => ({ get }) => {
 				const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
@@ -2999,8 +3252,8 @@ function addAtomToTimeline(store, atomToken, tl) {
 	}, { topicType: `atom` });
 	tl.subscriptions.set(atom$1.key, atom$1.subject.subscribe(`timeline`, function timelineCapturesAtomUpdate(update) {
 		const target = newest(store);
-		const currentSelectorKey = store.operation.open && store.operation.token.type === `selector` ? store.operation.token.key : null;
-		const currentSelectorTime = store.operation.open && store.operation.token.type === `selector` ? store.operation.time : null;
+		const currentSelectorKey = store.operation.open && store.operation.token.type === `writable_pure_selector` ? store.operation.token.key : null;
+		const currentSelectorTime = store.operation.open && store.operation.token.type === `writable_pure_selector` ? store.operation.time : null;
 		const txUpdateInProgress = target.on.transactionApplying.state?.update;
 		store.logger.info(`⏳`, `timeline`, tl.key, `atom`, atomToken.key, `went`, update.oldValue, `->`, update.newValue, txUpdateInProgress ? `in transaction "${txUpdateInProgress.key}"` : currentSelectorKey ? `in selector "${currentSelectorKey}"` : ``);
 		if (tl.timeTraveling === null) if (txUpdateInProgress) joinTransaction(store, tl, txUpdateInProgress);
@@ -3209,5 +3462,5 @@ const timeTravel = (store, action, token) => {
 };
 
 //#endregion
-export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Join, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, installIntoStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, 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 };
+export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Join, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, installIntoStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, 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 };
 //# sourceMappingURL=index.js.map