atom.io 0.28.1 → 0.29.0

package/dist/{chunk-6WL4RQMQ.js → chunk-XPYU2HY2.js}

@@ -209,9 +209,7 @@ function actUponStore(token, id, store) {
 }
 
 // internal/src/set-state/become.ts
-var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
-  originalThing instanceof Function ? originalThing() : originalThing
-) : nextVersionOfThing;
+var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
 
 // internal/src/get-state/read-or-compute-value.ts
 var readOrComputeValue = (state, target) => {
@@ -235,7 +233,7 @@ var readOrComputeValue = (state, target) => {
 };
 
 // internal/src/operation.ts
-var openOperation = (token, store) => {
+var openOperation = (store, token) => {
   if (store.operation.open) {
     const rejectionTime = performance.now();
     store.logger.info(
@@ -272,25 +270,25 @@ var closeOperation = (store) => {
   store.operation = { open: false };
   store.on.operationClose.next(store.operation);
 };
-var isDone = (key, store) => {
+var isDone = (store, key) => {
   if (!store.operation.open) {
-    store.logger.warn(
+    store.logger.error(
       `\u{1F41E}`,
       `unknown`,
       key,
-      `isDone called outside of an operation. This is probably a bug.`
+      `isDone called outside of an operation. This is probably a bug in AtomIO.`
     );
     return true;
   }
   return store.operation.done.has(key);
 };
-var markDone = (key, store) => {
+var markDone = (store, key) => {
   if (!store.operation.open) {
-    store.logger.warn(
+    store.logger.error(
       `\u{1F41E}`,
       `unknown`,
       key,
-      `markDone called outside of an operation. This is probably a bug.`
+      `markDone called outside of an operation. This is probably a bug in AtomIO.`
     );
     return;
   }
@@ -348,11 +346,11 @@ var evictDownStream = (atom, store) => {
       );
     }
     for (const key of downstreamKeys) {
-      if (isDone(key, target)) {
+      if (isDone(target, key)) {
         continue;
       }
       evictCachedValue(key, target);
-      markDone(key, target);
+      markDone(target, key);
     }
   }
 };
@@ -362,7 +360,7 @@ function shouldUpdateBeStowed(key, update) {
   if (isTransceiver(update.newValue)) {
     return false;
   }
-  if (key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
+  if (key.includes(`\u{1F50D}`)) {
     return false;
   }
   return true;
@@ -419,7 +417,7 @@ var setAtom = (atom, next, target) => {
   if (isAtomDefault(atom.key, target)) {
     markAtomAsNotDefault(atom.key, target);
   }
-  markDone(atom.key, target);
+  markDone(target, atom.key);
   evictDownStream(atom, target);
   const update = { oldValue, newValue };
   if (isRootStore(target)) {
@@ -791,7 +789,7 @@ var createWritableSelector = (store, options, family) => {
       `)`
     );
     cacheValue(options.key, newValue, subject, innerTarget);
-    markDone(options.key, innerTarget);
+    markDone(innerTarget, options.key);
     if (isRootStore(innerTarget)) {
       subject.next({ newValue, oldValue });
     }
@@ -879,14 +877,6 @@ function disposeSelector(selectorToken, store) {
     }
     target.valueMap.delete(key);
     target.selectorAtoms.delete(key);
-    const downstreamTokens = target.selectorGraph.getRelationEntries({ upstreamSelectorKey: key }).filter(([_, { source }]) => source === key).map(
-      ([downstreamSelectorKey]) => target.selectors.get(downstreamSelectorKey) ?? target.readonlySelectors.get(downstreamSelectorKey)
-    );
-    for (const downstreamToken of downstreamTokens) {
-      if (downstreamToken) {
-        disposeSelector(downstreamToken, store);
-      }
-    }
     target.selectorGraph.delete(key);
     store.logger.info(`\u{1F525}`, selectorToken.type, key, `deleted`);
     if (isChildStore(target) && target.transactionMeta.phase === `building`) {
@@ -1414,7 +1404,7 @@ ${disposal.trace}` : `No previous disposal trace was found.`
     );
     return;
   }
-  const rejectionTime = openOperation(token, store);
+  const rejectionTime = openOperation(store, token);
   if (rejectionTime) {
     const unsubscribe = store.on.operationClose.subscribe(
       `waiting to set "${token.key}" at T-${rejectionTime}`,
@@ -1449,7 +1439,7 @@ function ingestAtomUpdate(applying, atomUpdate, store) {
 function ingestCreationEvent(update, applying, store) {
   switch (applying) {
     case `newValue`: {
-      createInStore(update.token, store);
+      createInStore(update, store);
       break;
     }
     case `oldValue`: {
@@ -1465,34 +1455,18 @@ function ingestDisposalEvent(update, applying, store) {
       break;
     }
     case `oldValue`: {
-      createInStore(update.token, store);
+      createInStore(update, store);
       store.valueMap.set(update.token.key, update.value);
       break;
     }
   }
 }
-function createInStore(token, store) {
-  if (token.family) {
-    const family = store.families.get(token.family.key);
+function createInStore(update, store) {
+  const { family: familyMeta } = update.token;
+  if (familyMeta) {
+    const family = store.families.get(familyMeta.key);
     if (family) {
-      const molecule = store.molecules.get(token.family.subKey);
-      if (molecule) {
-        growMoleculeInStore(molecule, family, store);
-        return;
-      }
-      if (store.config.lifespan === `immortal`) {
-        store.logger.error(
-          `\u{1F41E}`,
-          `atom`,
-          token.family.key,
-          `tried to create member`,
-          `"${token.family.subKey}"`,
-          `but a molecule with that key was not found in store`,
-          `"${store.config.name}"`
-        );
-        return;
-      }
-      initFamilyMemberInStore(store, family, parseJson(token.family.subKey));
+      findInStore(store, family, parseJson(familyMeta.subKey));
     }
   }
 }
@@ -1908,7 +1882,7 @@ var Store = class {
     lifespan: `ephemeral`
   };
   loggers = [
-    new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`))
+    new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`\u{1F50D}`))
   ];
   logger = {
     error: (...messages) => {
@@ -2715,15 +2689,6 @@ function disposeAtom(atomToken, store) {
     }
     target.atoms.delete(key);
     target.valueMap.delete(key);
-    const selectorKeys = target.selectorAtoms.getRelatedKeys(key);
-    if (selectorKeys) {
-      for (const selectorKey of selectorKeys) {
-        const token = target.selectors.get(selectorKey) ?? target.readonlySelectors.get(selectorKey);
-        if (token) {
-          disposeSelector(token, store);
-        }
-      }
-    }
     target.selectorAtoms.delete(key);
     target.atomsThatAreDefault.delete(key);
     target.timelineTopics.delete(key);

package/eslint-plugin/dist/index.js

@@ -65,7 +65,6 @@ function walk(node, callback, depth = 0) {
     case `AwaitExpression`:
       walk(node.argument, callback, depth + 1);
       break;
-    case `FunctionDeclaration`:
     case `FunctionExpression`:
     case `ArrowFunctionExpression`:
       for (const param of node.params) {

package/eslint-plugin/src/walk.ts

@@ -11,7 +11,6 @@ export function walk(
 		case `AwaitExpression`:
 			walk(node.argument, callback, depth + 1)
 			break
-		case `FunctionDeclaration`:
 		case `FunctionExpression`:
 		case `ArrowFunctionExpression`:
 			for (const param of node.params) {

package/internal/dist/index.d.ts

@@ -207,10 +207,10 @@ type OperationProgress = {
     time: number;
     token: WritableToken<any>;
 };
-declare const openOperation: (token: WritableToken<any>, store: Store) => number | undefined;
+declare const openOperation: (store: Store, token: WritableToken<any>) => number | undefined;
 declare const closeOperation: (store: Store) => void;
-declare const isDone: (key: string, store: Store) => boolean;
-declare const markDone: (key: string, store: Store) => void;
+declare const isDone: (store: Store, key: string) => boolean;
+declare const markDone: (store: Store, key: string) => void;
 
 type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = Flat<StateUpdate<TokenType<ManagedAtom>> & {
     key: string;
@@ -496,7 +496,7 @@ declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) =>
 declare function ingestAtomUpdate(applying: `newValue` | `oldValue`, atomUpdate: KeyedStateUpdate<any>, store: Store): void;
 
 declare function ingestCreationEvent(update: StateCreation<any>, applying: `newValue` | `oldValue`, store: Store): void;
-declare function ingestDisposalEvent(update: StateDisposal<any>, applying: `newValue` | `oldValue`, store: Store): void;
+declare function ingestDisposalEvent(update: StateDisposal<ReadableToken<any>>, applying: `newValue` | `oldValue`, store: Store): void;
 declare function ingestMoleculeCreationEvent(update: MoleculeCreation<any>, applying: `newValue` | `oldValue`, store: Store): void;
 declare function ingestMoleculeDisposalEvent(update: MoleculeDisposal, applying: `newValue` | `oldValue`, store: Store): void;
 

package/internal/dist/index.js

@@ -1,3 +1,3 @@
-export { FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, 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, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-6WL4RQMQ.js';
+export { FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, 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, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-XPYU2HY2.js';
 import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';

package/internal/src/atom/dispose-atom.ts

@@ -30,17 +30,6 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 		}
 		target.atoms.delete(key)
 		target.valueMap.delete(key)
-		const selectorKeys = target.selectorAtoms.getRelatedKeys(key)
-		if (selectorKeys) {
-			for (const selectorKey of selectorKeys) {
-				const token =
-					target.selectors.get(selectorKey) ??
-					target.readonlySelectors.get(selectorKey)
-				if (token) {
-					disposeSelector(token, store)
-				}
-			}
-		}
 		target.selectorAtoms.delete(key)
 		target.atomsThatAreDefault.delete(key)
 		target.timelineTopics.delete(key)

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

@@ -7,7 +7,11 @@ import type {
 } from "atom.io"
 import { parseJson, stringifyJson } from "atom.io/json"
 
-import { disposeFromStore, initFamilyMemberInStore } from "../families"
+import {
+	disposeFromStore,
+	findInStore,
+	initFamilyMemberInStore,
+} from "../families"
 import { growMoleculeInStore, makeMoleculeInStore } from "../molecule"
 import { type Store, withdraw } from "../store"
 
@@ -18,7 +22,7 @@ export function ingestCreationEvent(
 ): void {
 	switch (applying) {
 		case `newValue`: {
-			createInStore(update.token, store)
+			createInStore(update, store)
 			break
 		}
 		case `oldValue`: {
@@ -29,7 +33,7 @@ export function ingestCreationEvent(
 }
 
 export function ingestDisposalEvent(
-	update: StateDisposal<any>,
+	update: StateDisposal<ReadableToken<any>>,
 	applying: `newValue` | `oldValue`,
 	store: Store,
 ): void {
@@ -39,35 +43,22 @@ export function ingestDisposalEvent(
 			break
 		}
 		case `oldValue`: {
-			createInStore(update.token, store)
+			createInStore(update, store)
 			store.valueMap.set(update.token.key, update.value)
 			break
 		}
 	}
 }
 
-function createInStore(token: ReadableToken<any>, store: Store): void {
-	if (token.family) {
-		const family = store.families.get(token.family.key)
+function createInStore(
+	update: StateCreation<any> | StateDisposal<any>,
+	store: Store,
+): void {
+	const { family: familyMeta } = update.token
+	if (familyMeta) {
+		const family = store.families.get(familyMeta.key)
 		if (family) {
-			const molecule = store.molecules.get(token.family.subKey)
-			if (molecule) {
-				growMoleculeInStore(molecule, family, store)
-				return
-			}
-			if (store.config.lifespan === `immortal`) {
-				store.logger.error(
-					`🐞`,
-					`atom`,
-					token.family.key,
-					`tried to create member`,
-					`"${token.family.subKey}"`,
-					`but a molecule with that key was not found in store`,
-					`"${store.config.name}"`,
-				)
-				return
-			}
-			initFamilyMemberInStore(store, family, parseJson(token.family.subKey))
+			findInStore(store, family, parseJson(familyMeta.subKey))
 		}
 	}
 }

package/internal/src/operation.ts

@@ -16,8 +16,8 @@ export type OperationProgress =
 	  }
 
 export const openOperation = (
-	token: WritableToken<any>,
 	store: Store,
+	token: WritableToken<any>,
 ): number | undefined => {
 	if (store.operation.open) {
 		const rejectionTime = performance.now()
@@ -60,25 +60,25 @@ export const closeOperation = (store: Store): void => {
 	store.on.operationClose.next(store.operation)
 }
 
-export const isDone = (key: string, store: Store): boolean => {
+export const isDone = (store: Store, key: string): boolean => {
 	if (!store.operation.open) {
-		store.logger.warn(
+		store.logger.error(
 			`🐞`,
 			`unknown`,
 			key,
-			`isDone called outside of an operation. This is probably a bug.`,
+			`isDone called outside of an operation. This is probably a bug in AtomIO.`,
 		)
 		return true
 	}
 	return store.operation.done.has(key)
 }
-export const markDone = (key: string, store: Store): void => {
+export const markDone = (store: Store, key: string): void => {
 	if (!store.operation.open) {
-		store.logger.warn(
+		store.logger.error(
 			`🐞`,
 			`unknown`,
 			key,
-			`markDone called outside of an operation. This is probably a bug.`,
+			`markDone called outside of an operation. This is probably a bug in AtomIO.`,
 		)
 		return
 	}

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

@@ -48,7 +48,7 @@ export const createWritableSelector = <T>(
 			`)`,
 		)
 		cacheValue(options.key, newValue, subject, innerTarget)
-		markDone(options.key, innerTarget)
+		markDone(innerTarget, options.key)
 		if (isRootStore(innerTarget)) {
 			subject.next({ newValue, oldValue })
 		}

package/internal/src/selector/dispose-selector.ts

@@ -52,19 +52,6 @@ export function disposeSelector(
 		}
 		target.valueMap.delete(key)
 		target.selectorAtoms.delete(key)
-		const downstreamTokens = target.selectorGraph
-			.getRelationEntries({ upstreamSelectorKey: key })
-			.filter(([_, { source }]) => source === key)
-			.map(
-				([downstreamSelectorKey]) =>
-					target.selectors.get(downstreamSelectorKey) ??
-					target.readonlySelectors.get(downstreamSelectorKey),
-			)
-		for (const downstreamToken of downstreamTokens) {
-			if (downstreamToken) {
-				disposeSelector(downstreamToken, store)
-			}
-		}
 		target.selectorGraph.delete(key)
 		store.logger.info(`🔥`, selectorToken.type, key, `deleted`)
 		if (isChildStore(target) && target.transactionMeta.phase === `building`) {

package/internal/src/set-state/become.ts

@@ -4,7 +4,5 @@ export const become =
 	<T>(nextVersionOfThing: Modify<T> | T) =>
 	(originalThing: T): T =>
 		nextVersionOfThing instanceof Function
-			? nextVersionOfThing(
-					originalThing instanceof Function ? originalThing() : originalThing,
-				)
+			? nextVersionOfThing(originalThing)
 			: nextVersionOfThing

package/internal/src/set-state/evict-downstream.ts

@@ -26,11 +26,11 @@ export const evictDownStream = <T>(atom: Atom<T>, store: Store): void => {
 			)
 		}
 		for (const key of downstreamKeys) {
-			if (isDone(key, target)) {
+			if (isDone(target, key)) {
 				continue
 			}
 			evictCachedValue(key, target)
-			markDone(key, target)
+			markDone(target, key)
 		}
 	}
 }

package/internal/src/set-state/set-atom.ts

@@ -30,7 +30,7 @@ export const setAtom = <T>(
 	if (isAtomDefault(atom.key, target)) {
 		markAtomAsNotDefault(atom.key, target)
 	}
-	markDone(atom.key, target)
+	markDone(target, atom.key)
 	evictDownStream(atom, target)
 	const update = { oldValue, newValue }
 	if (isRootStore(target)) {

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

@@ -58,7 +58,7 @@ export function setIntoStore<T, New extends T>(
 		return
 	}
 
-	const rejectionTime = openOperation(token, store)
+	const rejectionTime = openOperation(store, token)
 	if (rejectionTime) {
 		const unsubscribe = store.on.operationClose.subscribe(
 			`waiting to set "${token.key}" at T-${rejectionTime}`,

package/internal/src/set-state/stow-update.ts

@@ -11,8 +11,8 @@ function shouldUpdateBeStowed(key: string, update: StateUpdate<any>): boolean {
 	if (isTransceiver(update.newValue)) {
 		return false
 	}
-	// do not stow updates where the key contains 👁‍🗨
-	if (key.includes(`👁‍🗨`)) {
+	// do not stow updates where the key contains 🔍
+	if (key.includes(`🔍`)) {
 		return false
 	}
 	return true

package/internal/src/store/store.ts

@@ -132,7 +132,7 @@ export class Store implements Lineage {
 	}
 
 	public loggers: AtomIOLogger[] = [
-		new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`👁‍🗨`)),
+		new AtomIOLogger(`warn`, (_, __, key) => !key.includes(`🔍`)),
 	]
 	public logger: Logger = {
 		error: (...messages) => {

package/introspection/dist/index.d.ts

@@ -1,13 +1,13 @@
 import { AtomToken, SelectorToken, ReadonlySelectorToken, TransactionToken, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken, ReadableToken } from 'atom.io';
 import * as Internal from 'atom.io/internal';
-import { Func, Timeline, Flat } from 'atom.io/internal';
+import { Func, Timeline, Store, Flat } from 'atom.io/internal';
 import { Json } from 'atom.io/json';
 
 type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>;
 
 type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>;
 
-declare const attachIntrospectionStates: (store?: Internal.Store) => {
+type IntrospectionStates = {
     atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
     selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;
     transactionIndex: ReadonlySelectorToken<TransactionToken<Func>[]>;
@@ -16,6 +16,7 @@ declare const attachIntrospectionStates: (store?: Internal.Store) => {
     timelineSelectors: ReadonlySelectorFamilyToken<Timeline<any>, string>;
     typeSelectors: ReadonlySelectorFamilyToken<string, string>;
 };
+declare const attachIntrospectionStates: (store: Store) => IntrospectionStates;
 
 type ListResourcesParam = {
     atomFamilies: boolean;
@@ -78,12 +79,13 @@ declare const primitiveRefinery: Refinery<{
     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;
+    object: typeof isPlainObject;
     array: (input: unknown) => input is Json.Tree.Array;
 }>;
 declare const jsonRefinery: Refinery<{
-    object: (input: unknown) => input is Json.Tree.Object;
+    object: typeof isPlainObject;
     array: (input: unknown) => input is Json.Tree.Array;
     number: (input: unknown) => input is number;
     string: (input: unknown) => input is string;
@@ -128,14 +130,21 @@ declare const prettyJson: Differ<{
     boolean: (input: unknown) => input is boolean;
     null: (input: unknown) => input is null;
 }, {
-    object: (input: unknown) => input is Json.Tree.Object;
+    object: typeof isPlainObject;
     array: (input: unknown) => input is Json.Tree.Array;
 }>;
 
+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;
+
 type FamilyNode<Token extends ReadableToken<unknown>> = {
     key: string;
     familyMembers: Map<string, Token>;
 };
 type WritableTokenIndex<Token extends ReadableToken<unknown>> = Map<string, FamilyNode<Token> | Token>;
 
-export { Auditor, type ClassSignature, Differ, type FamilyNode, type JsonType, type ListResourcesParam, type Refinement, type RefinementStrategy, type RefinementSupport, Refinery, type Supported, type WritableTokenIndex, attachIntrospectionStates, diffArray, diffBoolean, diffNumber, diffObject, diffString, discoverType, jsonRefinery, jsonTreeRefinery, prettyJson, primitiveRefinery };
+export { Auditor, type ClassSignature, Differ, type FamilyNode, type InspectNode, type InspectionResult, type IntrospectionStates, type JsonType, type ListResourcesParam, type Refinement, type RefinementStrategy, type RefinementSupport, Refinery, type Supported, type WritableTokenIndex, attachIntrospectionStates, diffArray, diffBoolean, diffNumber, diffObject, diffString, discoverType, isPlainObject, jsonRefinery, jsonTreeRefinery, prettyJson, primitiveRefinery, sprawl };