flightdeck 0.2.16 → 0.2.17

package/dist/{chunk-AP2UJF2F.js → chunk-7KMVUPT3.js}

@@ -218,9 +218,8 @@ function createReadonlySelectorFamily(store, options, internalRoles) {
     default: (key) => {
       const getFn = options.get(key);
       return getFn({
-        get: (...ps) => getFromStore(store, ...ps),
-        find: (token, k) => findInStore(store, token, k),
-        seek: (token, k) => seekInStore(store, token, k),
+        get: (...args) => getFromStore(store, ...args),
+        find: (...args) => findInStore(store, ...args),
         json: (token) => getJsonToken(store, token)
       });
     }
@@ -314,6 +313,22 @@ function atomFamily(options) {
   return createAtomFamily(IMPLICIT.STORE, options);
 }
 
+// ../atom.io/src/join.ts
+function join(options, defaultContent, store = IMPLICIT.STORE) {
+  store.joins.set(options.key, new Join(options, defaultContent, store));
+  const token = {
+    key: options.key,
+    type: `join`,
+    a: options.between[0],
+    b: options.between[1],
+    cardinality: options.cardinality
+  };
+  return token;
+}
+function getInternalRelations(token) {
+  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
+}
+
 // ../atom.io/src/logger.ts
 var simpleLog = (logLevel) => (icon, denomination, tokenKey, message, ...rest) => {
   console[logLevel](
@@ -429,8 +444,12 @@ var abortTransaction = (store) => {
   target.parent.child = null;
 };
 
+// ../atom.io/internal/src/capitalize.ts
+function capitalize(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
+
 // ../atom.io/internal/src/pretty-print.ts
-var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 function prettyPrintTokenType(token) {
   return token.type.split(`_`).map(capitalize).join(` `);
 }
@@ -445,9 +464,9 @@ var NotFoundError = class extends Error {
 };
 
 // ../atom.io/internal/src/transaction/act-upon-store.ts
-function actUponStore(token, id, store) {
+function actUponStore(store, token, id) {
   return (...parameters) => {
-    const tx = withdraw(token, store);
+    const tx = withdraw(store, token);
     if (tx) {
       return tx.run(parameters, id);
     }
@@ -459,7 +478,7 @@ function actUponStore(token, id, store) {
 var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(originalThing) : nextVersionOfThing;
 
 // ../atom.io/internal/src/get-state/read-or-compute-value.ts
-var readOrComputeValue = (state, target) => {
+var readOrComputeValue = (target, state) => {
   if (target.valueMap.has(state.key)) {
     target.logger.info(`\u{1F4D6}`, state.type, state.key, `reading cached value`);
     return readCachedValue(state, target);
@@ -543,7 +562,7 @@ var markDone = (store, key) => {
 };
 
 // ../atom.io/internal/src/set-state/emit-update.ts
-var emitUpdate = (state, update, store) => {
+var emitUpdate = (store, state, update) => {
   switch (state.type) {
     case `mutable_atom`:
       store.logger.info(
@@ -573,7 +592,7 @@ var emitUpdate = (state, update, store) => {
 };
 
 // ../atom.io/internal/src/set-state/evict-downstream.ts
-var evictDownStream = (atom2, store) => {
+var evictDownStream = (store, atom2) => {
   const target = newest(store);
   const downstreamKeys = target.selectorAtoms.getRelatedKeys(atom2.key);
   target.logger.info(
@@ -612,7 +631,7 @@ function shouldUpdateBeStowed(key, update) {
   }
   return true;
 }
-var stowUpdate = (state, update, store) => {
+var stowUpdate = (store, state, update) => {
   const { key } = state;
   const target = newest(store);
   if (!isChildStore(target) || target.transactionMeta.phase !== `building`) {
@@ -651,44 +670,44 @@ var stowUpdate = (state, update, store) => {
 
 // ../atom.io/internal/src/set-state/set-atom.ts
 var setAtom = (atom2, next, target) => {
-  const oldValue = readOrComputeValue(atom2, target);
+  const oldValue = readOrComputeValue(target, atom2);
   let newValue = oldValue;
   if (atom2.type === `mutable_atom` && isChildStore(target)) {
     const { parent } = target;
-    const copiedValue = copyMutableIfNeeded(atom2, parent, target);
+    const copiedValue = copyMutableIfNeeded(target, atom2, parent);
     newValue = copiedValue;
   }
   newValue = become(next)(newValue);
   target.logger.info(`\u{1F4DD}`, `atom`, atom2.key, `set to`, newValue);
-  newValue = cacheValue(atom2.key, newValue, atom2.subject, target);
-  if (isAtomDefault(atom2.key, target)) {
-    markAtomAsNotDefault(atom2.key, target);
+  newValue = cacheValue(target, atom2.key, newValue, atom2.subject);
+  if (isAtomDefault(target, atom2.key)) {
+    markAtomAsNotDefault(target, atom2.key);
   }
   markDone(target, atom2.key);
-  evictDownStream(atom2, target);
+  evictDownStream(target, atom2);
   const update = { oldValue, newValue };
   if (isRootStore(target)) {
-    emitUpdate(atom2, update, target);
+    emitUpdate(target, atom2, update);
   } else if (target.parent) {
     if (target.on.transactionApplying.state === null) {
-      stowUpdate(atom2, update, target);
+      stowUpdate(target, atom2, update);
     } else if (atom2.key.startsWith(`*`)) {
       const mutableKey = atom2.key.slice(1);
       const mutableAtom = target.atoms.get(mutableKey);
       let transceiver = target.valueMap.get(mutableKey);
       if (mutableAtom.type === `mutable_atom` && isChildStore(target)) {
         const { parent } = target;
-        const copiedValue = copyMutableIfNeeded(mutableAtom, parent, target);
+        const copiedValue = copyMutableIfNeeded(target, mutableAtom, parent);
         transceiver = copiedValue;
       }
       const accepted = transceiver.do(update.newValue) === null;
-      if (accepted) evictDownStream(mutableAtom, target);
+      if (accepted) evictDownStream(target, mutableAtom);
     }
   }
 };
 
 // ../atom.io/internal/src/set-state/set-atom-or-selector.ts
-var setAtomOrSelector = (state, value, store) => {
+var setAtomOrSelector = (store, state, value) => {
   switch (state.type) {
     case `atom`:
     case `mutable_atom`:
@@ -762,8 +781,8 @@ ${disposal.trace}` : `No previous disposal trace was found.`
     );
     return;
   }
-  const state = withdraw(token, store);
-  setAtomOrSelector(state, value, store);
+  const state = withdraw(store, token);
+  setAtomOrSelector(store, state, value);
   closeOperation(store);
 }
 
@@ -1137,7 +1156,7 @@ function ingestTransactionUpdate(applying, transactionUpdate, store) {
 }
 
 // ../atom.io/internal/src/transaction/set-epoch-number.ts
-function setEpochNumberOfAction(transactionKey, newEpoch, store) {
+function setEpochNumberOfAction(store, transactionKey, newEpoch) {
   const isRoot = isRootStore(store);
   if (!isRoot) {
     return;
@@ -1176,14 +1195,14 @@ var applyTransaction = (output, store) => {
   ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent);
   if (isRootStore(parent)) {
     setEpochNumberOfAction(
+      parent,
       child.transactionMeta.update.key,
-      child.transactionMeta.update.epoch,
-      parent
-    );
-    const myTransaction = withdraw(
-      { key: child.transactionMeta.update.key, type: `transaction` },
-      store
+      child.transactionMeta.update.epoch
     );
+    const myTransaction = withdraw(store, {
+      key: child.transactionMeta.update.key,
+      type: `transaction`
+    });
     myTransaction?.subject.next(child.transactionMeta.update);
     store.logger.info(
       `\u{1F6EC}`,
@@ -1239,13 +1258,13 @@ ${disposal.trace}` : `No previous disposal trace was found.`
         if (store.defaults.has(family.key)) {
           return store.defaults.get(token.family.key);
         }
-        const defaultValue = withdraw(family, store).default(subKey);
+        const defaultValue = withdraw(store, family).default(subKey);
         store.defaults.set(family.key, defaultValue);
         return defaultValue;
       }
     }
   }
-  return readOrComputeValue(withdraw(token, store), store);
+  return readOrComputeValue(store, withdraw(store, token));
 }
 
 // ../atom.io/internal/src/junction.ts
@@ -1594,7 +1613,7 @@ var LazyMap = class extends Map {
 };
 
 // ../atom.io/internal/src/transaction/build-transaction.ts
-var buildTransaction = (key, params, store, id) => {
+var buildTransaction = (store, key, params, id) => {
   const parent = newest(store);
   const childBase = {
     parent,
@@ -1633,7 +1652,7 @@ var buildTransaction = (key, params, store, id) => {
     }),
     miscResources: new LazyMap(parent.miscResources)
   };
-  const epoch = getEpochNumberOfAction(key, store);
+  const epoch = getEpochNumberOfAction(store, key);
   const transactionMeta = {
     phase: `building`,
     update: {
@@ -1650,9 +1669,8 @@ var buildTransaction = (key, params, store, id) => {
       set: (...ps) => {
         setIntoStore(child, ...ps);
       },
-      run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
+      run: (token, identifier = arbitrary()) => actUponStore(child, token, identifier),
       find: (token, k) => findInStore(child, token, k),
-      seek: (token, k) => seekInStore(child, token, k),
       json: (token) => getJsonToken(child, token),
       dispose: (...ps) => {
         disposeFromStore(child, ...ps);
@@ -1675,12 +1693,12 @@ var buildTransaction = (key, params, store, id) => {
 };
 
 // ../atom.io/internal/src/transaction/create-transaction.ts
-function createTransaction(options, store) {
+function createTransaction(store, options) {
   const newTransaction = {
     key: options.key,
     type: `transaction`,
     run: (params, id) => {
-      const childStore = buildTransaction(options.key, params, store, id);
+      const childStore = buildTransaction(store, options.key, params, id);
       try {
         const target2 = newest(store);
         const { toolkit } = childStore.transactionMeta;
@@ -1693,7 +1711,7 @@ function createTransaction(options, store) {
         throw thrown;
       }
     },
-    install: (s) => createTransaction(options, s),
+    install: (s) => createTransaction(s, options),
     subject: new Subject()
   };
   const target = newest(store);
@@ -1704,7 +1722,7 @@ function createTransaction(options, store) {
 }
 
 // ../atom.io/internal/src/transaction/get-epoch-number.ts
-function getEpochNumberOfAction(transactionKey, store) {
+function getEpochNumberOfAction(store, transactionKey) {
   const isRoot = isRootStore(store);
   const continuity = isRoot ? store.transactionMeta.actionContinuities.getRelatedKey(transactionKey) : undefined;
   const epoch = isRoot && continuity !== undefined ? store.transactionMeta.epoch.get(continuity) : undefined;
@@ -1713,7 +1731,7 @@ function getEpochNumberOfAction(transactionKey, store) {
 
 // ../atom.io/src/transaction.ts
 function transaction(options) {
-  return createTransaction(options, IMPLICIT.STORE);
+  return createTransaction(IMPLICIT.STORE, options);
 }
 
 // ../atom.io/internal/src/store/store.ts
@@ -1884,7 +1902,7 @@ var IMPLICIT = {
 };
 
 // ../atom.io/internal/src/store/withdraw.ts
-function withdraw(token, store) {
+function withdraw(store, token) {
   let withdrawn;
   let target = store;
   while (target !== null) {
@@ -2012,40 +2030,37 @@ function disposeFromStore(store, ...params) {
     token = maybeToken;
   }
   try {
-    withdraw(token, store);
+    withdraw(store, token);
   } catch (thrown) {
     store.logger.error(
       `\u274C`,
       token.type,
       token.key,
       `could not be disposed because it was not found in the store "${store.config.name}".`
-      // disposal
-      // 	? `\n   This state was most recently disposed\n${disposal.trace}`
-      // 	: `No previous disposal trace was found.`,
     );
     return;
   }
   switch (token.type) {
     case `atom`:
     case `mutable_atom`:
-      disposeAtom(token, store);
+      disposeAtom(store, token);
       break;
     case `selector`:
     case `readonly_selector`:
-      disposeSelector(token, store);
+      disposeSelector(store, token);
       break;
   }
 }
 
 // ../atom.io/internal/src/keys.ts
-var isAtomKey = (key, store) => newest(store).atoms.has(key);
-var isSelectorKey = (key, store) => newest(store).selectors.has(key);
-var isReadonlySelectorKey = (key, store) => newest(store).readonlySelectors.has(key);
-var isStateKey = (key, store) => isAtomKey(key, store) || isSelectorKey(key, store) || isReadonlySelectorKey(key, store);
+var isAtomKey = (store, key) => newest(store).atoms.has(key);
+var isSelectorKey = (store, key) => newest(store).selectors.has(key);
+var isReadonlySelectorKey = (store, key) => newest(store).readonlySelectors.has(key);
+var isStateKey = (store, key) => isAtomKey(store, key) || isSelectorKey(store, key) || isReadonlySelectorKey(store, key);
 
 // ../atom.io/internal/src/selector/get-selector-dependency-keys.ts
 var getSelectorDependencyKeys = (key, store) => {
-  const sources = newest(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(source, store));
+  const sources = newest(store).selectorGraph.getRelationEntries({ downstreamSelectorKey: key }).filter(([_, { source }]) => source !== key).map(([_, { source }]) => source).filter((source) => isStateKey(store, source));
   return sources;
 };
 
@@ -2062,7 +2077,7 @@ var traceSelectorAtoms = (directDependencyKey, covered, store) => {
       continue;
     }
     covered.add(indirectDependencyKey);
-    if (!isAtomKey(indirectDependencyKey, store)) {
+    if (!isAtomKey(store, indirectDependencyKey)) {
       indirectDependencyKeys.push(
         ...getSelectorDependencyKeys(indirectDependencyKey, store)
       );
@@ -2077,7 +2092,7 @@ var traceAllSelectorAtoms = (selector, store) => {
   const directDependencyKeys = getSelectorDependencyKeys(selectorKey, store);
   const covered = /* @__PURE__ */ new Set();
   return directDependencyKeys.flatMap(
-    (depKey) => isAtomKey(depKey, store) ? depKey : traceSelectorAtoms(depKey, covered, store)
+    (depKey) => isAtomKey(store, depKey) ? depKey : traceSelectorAtoms(depKey, covered, store)
   );
 };
 
@@ -2124,8 +2139,8 @@ var registerSelector = (selectorKey, covered, store) => ({
     } else {
       [dependency] = params;
     }
-    const dependencyState = withdraw(dependency, store);
-    const dependencyValue = readOrComputeValue(dependencyState, store);
+    const dependencyState = withdraw(store, dependency);
+    const dependencyValue = readOrComputeValue(store, dependencyState);
     store.logger.info(
       `\u{1F50C}`,
       `selector`,
@@ -2159,11 +2174,10 @@ var registerSelector = (selectorKey, covered, store) => ({
       token = findInStore(store, family, key);
     }
     const target = newest(store);
-    const state = withdraw(token, target);
-    setAtomOrSelector(state, value, target);
+    const state = withdraw(target, token);
+    setAtomOrSelector(target, state, value);
   },
   find: (token, key) => findInStore(store, token, key),
-  seek: (token, key) => seekInStore(store, token, key),
   json: (token) => getJsonToken(store, token)
 });
 
@@ -2172,14 +2186,10 @@ var createReadonlySelector = (store, options, family) => {
   const target = newest(store);
   const subject = new Subject();
   const covered = /* @__PURE__ */ new Set();
-  const { get, find, seek, json } = registerSelector(
-    options.key,
-    covered,
-    target
-  );
+  const { get, find, json } = registerSelector(options.key, covered, target);
   const getSelf = () => {
-    const value = options.get({ get, find, seek, json });
-    cacheValue(options.key, value, subject, newest(store));
+    const value = options.get({ get, find, json });
+    cacheValue(newest(store), options.key, value, subject);
     covered.clear();
     return value;
   };
@@ -2216,11 +2226,11 @@ var createWritableSelector = (store, options, family) => {
   const subject = new Subject();
   const covered = /* @__PURE__ */ new Set();
   const setterToolkit = registerSelector(options.key, covered, target);
-  const { find, get, seek, json } = setterToolkit;
-  const getterToolkit = { find, get, seek, json };
+  const { find, get, json } = setterToolkit;
+  const getterToolkit = { find, get, json };
   const getSelf = (getFn = options.get, innerTarget = newest(store)) => {
     const value = getFn(getterToolkit);
-    cacheValue(options.key, value, subject, innerTarget);
+    cacheValue(innerTarget, options.key, value, subject);
     covered.clear();
     return value;
   };
@@ -2238,7 +2248,7 @@ var createWritableSelector = (store, options, family) => {
       newValue,
       `)`
     );
-    cacheValue(options.key, newValue, subject, innerTarget);
+    cacheValue(innerTarget, options.key, newValue, subject);
     markDone(innerTarget, options.key);
     if (isRootStore(innerTarget)) {
       subject.next({ newValue, oldValue });
@@ -2281,10 +2291,10 @@ function createStandaloneSelector(store, options) {
 }
 
 // ../atom.io/internal/src/selector/dispose-selector.ts
-function disposeSelector(selectorToken, store) {
+function disposeSelector(store, selectorToken) {
   const target = newest(store);
   const { key } = selectorToken;
-  const selector = withdraw(selectorToken, target);
+  const selector = withdraw(target, selectorToken);
   if (!selector.family) {
     store.logger.error(
       `\u274C`,
@@ -2297,23 +2307,31 @@ function disposeSelector(selectorToken, store) {
     if (molecule) {
       target.moleculeData.delete(selector.family.subKey, selector.family.key);
     }
+    let familyToken;
     switch (selectorToken.type) {
       case `selector`:
         {
           target.selectors.delete(key);
-          withdraw(
-            { key: selector.family.key, type: `selector_family` },
-            store
-          );
+          familyToken = {
+            key: selector.family.key,
+            type: `selector_family`
+          };
+          const family = withdraw(store, familyToken);
+          family.subject.next({
+            type: `state_disposal`,
+            subType: `selector`,
+            token: selectorToken
+          });
         }
         break;
       case `readonly_selector`:
         {
           target.readonlySelectors.delete(key);
-          const family = withdraw(
-            { key: selector.family.key, type: `readonly_selector_family` },
-            store
-          );
+          familyToken = {
+            key: selector.family.key,
+            type: `readonly_selector_family`
+          };
+          const family = withdraw(store, familyToken);
           family.subject.next({
             type: `state_disposal`,
             subType: `selector`,
@@ -2382,7 +2400,6 @@ function createWritableSelectorFamily(store, options, internalRoles) {
       return getFn({
         get: (...ps) => getFromStore(store, ...ps),
         find: (token, k) => findInStore(store, token, k),
-        seek: (token, k) => seekInStore(store, token, k),
         json: (token) => getJsonToken(store, token)
       });
     }
@@ -2392,7 +2409,7 @@ function createWritableSelectorFamily(store, options, internalRoles) {
 }
 
 // ../atom.io/json/src/select-json-family.ts
-function selectJsonFamily(atomFamilyToken, transform, store = IMPLICIT.STORE) {
+function selectJsonFamily(store, atomFamilyToken, transform) {
   const jsonFamily = createWritableSelectorFamily(
     store,
     {
@@ -2407,15 +2424,6 @@ function selectJsonFamily(atomFamilyToken, transform, store = IMPLICIT.STORE) {
     },
     [`mutable`, `json`]
   );
-  const atomFamily2 = withdraw(atomFamilyToken, store);
-  atomFamily2.subject.subscribe(
-    `store=${store.config.name}::json-selector-family`,
-    (event) => {
-      if (event.token.family) {
-        seekInStore(store, jsonFamily, parseJson(event.token.family.subKey));
-      }
-    }
-  );
   return jsonFamily;
 }
 
@@ -2424,7 +2432,7 @@ var parseJson = (str) => JSON.parse(str);
 var stringifyJson = (json) => JSON.stringify(json);
 
 // ../atom.io/internal/src/subscribe/recall-state.ts
-var recallState = (state, store) => {
+var recallState = (store, state) => {
   const target = newest(store);
   if (target.operation.open) {
     return target.operation.prev.get(state.key);
@@ -2433,7 +2441,7 @@ var recallState = (state, store) => {
 };
 
 // ../atom.io/internal/src/subscribe/subscribe-to-root-atoms.ts
-var subscribeToRootAtoms = (selector, store) => {
+var subscribeToRootAtoms = (store, selector) => {
   const target = newest(store);
   const dependencySubscriptions = traceAllSelectorAtoms(selector, store).map(
     (atomKey) => {
@@ -2457,8 +2465,8 @@ var subscribeToRootAtoms = (selector, store) => {
             `->`,
             atomChange.newValue
           );
-          const oldValue = recallState(selector, target);
-          const newValue = readOrComputeValue(selector, target);
+          const oldValue = recallState(target, selector);
+          const newValue = readOrComputeValue(target, selector);
           store.logger.info(
             `\u2728`,
             selector.type,
@@ -2477,7 +2485,7 @@ var subscribeToRootAtoms = (selector, store) => {
 };
 
 // ../atom.io/internal/src/subscribe/subscribe-to-state.ts
-function subscribeToState(token, handleUpdate, key, store) {
+function subscribeToState(store, token, key, handleUpdate) {
   function safelyHandleUpdate(update) {
     if (store.operation.open) {
       const unsubscribe2 = store.on.operationClose.subscribe(
@@ -2491,17 +2499,17 @@ function subscribeToState(token, handleUpdate, key, store) {
       handleUpdate(update);
     }
   }
-  const state = withdraw(token, store);
+  const state = withdraw(store, token);
   store.logger.info(`\u{1F440}`, state.type, state.key, `Adding subscription "${key}"`);
   const isSelector = state.type === `selector` || state.type === `readonly_selector`;
   let dependencyUnsubFunctions = null;
   let updateHandler = safelyHandleUpdate;
   if (isSelector) {
-    dependencyUnsubFunctions = subscribeToRootAtoms(state, store);
+    dependencyUnsubFunctions = subscribeToRootAtoms(store, state);
     updateHandler = (update) => {
       if (dependencyUnsubFunctions) {
         dependencyUnsubFunctions.length = 0;
-        dependencyUnsubFunctions.push(...subscribeToRootAtoms(state, store));
+        dependencyUnsubFunctions.push(...subscribeToRootAtoms(store, state));
       }
       safelyHandleUpdate(update);
     };
@@ -2525,8 +2533,8 @@ function subscribeToState(token, handleUpdate, key, store) {
 }
 
 // ../atom.io/internal/src/subscribe/subscribe-to-timeline.ts
-var subscribeToTimeline = (token, handleUpdate, key, store) => {
-  const tl = withdraw(token, store);
+var subscribeToTimeline = (store, token, key, handleUpdate) => {
+  const tl = withdraw(store, token);
   store.logger.info(`\u{1F440}`, `timeline`, token.key, `Adding subscription "${key}"`);
   const unsubscribe = tl.subject.subscribe(key, handleUpdate);
   return () => {
@@ -2577,7 +2585,9 @@ var Tracker = class {
       }
     );
     this.unsubscribeFromState = subscribeToState(
+      target,
       mutableState,
+      subscriptionKey,
       (update) => {
         if (update.newValue !== update.oldValue) {
           this.unsubscribeFromInnerValue();
@@ -2588,15 +2598,15 @@ var Tracker = class {
             }
           );
         }
-      },
-      subscriptionKey,
-      target
+      }
     );
   }
   updateCore(mutableState, latestUpdateState, target) {
     const subscriptionKey = `tracker:${target.config.name}:${isChildStore(target) ? target.transactionMeta.update.key : `main`}:${mutableState.key}`;
     subscribeToState(
+      target,
       latestUpdateState,
+      subscriptionKey,
       ({ newValue, oldValue }) => {
         const timelineId = target.timelineTopics.getRelatedKey(
           latestUpdateState.key
@@ -2605,7 +2615,9 @@ var Tracker = class {
           const timelineData = target.timelines.get(timelineId);
           if (timelineData?.timeTraveling) {
             const unsubscribe2 = subscribeToTimeline(
+              target,
               { key: timelineId, type: `timeline` },
+              subscriptionKey,
               (update) => {
                 unsubscribe2();
                 setIntoStore(target, mutableState, (transceiver) => {
@@ -2616,9 +2628,7 @@ var Tracker = class {
                   }
                   return transceiver;
                 });
-              },
-              subscriptionKey,
-              target
+              }
             );
             return;
           }
@@ -2646,14 +2656,12 @@ var Tracker = class {
             }
           }
         );
-      },
-      subscriptionKey,
-      target
+      }
     );
   }
   mutableState;
   latestUpdateState;
-  dispose;
+  [Symbol.dispose];
   constructor(mutableState, store) {
     this.mutableState = mutableState;
     const target = newest(store);
@@ -2661,7 +2669,7 @@ var Tracker = class {
     this.observeCore(mutableState, this.latestUpdateState, target);
     this.updateCore(mutableState, this.latestUpdateState, target);
     target.trackers.set(mutableState.key, this);
-    this.dispose = () => {
+    this[Symbol.dispose] = () => {
       this.unsubscribeFromInnerValue();
       this.unsubscribeFromState();
       target.trackers.delete(mutableState.key);
@@ -2708,8 +2716,8 @@ function createMutableAtom(store, options, family) {
   }
   const initialValue = options.default();
   target.atoms.set(newAtom.key, newAtom);
-  markAtomAsDefault(options.key, store);
-  cacheValue(options.key, initialValue, subject, target);
+  markAtomAsDefault(store, options.key);
+  cacheValue(target, options.key, initialValue, subject);
   const token = deposit(newAtom);
   if (options.effects) {
     let effectIndex = 0;
@@ -2719,7 +2727,7 @@ function createMutableAtom(store, options, family) {
         setSelf: (next) => {
           setIntoStore(store, token, next);
         },
-        onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
+        onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle)
       });
       if (cleanup) {
         cleanupFunctions.push(cleanup);
@@ -2741,6 +2749,7 @@ function createMutableAtom(store, options, family) {
 
 // ../atom.io/internal/src/mutable/tracker-family.ts
 var FamilyTracker = class {
+  trackers = /* @__PURE__ */ new Map();
   Update;
   latestUpdateAtoms;
   mutableAtoms;
@@ -2753,26 +2762,27 @@ var FamilyTracker = class {
       },
       [`mutable`, `updates`]
     );
-    this.latestUpdateAtoms = withdraw(updateAtoms, store);
+    this.latestUpdateAtoms = withdraw(store, updateAtoms);
     this.mutableAtoms = mutableAtoms;
     this.mutableAtoms.subject.subscribe(
       `store=${store.config.name}::tracker-atom-family`,
       (event) => {
-        if (event.token.family) {
-          const key = parseJson(event.token.family.subKey);
-          seekInStore(store, this.latestUpdateAtoms, key);
-          new Tracker(event.token, store);
-        }
-      }
-    );
-    this.latestUpdateAtoms.subject.subscribe(
-      `store=${store.config.name}::tracker-atom-family`,
-      (event) => {
-        if (event.token.family) {
-          const key = parseJson(event.token.family.subKey);
-          const mutableAtomToken = seekInStore(store, this.mutableAtoms, key);
-          if (mutableAtomToken) {
-            new Tracker(mutableAtomToken, store);
+        const { type, token } = event;
+        if (token.family) {
+          const key = parseJson(token.family.subKey);
+          switch (type) {
+            case `state_creation`:
+              this.trackers.set(key, new Tracker(token, store));
+              break;
+            case `state_disposal`:
+              {
+                const tracker = this.trackers.get(key);
+                if (tracker) {
+                  tracker[Symbol.dispose]();
+                  this.trackers.delete(key);
+                }
+              }
+              break;
           }
         }
       }
@@ -2825,7 +2835,7 @@ function createMutableAtomFamily(store, options, internalRoles) {
     internalRoles
   });
   store.families.set(options.key, atomFamily2);
-  selectJsonFamily(atomFamily2, options, store);
+  selectJsonFamily(store, atomFamily2, options);
   new FamilyTracker(atomFamily2, store);
   return familyToken;
 }
@@ -2847,7 +2857,7 @@ var getJsonToken = (store, mutableAtomToken) => {
       key: jsonFamilyKey,
       type: `selector_family`
     };
-    const family = withdraw(jsonFamilyToken, target);
+    const family = withdraw(target, jsonFamilyToken);
     const subKey = JSON.parse(mutableAtomToken.family.subKey);
     const jsonToken = findInStore(store, family, subKey);
     return jsonToken;
@@ -2878,7 +2888,7 @@ function isTransceiver(value) {
 }
 
 // ../atom.io/internal/src/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(atom2, origin, target) {
+function copyMutableIfNeeded(target, atom2, origin) {
   const originValue = origin.valueMap.get(atom2.key);
   const targetValue = target.valueMap.get(atom2.key);
   if (originValue === targetValue) {
@@ -2896,7 +2906,7 @@ function copyMutableIfNeeded(atom2, origin, target) {
 }
 
 // ../atom.io/internal/src/caching.ts
-function cacheValue(key, value, subject, target) {
+function cacheValue(target, key, value, subject) {
   const currentValue = target.valueMap.get(key);
   if (currentValue instanceof Future) {
     const future = currentValue;
@@ -2906,7 +2916,7 @@ function cacheValue(key, value, subject, target) {
     const future = new Future(value);
     target.valueMap.set(key, future);
     future.then((resolved) => {
-      cacheValue(key, resolved, subject, target);
+      cacheValue(target, key, resolved, subject);
       subject.next({ newValue: resolved, oldValue: future });
     }).catch((thrown) => {
       target.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
@@ -2920,7 +2930,7 @@ var readCachedValue = (token, target) => {
   let value = target.valueMap.get(token.key);
   if (token.type === `mutable_atom` && isChildStore(target)) {
     const { parent } = target;
-    const copiedValue = copyMutableIfNeeded(token, parent, target);
+    const copiedValue = copyMutableIfNeeded(target, token, parent);
     value = copiedValue;
   }
   return value;
@@ -2943,15 +2953,15 @@ var evictCachedValue = (key, target) => {
 };
 
 // ../atom.io/internal/src/atom/is-default.ts
-var isAtomDefault = (key, store) => {
+var isAtomDefault = (store, key) => {
   const core = newest(store);
   return core.atomsThatAreDefault.has(key);
 };
-var markAtomAsDefault = (key, store) => {
+var markAtomAsDefault = (store, key) => {
   const core = newest(store);
   core.atomsThatAreDefault = new Set(core.atomsThatAreDefault).add(key);
 };
-var markAtomAsNotDefault = (key, store) => {
+var markAtomAsNotDefault = (store, key) => {
   const core = newest(store);
   core.atomsThatAreDefault = new Set(newest(store).atomsThatAreDefault);
   core.atomsThatAreDefault.delete(key);
@@ -2999,8 +3009,8 @@ function createRegularAtom(store, options, family) {
     initialValue = options.default();
   }
   target.atoms.set(newAtom.key, newAtom);
-  markAtomAsDefault(options.key, store);
-  cacheValue(options.key, initialValue, subject, target);
+  markAtomAsDefault(store, options.key);
+  cacheValue(target, options.key, initialValue, subject);
   const token = deposit(newAtom);
   if (options.effects) {
     let effectIndex = 0;
@@ -3010,7 +3020,7 @@ function createRegularAtom(store, options, family) {
         setSelf: (next) => {
           setIntoStore(store, token, next);
         },
-        onSet: (handle) => subscribeToState(token, handle, `effect[${effectIndex}]`, store)
+        onSet: (handle) => subscribeToState(store, token, `effect[${effectIndex}]`, handle)
       });
       if (cleanup) {
         cleanupFunctions.push(cleanup);
@@ -3040,16 +3050,16 @@ function createStandaloneAtom(store, options) {
 }
 
 // ../atom.io/internal/src/atom/dispose-atom.ts
-function disposeAtom(atomToken, store) {
+function disposeAtom(store, atomToken) {
   const target = newest(store);
   const { key, family } = atomToken;
-  const atom2 = withdraw(atomToken, target);
+  const atom2 = withdraw(target, atomToken);
   if (!family) {
     store.logger.error(`\u274C`, `atom`, key, `Standalone atoms cannot be disposed.`);
   } else {
     atom2.cleanup?.();
     const lastValue = store.valueMap.get(atom2.key);
-    const atomFamily2 = withdraw({ key: family.key, type: `atom_family` }, store);
+    const atomFamily2 = withdraw(store, { key: family.key, type: `atom_family` });
     const disposal = {
       type: `state_disposal`,
       subType: `atom`,
@@ -3065,7 +3075,7 @@ function disposeAtom(atomToken, store) {
     store.timelineTopics.delete(key);
     if (atomToken.type === `mutable_atom`) {
       const updateToken = getUpdateToken(atomToken);
-      disposeAtom(updateToken, store);
+      disposeAtom(store, updateToken);
       store.trackers.delete(key);
     }
     store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
@@ -3082,211 +3092,6 @@ function disposeAtom(atomToken, store) {
   }
 }
 
-// ../atom.io/introspection/src/refinery.ts
-var Refinery = class {
-  supported;
-  constructor(supported) {
-    this.supported = supported;
-  }
-  refine(input) {
-    for (const [key, refiner] of Object.entries(this.supported)) {
-      try {
-        if (
-          // @ts-expect-error that's the point
-          refiner(input) === true && refiner !== Boolean
-        ) {
-          return { type: key, data: input };
-        }
-      } catch (_) {
-        try {
-          if (input instanceof refiner) {
-            return { type: key, data: input };
-          }
-        } catch (__) {
-        }
-      }
-    }
-    return null;
-  }
-};
-var 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;
-}
-var jsonTreeRefinery = new Refinery({
-  object: isPlainObject,
-  array: (input) => Array.isArray(input)
-});
-var jsonRefinery = new Refinery({
-  ...primitiveRefinery.supported,
-  ...jsonTreeRefinery.supported
-});
-var discoverType = (input) => {
-  if (input === undefined) {
-    return `undefined`;
-  }
-  const refined = jsonRefinery.refine(input);
-  if (refined) {
-    return refined.type;
-  }
-  return Object.getPrototypeOf(input).constructor.name;
-};
-
-// ../atom.io/introspection/src/sprawl.ts
-var sprawl = (tree, inspector) => {
-  const walk = (path, node) => {
-    const inspect2 = (p, n) => {
-      const result2 = inspector(p, n);
-      if (result2) return result2;
-      return null;
-    };
-    const result = inspect2(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);
-};
-
-// ../atom.io/introspection/src/differ.ts
-function diffNumber(a, b) {
-  const sign = a < b ? `+` : `-`;
-  return {
-    summary: `${sign}${Math.abs(a - b)} (${a} \u2192 ${b})`
-  };
-}
-function diffString(a, b) {
-  const sign = a.length < b.length ? `+` : `-`;
-  return {
-    summary: `${sign}${Math.abs(a.length - b.length)} ("${a}" \u2192 "${b}")`
-  };
-}
-function diffBoolean(a, b) {
-  return {
-    summary: `${a} \u2192 ${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 === undefined) {
-        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 === undefined) {
-        added.push([key, JSON.stringify(nodeB)]);
-      }
-    }
-  });
-  summary = `\uFF5E${changed.length} \uFF0B${added.length} \uFF0D${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} \u2192 ${typeB}`
-      };
-    }
-    return {
-      summary: `Type change: ${typeA} \u2192 ${typeB}`
-    };
-  }
-};
-new Differ(primitiveRefinery, jsonTreeRefinery, {
-  number: diffNumber,
-  string: diffString,
-  boolean: diffBoolean,
-  null: () => ({ summary: `No Change` }),
-  object: diffObject,
-  array: diffArray
-});
-
 // ../atom.io/transceivers/set-rtx/src/set-rtx.ts
 var SetRTX = class _SetRTX extends Set {
   mode = `record`;
@@ -3499,10 +3304,7 @@ var SetRTX = class _SetRTX extends Set {
   }
 };
 
-// ../atom.io/data/src/join.ts
-function capitalize2(string) {
-  return string[0].toUpperCase() + string.slice(1);
-}
+// ../atom.io/internal/src/join/join-internal.ts
 var Join = class {
   toolkit;
   options;
@@ -3534,7 +3336,6 @@ var Join = class {
         setIntoStore(store, ...ps);
       },
       find: (...ps) => findInStore(store, ...ps),
-      seek: (...ps) => seekInStore(store, ...ps),
       json: (token) => getJsonToken(store, token)
     };
     const aSide = options.between[0];
@@ -3800,8 +3601,8 @@ var Join = class {
     switch (options.cardinality) {
       case `1:1`: {
         const singleRelatedKeySelectors = createSingleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeyOf${capitalize2(bSide)}`;
-        const stateKeyB = `${bSide}KeyOf${capitalize2(aSide)}`;
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: singleRelatedKeySelectors,
           [stateKeyB]: singleRelatedKeySelectors
@@ -3809,8 +3610,8 @@ var Join = class {
         let states;
         if (defaultContent) {
           const singleEntrySelectors = createSingleEntrySelectorFamily();
-          const entriesStateKeyA = `${aSide}EntryOf${capitalize2(bSide)}`;
-          const entriesStateKeyB = `${bSide}EntryOf${capitalize2(aSide)}`;
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
           const contentStates = {
             [entriesStateKeyA]: singleEntrySelectors,
             [entriesStateKeyB]: singleEntrySelectors
@@ -3826,8 +3627,8 @@ var Join = class {
       case `1:n`: {
         const singleRelatedKeySelectors = createSingleKeySelectorFamily();
         const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeyOf${capitalize2(bSide)}`;
-        const stateKeyB = `${bSide}KeysOf${capitalize2(aSide)}`;
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: singleRelatedKeySelectors,
           [stateKeyB]: multipleRelatedKeysSelectors
@@ -3836,8 +3637,8 @@ var Join = class {
         if (defaultContent) {
           const singleRelatedEntrySelectors = createSingleEntrySelectorFamily();
           const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
-          const entriesStateKeyA = `${aSide}EntryOf${capitalize2(bSide)}`;
-          const entriesStateKeyB = `${bSide}EntriesOf${capitalize2(
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
             aSide
           )}`;
           const contentStates = {
@@ -3854,8 +3655,8 @@ var Join = class {
       }
       default: {
         const multipleRelatedKeysSelectors = getMultipleKeySelectorFamily();
-        const stateKeyA = `${aSide}KeysOf${capitalize2(bSide)}`;
-        const stateKeyB = `${bSide}KeysOf${capitalize2(aSide)}`;
+        const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: multipleRelatedKeysSelectors,
           [stateKeyB]: multipleRelatedKeysSelectors
@@ -3863,10 +3664,10 @@ var Join = class {
         let states;
         if (defaultContent) {
           const multipleRelatedEntriesSelectors = getMultipleEntrySelectorFamily();
-          const entriesStateKeyA = `${aSide}EntriesOf${capitalize2(
+          const entriesStateKeyA = `${aSide}EntriesOf${capitalize(
             bSide
           )}`;
-          const entriesStateKeyB = `${bSide}EntriesOf${capitalize2(
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
             aSide
           )}`;
           const contentStates = {
@@ -3883,17 +3684,8 @@ var Join = class {
     }
   }
 };
-function join(options, defaultContent, store = IMPLICIT.STORE) {
-  store.joins.set(options.key, new Join(options, defaultContent, store));
-  const token = {
-    key: options.key,
-    type: `join`,
-    a: options.between[0],
-    b: options.between[1],
-    cardinality: options.cardinality
-  };
-  return token;
-}
+
+// ../atom.io/internal/src/join/get-join.ts
 function getJoin(token, store) {
   let myJoin = store.joins.get(token.key);
   if (myJoin === undefined) {
@@ -3909,6 +3701,8 @@ function getJoin(token, store) {
   }
   return myJoin;
 }
+
+// ../atom.io/internal/src/join/edit-relations-in-store.ts
 function editRelationsInStore(token, change, store) {
   const myJoin = getJoin(token, store);
   const target = newest(store);
@@ -3921,14 +3715,218 @@ function editRelationsInStore(token, change, store) {
     change(myJoin.relations);
   }
 }
+
+// ../atom.io/internal/src/join/get-internal-relations-from-store.ts
 function getInternalRelationsFromStore(token, store) {
   const myJoin = getJoin(token, store);
   const family = myJoin.core.relatedKeysAtoms;
   return family;
 }
-function getInternalRelations(token) {
-  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
+
+// ../atom.io/introspection/src/refinery.ts
+var Refinery = class {
+  supported;
+  constructor(supported) {
+    this.supported = supported;
+  }
+  refine(input) {
+    for (const [key, refiner] of Object.entries(this.supported)) {
+      try {
+        if (
+          // @ts-expect-error that's the point
+          refiner(input) === true && refiner !== Boolean
+        ) {
+          return { type: key, data: input };
+        }
+      } catch (_) {
+        try {
+          if (input instanceof refiner) {
+            return { type: key, data: input };
+          }
+        } catch (__) {
+        }
+      }
+    }
+    return null;
+  }
+};
+var 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;
+}
+var jsonTreeRefinery = new Refinery({
+  object: isPlainObject,
+  array: (input) => Array.isArray(input)
+});
+var jsonRefinery = new Refinery({
+  ...primitiveRefinery.supported,
+  ...jsonTreeRefinery.supported
+});
+var discoverType = (input) => {
+  if (input === undefined) {
+    return `undefined`;
+  }
+  const refined = jsonRefinery.refine(input);
+  if (refined) {
+    return refined.type;
+  }
+  return Object.getPrototypeOf(input).constructor.name;
+};
+
+// ../atom.io/introspection/src/sprawl.ts
+var sprawl = (tree, inspector) => {
+  const walk = (path, node) => {
+    const inspect2 = (p, n) => {
+      const result2 = inspector(p, n);
+      if (result2) return result2;
+      return null;
+    };
+    const result = inspect2(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);
+};
+
+// ../atom.io/introspection/src/differ.ts
+function diffNumber(a, b) {
+  const sign = a < b ? `+` : `-`;
+  return {
+    summary: `${sign}${Math.abs(a - b)} (${a} \u2192 ${b})`
+  };
+}
+function diffString(a, b) {
+  const sign = a.length < b.length ? `+` : `-`;
+  return {
+    summary: `${sign}${Math.abs(a.length - b.length)} ("${a}" \u2192 "${b}")`
+  };
 }
+function diffBoolean(a, b) {
+  return {
+    summary: `${a} \u2192 ${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 === undefined) {
+        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 === undefined) {
+        added.push([key, JSON.stringify(nodeB)]);
+      }
+    }
+  });
+  summary = `\uFF5E${changed.length} \uFF0B${added.length} \uFF0D${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} \u2192 ${typeB}`
+      };
+    }
+    return {
+      summary: `Type change: ${typeA} \u2192 ${typeB}`
+    };
+  }
+};
+new Differ(primitiveRefinery, jsonTreeRefinery, {
+  number: diffNumber,
+  string: diffString,
+  boolean: diffBoolean,
+  null: () => ({ summary: `No Change` }),
+  object: diffObject,
+  array: diffArray
+});
 
 // ../atom.io/realtime/src/shared-room-store.ts
 atom({
@@ -4764,5 +4762,5 @@ var FlightDeckLogger = class {
 };
 
 export { FLIGHTDECK_ERROR, FLIGHTDECK_INFO, FLIGHTDECK_LNAV_FORMAT, FLIGHTDECK_SETUP_PHASES, FLIGHTDECK_UPDATE_PHASES, FLIGHTDECK_WARN, FlightDeck, FlightDeckLogger, flightDeckLogSchema, isVersionNumber };
-//# sourceMappingURL=chunk-AP2UJF2F.js.map
-//# sourceMappingURL=chunk-AP2UJF2F.js.map
+//# sourceMappingURL=chunk-7KMVUPT3.js.map
+//# sourceMappingURL=chunk-7KMVUPT3.js.map