atom.io 0.32.3 → 0.33.0

package/dist/introspection/index.d.ts

@@ -0,0 +1,153 @@
+import * as Internal from "atom.io/internal";
+import { Flat, Func, Refinement, Store, Timeline } from "atom.io/internal";
+import { Json } from "atom.io/json";
+import { AtomToken, ReadableToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, SelectorToken, TimelineToken, TransactionToken, TransactionUpdate } from "atom.io";
+
+//#region src/introspection/attach-atom-index.d.ts
+type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>;
+
+//#endregion
+//#region src/introspection/attach-selector-index.d.ts
+type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>;
+
+//#endregion
+//#region src/introspection/attach-introspection-states.d.ts
+type IntrospectionStates = {
+  atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
+  selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;
+  transactionIndex: ReadonlySelectorToken<TransactionToken<Func>[]>;
+  transactionLogSelectors: ReadonlySelectorFamilyToken<TransactionUpdate<Func>[], string>;
+  timelineIndex: ReadonlySelectorToken<TimelineToken<any>[]>;
+  timelineSelectors: ReadonlySelectorFamilyToken<Timeline<any>, string>;
+  typeSelectors: ReadonlySelectorFamilyToken<string, string>;
+};
+declare const attachIntrospectionStates: (store: Store) => IntrospectionStates;
+
+//#endregion
+//#region src/introspection/auditor.d.ts
+type ListResourcesParam = {
+  atomFamilies: boolean;
+  selectorFamilies: boolean;
+};
+/**
+* Auditor is a tool for identifying lingering resources in your store that may result in memory leaks.
+* @experimental
+*/
+declare class Auditor {
+  readonly store: Internal.Store;
+  auditorCreatedAt: number;
+  statesCreatedAt: Map<string, number>;
+  readonly atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
+  readonly selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;
+  disposed: boolean;
+  private readonly unsubscribeFromAtomCreation;
+  private readonly unsubscribeFromAtomDisposal;
+  private readonly unsubscribeFromSelectorCreation;
+  private readonly unsubscribeFromSelectorDisposal;
+  /**
+  * @param {Store} store - The store to audit.
+  */
+  constructor(store?: Internal.Store);
+  static readonly DEFAULT_LIST_RESOURCES_PARAM: ListResourcesParam;
+  /**
+  * Lists all resources in the store, along with their creation time.
+  *
+  * @param {ListResourcesParam} [param] - Optional parameters for filtering the list of resources.
+  * @returns {readonly [ReadableToken<unknown>, number]}[] - An array of tuples, where each tuple contains a state token belonging to a family in the store and that state's creation time.
+  */
+  listResources(param?: ListResourcesParam): (readonly [ReadableToken<unknown>, number])[];
+  [Symbol.dispose](): void;
+}
+
+//#endregion
+//#region src/introspection/refinery.d.ts
+type ClassSignature = abstract new (...args: any) => any;
+type RefinementStrategy = ClassSignature | Refinement<unknown, any>;
+type Supported<Refine extends RefinementStrategy> = Refine extends Refinement<unknown, infer T> ? T : Refine extends ClassSignature ? InstanceType<Refine> : never;
+type RefinementSupport = Record<string, RefinementStrategy>;
+declare class Refinery<SupportedTypes extends RefinementSupport> {
+  supported: SupportedTypes;
+  constructor(supported: SupportedTypes);
+  refine<T>(input: T): Flat<{ [K in keyof SupportedTypes]: T extends Supported<SupportedTypes[K]> ? {
+    type: K;
+    data: Supported<SupportedTypes[K]>;
+  } : Supported<SupportedTypes[K]> extends T ? {
+    type: K;
+    data: Supported<SupportedTypes[K]>;
+  } : never }>[keyof SupportedTypes] | (T extends Supported<SupportedTypes[keyof SupportedTypes]> ? never : null);
+}
+declare const primitiveRefinery: Refinery<{
+  number: (input: unknown) => input is number;
+  string: (input: unknown) => input is string;
+  boolean: (input: unknown) => input is boolean;
+  null: (input: unknown) => input is null;
+}>;
+declare function isPlainObject(input: unknown): input is Json.Tree.Object;
+declare const jsonTreeRefinery: Refinery<{
+  object: (input: unknown) => input is Json.Tree.Object;
+  array: (input: unknown) => input is Json.Tree.Array;
+}>;
+declare const jsonRefinery: Refinery<{
+  object: (input: unknown) => input is Json.Tree.Object;
+  array: (input: unknown) => input is Json.Tree.Array;
+  number: (input: unknown) => input is number;
+  string: (input: unknown) => input is string;
+  boolean: (input: unknown) => input is boolean;
+  null: (input: unknown) => input is null;
+}>;
+type JsonType = keyof typeof jsonRefinery.supported;
+declare const discoverType: (input: unknown) => JsonType | `Map` | `Set` | `undefined` | (string & {});
+
+//#endregion
+//#region src/introspection/differ.d.ts
+declare function diffNumber(a: number, b: number): Delta;
+declare function diffString(a: string, b: string): Delta;
+declare function diffBoolean(a: boolean, b: boolean): Delta;
+declare function diffObject(a: Json.Tree.Object, b: Json.Tree.Object, recurse: Diff<unknown>): Delta;
+declare function diffArray(a: Json.Tree.Array, b: Json.Tree.Array, recurse: Diff<unknown>): Delta;
+type Delta = {
+  summary: string;
+  added?: [path: string, addedStringifiedValue: string][];
+  removed?: [path: string, removedStringifiedValue: string][];
+  changed?: [path: string, delta: Delta][];
+};
+type Diff<T> = (a: T, b: T) => Delta;
+type DiffTree<T> = (a: T, b: T, recurse: Differ<any, any>[`diff`]) => Delta;
+declare class Differ<Leaf extends Record<string, any>, Tree extends Record<string, any>> {
+  leafRefinery: Refinery<Leaf>;
+  treeRefinery: Refinery<Tree>;
+  leafDiffers: { [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>> };
+  treeDiffers: { [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>> };
+  constructor(leafRefinery: Refinery<Leaf>, treeRefinery: Refinery<Tree>, diffFunctions: { [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>> } & { [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>> });
+  diff(a: unknown, b: unknown): Delta;
+}
+declare const prettyJson: Differ<{
+  number: (input: unknown) => input is number;
+  string: (input: unknown) => input is string;
+  boolean: (input: unknown) => input is boolean;
+  null: (input: unknown) => input is null;
+}, {
+  object: (input: unknown) => input is Json.Tree.Object;
+  array: (input: unknown) => input is Json.Tree.Array;
+}>;
+
+//#endregion
+//#region src/introspection/sprawl.d.ts
+type InspectionResult = Partial<{
+  pathComplete: true;
+  jobComplete: true;
+}>;
+type InspectNode = (path: string[], node: unknown) => InspectionResult | void;
+declare const sprawl: (tree: Array<unknown> | object, inspector: InspectNode) => void;
+
+//#endregion
+//#region src/introspection/index.d.ts
+type FamilyNode<Token extends ReadableToken<unknown>> = {
+  key: string;
+  familyMembers: Map<string, Token>;
+};
+type WritableTokenIndex<Token extends ReadableToken<unknown>> = Map<string, FamilyNode<Token> | Token>;
+
+//#endregion
+export { Auditor, ClassSignature, Differ, FamilyNode, InspectNode, InspectionResult, IntrospectionStates, JsonType, ListResourcesParam, RefinementStrategy, RefinementSupport, Refinery, Supported, WritableTokenIndex, attachIntrospectionStates, diffArray, diffBoolean, diffNumber, diffObject, diffString, discoverType, isPlainObject, jsonRefinery, jsonTreeRefinery, prettyJson, primitiveRefinery, sprawl };
+//# sourceMappingURL=index.d.ts.map

package/dist/introspection/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["store: Store","store: Store","store: Store","store: Internal.Store","param: ListResourcesParam","supported: SupportedTypes","input: T","primitiveRefinery: Refinery<{\n\tnumber: (input: unknown) => input is number\n\tstring: (input: unknown) => input is string\n\tboolean: (input: unknown) => input is boolean\n\tnull: (input: unknown) => input is null\n}>","input: unknown","jsonTreeRefinery: Refinery<{\n\tobject: (input: unknown) => input is Json.Tree.Object\n\tarray: (input: unknown) => input is Json.Tree.Array\n}>","jsonRefinery: Refinery<{\n\tobject: (input: unknown) => input is Json.Tree.Object\n\tarray: (input: unknown) => input is Json.Tree.Array\n\tnumber: (input: unknown) => input is number\n\tstring: (input: unknown) => input is string\n\tboolean: (input: unknown) => input is boolean\n\tnull: (input: unknown) => input is null\n}>","a: number","b: number","a: string","b: string","a: boolean","b: boolean","a: Json.Tree.Object","b: Json.Tree.Object","recurse: Diff<unknown>","a: Json.Tree.Array","b: Json.Tree.Array","a: T","b: T","recurse: Differ<any, any>[`diff`]","leafRefinery: Refinery<Leaf>","treeRefinery: Refinery<Tree>","diffFunctions: {\n\t\t\t[KT in keyof Tree]: DiffTree<Supported<Tree[KT]>>\n\t\t} & { [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>> }","a: unknown","b: unknown","prettyJson: Differ<\n\t{\n\t\tnumber: (input: unknown) => input is number\n\t\tstring: (input: unknown) => input is string\n\t\tboolean: (input: unknown) => input is boolean\n\t\tnull: (input: unknown) => input is null\n\t},\n\t{\n\t\tobject: (input: unknown) => input is Json.Tree.Object\n\t\tarray: (input: unknown) => input is Json.Tree.Array\n\t}\n>","input: unknown","path: string[]","node: unknown","tree: Array<unknown> | object","inspector: InspectNode"],"sources":["../../src/introspection/attach-atom-index.ts","../../src/introspection/attach-selector-index.ts","../../src/introspection/attach-introspection-states.ts","../../src/introspection/auditor.ts","../../src/introspection/refinery.ts","../../src/introspection/differ.ts","../../src/introspection/sprawl.ts","../../src/introspection/index.ts"],"sourcesContent":null,"mappings":"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"}

package/dist/introspection/index.js

@@ -0,0 +1,520 @@
+import * as Internal from "atom.io/internal";
+import { Subject, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneSelector, deposit, isReservedIntrospectionKey } from "atom.io/internal";
+import { getState } from "atom.io";
+
+//#region src/introspection/attach-atom-index.ts
+const attachAtomIndex = (store) => {
+	const atomTokenIndexState__INTERNAL = createRegularAtom(store, {
+		key: `🔍 Atom Token Index (Internal)`,
+		default: () => {
+			const base = new Map();
+			for (const [key, val] of store.atoms) {
+				if (isReservedIntrospectionKey(key)) continue;
+				const token = deposit(val);
+				if (val.family) {
+					let familyNode = base.get(val.family.key);
+					if (!familyNode || !(`familyMembers` in familyNode)) {
+						familyNode = {
+							key: val.family.key,
+							familyMembers: new Map()
+						};
+						base.set(val.family.key, familyNode);
+					}
+					familyNode.familyMembers.set(val.family.subKey, token);
+				} else base.set(key, token);
+			}
+			return base;
+		},
+		effects: [({ setSelf }) => {
+			store.on.atomCreation.subscribe(`introspection`, (atomToken) => {
+				if (isReservedIntrospectionKey(atomToken.key)) return;
+				setSelf((self) => {
+					if (atomToken.family) {
+						const { key: familyKey, subKey } = atomToken.family;
+						let familyNode = self.get(familyKey);
+						if (familyNode === void 0 || !(`familyMembers` in familyNode)) {
+							familyNode = {
+								key: familyKey,
+								familyMembers: new Map()
+							};
+							self.set(familyKey, familyNode);
+						}
+						familyNode.familyMembers.set(subKey, atomToken);
+					} else self.set(atomToken.key, atomToken);
+					return self;
+				});
+			});
+			store.on.atomDisposal.subscribe(`introspection`, (atomToken) => {
+				setSelf((self) => {
+					if (atomToken.family) {
+						const { key: familyKey, subKey } = atomToken.family;
+						const familyNode = self.get(familyKey);
+						if (familyNode && `familyMembers` in familyNode) {
+							familyNode.familyMembers.delete(subKey);
+							if (familyNode.familyMembers.size === 0) self.delete(familyKey);
+						}
+					} else self.delete(atomToken.key);
+					return self;
+				});
+			});
+		}]
+	}, void 0);
+	return createStandaloneSelector(store, {
+		key: `🔍 Atom Token Index`,
+		get: ({ get }) => get(atomTokenIndexState__INTERNAL)
+	});
+};
+
+//#endregion
+//#region src/introspection/attach-selector-index.ts
+const attachSelectorIndex = (store) => {
+	const readonlySelectorTokenIndexState__INTERNAL = createRegularAtom(store, {
+		key: `🔍 Selector Token Index (Internal)`,
+		default: () => {
+			const base = new Map();
+			for (const map of [store.readonlySelectors, store.selectors]) for (const [key, val] of map) {
+				if (isReservedIntrospectionKey(key)) continue;
+				const token = deposit(val);
+				if (val.family) {
+					let familyNode = base.get(val.family.key);
+					if (!familyNode || !(`familyMembers` in familyNode)) {
+						familyNode = {
+							key: val.family.key,
+							familyMembers: new Map()
+						};
+						base.set(val.family.key, familyNode);
+					}
+					familyNode.familyMembers.set(val.family.subKey, token);
+				} else base.set(key, token);
+			}
+			return base;
+		},
+		effects: [({ setSelf }) => {
+			store.on.selectorCreation.subscribe(`introspection`, (selectorToken) => {
+				if (isReservedIntrospectionKey(selectorToken.key)) return;
+				setSelf((self) => {
+					if (selectorToken.family) {
+						const { key: familyKey, subKey } = selectorToken.family;
+						let familyNode = self.get(familyKey);
+						if (familyNode === void 0 || !(`familyMembers` in familyNode)) {
+							familyNode = {
+								key: familyKey,
+								familyMembers: new Map()
+							};
+							self.set(familyKey, familyNode);
+						}
+						familyNode.familyMembers.set(subKey, selectorToken);
+					} else self.set(selectorToken.key, selectorToken);
+					return self;
+				});
+			});
+			store.on.selectorDisposal.subscribe(`introspection`, (selectorToken) => {
+				setSelf((self) => {
+					if (selectorToken.family) {
+						const { key: familyKey, subKey } = selectorToken.family;
+						const familyNode = self.get(familyKey);
+						if (familyNode && `familyMembers` in familyNode) {
+							familyNode.familyMembers.delete(subKey);
+							if (familyNode.familyMembers.size === 0) self.delete(familyKey);
+						}
+					} else self.delete(selectorToken.key);
+					return self;
+				});
+			});
+		}]
+	}, void 0);
+	return createStandaloneSelector(store, {
+		key: `🔍 Selector Token Index`,
+		get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL)
+	});
+};
+
+//#endregion
+//#region src/introspection/attach-timeline-family.ts
+const attachTimelineFamily = (store) => {
+	const findTimelineLogState__INTERNAL = createRegularAtomFamily(store, {
+		key: `🔍 Timeline Update Log (Internal)`,
+		default: (key) => store.timelines.get(key) ?? {
+			type: `timeline`,
+			key: ``,
+			at: 0,
+			timeTraveling: null,
+			history: [],
+			selectorTime: null,
+			transactionKey: null,
+			install: () => {},
+			subject: new Subject(),
+			subscriptions: new Map()
+		},
+		effects: (key) => [({ setSelf }) => {
+			const tl = store.timelines.get(key);
+			tl?.subject.subscribe(`introspection`, (_) => {
+				setSelf({ ...tl });
+			});
+		}]
+	});
+	const findTimelineLogState = createSelectorFamily(store, {
+		key: `🔍 Timeline Update Log`,
+		get: (key) => ({ get }) => get(findTimelineLogState__INTERNAL, key)
+	});
+	return findTimelineLogState;
+};
+
+//#endregion
+//#region src/introspection/attach-timeline-index.ts
+const attachTimelineIndex = (store) => {
+	const timelineTokenIndexState__INTERNAL = createRegularAtom(store, {
+		key: `🔍 Timeline Token Index (Internal)`,
+		default: () => [...store.timelines].map(([key]) => {
+			return {
+				key,
+				type: `timeline`
+			};
+		}),
+		effects: [({ setSelf }) => {
+			store.on.timelineCreation.subscribe(`introspection`, (timelineToken) => {
+				setSelf((state) => [...state, timelineToken]);
+			});
+		}]
+	}, void 0);
+	const timelineTokenIndex = createStandaloneSelector(store, {
+		key: `🔍 Timeline Token Index`,
+		get: ({ get }) => get(timelineTokenIndexState__INTERNAL)
+	});
+	return timelineTokenIndex;
+};
+
+//#endregion
+//#region src/introspection/attach-transaction-index.ts
+const attachTransactionIndex = (store) => {
+	const transactionTokenIndexState__INTERNAL = createRegularAtom(store, {
+		key: `🔍 Transaction Token Index (Internal)`,
+		default: () => [...store.transactions].map(([key]) => {
+			return {
+				key,
+				type: `transaction`
+			};
+		}),
+		effects: [({ setSelf }) => {
+			store.on.transactionCreation.subscribe(`introspection`, (transactionToken) => {
+				setSelf((state) => [...state, transactionToken]);
+			});
+		}]
+	}, void 0);
+	const transactionTokenIndex = createStandaloneSelector(store, {
+		key: `🔍 Transaction Token Index`,
+		get: ({ get }) => get(transactionTokenIndexState__INTERNAL)
+	});
+	return transactionTokenIndex;
+};
+
+//#endregion
+//#region src/introspection/attach-transaction-logs.ts
+const attachTransactionLogs = (store) => {
+	const transactionUpdateLogAtoms = createRegularAtomFamily(store, {
+		key: `🔍 Transaction Update Log (Internal)`,
+		default: () => [],
+		effects: (key) => [({ setSelf }) => {
+			const tx = store.transactions.get(key);
+			tx?.subject.subscribe(`introspection`, (transactionUpdate) => {
+				if (transactionUpdate.key === key) setSelf((state) => [...state, transactionUpdate]);
+			});
+		}]
+	});
+	const findTransactionUpdateLogState = createSelectorFamily(store, {
+		key: `🔍 Transaction Update Log`,
+		get: (key) => ({ get }) => get(transactionUpdateLogAtoms, key)
+	});
+	return findTransactionUpdateLogState;
+};
+
+//#endregion
+//#region src/introspection/refinery.ts
+var Refinery = class {
+	supported;
+	constructor(supported) {
+		this.supported = supported;
+	}
+	refine(input) {
+		for (const [key, refiner] of Object.entries(this.supported)) try {
+			if (refiner(input) === true && refiner !== Boolean) return {
+				type: key,
+				data: input
+			};
+		} catch (_) {
+			try {
+				if (input instanceof refiner) return {
+					type: key,
+					data: input
+				};
+			} catch (__) {}
+		}
+		return null;
+	}
+};
+const primitiveRefinery = new Refinery({
+	number: (input) => typeof input === `number`,
+	string: (input) => typeof input === `string`,
+	boolean: (input) => typeof input === `boolean`,
+	null: (input) => input === null
+});
+function isPlainObject(input) {
+	if (!input) return false;
+	const prototype = Object.getPrototypeOf(input);
+	return prototype === Object.prototype;
+}
+const jsonTreeRefinery = new Refinery({
+	object: isPlainObject,
+	array: (input) => Array.isArray(input)
+});
+const jsonRefinery = new Refinery({
+	...primitiveRefinery.supported,
+	...jsonTreeRefinery.supported
+});
+const discoverType = (input) => {
+	if (input === void 0) return `undefined`;
+	const refined = jsonRefinery.refine(input);
+	if (refined) return refined.type;
+	return Object.getPrototypeOf(input).constructor.name;
+};
+
+//#endregion
+//#region src/introspection/attach-type-selectors.ts
+const attachTypeSelectors = (store) => {
+	const typeSelectors = createReadonlySelectorFamily(store, {
+		key: `🔍 State Type`,
+		get: (key) => ({ get }) => {
+			let state;
+			try {
+				const token = store.atoms.get(key) ?? store.selectors.get(key) ?? store.readonlySelectors.get(key);
+				if (token === void 0) throw new Error(`Could not find state with key "${key}"`);
+				state = get(token);
+			} catch (thrown) {
+				return `error`;
+			}
+			const typeOfState = discoverType(state);
+			return typeOfState;
+		}
+	});
+	return typeSelectors;
+};
+
+//#endregion
+//#region src/introspection/attach-introspection-states.ts
+const attachIntrospectionStates = (store) => {
+	return {
+		atomIndex: attachAtomIndex(store),
+		selectorIndex: attachSelectorIndex(store),
+		transactionIndex: attachTransactionIndex(store),
+		transactionLogSelectors: attachTransactionLogs(store),
+		timelineIndex: attachTimelineIndex(store),
+		timelineSelectors: attachTimelineFamily(store),
+		typeSelectors: attachTypeSelectors(store)
+	};
+};
+
+//#endregion
+//#region src/introspection/auditor.ts
+/**
+* Auditor is a tool for identifying lingering resources in your store that may result in memory leaks.
+* @experimental
+*/
+var Auditor = class Auditor {
+	store;
+	auditorCreatedAt = performance.now();
+	statesCreatedAt = new Map();
+	atomIndex;
+	selectorIndex;
+	disposed = false;
+	unsubscribeFromAtomCreation;
+	unsubscribeFromAtomDisposal;
+	unsubscribeFromSelectorCreation;
+	unsubscribeFromSelectorDisposal;
+	/**
+	* @param {Store} store - The store to audit.
+	*/
+	constructor(store = Internal.IMPLICIT.STORE) {
+		this.store = store;
+		this.atomIndex = attachAtomIndex(this.store);
+		this.selectorIndex = attachSelectorIndex(this.store);
+		this.unsubscribeFromAtomCreation = this.store.on.atomCreation.subscribe(`auditor-${this.auditorCreatedAt}`, ({ key }) => {
+			this.statesCreatedAt.set(key, performance.now() - this.auditorCreatedAt);
+		});
+		this.unsubscribeFromAtomDisposal = this.store.on.atomDisposal.subscribe(`auditor-${this.auditorCreatedAt}`, ({ key }) => {
+			this.statesCreatedAt.delete(key);
+		});
+		this.unsubscribeFromSelectorCreation = this.store.on.selectorCreation.subscribe(`auditor-${this.auditorCreatedAt}`, ({ key }) => {
+			this.statesCreatedAt.set(key, performance.now() - this.auditorCreatedAt);
+		});
+		this.unsubscribeFromSelectorDisposal = this.store.on.selectorDisposal.subscribe(`auditor-${this.auditorCreatedAt}`, ({ key }) => {
+			this.statesCreatedAt.delete(key);
+		});
+	}
+	static DEFAULT_LIST_RESOURCES_PARAM = {
+		atomFamilies: true,
+		selectorFamilies: true
+	};
+	/**
+	* Lists all resources in the store, along with their creation time.
+	*
+	* @param {ListResourcesParam} [param] - Optional parameters for filtering the list of resources.
+	* @returns {readonly [ReadableToken<unknown>, number]}[] - An array of tuples, where each tuple contains a state token belonging to a family in the store and that state's creation time.
+	*/
+	listResources(param = Auditor.DEFAULT_LIST_RESOURCES_PARAM) {
+		if (this.disposed) throw new Error(`This Auditor has been disposed`);
+		const atoms = getState(this.atomIndex);
+		const selectors = getState(this.selectorIndex);
+		const atomFamilyNodes = [...atoms.values()].filter((node) => `familyMembers` in node);
+		const selectorFamilyNodes = [...selectors.values()].filter((node) => `familyMembers` in node);
+		const currentTime = performance.now();
+		const resources = [];
+		if (param.atomFamilies) for (const familyNode of atomFamilyNodes) {
+			const tokens = familyNode.familyMembers.values();
+			for (const token of tokens) {
+				const storedTime = this.statesCreatedAt.get(token.key);
+				const creationTime = storedTime ?? this.auditorCreatedAt;
+				const age = currentTime - creationTime;
+				resources.push([token, age]);
+			}
+		}
+		if (param.selectorFamilies) for (const familyNode of selectorFamilyNodes) {
+			const tokens = familyNode.familyMembers.values();
+			for (const token of tokens) {
+				const storedTime = this.statesCreatedAt.get(token.key);
+				const creationTime = storedTime ?? this.auditorCreatedAt;
+				const age = currentTime - creationTime;
+				resources.push([token, age]);
+			}
+		}
+		return resources;
+	}
+	[Symbol.dispose]() {
+		this.unsubscribeFromAtomCreation();
+		this.unsubscribeFromAtomDisposal();
+		this.unsubscribeFromSelectorCreation();
+		this.unsubscribeFromSelectorDisposal();
+		this.disposed = true;
+	}
+};
+
+//#endregion
+//#region src/introspection/sprawl.ts
+const sprawl = (tree, inspector) => {
+	const walk = (path, node) => {
+		const inspect = (p, n) => {
+			const result$1 = inspector(p, n);
+			if (result$1) return result$1;
+			return null;
+		};
+		const result = inspect(path, node);
+		if (result?.jobComplete ?? result?.pathComplete) return result;
+		const childEntries = Array.isArray(node) ? node.map((v, i) => [i, v]) : isPlainObject(node) ? Object.entries(node) : [];
+		for (const [k, v] of childEntries) {
+			const subResult = walk([...path, k], v);
+			if (subResult?.jobComplete) return subResult;
+		}
+		return {};
+	};
+	walk([], tree);
+};
+
+//#endregion
+//#region src/introspection/differ.ts
+function diffNumber(a, b) {
+	const sign = a < b ? `+` : `-`;
+	return { summary: `${sign}${Math.abs(a - b)} (${a} → ${b})` };
+}
+function diffString(a, b) {
+	const sign = a.length < b.length ? `+` : `-`;
+	return { summary: `${sign}${Math.abs(a.length - b.length)} ("${a}" → "${b}")` };
+}
+function diffBoolean(a, b) {
+	return { summary: `${a} → ${b}` };
+}
+function diffObject(a, b, recurse) {
+	let summary = ``;
+	const added = [];
+	const removed = [];
+	const changed = [];
+	sprawl(a, (path, nodeA) => {
+		let key;
+		for (key of path) {
+			const nodeB = b[key];
+			if (nodeB === void 0) removed.push([key, JSON.stringify(nodeA)]);
+			else {
+				const delta = recurse(nodeA, nodeB);
+				if (delta.summary !== `No Change`) changed.push([key, delta]);
+			}
+		}
+	});
+	sprawl(b, (path, nodeB) => {
+		let key;
+		for (key of path) {
+			const nodeA = a[key];
+			if (nodeA === void 0) added.push([key, JSON.stringify(nodeB)]);
+		}
+	});
+	summary = `～${changed.length} ＋${added.length} －${removed.length}`;
+	return {
+		summary,
+		added,
+		removed,
+		changed
+	};
+}
+function diffArray(a, b, recurse) {
+	return diffObject(a, b, recurse);
+}
+var Differ = class {
+	leafRefinery;
+	treeRefinery;
+	leafDiffers;
+	treeDiffers;
+	constructor(leafRefinery, treeRefinery, diffFunctions) {
+		this.leafRefinery = leafRefinery;
+		this.treeRefinery = treeRefinery;
+		this.leafDiffers = {};
+		this.treeDiffers = {};
+		for (const key of Object.keys(leafRefinery.supported)) {
+			const diffFunction = diffFunctions[key];
+			this.leafDiffers[key] = diffFunction;
+		}
+		for (const key of Object.keys(treeRefinery.supported)) {
+			const diffFunction = diffFunctions[key];
+			this.treeDiffers[key] = diffFunction;
+		}
+	}
+	diff(a, b) {
+		if (a === b) return { summary: `No Change` };
+		const aRefined = this.leafRefinery.refine(a) ?? this.treeRefinery.refine(a);
+		const bRefined = this.leafRefinery.refine(b) ?? this.treeRefinery.refine(b);
+		if (aRefined !== null && bRefined !== null) {
+			if (aRefined.type === bRefined.type) {
+				if (aRefined.type in this.leafDiffers) {
+					const delta = this.leafDiffers[aRefined.type](aRefined.data, bRefined.data);
+					return delta;
+				}
+				if (aRefined.type in this.treeDiffers) {
+					const delta = this.treeDiffers[aRefined.type](aRefined.data, bRefined.data, (x, y) => this.diff(x, y));
+					return delta;
+				}
+			}
+		}
+		const typeA = discoverType(a);
+		const typeB = discoverType(b);
+		if (typeA === typeB) return { summary: `${typeA} → ${typeB}` };
+		return { summary: `Type change: ${typeA} → ${typeB}` };
+	}
+};
+const prettyJson = new Differ(primitiveRefinery, jsonTreeRefinery, {
+	number: diffNumber,
+	string: diffString,
+	boolean: diffBoolean,
+	null: () => ({ summary: `No Change` }),
+	object: diffObject,
+	array: diffArray
+});
+
+//#endregion
+export { Auditor, Differ, Refinery, attachIntrospectionStates, diffArray, diffBoolean, diffNumber, diffObject, diffString, discoverType, isPlainObject, jsonRefinery, jsonTreeRefinery, prettyJson, primitiveRefinery, sprawl };
+//# sourceMappingURL=index.js.map