opshot 0.3.4 → 0.4.0

package/dist/index.js

@@ -1,69 +1,11 @@
-import { memo, useState, useReducer, useEffect, useRef, createElement } from 'react';
+import * as React from 'react';
+import { memo, useState, useReducer, useRef, useEffect, createElement, useLayoutEffect } from 'react';
 
 // node_modules/proxy-compare/dist/index.js
 var GET_ORIGINAL_SYMBOL = /* @__PURE__ */ Symbol();
-var HAS_KEY_PROPERTY = "h";
-var ALL_OWN_KEYS_PROPERTY = "w";
-var HAS_OWN_KEY_PROPERTY = "o";
-var KEYS_PROPERTY = "k";
 var getProto = Object.getPrototypeOf;
 var objectsToTrack = /* @__PURE__ */ new WeakMap();
 var isObjectToTrack = (obj) => obj && (objectsToTrack.has(obj) ? objectsToTrack.get(obj) : getProto(obj) === Object.prototype || getProto(obj) === Array.prototype);
-var isObject = (x) => typeof x === "object" && x !== null;
-var getOriginalObject = (obj) => (
-  // unwrap proxy
-  obj[GET_ORIGINAL_SYMBOL] || // otherwise
-  obj
-);
-var isAllOwnKeysChanged = (prevObj, nextObj) => {
-  const prevKeys = Reflect.ownKeys(prevObj);
-  const nextKeys = Reflect.ownKeys(nextObj);
-  return prevKeys.length !== nextKeys.length || prevKeys.some((k, i) => k !== nextKeys[i]);
-};
-var isChanged = (prevObj, nextObj, affected, cache, isEqual = Object.is) => {
-  if (isEqual(prevObj, nextObj)) {
-    return false;
-  }
-  if (!isObject(prevObj) || !isObject(nextObj))
-    return true;
-  const used = affected.get(getOriginalObject(prevObj));
-  if (!used)
-    return true;
-  if (cache) {
-    const hit = cache.get(prevObj);
-    if (hit === nextObj) {
-      return false;
-    }
-    cache.set(prevObj, nextObj);
-  }
-  let changed = null;
-  for (const key of used[HAS_KEY_PROPERTY] || []) {
-    changed = Reflect.has(prevObj, key) !== Reflect.has(nextObj, key);
-    if (changed)
-      return changed;
-  }
-  if (used[ALL_OWN_KEYS_PROPERTY] === true) {
-    changed = isAllOwnKeysChanged(prevObj, nextObj);
-    if (changed)
-      return changed;
-  } else {
-    for (const key of used[HAS_OWN_KEY_PROPERTY] || []) {
-      const hasPrev = !!Reflect.getOwnPropertyDescriptor(prevObj, key);
-      const hasNext = !!Reflect.getOwnPropertyDescriptor(nextObj, key);
-      changed = hasPrev !== hasNext;
-      if (changed)
-        return changed;
-    }
-  }
-  for (const key of used[KEYS_PROPERTY] || []) {
-    changed = isChanged(prevObj[key], nextObj[key], affected, cache, isEqual);
-    if (changed)
-      return changed;
-  }
-  if (changed === null)
-    throw new Error("invalid used");
-  return changed;
-};
 var getUntracked = (obj) => {
   if (isObjectToTrack(obj)) {
     return obj[GET_ORIGINAL_SYMBOL] || null;
@@ -75,8 +17,8 @@ var markToTrack = (obj, mark = true) => {
 };
 
 // node_modules/valtio/esm/vanilla.mjs
-var isObject2 = (x) => typeof x === "object" && x !== null;
-var canProxyDefault = (x) => isObject2(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer) && !(x instanceof Promise);
+var isObject = (x) => typeof x === "object" && x !== null;
+var canProxyDefault = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer) && !(x instanceof Promise);
 var createSnapshotDefault = (target, version) => {
   const cache = snapCache.get(target);
   if ((cache == null ? void 0 : cache[0]) === version) {
@@ -130,7 +72,7 @@ var createHandlerDefault = (isInitializing, addPropListener, removePropListener,
       return true;
     }
     removePropListener(prop);
-    if (isObject2(value)) {
+    if (isObject(value)) {
       value = getUntracked(value) || value;
     }
     const nextValue = !proxyStateMap.has(value) && canProxy(value) ? proxy(value) : value;
@@ -151,7 +93,7 @@ var canProxy = canProxyDefault;
 var createSnapshot = createSnapshotDefault;
 var createHandler = createHandlerDefault;
 function proxy(baseObject = {}) {
-  if (!isObject2(baseObject)) {
+  if (!isObject(baseObject)) {
     throw new Error("object required");
   }
   const found = proxyCache.get(baseObject);
@@ -266,31 +208,19 @@ function subscribe(proxyObject, callback, notifyInSync) {
   if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !proxyState) {
     console.warn("Please use proxy object");
   }
-  let promise;
   const ops = [];
   const addListener = proxyState[2];
-  let isListenerActive = false;
   const listener = (op) => {
     if (op) {
       ops.push(op);
     }
-    if (notifyInSync) {
+    {
       callback(ops.splice(0));
       return;
     }
-    if (!promise) {
-      promise = Promise.resolve().then(() => {
-        promise = void 0;
-        if (isListenerActive) {
-          callback(ops.splice(0));
-        }
-      });
-    }
   };
   const removeListener = addListener(listener);
-  isListenerActive = true;
   return () => {
-    isListenerActive = false;
     removeListener();
   };
 }
@@ -302,10 +232,6 @@ function snapshot(proxyObject) {
   const [target, ensureVersion] = proxyState;
   return createSnapshot(target, ensureVersion());
 }
-function ref(obj) {
-  refSet.add(obj);
-  return obj;
-}
 function unstable_getInternalStates() {
   return {
     proxyStateMap,
@@ -337,19 +263,222 @@ function unstable_replaceInternalFunction(name, fn) {
   }
 }
 
-// src/unsafeTrack.ts
-var unsafeTrackedSet = /* @__PURE__ */ new WeakSet();
-function unsafeTrack(value) {
-  unsafeTrackedSet.add(value);
-  return value;
+// src/declarations.ts
+function createDeclarationTrie() {
+  return { ignored: false, unsafe: false, children: /* @__PURE__ */ new Map() };
+}
+function declarationChild(trie, key) {
+  return trie?.children.get(String(key));
+}
+function ensureDeclarationChild(trie, key) {
+  const name = String(key);
+  const existing = trie.children.get(name);
+  if (existing !== void 0) return existing;
+  const child = createDeclarationTrie();
+  trie.children.set(name, child);
+  return child;
+}
+function declarationAtPath(trie, path) {
+  let current = trie;
+  for (const segment of path) current = ensureDeclarationChild(current, segment);
+  return current;
+}
+function graftDeclarationChildren(source, target) {
+  for (const [key, sourceChild] of source.children) {
+    const targetChild = ensureDeclarationChild(target, key);
+    if (sourceChild.ignored) targetChild.ignored = true;
+    if (sourceChild.unsafe) targetChild.unsafe = true;
+    graftDeclarationChildren(sourceChild, targetChild);
+  }
+}
+function hasDeclarations(trie) {
+  if (trie.ignored || trie.unsafe) return true;
+  for (const child of trie.children.values()) {
+    if (hasDeclarations(child)) return true;
+  }
+  return false;
+}
+
+// src/identity.ts
+var isObjectLike = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+var targetRegistry = /* @__PURE__ */ new WeakMap();
+var readProxyTargets = /* @__PURE__ */ new WeakMap();
+var identityRecords = /* @__PURE__ */ new WeakMap();
+var nextInternId = 0;
+var { proxyStateMap: proxyStateMap2 } = unstable_getInternalStates();
+function registerSnapshotCopy(copy, target) {
+  targetRegistry.set(copy, target);
+}
+function getRegisteredTarget(copy) {
+  return targetRegistry.get(copy);
+}
+var registerReadProxyTarget = (readProxy, target) => {
+  readProxyTargets.set(readProxy, target);
+};
+var getRegisteredReadProxyTarget = (readProxy) => readProxyTargets.get(readProxy);
+function peelIdentityLayer(current) {
+  const untracked = getUntracked(current);
+  if (untracked !== null && untracked !== current) return untracked;
+  const readProxyTarget = getRegisteredReadProxyTarget(current);
+  if (readProxyTarget !== void 0 && readProxyTarget !== current) return readProxyTarget;
+  const registeredTarget = targetRegistry.get(current);
+  if (registeredTarget !== void 0 && registeredTarget !== current) return registeredTarget;
+  return void 0;
+}
+function resolveIdentity(value) {
+  let current = value;
+  while (isObjectLike(current)) {
+    const peeled = peelIdentityLayer(current);
+    if (peeled !== void 0) {
+      current = peeled;
+      continue;
+    }
+    const entry = proxyStateMap2.get(current);
+    if (entry !== void 0) {
+      const target = entry[0];
+      if (target !== current) {
+        current = target;
+        continue;
+      }
+    }
+    break;
+  }
+  return current;
+}
+var recordFor = (key) => {
+  let record = identityRecords.get(key);
+  if (record === void 0) {
+    record = {};
+    identityRecords.set(key, record);
+  }
+  return record;
+};
+function identify(value) {
+  const target = resolveIdentity(value);
+  if (!isObjectLike(target)) return value;
+  const record = recordFor(target);
+  if (record.token !== void 0) return record.token;
+  const token = Object.freeze({});
+  record.token = token;
+  return token;
+}
+var internIdentity = (key) => {
+  const resolved = resolveIdentity(key);
+  const record = recordFor(resolved);
+  if (record.id !== void 0) return record.id;
+  const id = nextInternId;
+  nextInternId += 1;
+  record.id = id;
+  return id;
+};
+function isSameIdentity(first, second) {
+  const resolvedFirst = resolveIdentity(first);
+  const resolvedSecond = resolveIdentity(second);
+  return resolvedFirst === resolvedSecond;
+}
+
+// src/peelReadProxy.ts
+var { proxyStateMap: proxyStateMap3 } = unstable_getInternalStates();
+var isObjectLike2 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+function peelReadProxy(value) {
+  if (!isObjectLike2(value) || proxyStateMap3.has(value)) return value;
+  let current = value;
+  while (isObjectLike2(current)) {
+    const registeredTarget = getRegisteredReadProxyTarget(current);
+    if (registeredTarget === void 0) break;
+    current = registeredTarget;
+  }
+  return current;
+}
+
+// src/handle.ts
+var occupancies = /* @__PURE__ */ new WeakMap();
+var { proxyStateMap: proxyStateMap4 } = unstable_getInternalStates();
+var rawTargetOf = (value) => proxyStateMap4.get(value)?.[0] ?? value;
+function registerHandle(target, handle) {
+  let occupants = occupancies.get(target);
+  if (occupants === void 0) {
+    occupants = /* @__PURE__ */ new Set();
+    occupancies.set(target, occupants);
+  }
+  for (const reference of occupants) {
+    if (reference.deref() === handle) return;
+  }
+  occupants.add(new WeakRef(handle));
+}
+var rawOf = (node) => {
+  const peeled = peelReadProxy(node);
+  return rawTargetOf(typeof peeled === "object" && peeled !== null ? peeled : node);
+};
+function handlesOf(node) {
+  const target = rawOf(node);
+  const occupants = occupancies.get(target);
+  if (occupants === void 0) return [];
+  const handles = new Array();
+  for (const reference of occupants) {
+    const handle = reference.deref();
+    if (handle === void 0) {
+      occupants.delete(reference);
+      continue;
+    }
+    handles.push(handle);
+  }
+  return handles;
 }
-function isUnsafeTracked(value) {
-  return typeof value === "object" && value !== null && unsafeTrackedSet.has(value);
+function handleOf(node) {
+  const target = rawOf(node);
+  for (const handle of handlesOf(node)) {
+    if (rawTargetOf(handle.proxy.root) === target) return handle;
+  }
+  return void 0;
 }
+function requireHandle(state, message) {
+  const handle = handleOf(state);
+  if (handle === void 0) throw new Error(message);
+  return handle;
+}
+
+// src/ops/predicates.ts
+var MAX_ARRAY_LENGTH = 4294967295;
+var isObjectLike3 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+var isCanonicalArrayIndex = (segment) => Number.isInteger(segment) && typeof segment === "number" && segment >= 0 && segment < MAX_ARRAY_LENGTH;
+var isCanonicalArrayIndexString = (key) => {
+  const index = Number(key);
+  return Number.isInteger(index) && index >= 0 && index < MAX_ARRAY_LENGTH && String(index) === key;
+};
+
+// src/utils/dataEntries.ts
+var walkDataEntries = (value, includeArrayLength = false) => {
+  const entries = new Array();
+  for (const key of Object.keys(value)) {
+    if (key === "__proto__") continue;
+    const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !("value" in descriptor)) continue;
+    entries.push({ key, value: descriptor.value, writable: descriptor.writable === true });
+  }
+  if (includeArrayLength && Array.isArray(value)) {
+    const lengthDescriptor = Reflect.getOwnPropertyDescriptor(value, "length");
+    entries.push({
+      key: "length",
+      value: value.length,
+      writable: lengthDescriptor?.writable === true
+    });
+  }
+  return entries;
+};
+var segmentFor = (parent, key) => Array.isArray(parent) && isCanonicalArrayIndexString(key) ? Number(key) : key;
+var dataEntryValuesOf = (value) => {
+  const entries = /* @__PURE__ */ new Map();
+  for (const entry of walkDataEntries(value)) {
+    entries.set(entry.key, entry.value);
+  }
+  return entries;
+};
+var carriedOwnKeysOf = (value) => Reflect.ownKeys(value).filter((key) => key !== "__proto__");
 
 // src/valtio/classify.ts
-var { refSet: refSet2 } = unstable_getInternalStates();
 var sourceCache = /* @__PURE__ */ new WeakMap();
+var kindCache = /* @__PURE__ */ new WeakMap();
 var readSource = (constructor) => {
   const cached = sourceCache.get(constructor);
   if (cached !== void 0) return cached;
@@ -357,16 +486,31 @@ var readSource = (constructor) => {
   sourceCache.set(constructor, source);
   return source;
 };
+var privateNameAccess = /\.\s*#[A-Za-z_$]/;
+var privateNameDeclaration = new RegExp(
+  String.raw`[{;}](?:\s|\/\*[\s\S]*?\*\/|\/\/[^\n]*\n|static\b|async\b|get\b|set\b|\*)*` + String.raw`#[A-Za-z_$][\w$]*` + String.raw`(?:[ \t]*(?:\/\*[\s\S]*?\*\/[ \t]*)*[(=;}]|[ \t]*(?:\/\/[^\n]*|\/\*[\s\S]*?\*\/[ \t]*)?(?:\r?\n|$))`,
+  "m"
+);
+var hasPrivateName = (source) => privateNameAccess.test(source) || privateNameDeclaration.test(source);
 var classifyChain = (initialConstructor) => {
+  if (typeof initialConstructor !== "function") return "cleanClass";
+  const cached = kindCache.get(initialConstructor);
+  if (cached !== void 0) return cached;
   let sawNativeSource = false;
   let current = initialConstructor;
+  let kind = "cleanClass";
   while (typeof current === "function" && current !== Object && current !== Array && current !== Function.prototype) {
     const source = readSource(current);
-    if (source.includes("#")) return "privateClass";
+    if (hasPrivateName(source)) {
+      kind = "privateClass";
+      break;
+    }
     if (source.includes("[native code]")) sawNativeSource = true;
     current = Reflect.getPrototypeOf(current);
   }
-  return sawNativeSource ? "nativeClass" : "cleanClass";
+  if (kind !== "privateClass") kind = sawNativeSource ? "nativeClass" : "cleanClass";
+  kindCache.set(initialConstructor, kind);
+  return kind;
 };
 function classifyValue(value) {
   const prototype = Object.getPrototypeOf(value);
@@ -375,142 +519,71 @@ function classifyValue(value) {
   if (prototype === Object.prototype || prototype === null) return "plain";
   return classifyChain(value.constructor);
 }
-function hasOwnEnumerableFunction(value) {
-  for (const key of Reflect.ownKeys(value)) {
-    const descriptor = Object.getOwnPropertyDescriptor(value, key);
-    if (!descriptor?.enumerable || !("value" in descriptor)) continue;
-    if (typeof descriptor.value === "function") return true;
-  }
-  return false;
+function unfrozenAdmissionDecision(value) {
+  if (typeof value !== "object" || value === null) return { lane: "leaf" };
+  const kind = classifyValue(value);
+  if (kind === "plain" || kind === "plainArray" || kind === "cleanClass") return { lane: "tracked" };
+  return { lane: "dangerous", kind };
+}
+function admissionDecision(value) {
+  if (typeof value !== "object" || value === null) return { lane: "leaf" };
+  if (Object.isFrozen(value)) return { lane: "untracked" };
+  return unfrozenAdmissionDecision(value);
 }
 function admissionLane(value) {
-  if (typeof value !== "object" || value === null) return "leaf";
-  if (refSet2.has(value)) return "leaf";
-  if (isUnsafeTracked(value)) return "track";
-  const kind = classifyValue(value);
-  if ((kind === "plain" || kind === "plainArray" || kind === "cleanClass") && Object.isFrozen(value)) return "leaf";
-  if (kind === "plain" || kind === "plainArray") return "track";
-  if (kind === "cleanClass" && !hasOwnEnumerableFunction(value)) return "track";
-  return "reject";
+  return admissionDecision(value).lane;
 }
-function isTrackable(value) {
-  return admissionLane(value) === "track";
+function unfrozenAdmissionLane(value) {
+  return unfrozenAdmissionDecision(value).lane;
 }
 
-// src/ops/path.ts
-var createOperationPath = (segments) => Object.freeze([...segments]);
-var appendOperationPath = (path, segment) => Object.freeze([...path, segment]);
-var escapeSegment = (segment) => segment.replaceAll("~", "~0").replaceAll("/", "~1");
-var formatSegment = (segment) => typeof segment === "string" ? escapeSegment(segment) : String(segment);
-var formatOperationPath = (path) => path.length === 0 ? "" : `/${path.map(formatSegment).join("/")}`;
-var assertSafePath = (path) => {
-  for (let index = 0; index < path.length; index++) {
-    const segment = path[index];
-    if (segment === "__proto__" || segment === "prototype" && path[index - 1] === "constructor") {
-      throw new Error(`opshot: reserved operation path ${formatOperationPath(path)}`);
-    }
-  }
-};
-
 // src/ops/cloneValue.ts
-var { refSet: refSet3 } = unstable_getInternalStates();
-var isPlainArray = (value) => Array.isArray(value) && !refSet3.has(value);
-var isPlainObject = (value) => isTrackable(value) && !Array.isArray(value);
-var isCloneable = (value) => isTrackable(value);
-var CyclicValueError = class extends Error {
-  constructor(path) {
-    super(`opshot: cyclic value at ${formatOperationPath(path)}; use ignore() for back-linked structures, or ids`);
-    this.name = "CyclicValueError";
-    this.path = createOperationPath(path);
+var { proxyStateMap: proxyStateMap5 } = unstable_getInternalStates();
+var MissingOwnDescriptorError = class extends Error {
+  constructor() {
+    super("opshot: carried own key has no property descriptor");
+    this.name = "MissingOwnDescriptorError";
   }
 };
-var cyclicError = (path) => new CyclicValueError(path);
-var getCyclicPath = (error) => error instanceof CyclicValueError ? error.path : void 0;
-var CLONE_IN_PROGRESS = /* @__PURE__ */ Symbol("opshot.cloneValue.inProgress");
+var isInstrumented = (value) => proxyStateMap5.has(value) || getRegisteredTarget(value) !== void 0;
+var isPlainArray = (value) => Array.isArray(value);
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && (admissionLane(value) === "tracked" || isInstrumented(value));
+var isStructurallyCloneableFrozen = (value) => {
+  if (!Object.isFrozen(value)) return false;
+  if (Array.isArray(value)) return true;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+var isCloneable = (value) => typeof value === "object" && value !== null && (admissionLane(value) === "tracked" || isInstrumented(value) || isStructurallyCloneableFrozen(value));
 var cloneValue = (value, memo2, path) => {
   if (!isCloneable(value)) return value;
   const cached = memo2.get(value);
-  if (cached === CLONE_IN_PROGRESS) throw cyclicError(path);
   if (cached !== void 0) return cached;
-  memo2.set(value, CLONE_IN_PROGRESS);
   const array = isPlainArray(value);
   const clone = array ? [] : {};
   Reflect.setPrototypeOf(clone, Reflect.getPrototypeOf(value));
-  for (const key of Reflect.ownKeys(value)) {
+  memo2.set(value, clone);
+  for (const key of carriedOwnKeysOf(value)) {
     const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
-    if (!descriptor) continue;
+    if (descriptor === void 0) throw new MissingOwnDescriptorError();
     if ("value" in descriptor) {
       Object.defineProperty(clone, key, {
         ...descriptor,
-        value: cloneValue(descriptor.value, memo2, path)
+        value: cloneValue(descriptor.value, memo2)
       });
     } else {
       Object.defineProperty(clone, key, descriptor);
     }
   }
-  memo2.set(value, clone);
-  if (isUnsafeTracked(value)) unsafeTrack(clone);
+  if (Object.isFrozen(value)) Object.freeze(clone);
   return clone;
 };
 
-// src/react/wrapperRegistry.ts
-var wrapperTargets = /* @__PURE__ */ new WeakMap();
-var registerWrapperTarget = (wrapper, target) => {
-  wrapperTargets.set(wrapper, target);
-};
-var getRegisteredWrapperTarget = (wrapper) => wrapperTargets.get(wrapper);
-
-// src/identity.ts
-var isObjectLike = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-var targetRegistry = /* @__PURE__ */ new WeakMap();
-var identityTokenRegistry = /* @__PURE__ */ new WeakMap();
-var { proxyStateMap: proxyStateMap2 } = unstable_getInternalStates();
-function registerSnapshotCopy(copy, target) {
-  targetRegistry.set(copy, target);
-}
-function getRegisteredTarget(copy) {
-  return targetRegistry.get(copy);
-}
-function peelIdentityLayer(current) {
-  const untracked = getUntracked(current);
-  if (untracked !== null && untracked !== current) return untracked;
-  const wrapperTarget = getRegisteredWrapperTarget(current);
-  if (wrapperTarget !== void 0 && wrapperTarget !== current) return wrapperTarget;
-  const registeredTarget = targetRegistry.get(current);
-  if (registeredTarget !== void 0 && registeredTarget !== current) return registeredTarget;
-  return void 0;
-}
-function resolveIdentity(value) {
-  let current = value;
-  while (isObjectLike(current)) {
-    const peeled = peelIdentityLayer(current);
-    if (peeled !== void 0) {
-      current = peeled;
-      continue;
-    }
-    const proxyState = proxyStateMap2.get(current);
-    if (proxyState !== void 0 && proxyState[0] !== current) {
-      current = proxyState[0];
-      continue;
-    }
-    break;
-  }
-  return current;
-}
-function identify(value) {
-  const target = resolveIdentity(value);
-  if (!isObjectLike(target)) return value;
-  const existing = identityTokenRegistry.get(target);
-  if (existing !== void 0) return existing;
-  const token = Object.freeze({});
-  identityTokenRegistry.set(target, token);
-  return token;
-}
-function isSameIdentity(first, second) {
-  const resolvedFirst = resolveIdentity(first);
-  const resolvedSecond = resolveIdentity(second);
-  return resolvedFirst === resolvedSecond || resolvedFirst !== resolvedFirst && resolvedSecond !== resolvedSecond;
-}
+// src/ops/path.ts
+var createOperationPath = (segments) => Array.isArray(segments) && Object.isFrozen(segments) ? segments : Object.freeze([...segments]);
+var appendOperationPath = (path, segment) => Object.freeze([...path, segment]);
+var formatSegment = (segment) => String(segment);
+var formatOperationPath = (path) => path.length === 0 ? "/" : `/${path.map(formatSegment).join("/")}`;
 
 // src/ops/operation.ts
 var operationBrand = /* @__PURE__ */ Symbol.for("opshot.operation");
@@ -521,354 +594,1416 @@ var OperationHalf = class {
   }
 };
 Object.defineProperty(OperationHalf.prototype, operationBrand, { value: true });
-var ValueHalf = class extends OperationHalf {
-  get value() {
-    return cloneValue(valueOriginals.get(this), /* @__PURE__ */ new WeakMap(), this.path);
-  }
-  constructor(path, value) {
+var AssignHalf = class extends OperationHalf {
+  constructor(path, value, original = value, ids) {
     super(path);
-    valueOriginals.set(this, value);
-    if (!isCloneable(value)) Object.defineProperty(this, "value", { value, enumerable: true });
+    this.verb = "assign";
+    valueOriginals.set(this, original);
+    this.value = cloneValue(value, /* @__PURE__ */ new WeakMap(), this.path);
+    if (ids !== void 0) this.ids = ids;
   }
 };
-var AddHalf = class extends ValueHalf {
+var DeleteHalf = class extends OperationHalf {
   constructor() {
     super(...arguments);
-    this.op = "add";
+    this.verb = "delete";
   }
 };
-var ReplaceHalf = class extends ValueHalf {
-  constructor() {
-    super(...arguments);
-    this.op = "replace";
+var LinkHalf = class extends OperationHalf {
+  constructor(path, ref) {
+    super(path);
+    this.verb = "link";
+    this.ref = ref;
   }
 };
-var RemoveHalf = class extends OperationHalf {
-  constructor() {
-    super(...arguments);
-    this.op = "remove";
-  }
+var stampOf = (operation) => {
+  const value = Object.getOwnPropertyDescriptor(operation, "stamp")?.value;
+  return typeof value === "object" && value !== null ? value : void 0;
+};
+var versionOf = (operation) => {
+  const value = Reflect.get(operation, "version");
+  return typeof value === "number" && Number.isInteger(value) ? value : void 0;
 };
-var isOperation = (value) => typeof value === "object" && value !== null && operationBrand in value;
+var stampOperation = (handle, operation) => {
+  handle.version += 1;
+  Object.defineProperty(operation, "stamp", { value: handle.stamp, enumerable: false });
+  Object.defineProperty(operation, "version", { value: handle.version, enumerable: true });
+};
+var isMutation = (value) => typeof value === "object" && value !== null && operationBrand in value;
 var getValueOriginal = (half) => valueOriginals.get(half);
-var createAddOperation = (path, value) => new AddHalf(path, value);
-var createReplaceOperation = (path, value) => new ReplaceHalf(path, value);
-var createRemoveOperation = (path) => new RemoveHalf(path);
+var createAssignMutation = (path, value, original = value, ids) => new AssignHalf(path, value, original, ids);
+var createDeleteMutation = (path) => new DeleteHalf(path);
+var createLinkMutation = (path, ref) => new LinkHalf(path, ref);
 
-// src/ops/weight.ts
-var NODE_WEIGHT = 32;
-var KEY_WEIGHT = 16;
-var CHARACTER_WEIGHT = 2;
-var LEAF_WEIGHT = 16;
-var OPERATION_WEIGHT = 512;
-var addWeight = (state, amount) => {
-  state.weight += amount;
-  return state.weight <= state.budget;
-};
-var weigh = (value, state) => {
-  if (state.weight > state.budget) return;
-  if (typeof value === "string") {
-    addWeight(state, LEAF_WEIGHT + CHARACTER_WEIGHT * value.length);
-    return;
-  }
-  if (value === null || typeof value !== "object" && typeof value !== "function") {
-    addWeight(state, LEAF_WEIGHT);
-    return;
-  }
-  if (state.seen.has(value)) return;
-  if (isCloneable(value)) {
-    state.seen.add(value);
-    if (!addWeight(state, NODE_WEIGHT)) return;
-    for (const key of Object.keys(value)) {
-      const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
-      if (!descriptor || !("value" in descriptor)) continue;
-      if (!addWeight(state, KEY_WEIGHT)) return;
-      weigh(descriptor.value, state);
-      if (state.weight > state.budget) return;
-    }
-  }
+// src/intern.ts
+var { proxyStateMap: proxyStateMap6, proxyCache: proxyCache2 } = unstable_getInternalStates();
+var rawTargetOf2 = (value) => proxyStateMap6.get(value)?.[0] ?? value;
+var occupancyNodeOf = (node) => {
+  const peeled = peelReadProxy(node);
+  const object = typeof peeled === "object" && peeled !== null ? peeled : node;
+  return rawTargetOf2(getRegisteredTarget(object) ?? object);
 };
-var weighValue = (value, budget) => {
-  const state = { weight: 0, budget, seen: /* @__PURE__ */ new WeakSet() };
-  weigh(value, state);
-  return state.weight;
+var liveOfInterned = (raw) => proxyCache2.get(raw) ?? raw;
+var departingNodes = /* @__PURE__ */ new WeakMap();
+var committedIdOf = (handle, raw) => handle.nodes.get(raw)?.id;
+var writeId = (handle, raw, id) => {
+  const record = handle.nodes.get(raw);
+  if (record === void 0) handle.nodes.set(raw, { edges: [], id });
+  else {
+    if (record.id !== void 0 && record.id !== id) handle.byId.delete(record.id);
+    record.id = id;
+  }
+  handle.byId.set(id, raw);
 };
-
-// src/ops/diff.ts
-var UNCAPPED_WEIGHT = Number.MAX_SAFE_INTEGER;
-var IncompatibleSnapshotRootsError = class extends Error {
-  constructor() {
-    super("opshot: diffSnapshots requires compatible supported object roots");
-    this.name = "IncompatibleSnapshotRootsError";
-  }
+function internNode(handle, node) {
+  const raw = occupancyNodeOf(node);
+  const existing = committedIdOf(handle, raw);
+  if (existing !== void 0) return existing;
+  const id = handle.nextInternId;
+  handle.nextInternId += 1;
+  writeId(handle, raw, id);
+  return id;
+}
+var stagedBindIdOf = (capture, raw) => capture.bindIdByNode.get(raw);
+var stagedMintIdOf = (capture, raw) => capture.mintIdByNode.get(raw);
+var stagedNodeOf = (capture, id) => capture.bindNodeById.get(id) ?? capture.mintNodeById.get(id);
+var nextStagedIdOf = (handle, capture) => Math.max(handle.nextInternId, capture.nextStagedId);
+var stageMint = (capture, raw, id) => {
+  capture.mints.push({ node: raw, id });
+  capture.mintIdByNode.set(raw, id);
+  capture.mintNodeById.set(id, raw);
+  if (id + 1 > capture.nextStagedId) capture.nextStagedId = id + 1;
 };
-var addPair = (path, after) => ({
-  do: createAddOperation(path, after),
-  undo: createRemoveOperation(path)
-});
-var removePair = (path, before) => ({
-  do: createRemoveOperation(path),
-  undo: createAddOperation(path, before)
-});
-var replacePair = (path, before, after) => ({
-  do: createReplaceOperation(path, after),
-  undo: createReplaceOperation(path, before)
-});
-var weighCarried = (value) => weighValue(value, UNCAPPED_WEIGHT);
-var pushAdd = (ops, path, after) => {
-  ops.push(addPair(path, after));
-  return OPERATION_WEIGHT + weighCarried(after);
-};
-var pushRemove = (ops, path, before) => {
-  ops.push(removePair(path, before));
-  return OPERATION_WEIGHT + weighCarried(before);
-};
-var pushReplace = (ops, path, before, after) => {
-  ops.push(replacePair(path, before, after));
-  return OPERATION_WEIGHT + weighCarried(before) + weighCarried(after);
-};
-var tryCollapse = (before, after, path, ops, opsStart, atomicWeight) => {
-  if (atomicWeight === 0) return 0;
-  const beforeWeight = weighValue(before, atomicWeight);
-  const afterWeight = weighValue(after, atomicWeight - beforeWeight);
-  const collapsedWeight = OPERATION_WEIGHT + beforeWeight + afterWeight;
-  if (collapsedWeight < atomicWeight) {
-    assertSafeSubtree(before, path);
-    assertSafeSubtree(after, path);
-    ops.splice(opsStart, ops.length - opsStart, replacePair(path, before, after));
-    return collapsedWeight;
-  }
-  return atomicWeight;
+var stageBind = (capture, raw, id) => {
+  capture.binds.push({ node: raw, id });
+  capture.bindIdByNode.set(raw, id);
+  capture.bindNodeById.set(id, raw);
+  if (id + 1 > capture.nextStagedId) capture.nextStagedId = id + 1;
 };
-var hasAncestorPair = (ancestors, before, after) => ancestors.get(before)?.has(after) ?? false;
-var enterAncestorPair = (ancestors, before, after) => {
-  const afterSet = ancestors.get(before) ?? /* @__PURE__ */ new Set();
-  afterSet.add(after);
-  ancestors.set(before, afterSet);
+var namedRawOf = (handle, id, capture) => {
+  const staged = capture === void 0 ? void 0 : stagedNodeOf(capture, id);
+  return staged ?? handle.byId.get(id);
 };
-var exitAncestorPair = (ancestors, before, after) => {
-  const afterSet = ancestors.get(before);
-  if (!afterSet) return;
-  afterSet.delete(after);
-  if (afterSet.size === 0) ancestors.delete(before);
+function internedIdOf(handle, node, capture) {
+  const raw = occupancyNodeOf(node);
+  const bound = capture === void 0 ? void 0 : stagedBindIdOf(capture, raw);
+  if (bound !== void 0) return bound;
+  const committed = committedIdOf(handle, raw);
+  if (committed !== void 0) return committed;
+  if (capture === void 0) return void 0;
+  return stagedMintIdOf(capture, raw);
+}
+function stageVend(handle, capture, node) {
+  const raw = occupancyNodeOf(node);
+  const bound = stagedBindIdOf(capture, raw);
+  if (bound !== void 0) return bound;
+  const committed = committedIdOf(handle, raw);
+  if (committed !== void 0) return committed;
+  const staged = stagedMintIdOf(capture, raw);
+  if (staged !== void 0) return staged;
+  const id = nextStagedIdOf(handle, capture);
+  stageMint(capture, raw, id);
+  return id;
+}
+var commitName = (handle, raw, id) => {
+  writeId(handle, raw, id);
+  if (id >= handle.nextInternId) handle.nextInternId = id + 1;
 };
-var isObjectLike2 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-var sharesStorageIdentity = (before, after) => isObjectLike2(before) && isObjectLike2(after) && isSameIdentity(before, after);
-var assertSafeSubtree = (value, path, activeAncestors = /* @__PURE__ */ new WeakSet()) => {
-  if (!isPlainArray(value) && !isPlainObject(value)) return;
-  if (activeAncestors.has(value)) return;
-  activeAncestors.add(value);
-  try {
-    for (const key of Object.keys(value)) {
-      const nextPath = appendOperationPath(path, key);
-      assertSafePath(nextPath);
-      const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
-      if (descriptor && "value" in descriptor) assertSafeSubtree(descriptor.value, nextPath, activeAncestors);
+function commitVends(handle, capture) {
+  for (const { node, id } of capture.mints) commitName(handle, node, id);
+  capture.mints.length = 0;
+  for (const { node, id } of capture.binds) commitName(handle, node, id);
+  capture.binds.length = 0;
+  capture.bindIdByNode.clear();
+  capture.bindNodeById.clear();
+  capture.mintIdByNode.clear();
+  capture.mintNodeById.clear();
+  capture.nextStagedId = 0;
+}
+function nodeOfInternedId(handle, id, capture) {
+  const raw = namedRawOf(handle, id, capture);
+  if (raw === void 0) return void 0;
+  return liveOfInterned(raw);
+}
+var walkTracked = (node, visits, chains, resolve, visit) => {
+  const walk = (current, currentChains, parent, key) => {
+    const raw = occupancyNodeOf(current);
+    if (visits.has(raw)) return;
+    visits.add(raw);
+    if (admissionLane(current) === "untracked") return;
+    if (!visit(current, raw, parent, key)) return;
+    const source = getRegisteredTarget(current) ?? current;
+    for (const entry of walkDataEntries(source)) {
+      if (typeof entry.value !== "object" || entry.value === null) continue;
+      if (currentChains === void 0 || resolve === void 0) {
+        walk(entry.value, currentChains, current, entry.key);
+        continue;
+      }
+      const childChains = resolve(source, currentChains, segmentFor(source, entry.key), entry);
+      if (childChains === void 0) continue;
+      walk(entry.value, childChains, current, entry.key);
     }
-  } finally {
-    activeAncestors.delete(value);
-  }
+  };
+  walk(node, chains);
 };
-var isCanonicalArrayIndex = (key) => {
-  const index = Number(key);
-  return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key;
+function internSubtree(handle, node, chains, resolve, capture) {
+  walkTracked(node, /* @__PURE__ */ new Set(), chains, resolve, (current) => {
+    if (capture === void 0) internNode(handle, current);
+    else stageVend(handle, capture, current);
+    return true;
+  });
+}
+function queueDeparture(handle, node) {
+  const raw = occupancyNodeOf(node);
+  let queued = departingNodes.get(handle);
+  if (queued === void 0) {
+    queued = /* @__PURE__ */ new Set();
+    departingNodes.set(handle, queued);
+  }
+  queued.add(raw);
+}
+var parentOfEdge = (parent) => occupancyNodeOf(parent);
+var isOccupiedMember = (handle, node) => {
+  const root = rawTargetOf2(handle.proxy.root);
+  const raw = occupancyNodeOf(node);
+  if (raw === root) return true;
+  const seen = /* @__PURE__ */ new Set();
+  const walk = (current) => {
+    if (current === root) return true;
+    if (seen.has(current)) return false;
+    seen.add(current);
+    const edges = handle.nodes.get(current)?.edges;
+    if (edges === void 0) return false;
+    for (const edge of edges) {
+      if (walk(parentOfEdge(edge.parent))) return true;
+    }
+    return false;
+  };
+  return walk(raw);
 };
-var diffObjectProperties = (before, after, path, ops, ancestors, ignoreArrayIndexes) => {
-  let weight = 0;
-  for (const key of /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])) {
-    if (ignoreArrayIndexes && isCanonicalArrayIndex(key)) continue;
-    const nextPath = appendOperationPath(path, key);
-    assertSafePath(nextPath);
-    const beforeDescriptor = Reflect.getOwnPropertyDescriptor(before, key);
-    const afterDescriptor = Reflect.getOwnPropertyDescriptor(after, key);
-    if (beforeDescriptor?.get || afterDescriptor?.get) continue;
-    if (!beforeDescriptor) {
-      assertSafeSubtree(Reflect.get(after, key), nextPath);
-      weight += pushAdd(ops, nextPath, Reflect.get(after, key));
-    } else if (!afterDescriptor) {
-      assertSafeSubtree(Reflect.get(before, key), nextPath);
-      weight += pushRemove(ops, nextPath, Reflect.get(before, key));
-    } else {
-      weight += diffValue(Reflect.get(before, key), Reflect.get(after, key), nextPath, ops, ancestors);
+var walkUnoccupiedCluster = (handle, node, visit) => {
+  walkTracked(node, /* @__PURE__ */ new Set(), void 0, void 0, (_current, raw) => {
+    if (isOccupiedMember(handle, raw)) return false;
+    visit(raw, committedIdOf(handle, raw));
+    return true;
+  });
+};
+var isNamedSlot = (handle, raw, evicted) => handle.nodes.has(raw) || evicted?.has(raw) === true;
+var walkSlots = (carried, node, isTracked, visit) => {
+  const visits = /* @__PURE__ */ new Set();
+  const walk = (carriedCurrent, current, parent, key) => {
+    const raw = occupancyNodeOf(current);
+    const looping = visits.has(raw);
+    if (!looping) visits.add(raw);
+    if (admissionLane(current) === "untracked") return;
+    if (!isTracked(raw)) return;
+    if (!visit(raw, parent, key) || looping) return;
+    for (const entry of walkDataEntries(carriedCurrent)) {
+      if (typeof entry.value !== "object" || entry.value === null) continue;
+      const child = Reflect.get(current, entry.key);
+      if (typeof child !== "object" || child === null) continue;
+      walk(entry.value, child, current, entry.key);
     }
-  }
-  return weight;
+  };
+  walk(carried, node);
 };
-var diffArray = (before, after, path, ops, ancestors) => {
-  const overlap = Math.min(before.length, after.length);
-  let weight = 0;
-  for (let index = 0; index < overlap; index++) {
-    const beforePresent = Object.hasOwn(before, index);
-    const afterPresent = Object.hasOwn(after, index);
-    const nextPath = appendOperationPath(path, index);
-    if (!beforePresent && !afterPresent) continue;
-    if (!beforePresent) weight += pushAdd(ops, nextPath, after[index]);
-    else if (!afterPresent) weight += pushRemove(ops, nextPath, before[index]);
-    else weight += diffValue(before[index], after[index], nextPath, ops, ancestors);
+function evictDepartedClusters(handle) {
+  const evicted = /* @__PURE__ */ new Map();
+  const queued = departingNodes.get(handle);
+  if (queued === void 0) return evicted;
+  const ungrounded = new Array();
+  for (const node of queued) {
+    if (!isOccupiedMember(handle, node)) ungrounded.push(node);
+  }
+  queued.clear();
+  const members = new Array();
+  for (const node of ungrounded) {
+    walkUnoccupiedCluster(handle, node, (raw, id) => {
+      members.push(raw);
+      if (id !== void 0) evicted.set(raw, id);
+    });
   }
-  if (after.length > before.length) {
-    weight += pushReplace(ops, appendOperationPath(path, "length"), before.length, after.length);
-    for (let index = before.length; index < after.length; index++) {
-      if (Object.hasOwn(after, index)) weight += pushAdd(ops, appendOperationPath(path, index), after[index]);
+  for (const raw of members) handle.nodes.delete(raw);
+  for (const id of evicted.values()) handle.byId.delete(id);
+  return evicted;
+}
+function bindVendedIds(handle, node, carried, ids, capture, parent, key) {
+  let index = 0;
+  walkSlots(
+    carried,
+    node,
+    (raw) => isNamedSlot(handle, raw),
+    (raw, walkParent, walkKey) => {
+      const id = ids[index];
+      if (id === void 0) return true;
+      index += 1;
+      const held = namedRawOf(handle, id, capture);
+      const slotParent = walkParent ?? parent;
+      const slotKey = walkKey ?? key;
+      if (held !== void 0) {
+        if (occupancyNodeOf(held) !== raw && slotParent !== void 0 && slotKey !== void 0) {
+          Reflect.set(slotParent, slotKey, liveOfInterned(held));
+        }
+        return false;
+      }
+      if (capture === void 0) commitName(handle, raw, id);
+      else stageBind(capture, raw, id);
+      return true;
     }
-  } else if (after.length < before.length) {
-    for (let index = after.length; index < before.length; index++) {
-      if (Object.hasOwn(before, index)) weight += pushRemove(ops, appendOperationPath(path, index), before[index]);
+  );
+}
+function rewindAdmission(handle, node) {
+  const ids = new Array();
+  walkUnoccupiedCluster(handle, node, (raw, id) => {
+    if (id === void 0) return;
+    ids.push(id);
+    const record = handle.nodes.get(raw);
+    if (record !== void 0) record.id = void 0;
+    handle.byId.delete(id);
+  });
+  return ids;
+}
+function annotateDepartureUndos(handle, ops, evicted) {
+  if (evicted.size === 0) return;
+  const claimedMembers = /* @__PURE__ */ new Set();
+  for (let index = ops.length - 1; index >= 0; index--) {
+    const operation = ops[index];
+    if (operation === void 0) continue;
+    const undo = operation.undo;
+    if (undo.verb !== "assign") continue;
+    const original = getValueOriginal(undo) ?? undo.value;
+    if (typeof original !== "object" || original === null) continue;
+    const restoredId = evicted.get(occupancyNodeOf(original));
+    if (restoredId === void 0) continue;
+    const ids = new Array();
+    const claimsBefore = claimedMembers.size;
+    walkSlots(
+      original,
+      original,
+      (raw) => isNamedSlot(handle, raw, evicted),
+      (raw) => {
+        const retiredId = evicted.get(raw);
+        const id = retiredId ?? committedIdOf(handle, raw);
+        if (id !== void 0) ids.push(id);
+        if (retiredId === void 0 || claimedMembers.has(raw)) return false;
+        claimedMembers.add(raw);
+        return true;
+      }
+    );
+    operation.undo = claimedMembers.size > claimsBefore ? createAssignMutation(undo.path, undo.value, original, ids) : createLinkMutation(undo.path, restoredId);
+  }
+}
+
+// src/edges.ts
+var { proxyStateMap: proxyStateMap7 } = unstable_getInternalStates();
+var rawTargetOf3 = (value) => proxyStateMap7.get(value)?.[0] ?? value;
+var rawOf2 = (node) => {
+  const peeled = peelReadProxy(node);
+  return rawTargetOf3(typeof peeled === "object" && peeled !== null ? peeled : node);
+};
+var occupancyRootOf = (handle) => rawTargetOf3(handle.proxy.root);
+var edgesOf = (handle, node) => handle.nodes.get(node)?.edges;
+var pathHasIgnored = (trie, path) => {
+  if (trie.ignored) return true;
+  let current = trie;
+  for (const key of path) {
+    current = declarationChild(current, key);
+    if (current === void 0) return false;
+    if (current.ignored) return true;
+  }
+  return false;
+};
+var pathIsTainted = (trie, path) => {
+  if (trie.unsafe) return true;
+  let current = trie;
+  for (const key of path) {
+    current = declarationChild(current, key);
+    if (current === void 0) return false;
+    if (current.unsafe) return true;
+  }
+  return false;
+};
+var walkGroundedChains = (handle, node, onGround) => {
+  const root = occupancyRootOf(handle);
+  const walk = (current, reverseKeys, pathVisited) => {
+    if (current === root) return onGround([...reverseKeys].reverse());
+    if (pathVisited.has(current)) return false;
+    pathVisited.add(current);
+    const edges = edgesOf(handle, current);
+    if (edges !== void 0) {
+      for (const edge of edges) {
+        if (walk(rawOf2(edge.parent), [...reverseKeys, edge.key], pathVisited)) {
+          pathVisited.delete(current);
+          return true;
+        }
+      }
+    }
+    pathVisited.delete(current);
+    return false;
+  };
+  walk(rawOf2(node), [], /* @__PURE__ */ new Set());
+};
+function addInEdge(handle, node, parent, key) {
+  const rawNode = rawOf2(node);
+  const rawParent = rawOf2(parent);
+  let record = handle.nodes.get(rawNode);
+  if (record === void 0) {
+    record = { edges: [], id: void 0 };
+    handle.nodes.set(rawNode, record);
+  }
+  if (record.edges.some((edge) => rawOf2(edge.parent) === rawParent && edge.key === key)) return;
+  record.edges.push({ parent: rawParent, key });
+  registerHandle(rawNode, handle);
+}
+function hasOtherRoutes(handle, node, parent, key) {
+  const edges = handle.nodes.get(rawOf2(node))?.edges;
+  if (edges === void 0) return false;
+  const rawParent = rawOf2(parent);
+  return edges.some((edge) => rawOf2(edge.parent) !== rawParent || edge.key !== key);
+}
+function removeInEdge(handle, node, parent, key) {
+  const rawNode = rawOf2(node);
+  const rawParent = rawOf2(parent);
+  const record = handle.nodes.get(rawNode);
+  if (record === void 0) return;
+  const index = record.edges.findIndex((edge) => rawOf2(edge.parent) === rawParent && edge.key === key);
+  if (index === -1) return;
+  record.edges.splice(index, 1);
+  if (rawNode !== occupancyRootOf(handle)) queueDeparture(handle, rawNode);
+}
+function edgeStatusOf(handle, node) {
+  const rawNode = rawOf2(node);
+  const root = occupancyRootOf(handle);
+  if (rawNode === root) {
+    return { occupied: true, unsafe: handle.declarations?.unsafe === true };
+  }
+  if (handle.declarations === void 0) {
+    let occupied = false;
+    walkGroundedChains(handle, rawNode, () => {
+      occupied = true;
+      return true;
+    });
+    return { occupied, unsafe: false };
+  }
+  const declarations = handle.declarations;
+  const status = { occupied: false, hasClean: false };
+  walkGroundedChains(handle, rawNode, (pathFromRoot) => {
+    status.occupied = true;
+    if (!pathIsTainted(declarations, pathFromRoot)) {
+      status.hasClean = true;
+      return true;
+    }
+    return false;
+  });
+  return { occupied: status.occupied, unsafe: status.occupied && !status.hasClean };
+}
+function isIgnoredFrontier(handle, parent, key) {
+  const trie = handle.declarations;
+  if (trie === void 0) return false;
+  let hit = false;
+  walkGroundedChains(handle, parent, (pathFromRoot) => {
+    if (pathHasIgnored(trie, [...pathFromRoot, key])) {
+      hit = true;
+      return true;
+    }
+    return false;
+  });
+  return hit;
+}
+var uniqueNodeChains = (entries) => {
+  const unique = new Array();
+  const undefinedFlags = /* @__PURE__ */ new Set();
+  const definedFlags = /* @__PURE__ */ new WeakMap();
+  for (const entry of entries) {
+    const flags = `${entry.tainted ? "1" : "0"}${entry.ignored ? "1" : "0"}`;
+    if (entry.residual === void 0) {
+      if (undefinedFlags.has(flags)) continue;
+      undefinedFlags.add(flags);
+      unique.push(entry);
+      continue;
+    }
+    let seen = definedFlags.get(entry.residual);
+    if (seen === void 0) {
+      seen = /* @__PURE__ */ new Set();
+      definedFlags.set(entry.residual, seen);
+    }
+    if (seen.has(flags)) continue;
+    seen.add(flags);
+    unique.push(entry);
+  }
+  return unique;
+};
+var uniqueResiduals = (residuals) => {
+  const unique = new Array();
+  let sawUndefined = false;
+  const seen = /* @__PURE__ */ new Set();
+  for (const residual of residuals) {
+    if (residual === void 0) {
+      if (sawUndefined) continue;
+      sawUndefined = true;
+      unique.push(void 0);
+      continue;
+    }
+    if (seen.has(residual)) continue;
+    seen.add(residual);
+    unique.push(residual);
+  }
+  return unique;
+};
+var chainsAtNode = (handle, node, memo2, computing) => {
+  const raw = rawOf2(node);
+  const cached = memo2.get(raw);
+  if (cached !== void 0) return cached;
+  if (computing.has(raw)) return { occupied: false, entries: [], cut: true };
+  if (raw === occupancyRootOf(handle)) {
+    const trie = handle.declarations;
+    const result2 = {
+      occupied: true,
+      entries: [
+        {
+          residual: trie,
+          tainted: trie?.unsafe === true,
+          ignored: trie?.ignored === true
+        }
+      ],
+      cut: false
+    };
+    memo2.set(raw, result2);
+    return result2;
+  }
+  computing.add(raw);
+  const aggregated = new Array();
+  let occupied = false;
+  let cut = false;
+  const edges = edgesOf(handle, raw);
+  if (edges !== void 0) {
+    for (const edge of edges) {
+      const parent = chainsAtNode(handle, edge.parent, memo2, computing);
+      if (parent.cut) cut = true;
+      if (!parent.occupied) continue;
+      occupied = true;
+      for (const entry of parent.entries) {
+        const child = entry.residual === void 0 ? void 0 : declarationChild(entry.residual, edge.key);
+        aggregated.push({
+          residual: child,
+          tainted: entry.tainted || child?.unsafe === true,
+          ignored: entry.ignored || child?.ignored === true
+        });
+      }
+    }
+  }
+  computing.delete(raw);
+  const result = { occupied, entries: uniqueNodeChains(aggregated), cut };
+  if (!cut) memo2.set(raw, result);
+  return result;
+};
+function descendChains(chains, key) {
+  const next = new Array();
+  let ignored = false;
+  for (const residual of chains) {
+    if (residual === void 0) {
+      next.push(void 0);
+      continue;
+    }
+    const child = declarationChild(residual, key);
+    if (child?.ignored === true) ignored = true;
+    if (child?.unsafe === true) continue;
+    next.push(child);
+  }
+  return {
+    ignored,
+    unsafe: chains.length > 0 && next.length === 0,
+    chains: uniqueResiduals(next)
+  };
+}
+var childChainsOf = (chains, key) => descendChains(chains, key).chains;
+var isChainsIgnored = (chains) => chains.some((chain) => chain?.ignored === true);
+var isChainsUnsafe = (chains) => chains.length === 0;
+var chainsAtRoot = (declarations) => declarations?.unsafe === true ? [] : [declarations];
+function nodeChainsOf(handle, node) {
+  const nodeChains = chainsAtNode(handle, node, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+  if (!nodeChains.occupied) return void 0;
+  const chains = new Array();
+  for (const entry of nodeChains.entries) {
+    if (entry.tainted) continue;
+    chains.push(entry.residual);
+  }
+  return uniqueResiduals(chains);
+}
+function slotStatusOf(handle, parent, key) {
+  const parentChains = chainsAtNode(handle, parent, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+  if (!parentChains.occupied) {
+    return { occupied: false, unsafe: false, ignored: false, chains: [] };
+  }
+  const chains = new Array();
+  let ignored = false;
+  for (const entry of parentChains.entries) {
+    const child = entry.residual === void 0 ? void 0 : declarationChild(entry.residual, key);
+    const slotIgnored = entry.ignored || child?.ignored === true;
+    const tainted = entry.tainted || child?.unsafe === true;
+    if (slotIgnored) ignored = true;
+    if (!tainted) chains.push(child);
+  }
+  return {
+    ignored,
+    occupied: true,
+    unsafe: chains.length === 0,
+    chains: uniqueResiduals(chains)
+  };
+}
+var isTrackedEdge = (entry) => {
+  const value = entry.value;
+  const target = isObjectLike3(value) ? getRegisteredTarget(value) ?? value : value;
+  return entry.writable && admissionLane(target) === "tracked";
+};
+var graphNodeOf = (value) => rawOf2(getRegisteredTarget(value) ?? value);
+function resolveChildChains(handle, parent, parentChains, key, child) {
+  const descended = descendChains(parentChains, key).chains;
+  const ignoredResidual = isChainsIgnored(parentChains) || isChainsIgnored(descended);
+  if (!isObjectLike3(parent) || !isObjectLike3(child)) {
+    if (ignoredResidual) return void 0;
+    return { chains: descended, descended, otherRoutes: false };
+  }
+  const graphParent = graphNodeOf(parent);
+  const graphChild = graphNodeOf(child);
+  const otherRoutes = hasOtherRoutes(handle, graphChild, graphParent, key);
+  const ignored = ignoredResidual || otherRoutes && isIgnoredFrontier(handle, graphParent, key);
+  if (ignored) return void 0;
+  const chains = otherRoutes ? nodeChainsOf(handle, graphChild) ?? descended : descended;
+  return { chains, descended, otherRoutes };
+}
+var seedFrom = (handle, node, chains, visits) => {
+  if (isChainsIgnored(chains)) return;
+  const raw = rawOf2(node);
+  if (visits.has(raw)) return;
+  visits.add(raw);
+  for (const entry of walkDataEntries(raw)) {
+    if (!isTrackedEdge(entry)) continue;
+    if (typeof entry.value !== "object" || entry.value === null) continue;
+    const key = segmentFor(raw, entry.key);
+    const resolved = resolveChildChains(handle, raw, chains, key, entry.value);
+    if (resolved === void 0) continue;
+    addInEdge(handle, entry.value, raw, key);
+    seedFrom(handle, entry.value, resolved.chains, visits);
+  }
+};
+function seedInEdges(handle) {
+  seedFrom(handle, handle.proxy.root, chainsAtRoot(handle.declarations), /* @__PURE__ */ new Set());
+}
+function seedInEdgesUnder(handle, node, chains) {
+  seedFrom(handle, node, chains, /* @__PURE__ */ new Set());
+}
+
+// src/occupancy.ts
+var { proxyStateMap: proxyStateMap8 } = unstable_getInternalStates();
+var rawTargetOf4 = (value) => proxyStateMap8.get(value)?.[0] ?? value;
+var liveOf = (value) => getRegisteredTarget(value) ?? rawTargetOf4(value);
+var createCaptureTables = () => ({
+  mints: [],
+  binds: [],
+  bindIdByNode: /* @__PURE__ */ new Map(),
+  bindNodeById: /* @__PURE__ */ new Map(),
+  mintIdByNode: /* @__PURE__ */ new Map(),
+  mintNodeById: /* @__PURE__ */ new Map(),
+  nextStagedId: 0
+});
+var occupancyKeyOf = (key) => typeof key === "number" ? String(key) : key;
+function bindVisitedOccupancy(handle, path, parent, key, child, unsafe = false, ignoredFrontier) {
+  if (path.length === 0) return "continue";
+  if (ignoredFrontier ?? isIgnoredFrontier(handle, parent, key)) return "skip";
+  const parentRaw = liveOf(parent);
+  const occupancyKey = occupancyKeyOf(key);
+  const admitted = unsafe || !handle.strict;
+  if (typeof child === "function") {
+    const parentKind = classifyValue(parentRaw);
+    if (parentKind === "plain" || parentKind === "plainArray") return "continue";
+    if (admitted) return "continue";
+    return "skip";
+  }
+  const stored = Reflect.get(parentRaw, occupancyKey);
+  const occupantSource = isObjectLike3(stored) ? stored : child;
+  if (typeof occupantSource !== "object" || occupantSource === null) return "continue";
+  const childLive = liveOf(occupantSource);
+  const descriptor = Reflect.getOwnPropertyDescriptor(parentRaw, occupancyKey);
+  if (descriptor !== void 0 && descriptor.writable !== true && admissionDecision(childLive).lane !== "untracked")
+    return "skip";
+  const decision = admissionDecision(childLive);
+  if (decision.lane === "untracked") return "skip";
+  if (decision.lane === "dangerous") {
+    if (admitted) return "continue";
+    return "skip";
+  }
+  if (!admitted && classifyValue(childLive) === "cleanClass") {
+    for (const entry of walkDataEntries(childLive)) {
+      if (typeof entry.value !== "function") continue;
+      return "skip";
+    }
+  }
+  return "continue";
+}
+function markDirtyPath(dirty, handle, path, parentLive) {
+  let current = handle.proxy.root;
+  if (isObjectLike3(current)) dirty.nodes.add(rawTargetOf4(current));
+  for (const segment of path) {
+    if (!isObjectLike3(current)) break;
+    current = Reflect.get(current, segment);
+    if (isObjectLike3(current)) dirty.nodes.add(rawTargetOf4(current));
+  }
+  if (parentLive === void 0 || path.length === 0) return;
+  const lastSegment = path[path.length - 1];
+  if (lastSegment === void 0) return;
+  const edge = typeof lastSegment === "number" ? String(lastSegment) : lastSegment;
+  const parentRaw = rawTargetOf4(parentLive);
+  let edges = dirty.edges.get(parentRaw);
+  if (edges === void 0) {
+    edges = /* @__PURE__ */ new Set();
+    dirty.edges.set(parentRaw, edges);
+  }
+  edges.add(edge);
+}
+var walkLiveOccupancies = (handle, capture) => {
+  const root = handle.proxy.root;
+  const visits = /* @__PURE__ */ new Set();
+  const rootChains = handle.declarations?.unsafe === true ? [] : [handle.declarations];
+  const walk = (node, path, chains) => {
+    if (chains.some((residual) => residual?.ignored === true)) return;
+    stageVend(handle, capture, node);
+    const nodeRaw = rawTargetOf4(node);
+    if (visits.has(nodeRaw)) return;
+    visits.add(nodeRaw);
+    for (const entry of walkDataEntries(node)) {
+      const key = segmentFor(node, entry.key);
+      const childPath = appendOperationPath(path, key);
+      const slot = slotStatusOf(handle, node, key);
+      const descended = descendChains(chains, key);
+      const ignored = slot.ignored || descended.ignored;
+      const unsafe = slot.occupied ? slot.unsafe : descended.unsafe;
+      const childChains = slot.occupied ? slot.chains : descended.chains;
+      if (ignored) continue;
+      const visit = bindVisitedOccupancy(handle, childPath, node, entry.key, entry.value, unsafe);
+      if (visit !== "continue") continue;
+      if (typeof entry.value === "object" && entry.value !== null) walk(entry.value, childPath, childChains);
     }
-    weight += pushReplace(ops, appendOperationPath(path, "length"), before.length, after.length);
+  };
+  walk(root, createOperationPath([]), rootChains);
+};
+function seedOccupancies(handle) {
+  const capture = createCaptureTables();
+  walkLiveOccupancies(handle, capture);
+  commitVends(handle, capture);
+}
+function syncHandleTables(handle, capture) {
+  walkLiveOccupancies(handle, capture);
+}
+
+// src/ops/admission.ts
+var { proxyStateMap: proxyStateMap9 } = unstable_getInternalStates();
+var rawTargetOf5 = (value) => proxyStateMap9.get(value)?.[0] ?? value;
+var MissingDiffParentError = class extends Error {
+  constructor() {
+    super("opshot: admitStep could not resolve a live parent");
+    this.name = "MissingDiffParentError";
+  }
+};
+var admitStep = (handle, dirty, path, liveParent, residual) => {
+  if (path.length === 0) {
+    return { visit: "continue", ignored: isChainsIgnored(residual), liveChild: liveParent, chains: residual };
+  }
+  const key = path[path.length - 1];
+  const liveChild = isObjectLike3(liveParent) && key !== void 0 ? Reflect.get(liveParent, key) : void 0;
+  if (handle === void 0) {
+    const childChains = key === void 0 ? residual : childChainsOf(residual, key);
+    return { visit: "continue", ignored: isChainsIgnored(childChains), liveChild, chains: childChains };
+  }
+  if (key === void 0) {
+    return { visit: "continue", ignored: isChainsIgnored(residual), liveChild: liveParent, chains: residual };
+  }
+  const resolved = resolveChildChains(handle, liveParent, residual, key, liveChild);
+  const ignored = resolved === void 0;
+  const chains = resolved?.chains ?? childChainsOf(residual, key);
+  if (dirty === void 0) return { visit: "continue", ignored, liveChild, chains };
+  if (ignored) return { visit: "skip", ignored, liveChild, chains };
+  if (resolved.otherRoutes) {
+    if (!isObjectLike3(liveParent) || !isObjectLike3(liveChild)) throw new MissingDiffParentError();
+    const slot = slotStatusOf(handle, liveParent, key);
+    let unsafe = slot.occupied ? slot.unsafe : isChainsUnsafe(resolved.descended);
+    const status = edgeStatusOf(handle, liveChild);
+    if (status.occupied) unsafe = status.unsafe;
+    return {
+      visit: bindVisitedOccupancy(handle, path, liveParent, key, liveChild, unsafe, false),
+      ignored,
+      liveChild,
+      chains
+    };
+  }
+  if (!isObjectLike3(liveParent)) throw new MissingDiffParentError();
+  return {
+    visit: bindVisitedOccupancy(handle, path, liveParent, key, liveChild, isChainsUnsafe(resolved.descended), false),
+    ignored,
+    liveChild,
+    chains
+  };
+};
+var admitDescendants = (handle, path, visits, residual, liveNode, unsafe = false) => {
+  if (handle === void 0) return;
+  if (!isObjectLike3(liveNode)) return;
+  const nodeKey = rawTargetOf5(liveNode);
+  if (visits.has(nodeKey)) return;
+  visits.add(nodeKey);
+  if (isChainsIgnored(residual)) return;
+  const nodeUnsafe = unsafe || isChainsUnsafe(residual);
+  for (const entry of walkDataEntries(liveNode)) {
+    if (typeof entry.value !== "object" || entry.value === null) continue;
+    const key = segmentFor(liveNode, entry.key);
+    const childPath = appendOperationPath(path, key);
+    const descended = descendChains(residual, key);
+    let ignored;
+    let childChains;
+    let childUnsafe;
+    let ignoredFrontier;
+    if (hasOtherRoutes(handle, entry.value, liveNode, key)) {
+      const slot = slotStatusOf(handle, liveNode, key);
+      ignored = slot.ignored || descended.ignored;
+      childChains = nodeChainsOf(handle, entry.value) ?? descended.chains;
+      childUnsafe = slot.occupied ? slot.unsafe : nodeUnsafe || descended.unsafe;
+      ignoredFrontier = void 0;
+    } else {
+      ignored = descended.ignored || isChainsIgnored(descended.chains);
+      childChains = descended.chains;
+      childUnsafe = nodeUnsafe || descended.unsafe;
+      ignoredFrontier = false;
+    }
+    if (ignored) continue;
+    const visit = bindVisitedOccupancy(
+      handle,
+      childPath,
+      liveNode,
+      entry.key,
+      entry.value,
+      childUnsafe,
+      ignoredFrontier
+    );
+    if (visit !== "continue") continue;
+    admitDescendants(handle, childPath, visits, childChains, Reflect.get(liveNode, key), childUnsafe);
+  }
+};
+var markChangedPath = (handle, dirty, path, liveParent) => {
+  if (handle === void 0 || dirty === void 0 || path.length === 0) return;
+  if (!isObjectLike3(liveParent)) return;
+  markDirtyPath(dirty, handle, path, liveParent);
+};
+var emitsSkippedOccupancy = (value) => isObjectLike3(value) && admissionLane(value) === "untracked";
+
+// src/ops/ancestorPairs.ts
+var MissingAncestorPairError = class extends Error {
+  constructor() {
+    super("opshot: exitAncestorPair without matching enterAncestorPair");
+    this.name = "MissingAncestorPairError";
   }
-  weight += diffObjectProperties(before, after, path, ops, ancestors, true);
-  return weight;
 };
-var walkContainer = (before, after, path, ops, ancestors, walk) => {
-  if (hasAncestorPair(ancestors, before, after)) throw cyclicError(path);
+var hasAncestorPair = (ancestors, before, after) => ancestors.get(before)?.has(after) ?? false;
+var enterAncestorPair = (ancestors, before, after) => {
+  const afterSet = ancestors.get(before) ?? /* @__PURE__ */ new Set();
+  afterSet.add(after);
+  ancestors.set(before, afterSet);
+};
+var exitAncestorPair = (ancestors, before, after) => {
+  const afterSet = ancestors.get(before);
+  if (afterSet === void 0) throw new MissingAncestorPairError();
+  afterSet.delete(after);
+  if (afterSet.size === 0) ancestors.delete(before);
+};
+var walkContainer = (ancestors, before, after, walk) => {
+  if (hasAncestorPair(ancestors, before, after)) return;
   enterAncestorPair(ancestors, before, after);
   try {
-    if (path.length === 0) {
-      walk();
-      return 0;
-    }
-    const opsStart = ops.length;
-    const atomicWeight = walk();
-    return tryCollapse(before, after, path, ops, opsStart, atomicWeight);
+    walk();
   } finally {
     exitAncestorPair(ancestors, before, after);
   }
 };
-var diffValue = (before, after, path, ops, ancestors) => {
-  if (Object.is(before, after)) return 0;
-  if (path.length > 0 && isObjectLike2(before) && isObjectLike2(after) && !sharesStorageIdentity(before, after)) {
-    assertSafeSubtree(before, path);
-    assertSafeSubtree(after, path);
-    return pushReplace(ops, path, before, after);
+
+// src/ops/internedOccupancy.ts
+var { proxyStateMap: proxyStateMap10 } = unstable_getInternalStates();
+var rawTargetOf6 = (value) => proxyStateMap10.get(value)?.[0] ?? value;
+var liveOf2 = (node) => getRegisteredTarget(node) ?? node;
+var occupancyNodeOf2 = (node) => rawTargetOf6(liveOf2(node));
+var internedOccupied = (handle, node, capture) => internedIdOf(handle, node, capture) !== void 0 && edgeStatusOf(handle, occupancyNodeOf2(node)).occupied;
+
+// src/ops/mintPairs.ts
+var additionPair = (path, after, ids) => ({
+  do: createAssignMutation(path, after, after, ids),
+  undo: createDeleteMutation(path)
+});
+var removalPair = (path, before) => ({
+  do: createDeleteMutation(path),
+  undo: createAssignMutation(path, before)
+});
+var linkUndo = (path, before, beforePresent, handle, capture) => {
+  if (!beforePresent) return createDeleteMutation(path);
+  if (handle !== void 0 && isObjectLike3(before) && internedOccupied(handle, before, capture)) {
+    const id = internedIdOf(handle, before, capture);
+    if (id !== void 0) return createLinkMutation(path, id);
+  }
+  return createAssignMutation(path, before);
+};
+var linkOperation = (path, ref, before, beforePresent, handle, capture) => ({
+  do: createLinkMutation(path, ref),
+  undo: linkUndo(path, before, beforePresent, handle, capture)
+});
+var changePair = (path, before, after, handle, capture, ids) => ({
+  do: createAssignMutation(path, after, after, ids),
+  undo: linkUndo(path, before, true, handle, capture)
+});
+
+// src/ops/diff.ts
+var IncompatibleObjectRootsError = class extends Error {
+  constructor() {
+    super("opshot: diffObjects requires compatible supported object roots");
+    this.name = "IncompatibleObjectRootsError";
+  }
+};
+var commitOperation = (context, pair) => {
+  context.ops.push(pair);
+};
+var commitLink = (context, path, ref, before, beforePresent) => {
+  commitOperation(context, linkOperation(path, ref, before, beforePresent, context.handle, context.capture));
+};
+var emptyContainerOf = (value) => isPlainArray(value) ? [] : {};
+var namedArrayEntriesOf = (value) => {
+  const named = /* @__PURE__ */ new Map();
+  for (const key of Object.keys(value)) {
+    if (key === "__proto__" || isCanonicalArrayIndexString(key)) continue;
+    const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !("value" in descriptor)) continue;
+    named.set(key, descriptor.value);
+  }
+  return named;
+};
+var mintDecomposedContents = (context, path, after, verdict) => {
+  const residual = verdict.chains;
+  const liveNode = verdict.liveChild;
+  if (isPlainArray(after)) {
+    if (after.length > 0)
+      commitOperation(
+        context,
+        changePair(appendOperationPath(path, "length"), 0, after.length, context.handle, context.capture)
+      );
+    for (let index = 0; index < after.length; index++) {
+      if (!Object.hasOwn(after, index)) continue;
+      const nextPath = appendOperationPath(path, index);
+      const childVerdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
+      pushAddition(context, nextPath, after[index], childVerdict, liveNode);
+    }
+    for (const [key, value] of namedArrayEntriesOf(after)) {
+      const nextPath = appendOperationPath(path, key);
+      const childVerdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
+      pushAddition(context, nextPath, value, childVerdict, liveNode);
+    }
+  } else {
+    for (const entry of walkDataEntries(after)) {
+      const nextPath = appendOperationPath(path, entry.key);
+      const childVerdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
+      pushAddition(context, nextPath, entry.value, childVerdict, liveNode);
+    }
+  }
+};
+var mintDecomposedAddition = (context, path, after, verdict) => {
+  commitOperation(context, {
+    do: createAssignMutation(path, emptyContainerOf(after), after),
+    undo: createDeleteMutation(path)
+  });
+  mintDecomposedContents(context, path, after, verdict);
+};
+var mintDecomposedChange = (context, path, before, after, verdict) => {
+  commitOperation(context, {
+    do: createAssignMutation(path, emptyContainerOf(after), after),
+    undo: linkUndo(path, before, true, context.handle, context.capture)
+  });
+  mintDecomposedContents(context, path, after, verdict);
+};
+var surveyAssignedSubtree = (handle, capture, node, residual, stopAtInternedOccupied) => {
+  const visits = /* @__PURE__ */ new Set();
+  const pending = new Array();
+  const visit = (current, currentResidual) => {
+    const raw = occupancyNodeOf2(current);
+    if (visits.has(raw)) return false;
+    visits.add(raw);
+    if (admissionLane(current) === "untracked") return false;
+    if (stopAtInternedOccupied) {
+      if (current !== node) pending.push(current);
+    } else stageVend(handle, capture, current);
+    const source = liveOf2(current);
+    for (const entry of walkDataEntries(source)) {
+      if (typeof entry.value !== "object" || entry.value === null) continue;
+      if (!isTrackedEdge(entry)) continue;
+      const key = segmentFor(source, entry.key);
+      const resolved = resolveChildChains(handle, source, currentResidual, key, entry.value);
+      if (resolved === void 0) continue;
+      const child = entry.value;
+      if (stopAtInternedOccupied && internedOccupied(handle, child, capture)) return true;
+      if (visit(child, resolved.chains)) return true;
+    }
+    return false;
+  };
+  if (stopAtInternedOccupied) stageVend(handle, capture, node);
+  const reachesInternedOccupied = visit(node, residual);
+  if (stopAtInternedOccupied && !reachesInternedOccupied) {
+    for (const pendingNode of pending) stageVend(handle, capture, pendingNode);
+  }
+  return { reachesInternedOccupied };
+};
+var internIdsOfSubtree = (handle, node, capture) => {
+  const seen = /* @__PURE__ */ new Set();
+  const ids = new Array();
+  const walk = (current) => {
+    const id = internedIdOf(handle, current, capture);
+    if (id === void 0 || seen.has(id)) return;
+    seen.add(id);
+    ids.push(id);
+    for (const entry of walkDataEntries(liveOf2(current))) {
+      if (typeof entry.value === "object" && entry.value !== null) walk(entry.value);
+    }
+  };
+  walk(node);
+  return ids.length === 0 ? void 0 : ids;
+};
+var mintAssignment = (context, path, before, after, beforePresent, verdict) => {
+  if (verdict.ignored) return;
+  const handle = context.handle;
+  if (isObjectLike3(after) && handle !== void 0) {
+    const internedId = internedIdOf(handle, after, context.capture);
+    if (internedId !== void 0 && internedOccupied(handle, after, context.capture)) {
+      const sameOccupant = isObjectLike3(before) && occupancyNodeOf2(before) === occupancyNodeOf2(after);
+      const beforeInterned = isObjectLike3(before) && internedIdOf(handle, before, context.capture) !== void 0;
+      const uninternedTrackedBefore = isObjectLike3(before) && !beforeInterned && admissionLane(before) !== "untracked";
+      if (!sameOccupant && !uninternedTrackedBefore) {
+        commitLink(context, path, internedId, before, beforePresent);
+        return;
+      }
+      surveyAssignedSubtree(handle, context.capture, after, verdict.chains, false);
+    } else if (admissionLane(after) !== "untracked" && (isPlainObject(after) || isPlainArray(after))) {
+      const { reachesInternedOccupied } = surveyAssignedSubtree(
+        handle,
+        context.capture,
+        after,
+        verdict.chains,
+        true
+      );
+      if (reachesInternedOccupied) {
+        if (!beforePresent) {
+          mintDecomposedAddition(context, path, after, verdict);
+          return;
+        }
+        mintDecomposedChange(context, path, before, after, verdict);
+        return;
+      }
+    } else {
+      admitDescendants(handle, path, /* @__PURE__ */ new Set(), verdict.chains, verdict.liveChild);
+      internSubtree(
+        handle,
+        after,
+        verdict.chains,
+        (parent, parentChains, key, entry) => isTrackedEdge(entry) ? resolveChildChains(handle, parent, parentChains, key, entry.value)?.chains : void 0,
+        context.capture
+      );
+    }
+  } else if (isObjectLike3(after)) admitDescendants(context.handle, path, /* @__PURE__ */ new Set(), verdict.chains, verdict.liveChild);
+  const ids = isObjectLike3(after) && handle !== void 0 ? internIdsOfSubtree(handle, after, context.capture) : void 0;
+  if (beforePresent) commitOperation(context, changePair(path, before, after, handle, context.capture, ids));
+  else commitOperation(context, additionPair(path, after, ids));
+};
+var pushAddition = (context, path, after, verdict, liveParent) => {
+  const { visit, ignored } = verdict;
+  if (visit === "skip") {
+    if (ignored || !emitsSkippedOccupancy(after)) return;
+  } else if (ignored) return;
+  markChangedPath(context.handle, context.dirty, path, liveParent);
+  mintAssignment(context, path, void 0, after, false, verdict);
+};
+var pushRemoval = (context, path, before, verdict, liveParent) => {
+  if (verdict.ignored) return;
+  markChangedPath(context.handle, context.dirty, path, liveParent);
+  const handle = context.handle;
+  if (isObjectLike3(before) && handle !== void 0) {
+    const id = internedIdOf(handle, before, context.capture);
+    if (id !== void 0 && internedOccupied(handle, before, context.capture)) {
+      commitOperation(context, {
+        do: createDeleteMutation(path),
+        undo: createLinkMutation(path, id)
+      });
+      return;
+    }
+  }
+  commitOperation(context, removalPair(path, before));
+};
+var pushChange = (context, path, before, after, verdict, liveParent) => {
+  markChangedPath(context.handle, context.dirty, path, liveParent);
+  mintAssignment(context, path, before, after, true, verdict);
+};
+var sharesStorageIdentity = (before, after) => isObjectLike3(before) && isObjectLike3(after) && isSameIdentity(before, after);
+var diffCollectedProperties = (context, before, after, path, residual, liveNode, beforeEntries, afterEntries) => {
+  const keys = /* @__PURE__ */ new Set([...beforeEntries.keys(), ...afterEntries.keys()]);
+  for (const key of keys) {
+    const nextPath = appendOperationPath(path, key);
+    const beforePresent = beforeEntries.has(key);
+    const afterPresent = afterEntries.has(key);
+    if (beforePresent && afterPresent) {
+      diffValue(context, beforeEntries.get(key), afterEntries.get(key), nextPath, residual, liveNode);
+    } else if (beforePresent && !Object.hasOwn(after, key)) {
+      const verdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
+      pushRemoval(context, nextPath, beforeEntries.get(key), verdict, liveNode);
+    } else if (afterPresent && !Object.hasOwn(before, key)) {
+      const verdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
+      pushAddition(context, nextPath, afterEntries.get(key), verdict, liveNode);
+    }
+  }
+};
+var diffObjectProperties = (context, before, after, path, residual, liveNode) => {
+  diffCollectedProperties(
+    context,
+    before,
+    after,
+    path,
+    residual,
+    liveNode,
+    dataEntryValuesOf(before),
+    dataEntryValuesOf(after)
+  );
+};
+var diffArray = (context, before, after, path, residual, liveNode) => {
+  const overlap = Math.min(before.length, after.length);
+  for (let index = 0; index < overlap; index++) {
+    const beforePresent = Object.hasOwn(before, index);
+    const afterPresent = Object.hasOwn(after, index);
+    if (!beforePresent && !afterPresent) continue;
+    const nextPath = appendOperationPath(path, index);
+    if (!beforePresent) {
+      const verdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
+      pushAddition(context, nextPath, after[index], verdict, liveNode);
+    } else if (!afterPresent) {
+      const verdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
+      pushRemoval(context, nextPath, before[index], verdict, liveNode);
+    } else diffValue(context, before[index], after[index], nextPath, residual, liveNode);
+  }
+  if (after.length > before.length) {
+    const lengthPath = appendOperationPath(path, "length");
+    const lengthVerdict = admitStep(context.handle, context.dirty, lengthPath, liveNode, residual);
+    pushChange(context, lengthPath, before.length, after.length, lengthVerdict, liveNode);
+    for (let index = before.length; index < after.length; index++) {
+      if (!Object.hasOwn(after, index)) continue;
+      const nextPath = appendOperationPath(path, index);
+      const verdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
+      pushAddition(context, nextPath, after[index], verdict, liveNode);
+    }
+  } else if (after.length < before.length) {
+    for (let index = after.length; index < before.length; index++) {
+      if (!Object.hasOwn(before, index)) continue;
+      const nextPath = appendOperationPath(path, index);
+      const verdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
+      pushRemoval(context, nextPath, before[index], verdict, liveNode);
+    }
+    const lengthPath = appendOperationPath(path, "length");
+    const lengthVerdict = admitStep(context.handle, context.dirty, lengthPath, liveNode, residual);
+    pushChange(context, lengthPath, before.length, after.length, lengthVerdict, liveNode);
+  }
+  diffCollectedProperties(
+    context,
+    before,
+    after,
+    path,
+    residual,
+    liveNode,
+    namedArrayEntriesOf(before),
+    namedArrayEntriesOf(after)
+  );
+};
+var diffValue = (context, before, after, path, residual, liveParent) => {
+  const replacing = path.length > 0 && isObjectLike3(before) && isObjectLike3(after) && !sharesStorageIdentity(before, after);
+  const verdict = admitStep(context.handle, context.dirty, path, liveParent, residual);
+  const { visit, ignored, liveChild, chains } = verdict;
+  if (visit === "skip" || ignored) {
+    if (Object.is(before, after)) return;
+    if (isObjectLike3(before) && isObjectLike3(after) && sharesStorageIdentity(before, after)) return;
+    if (ignored || !emitsSkippedOccupancy(after)) return;
+    pushChange(context, path, before, after, verdict, liveParent);
+    return;
+  }
+  if (Object.is(before, after)) return;
+  if (replacing) {
+    pushChange(context, path, before, after, verdict, liveParent);
+    return;
   }
   if (isPlainArray(before) && isPlainArray(after)) {
-    return walkContainer(before, after, path, ops, ancestors, () => diffArray(before, after, path, ops, ancestors));
+    walkContainer(context.ancestors, before, after, () => diffArray(context, before, after, path, chains, liveChild));
+    return;
   }
   if (isPlainObject(before) && isPlainObject(after)) {
-    return walkContainer(
+    walkContainer(
+      context.ancestors,
       before,
       after,
-      path,
-      ops,
-      ancestors,
-      () => diffObjectProperties(before, after, path, ops, ancestors, false)
+      () => diffObjectProperties(context, before, after, path, chains, liveChild)
     );
+    return;
   }
-  assertSafeSubtree(before, path);
-  assertSafeSubtree(after, path);
-  return pushReplace(ops, path, before, after);
+  pushChange(context, path, before, after, verdict, liveParent);
 };
 var getRootKind = (value) => {
   if (isPlainArray(value)) return "plainArray";
   if (isPlainObject(value)) return "plainObject";
   return void 0;
 };
-function diffSnapshots(before, after) {
+function diffObjects(before, after, handle, dirty, capture) {
   const beforeKind = getRootKind(before);
   const afterKind = getRootKind(after);
-  if (beforeKind === void 0 || beforeKind !== afterKind) throw new IncompatibleSnapshotRootsError();
+  if (beforeKind === void 0 || beforeKind !== afterKind) throw new IncompatibleObjectRootsError();
   const ops = new Array();
-  diffValue(before, after, createOperationPath([]), ops, /* @__PURE__ */ new Map());
+  const context = {
+    ops,
+    ancestors: /* @__PURE__ */ new Map(),
+    handle,
+    dirty,
+    capture: capture ?? createCaptureTables()
+  };
+  diffValue(
+    context,
+    before,
+    after,
+    createOperationPath([]),
+    handle === void 0 ? [void 0] : chainsAtRoot(handle.declarations),
+    handle?.proxy.root
+  );
   return ops;
 }
 
 // src/emit/emitterDeliver.ts
-var deliver = (record, ops, meta) => {
-  const groupDelivers = [...record.groupListeners?.values() ?? []].flatMap((byChannel) => [...byChannel.values()]);
-  for (const deliverToListener of groupDelivers) deliverToListener(record.target, ops, meta);
-  const ownDelivers = [...record.listeners.values()].flatMap((byChannel) => [...byChannel.values()]);
-  for (const deliverToListener of ownDelivers) deliverToListener(ops, meta);
+var collectDeliveries = (handle) => {
+  const deliveries = [];
+  for (const groupListeners of handle.groups ?? []) {
+    for (const byChannel of groupListeners.values()) {
+      for (const deliverToListener of byChannel.values()) {
+        deliveries.push({ kind: "group", deliver: deliverToListener });
+      }
+    }
+  }
+  for (const byChannel of handle.subscribers.values()) {
+    for (const deliverToListener of byChannel.values()) {
+      deliveries.push({ kind: "own", deliver: deliverToListener });
+    }
+  }
+  return deliveries;
 };
-
-// src/emit/resolveEmitterTarget.ts
-var { proxyStateMap: proxyStateMap3 } = unstable_getInternalStates();
-var isObjectLike3 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-function resolveEmitterTarget(state) {
-  let current = state;
-  while (isObjectLike3(current)) {
-    if (proxyStateMap3.has(current)) return current;
-    const peeled = peelIdentityLayer(current);
-    if (peeled === void 0) break;
-    current = peeled;
+var runDelivery = (pending, failures) => {
+  const handle = handleOf(pending.writeProxy);
+  if (handle !== void 0) handle.lastDirty = pending.dirty;
+  for (const delivery of pending.deliveries) {
+    try {
+      if (delivery.kind === "group") {
+        delivery.deliver(pending.writeProxy, pending.ops, pending.meta, pending.channelId);
+      } else {
+        delivery.deliver(pending.ops, pending.meta, pending.channelId);
+      }
+    } catch (error) {
+      failures.push(error);
+    }
   }
-  if (!isObjectLike3(current) || !proxyStateMap3.has(current)) throw new Error("opshot: expected a state object");
-  return current;
-}
+};
+var raiseFailures = (failures) => {
+  if (failures.length === 0) return;
+  if (failures.length > 1) throw new AggregateError(failures, "opshot: listeners failed during delivery");
+  throw failures[0];
+};
+var queuedDeliveries = [];
+var deliveryFailures = [];
+var isDraining = false;
+var prepareDelivery = (handle, ops, meta, channelId, dirty) => ({
+  writeProxy: handle.proxy.root,
+  deliveries: collectDeliveries(handle),
+  ops,
+  meta,
+  channelId,
+  dirty
+});
+var enqueueDelivery = (pending) => {
+  queuedDeliveries.push(pending);
+};
+var drainDeliveries = () => {
+  if (isDraining) return;
+  isDraining = true;
+  let failures = [];
+  try {
+    while (queuedDeliveries.length > 0) {
+      for (const queued of queuedDeliveries.splice(0, queuedDeliveries.length)) {
+        runDelivery(queued, deliveryFailures);
+      }
+    }
+  } finally {
+    isDraining = false;
+    failures = deliveryFailures.splice(0, deliveryFailures.length);
+  }
+  raiseFailures(failures);
+};
 
 // src/emit/emitterRegistry.ts
-var emitters = /* @__PURE__ */ new WeakMap();
-function getEmitter(state) {
-  return emitters.get(resolveEmitterTarget(state));
-}
-var hasListeners = (record) => record.listeners.size > 0 || (record.groupListeners?.size ?? 0) > 0;
-function getOrCreateEmitter(target, groupListeners) {
-  const resolved = resolveEmitterTarget(target);
-  const existing = emitters.get(resolved);
-  if (existing !== void 0) return existing;
-  const record = {
-    listeners: /* @__PURE__ */ new Map(),
-    groupListeners,
-    lastReported: snapshot(resolved),
-    isMutating: false,
-    target: resolved
+var { proxyStateMap: proxyStateMap11 } = unstable_getInternalStates();
+var targetOf = (writeProxy) => proxyStateMap11.get(writeProxy)?.[0] ?? writeProxy;
+
+// src/emit/emitter.ts
+function scheduleFlush(handle) {
+  if (handle.isFlushScheduled) return;
+  handle.isFlushScheduled = true;
+  const generation = handle.flushGeneration;
+  const run = () => {
+    if (generation !== handle.flushGeneration) return;
+    handle.isFlushScheduled = false;
+    emitWrites(handle);
   };
-  emitters.set(resolved, record);
-  return record;
+  void Promise.resolve().then(() => {
+    const emitOn = handle.emitOn;
+    if (emitOn === void 0) {
+      run();
+      return;
+    }
+    emitOn(run);
+  });
 }
-function deleteEmitter(target) {
-  emitters.delete(target);
+function armWatch(handle) {
+  handle.disarmWatch = subscribe(
+    handle.proxy.root,
+    () => {
+      handle.hasPendingWrites = true;
+      if (handle.isFlushHeld) return;
+      scheduleFlush(handle);
+    });
 }
-
-// src/emit/emitterBare.ts
-var augmentBareCycleError = (error) => {
-  const path = getCyclicPath(error);
-  if (path === void 0) return void 0;
-  return new Error(
-    `opshot: a bare write created a cyclic value at ${formatOperationPath(path)}. Cycles cannot be tracked. This surfaced asynchronously because the write was not inside transact. Use transact for catchable cycle errors, ignore() for back-linked structures, or ids.`
-  );
+var cloneSnapshotNode = (snap) => {
+  const clone = Array.isArray(snap) ? [] : Object.create(Reflect.getPrototypeOf(snap));
+  for (const key of carriedOwnKeysOf(snap)) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(snap, key);
+    if (descriptor !== void 0) Object.defineProperty(clone, key, descriptor);
+  }
+  if (Array.isArray(snap)) clone.length = snap.length;
+  registerSnapshotCopy(clone, getRegisteredTarget(snap) ?? targetOf(snap));
+  return clone;
 };
-var requireObjectSnapshot = (value) => {
-  if (value !== null && (typeof value === "object" || typeof value === "function")) return value;
-  throw new Error("opshot: state snapshots must have an object root");
+var reconcileUntracked = (snap, live, seen) => {
+  if (seen.has(live)) return snap;
+  seen.add(live);
+  let result;
+  const written = () => {
+    result ??= cloneSnapshotNode(snap);
+    return result;
+  };
+  for (const key of carriedOwnKeysOf(live)) {
+    const liveValue = Reflect.get(live, key);
+    if (typeof liveValue !== "object" || liveValue === null) continue;
+    if (admissionLane(liveValue) === "untracked") {
+      if (Reflect.get(snap, key) === liveValue) continue;
+      const snapChild2 = Reflect.get(snap, key);
+      if (typeof snapChild2 !== "object" || snapChild2 === null) continue;
+      if (getRegisteredTarget(snapChild2) !== targetOf(liveValue)) continue;
+      const descriptor = Reflect.getOwnPropertyDescriptor(live, key);
+      if (descriptor === void 0 || descriptor.get !== void 0 || descriptor.set !== void 0) continue;
+      Object.defineProperty(written(), key, {
+        value: liveValue,
+        enumerable: descriptor.enumerable,
+        configurable: true
+      });
+      continue;
+    }
+    const snapChild = Reflect.get(snap, key);
+    if (typeof snapChild !== "object" || snapChild === null) continue;
+    const reconciled = reconcileUntracked(snapChild, liveValue, seen);
+    if (reconciled === snapChild) continue;
+    Object.defineProperty(written(), key, {
+      value: reconciled,
+      enumerable: true,
+      configurable: true
+    });
+  }
+  return result ?? snap;
 };
-var armWatchdog = (record) => {
-  if (record.disarm !== void 0) return;
-  record.lastReported = snapshot(record.target);
-  record.disarm = subscribe(record.target, () => {
-    emitBareFlush(record.target);
-  });
+var captureDiffOf = (handle, from, capture) => {
+  const to = snapshot(handle.proxy.root);
+  const dirty = { edges: /* @__PURE__ */ new WeakMap(), nodes: /* @__PURE__ */ new WeakSet() };
+  if (from === to) {
+    syncHandleTables(handle, capture);
+    return { to, ops: [], dirty, capture };
+  }
+  return {
+    to,
+    ops: diffObjects(reconcileUntracked(from, handle.proxy.root, /* @__PURE__ */ new WeakSet()), to, handle, dirty, capture),
+    dirty,
+    capture
+  };
 };
-var disarmWatchdog = (record) => {
-  record.disarm?.();
-  record.disarm = void 0;
+var captureRange = (handle, meta, channelId) => {
+  handle.hasPendingWrites = false;
+  const from = handle.lastSnapshot;
+  const capture = handle.transactionCapture ?? createCaptureTables();
+  const committed = captureDiffOf(handle, from, capture);
+  const ops = committed.ops;
+  commitVends(handle, committed.capture);
+  handle.lastSnapshot = committed.to;
+  const evicted = evictDepartedClusters(handle);
+  if (ops.length > 0) annotateDepartureUndos(handle, ops, evicted);
+  if (ops.length > 0 && !handle.replaying) {
+    for (const operation of ops) stampOperation(handle, operation);
+  }
+  return ops.length > 0 ? prepareDelivery(handle, ops, meta, channelId, committed.dirty) : void 0;
 };
-var reportBareDiff = (record) => {
-  const current = snapshot(record.target);
-  if (current === record.lastReported) return;
-  const previous = record.lastReported;
-  record.lastReported = current;
-  if (!hasListeners(record)) return;
-  try {
-    const ops = diffSnapshots(requireObjectSnapshot(previous), requireObjectSnapshot(current));
-    if (ops.length === 0) return;
-    deliver(record, ops, void 0);
-  } catch (error) {
-    throw augmentBareCycleError(error) ?? error;
+function deliverCapturedRanges(ranges) {
+  for (const captured of ranges) {
+    if (captured !== void 0) enqueueDelivery(captured);
   }
+  drainDeliveries();
+}
+var emitRange = (handle, meta, channelId) => {
+  const captured = captureRange(handle, meta, channelId);
+  if (captured !== void 0) enqueueDelivery(captured);
+  drainDeliveries();
 };
-var settlePendingBare = (record) => {
-  reportBareDiff(record);
+function captureWrites(handle) {
+  return captureRange(handle, void 0, void 0);
+}
+function captureTransactionWrites(handle, meta, channelId) {
+  return captureRange(handle, meta, channelId);
+}
+function emitWrites(handle) {
+  emitRange(handle, void 0, void 0);
+}
+
+// src/emit/requireObjectSnapshot.ts
+var ObjectRootSnapshotError = class extends Error {
+  constructor() {
+    super("opshot: state snapshots must have an object root");
+    this.name = "ObjectRootSnapshotError";
+  }
 };
-function emitBareFlush(target) {
-  const record = getEmitter(target);
-  if (record === void 0) return;
-  reportBareDiff(record);
+var requireObjectSnapshot = (value) => {
+  if (value !== null && (typeof value === "object" || typeof value === "function")) return value;
+  throw new ObjectRootSnapshotError();
+};
+
+// src/ignore.ts
+var ignoreMarker = /* @__PURE__ */ Symbol("opshot.ignore");
+function ignore(value) {
+  return { [ignoreMarker]: value };
 }
-function mintGroupedEmitter(target, groupListeners) {
-  const record = getOrCreateEmitter(target, groupListeners);
-  armWatchdog(record);
-  return record;
+
+// src/isState.ts
+var { proxyStateMap: proxyStateMap12 } = unstable_getInternalStates();
+function isState(value) {
+  const resolved = peelReadProxy(value);
+  if (typeof resolved !== "object" || resolved === null) return false;
+  return proxyStateMap12.has(resolved);
+}
+
+// src/unsafeTrack.ts
+var unsafeMarker = /* @__PURE__ */ Symbol("opshot.unsafe");
+function unsafeTrack(value) {
+  return { [unsafeMarker]: value };
 }
 
 // src/utils/constructorName.ts
@@ -880,198 +2015,96 @@ var unsafeTrackDataOption = "unsafeTrack(value) to track its data anyway";
 var unsafeTrackPrivateOption = "unsafeTrack(value) tracks public fields while private methods throw on snapshots and undo drops that state";
 var unsafeTrackSlotOption = "unsafeTrack(value) tracks public fields while slot methods throw on snapshots and undo drops that state";
 var unsafeTrackLossyOption = "unsafeTrack(value) to track it lossily";
-var boundaryError = (className, reason, options) => new Error(
-  `opshot: ${className} cannot be tracked (${reason}). Options:
+var locationClause = (path) => path === void 0 || path.length === 0 ? "" : ` at /${path.join("/")}`;
+var boundaryError = (className, reason, options, path) => new Error(
+  `opshot: ${className}${locationClause(path)} cannot be tracked (${reason}). Options:
 ${options.map((option) => `- ${option}`).join("\n")}`
 );
-var slotContainerError = (className, trackedName) => boundaryError(className, "its state lives in internal slots", [
-  `use ${trackedName} for a tracked equivalent`,
-  unsafeTrackLossyOption,
-  ignoreOption
-]);
-var arraySubclassError = (className) => boundaryError(className, "array subclasses lose their prototype in snapshots", [
-  unsafeTrackDataOption,
-  ignoreOption
-]);
-var cleanClassError = (className) => boundaryError(className, "arrow-method writes won't be tracked", [unsafeTrackDataOption, ignoreOption]);
-var privateClassError = (className) => boundaryError(className, "its state is hidden in private fields", [unsafeTrackPrivateOption, ignoreOption]);
-var nativeClassError = (className) => boundaryError(className, "its state is hidden in internal slots", [unsafeTrackSlotOption, ignoreOption]);
+var slotContainerError = (className, trackedName, path) => boundaryError(
+  className,
+  "its state lives in internal slots",
+  [`use ${trackedName} for a tracked equivalent`, unsafeTrackLossyOption, ignoreOption],
+  path
+);
+var arraySubclassError = (className, path) => boundaryError(
+  className,
+  "array subclasses lose their prototype in snapshots",
+  [unsafeTrackDataOption, ignoreOption],
+  path
+);
+var cleanClassError = (className, path) => boundaryError(className, "arrow-method writes won't be tracked", [unsafeTrackDataOption, ignoreOption], path);
+var privateClassError = (className, path) => boundaryError(className, "its state is hidden in private fields", [unsafeTrackPrivateOption, ignoreOption], path);
+var nativeClassError = (className, path) => boundaryError(className, "its state is hidden in internal slots", [unsafeTrackSlotOption, ignoreOption], path);
+var nonWritablePropertyError = (value, path) => boundaryError(
+  constructorName(value.constructor),
+  "a non-writable property's interior is silently mutable and untracked",
+  ["make the property writable", "ignore(value) to declare the escape"],
+  path
+);
 var snapshotDonationError = (key) => new Error(
-  `opshot: cannot assign a snapshot generation at "${String(key)}": a snapshot generation is a read-view, and assigning it creates a dead region. Clone the value, or replay through applyOps.`
+  `opshot: cannot assign a snapshot generation at "${String(key)}": a snapshot generation is a read-view, and assigning it creates a dead region. Clone the value, or replay through applyOperations.`
 );
-var reservedDataPathError = (path) => new Error(`opshot: reserved data path /${path.join("/")}`);
 var inheritsFromPrototype = (value, prototype) => {
   for (let current = Reflect.getPrototypeOf(value); current !== null; current = Reflect.getPrototypeOf(current))
     if (current === prototype) return true;
   return false;
 };
-var rejectionError = (value, kind) => {
+var rejectionError = (value, kind, path) => {
   const className = constructorName(value.constructor);
-  if (inheritsFromPrototype(value, Map.prototype)) return slotContainerError(className, "TrackedMap");
-  if (inheritsFromPrototype(value, Set.prototype)) return slotContainerError(className, "TrackedSet");
-  if (inheritsFromPrototype(value, Date.prototype)) return slotContainerError(className, "TrackedDate");
+  if (inheritsFromPrototype(value, Map.prototype)) return slotContainerError(className, "TrackedMap", path);
+  if (inheritsFromPrototype(value, Set.prototype)) return slotContainerError(className, "TrackedSet", path);
+  if (inheritsFromPrototype(value, Date.prototype)) return slotContainerError(className, "TrackedDate", path);
   switch (kind) {
     case "arraySubclass":
-      return arraySubclassError(className);
+      return arraySubclassError(className, path);
     case "cleanClass":
-      return cleanClassError(className);
+      return cleanClassError(className, path);
     case "privateClass":
-      return privateClassError(className);
+      return privateClassError(className, path);
     case "nativeClass":
-      return nativeClassError(className);
+      return nativeClassError(className, path);
   }
 };
 
-// src/valtio/constructorPathGuard.ts
-var { refSet: refSet4 } = unstable_getInternalStates();
-var constructorPathTargetCounts = /* @__PURE__ */ new WeakMap();
-var rootGraphsByRoot = /* @__PURE__ */ new WeakMap();
-var rootGraphReferences = /* @__PURE__ */ new WeakMap();
-var rootGraphsByTarget = /* @__PURE__ */ new WeakMap();
-var getRawObject = (value) => {
-  const resolved = resolveIdentity(value);
-  return typeof resolved === "object" && resolved !== null ? resolved : void 0;
-};
-var getTrackedRawObject = (value) => {
-  const target = getRawObject(value);
-  if (!target || refSet4.has(target) || Object.isFrozen(target)) return void 0;
-  return isTrackable(target) ? target : void 0;
-};
-var getEnumerableDataChild = (target, key) => {
-  if (typeof key !== "string") return void 0;
-  const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-  if (!descriptor?.enumerable || !("value" in descriptor)) return void 0;
-  return getTrackedRawObject(descriptor.value);
-};
-var adjustConstructorPathTarget = (target, change) => {
-  const next = (constructorPathTargetCounts.get(target) ?? 0) + change;
-  if (next > 0) constructorPathTargetCounts.set(target, next);
-  else constructorPathTargetCounts.delete(target);
-};
-var constructorPathTargetCount = (target) => constructorPathTargetCounts.get(target) ?? 0;
-var releaseFinalizationState = (state) => {
-  if (!state.active) return;
-  state.active = false;
-  for (const { target, count } of state.constructorTargets) {
-    const resolved = target.deref();
-    if (resolved) adjustConstructorPathTarget(resolved, -count);
-  }
-  state.constructorTargets = [];
-};
-var rootGraphFinalizer = new FinalizationRegistry(releaseFinalizationState);
-var getRootGraphReference = (graph) => {
-  const existing = rootGraphReferences.get(graph);
-  if (existing) return existing;
-  const reference = new WeakRef(graph);
-  rootGraphReferences.set(graph, reference);
-  return reference;
-};
-var releaseRootGraph = (graph) => {
-  const reference = getRootGraphReference(graph);
-  for (const target of graph.targets) {
-    const references = rootGraphsByTarget.get(target);
-    references?.delete(reference);
-    if (references?.size === 0) rootGraphsByTarget.delete(target);
-  }
-  const root = graph.root.deref();
-  if (root) rootGraphsByRoot.delete(root);
-  releaseFinalizationState(graph.finalizationState);
-  rootGraphFinalizer.unregister(graph.finalizationState);
-  graph.targets.clear();
-  graph.constructorTargets.clear();
-};
-var getRootGraphs = (target) => {
-  const references = rootGraphsByTarget.get(target);
-  if (!references) return [];
-  const graphs = new Array();
-  for (const reference of references) {
-    const graph = reference.deref();
-    if (!graph) {
-      references.delete(reference);
-      continue;
-    }
-    if (!graph.root.deref()) {
-      releaseRootGraph(graph);
-      continue;
-    }
-    graphs.push(graph);
-  }
-  if (references.size === 0) rootGraphsByTarget.delete(target);
-  return graphs;
-};
-var recomputeRootGraph = (graph) => {
-  const root = graph.root.deref();
-  if (!root) {
-    releaseRootGraph(graph);
-    return;
+// src/valtio/snapshotAccessors.ts
+var { proxyStateMap: proxyStateMap13, snapCache: snapCache2 } = unstable_getInternalStates();
+var MissingOwnDescriptorError2 = class extends Error {
+  constructor() {
+    super("opshot: carried own key has no property descriptor");
+    this.name = "MissingOwnDescriptorError";
   }
-  const targets = /* @__PURE__ */ new Set();
-  const constructorTargets = /* @__PURE__ */ new Map();
-  const visit = (target) => {
-    if (targets.has(target)) return;
-    targets.add(target);
-    const constructorTarget = getEnumerableDataChild(target, "constructor");
-    if (constructorTarget)
-      constructorTargets.set(constructorTarget, (constructorTargets.get(constructorTarget) ?? 0) + 1);
-    for (const key of Object.keys(target)) {
-      const child = getEnumerableDataChild(target, key);
-      if (child) visit(child);
-    }
-  };
-  visit(root);
-  for (const [target, count] of graph.constructorTargets) adjustConstructorPathTarget(target, -count);
-  for (const [target, count] of constructorTargets) adjustConstructorPathTarget(target, count);
-  for (const target of graph.targets) {
-    if (targets.has(target)) continue;
-    const references = rootGraphsByTarget.get(target);
-    references?.delete(getRootGraphReference(graph));
-    if (references?.size === 0) rootGraphsByTarget.delete(target);
-  }
-  for (const target of targets) {
-    if (graph.targets.has(target)) continue;
-    const references = rootGraphsByTarget.get(target) ?? /* @__PURE__ */ new Set();
-    references.add(getRootGraphReference(graph));
-    rootGraphsByTarget.set(target, references);
-  }
-  graph.targets = targets;
-  graph.constructorTargets = constructorTargets;
-  graph.finalizationState.constructorTargets = [...constructorTargets].map(([target, count]) => ({
-    target: new WeakRef(target),
-    count
-  }));
-};
-var registerTrackedRoot = (value) => {
-  const root = getTrackedRawObject(value);
-  if (!root || rootGraphsByRoot.has(root)) return;
-  const finalizationState = { active: true, constructorTargets: [] };
-  const graph = {
-    root: new WeakRef(root),
-    finalizationState,
-    targets: /* @__PURE__ */ new Set(),
-    constructorTargets: /* @__PURE__ */ new Map()
-  };
-  rootGraphsByRoot.set(root, graph);
-  rootGraphFinalizer.register(root, finalizationState, finalizationState);
-  recomputeRootGraph(graph);
 };
-
-// src/valtio/snapshotAccessors.ts
-var { refSet: refSet5, proxyStateMap: proxyStateMap4, snapCache: snapCache2 } = unstable_getInternalStates();
 var createSnapshotPreservingAccessors = (target, version) => {
   const cached = snapCache2.get(target);
   if (cached?.[0] === version) {
     const cachedSnapshot = cached[1];
-    registerSnapshotCopy(cachedSnapshot, target);
+    for (const key of carriedOwnKeysOf(target)) {
+      const value = Reflect.get(target, key);
+      if (typeof value !== "object" || value === null) continue;
+      if (admissionLane(value) !== "untracked") continue;
+      if (Reflect.get(cachedSnapshot, key) === value) continue;
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+      if (descriptor === void 0 || descriptor.get !== void 0 || descriptor.set !== void 0) continue;
+      Object.defineProperty(cachedSnapshot, key, {
+        value,
+        enumerable: descriptor.enumerable,
+        configurable: true
+      });
+      markToTrack(value, false);
+    }
+    if (getRegisteredTarget(cachedSnapshot) === void 0) {
+      registerSnapshotCopy(cachedSnapshot, target);
+    }
     return cachedSnapshot;
   }
   const snap = Array.isArray(target) ? [] : Object.create(Reflect.getPrototypeOf(target));
   registerSnapshotCopy(snap, target);
   markToTrack(snap, true);
   snapCache2.set(target, [version, snap]);
-  for (const key of Reflect.ownKeys(target)) {
+  for (const key of carriedOwnKeysOf(target)) {
     if (Object.getOwnPropertyDescriptor(snap, key)) continue;
     const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-    if (!descriptor) continue;
+    if (descriptor === void 0) throw new MissingOwnDescriptorError2();
     if (descriptor.get || descriptor.set) {
       Object.defineProperty(snap, key, {
         get: descriptor.get,
@@ -1084,10 +2117,10 @@ var createSnapshotPreservingAccessors = (target, version) => {
     const value = Reflect.get(target, key);
     const snapshotDescriptor = { value, enumerable: descriptor.enumerable, configurable: true };
     if (typeof value === "object" && value !== null) {
-      if (refSet5.has(value)) {
+      if (admissionLane(value) === "untracked") {
         markToTrack(value, false);
       } else {
-        const childState = proxyStateMap4.get(value);
+        const childState = proxyStateMap13.get(value);
         if (childState)
           snapshotDescriptor.value = createSnapshotPreservingAccessors(childState[0], childState[1]());
       }
@@ -1097,96 +2130,320 @@ var createSnapshotPreservingAccessors = (target, version) => {
   if (Array.isArray(target) && snap.length !== target.length) {
     snap.length = target.length;
   }
-  if (isUnsafeTracked(target)) unsafeTrack(snap);
   return snap;
 };
 
 // src/valtio/boundary.ts
-var assertSafeDataPaths = (value, path = new Array(), activeAncestors = /* @__PURE__ */ new WeakSet()) => {
-  if (typeof value !== "object" || value === null || activeAncestors.has(value)) return;
-  activeAncestors.add(value);
-  try {
-    for (const key of Object.keys(value)) {
-      const nextPath = [...path, key];
-      if (key === "__proto__" || key === "prototype" && path[path.length - 1] === "constructor")
-        throw reservedDataPathError(nextPath);
-      const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
-      if (descriptor && "value" in descriptor) assertSafeDataPaths(descriptor.value, nextPath, activeAncestors);
+var { proxyStateMap: proxyStateMap14, proxyCache: proxyCache3 } = unstable_getInternalStates();
+var rawTargetOf7 = (value) => proxyStateMap14.get(value)?.[0] ?? value;
+var handleOwning = (target) => {
+  const handles = handlesOf(target);
+  const raw = rawTargetOf7(target);
+  for (const handle of handles) {
+    if (rawTargetOf7(handle.proxy.root) === raw) return handle;
+  }
+  return handles[0];
+};
+var segmentForProp = (parent, prop) => isPlainArray(parent) && isCanonicalArrayIndexString(prop) ? Number(prop) : prop;
+var setFrameStack = new Array();
+var currentSetParentOf = () => setFrameStack[setFrameStack.length - 1]?.target;
+var currentStatuses = () => setFrameStack[setFrameStack.length - 1]?.statuses;
+var heldStatusesOf = (target, prop) => {
+  const key = segmentForProp(target, prop);
+  const statuses = new Array();
+  for (const handle of handlesOf(target)) {
+    const slot = slotStatusOf(handle, target, key);
+    if (!slot.occupied) continue;
+    statuses.push({ handle, ignored: slot.ignored, unsafe: slot.unsafe, chains: slot.chains });
+  }
+  return statuses.length === 0 ? void 0 : statuses;
+};
+var inheritedStatusesOf = (target, prop) => {
+  const parent = setFrameStack[setFrameStack.length - 1];
+  if (parent?.statuses === void 0) return void 0;
+  const key = segmentForProp(target, prop);
+  return parent.statuses.map((status) => {
+    const descended = descendChains(status.chains, key);
+    return {
+      handle: status.handle,
+      ignored: status.ignored || descended.ignored,
+      unsafe: status.unsafe || descended.unsafe,
+      chains: descended.chains
+    };
+  });
+};
+var statusesForFrame = (target, prop, initializing) => {
+  if (typeof prop !== "string") return void 0;
+  if (!initializing) return heldStatusesOf(target, prop);
+  return inheritedStatusesOf(target, prop) ?? heldStatusesOf(target, prop);
+};
+var certifyAdmission = (value, path, unsafe = false) => {
+  const decision = admissionDecision(value);
+  if (decision.lane === "dangerous" && !unsafe) throw rejectionError(value, decision.kind, path);
+  return decision.lane;
+};
+var peelSnapshotsAndReadProxies = (value) => {
+  let current = value;
+  while (typeof current === "object" && current !== null) {
+    const untracked = getUntracked(current);
+    const next = peelReadProxy(untracked ?? current);
+    if (next === current) break;
+    current = next;
+  }
+  return current;
+};
+var walkDataPaths = (value, path, visits, mode, chains, ignored, unsafe) => {
+  const node = mode === "admission" ? rawTargetOf7(value) : value;
+  if (visits.has(node)) return;
+  visits.add(node);
+  if (ignored) return;
+  for (const entry of walkDataEntries(node)) {
+    const childPath = [...path, entry.key];
+    const descended = descendChains(chains, segmentForProp(node, entry.key));
+    const childIgnored = descended.ignored;
+    const childUnsafe = unsafe || descended.unsafe;
+    const childChains = descended.chains;
+    const child = entry.value;
+    if (mode === "admission" && classifyValue(node) === "cleanClass" && !unsafe && typeof child === "function")
+      throw rejectionError(node, "cleanClass", childPath);
+    if (typeof child !== "object" || child === null) continue;
+    if (!entry.writable) {
+      if (mode === "admission" && !childIgnored && !childUnsafe && admissionLane(child) !== "untracked")
+        throw nonWritablePropertyError(child, childPath);
+      continue;
     }
-  } finally {
-    activeAncestors.delete(value);
+    if (childIgnored) continue;
+    let childNode = child;
+    if (proxyStateMap14.has(childNode)) {
+      if (mode !== "admission") continue;
+      childNode = rawTargetOf7(childNode);
+    }
+    if (mode === "admission") {
+      if (childUnsafe) {
+        walkDataPaths(childNode, childPath, visits, mode, childChains, childIgnored, childUnsafe);
+        continue;
+      }
+      if (certifyAdmission(childNode, childPath, childUnsafe) === "tracked")
+        walkDataPaths(childNode, childPath, visits, mode, childChains, childIgnored, childUnsafe);
+      continue;
+    }
+    if (admissionLane(childNode) === "untracked") continue;
+    walkDataPaths(childNode, childPath, visits, mode, childChains, childIgnored, childUnsafe);
   }
 };
+var assertSafeDataPaths = (value, path, visits, mode = "admission", chains = []) => {
+  walkDataPaths(
+    value,
+    path,
+    visits,
+    mode,
+    chains,
+    chains.some((residual) => residual?.ignored === true),
+    chains.some((residual) => residual?.unsafe === true)
+  );
+};
+var certifyCurrentAssignment = (target, prop, resolved) => {
+  if (typeof prop !== "string") return;
+  const assignments = currentStatuses();
+  if (assignments === void 0) return;
+  const path = [prop];
+  for (const assignment of assignments) {
+    if (!assignment.handle.strict || assignment.ignored || assignment.unsafe) continue;
+    if (typeof resolved === "function") {
+      const parentKind = classifyValue(rawTargetOf7(target));
+      if (parentKind !== "plain" && parentKind !== "plainArray")
+        throw rejectionError(rawTargetOf7(target), parentKind, path);
+      continue;
+    }
+    const decision = admissionDecision(resolved);
+    if (decision.lane === "dangerous") throw rejectionError(resolved, decision.kind, path);
+    if (decision.lane === "tracked")
+      walkDataPaths(
+        resolved,
+        path,
+        /* @__PURE__ */ new Set(),
+        "admission",
+        assignment.chains,
+        assignment.ignored,
+        assignment.unsafe
+      );
+  }
+};
+var writesThroughAccessor = (target, property) => {
+  let holder = target;
+  while (holder !== null) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(holder, property);
+    if (descriptor !== void 0) return !("value" in descriptor);
+    holder = Reflect.getPrototypeOf(holder);
+  }
+  return false;
+};
+var refusesWrite = (target, property, value) => {
+  if (Array.isArray(target)) {
+    if (property === "length") {
+      const coercible = value === null || typeof value !== "object" && typeof value !== "function";
+      const newLength = coercible ? Number(value) : Number.NaN;
+      if (Number.isInteger(newLength) && newLength >= 0 && newLength < target.length) {
+        for (const key of Reflect.ownKeys(target)) {
+          if (typeof key !== "string") continue;
+          const index = Number(key);
+          if (Number.isInteger(index) && index >= newLength && index < 2 ** 32 - 1 && String(index) === key && Reflect.getOwnPropertyDescriptor(target, key)?.configurable !== true)
+            return true;
+        }
+      }
+    } else if (typeof property === "string") {
+      const index = Number(property);
+      if (Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === property && index >= target.length && Reflect.getOwnPropertyDescriptor(target, "length")?.writable === false)
+        return true;
+    }
+  }
+  let holder = target;
+  while (holder !== null) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(holder, property);
+    if (descriptor !== void 0) {
+      if ("value" in descriptor) {
+        if (descriptor.writable !== true) return true;
+        return holder !== target && !Object.isExtensible(target);
+      }
+      return descriptor.set === void 0;
+    }
+    holder = Reflect.getPrototypeOf(holder);
+  }
+  return !Object.isExtensible(target);
+};
+function canProxy2(value, parentTarget, unsafe = false) {
+  if (typeof value !== "object" || value === null) return false;
+  if (admissionLane(value) === "tracked") return true;
+  if (unsafe) return true;
+  if (proxyStateMap14.has(value)) return true;
+  const rootHandle = handleOwning(value);
+  if (rootHandle !== void 0 && rawTargetOf7(rootHandle.proxy.root) === rawTargetOf7(value) && (!rootHandle.strict || rootHandle.declarations?.unsafe === true))
+    return true;
+  if (parentTarget === void 0) return false;
+  const handles = handlesOf(parentTarget);
+  return handles.length === 1 && handles[0]?.strict === false && admissionLane(value) === "dangerous";
+}
+var MissingMutationTrapError = class extends Error {
+  constructor() {
+    super("opshot: valtio default handler is missing a mutation trap");
+    this.name = "MissingMutationTrapError";
+  }
+};
+var canProxyCurrentAssignment = (value) => {
+  const assignments = currentStatuses();
+  if (assignments === void 0) return canProxy2(value, currentSetParentOf());
+  const judging = assignments.filter((assignment) => !assignment.ignored);
+  if (judging.length === 0) return false;
+  return canProxy2(
+    value,
+    currentSetParentOf(),
+    judging.every((assignment) => assignment.unsafe || !assignment.handle.strict)
+  );
+};
+var truncatedOccupantsOf = (target, prop, next) => {
+  if (!Array.isArray(target) || prop !== "length") return void 0;
+  const coercible = next === null || typeof next !== "object" && typeof next !== "function";
+  const newLength = coercible ? Number(next) : Number.NaN;
+  if (!Number.isInteger(newLength) || newLength < 0 || newLength >= target.length) return void 0;
+  const truncated = new Array();
+  for (let index = newLength; index < target.length; index++) {
+    const occupant = Reflect.get(target, index);
+    if (typeof occupant === "object" && occupant !== null) truncated.push({ index, occupant });
+  }
+  return truncated;
+};
+var commitSetInEdges = (target, prop, previous, next, truncated) => {
+  const handles = handlesOf(target);
+  if (handles.length === 0) return;
+  if (truncated !== void 0) {
+    for (const { index, occupant } of truncated) {
+      for (const handle of handles) removeInEdge(handle, occupant, target, index);
+    }
+    return;
+  }
+  if (typeof prop !== "string") return;
+  const key = segmentForProp(target, prop);
+  const previousObject = typeof previous === "object" && previous !== null ? previous : void 0;
+  const nextObject = typeof next === "object" && next !== null && admissionLane(next) !== "untracked" ? next : void 0;
+  for (const handle of handles) {
+    if (isIgnoredFrontier(handle, target, key)) {
+      if (previousObject !== void 0) removeInEdge(handle, previousObject, target, key);
+      continue;
+    }
+    if (previousObject !== void 0) removeInEdge(handle, previousObject, target, key);
+    if (nextObject === void 0) continue;
+    const rawNext = rawTargetOf7(nextObject);
+    const wasOccupied = rawNext === rawTargetOf7(handle.proxy.root) || (handle.nodes.get(rawNext)?.edges.length ?? 0) > 0;
+    addInEdge(handle, nextObject, target, key);
+    if (wasOccupied) continue;
+    const slot = slotStatusOf(handle, target, key);
+    seedInEdgesUnder(handle, nextObject, slot.chains);
+  }
+};
+var commitDeleteInEdges = (target, prop, previous) => {
+  if (typeof prop !== "string") return;
+  if (typeof previous !== "object" || previous === null) return;
+  const key = segmentForProp(target, prop);
+  for (const handle of handlesOf(target)) removeInEdge(handle, previous, target, key);
+};
 var installed = false;
 function installBoundary() {
   if (installed) return;
   installed = true;
-  unstable_replaceInternalFunction("canProxy", () => (value) => {
-    if (typeof value !== "object" || value === null) return false;
-    const lane = admissionLane(value);
-    if (lane !== "reject") return lane === "track";
-    const kind = classifyValue(value);
-    if (kind === "plain" || kind === "plainArray") return true;
-    throw rejectionError(value, kind);
-  });
+  unstable_replaceInternalFunction("canProxy", () => (value) => canProxyCurrentAssignment(value));
   unstable_replaceInternalFunction("createSnapshot", () => createSnapshotPreservingAccessors);
   unstable_replaceInternalFunction(
     "createHandler",
     (createHandler2) => (isInitializing, addPropListener, removePropListener, notifyUpdate) => {
-      let setDepth = 0;
       const handler = createHandler2(isInitializing, addPropListener, removePropListener, notifyUpdate);
       const defaultDelete = handler.deleteProperty;
       const defaultSet = handler.set;
-      if (!defaultDelete || !defaultSet)
-        throw new Error("opshot: valtio default handler is missing a mutation trap");
+      if (!defaultDelete || !defaultSet) throw new MissingMutationTrapError();
       return {
         ...handler,
-        deleteProperty(target, prop) {
-          const rootGraphs = getRootGraphs(target);
-          const previousChild = rootGraphs.length > 0 ? getEnumerableDataChild(target, prop) : void 0;
-          const hadOwn = Object.hasOwn(target, prop);
-          const deleted = defaultDelete(target, prop);
-          if (deleted && hadOwn && previousChild && !Object.hasOwn(target, prop))
-            for (const graph of rootGraphs) recomputeRootGraph(graph);
-          return deleted;
-        },
         set(target, prop, value, receiver) {
           const assigned = value;
-          if (prop === "__proto__") throw reservedDataPathError(["__proto__"]);
-          if (prop === "prototype" && constructorPathTargetCount(target) > 0)
-            throw reservedDataPathError(["constructor", "prototype"]);
-          if (prop === "constructor" && typeof assigned === "object" && assigned !== null) {
-            const prototypeDescriptor = Reflect.getOwnPropertyDescriptor(assigned, "prototype");
-            if (prototypeDescriptor?.enumerable) throw reservedDataPathError(["constructor", "prototype"]);
-          }
-          assertSafeDataPaths(assigned, typeof prop === "string" ? [prop] : []);
-          if (typeof assigned === "object" && assigned !== null) {
-            const untracked = getUntracked(assigned) ?? assigned;
-            if (getRegisteredTarget(untracked) !== void 0) throw snapshotDonationError(prop);
-          }
-          const rootGraphs = getRootGraphs(target);
-          const previousChild = rootGraphs.length > 0 ? getEnumerableDataChild(target, prop) : void 0;
-          const previousLength = rootGraphs.length > 0 && Array.isArray(target) && prop === "length" ? Reflect.get(target, "length") : void 0;
-          setDepth += 1;
+          const resolved = peelSnapshotsAndReadProxies(assigned);
+          const truncated = truncatedOccupantsOf(target, prop, resolved);
+          const previous = typeof prop === "string" ? Reflect.get(target, prop) : void 0;
+          const initializing = isInitializing();
+          setFrameStack.push({ target, prop, statuses: statusesForFrame(target, prop, initializing) });
           try {
-            const written = defaultSet(target, prop, value, receiver);
-            const currentChild = rootGraphs.length > 0 ? getEnumerableDataChild(target, prop) : void 0;
-            const currentLength = previousLength === void 0 ? void 0 : Reflect.get(target, "length");
-            if (previousChild !== currentChild || previousLength !== currentLength)
-              for (const graph of rootGraphs) recomputeRootGraph(graph);
-            return written;
+            if (typeof resolved === "object" && resolved !== null) {
+              if (getRegisteredTarget(resolved) !== void 0) throw snapshotDonationError(prop);
+              if (refusesWrite(target, prop, resolved)) return false;
+              if (!initializing && !writesThroughAccessor(target, prop))
+                certifyCurrentAssignment(target, prop, resolved);
+              const alreadyTracked = proxyStateMap14.has(resolved) || proxyCache3.has(resolved);
+              const instrumented = !alreadyTracked && canProxyCurrentAssignment(resolved) ? proxy(resolved) : resolved;
+              const result2 = defaultSet(target, prop, instrumented, receiver);
+              if (result2 && !initializing) commitSetInEdges(target, prop, previous, instrumented, truncated);
+              return result2;
+            }
+            if (refusesWrite(target, prop, resolved)) return false;
+            if (!initializing && typeof resolved === "function" && !writesThroughAccessor(target, prop))
+              certifyCurrentAssignment(target, prop, resolved);
+            const result = defaultSet(target, prop, resolved, receiver);
+            if (result && !initializing) commitSetInEdges(target, prop, previous, resolved, truncated);
+            return result;
           } finally {
-            setDepth -= 1;
+            setFrameStack.pop();
           }
         },
+        deleteProperty(target, prop) {
+          const previous = typeof prop === "string" ? Reflect.get(target, prop) : void 0;
+          const result = defaultDelete(target, prop);
+          if (result && !isInitializing()) commitDeleteInEdges(target, prop, previous);
+          return result;
+        },
         defineProperty(target, prop, descriptor) {
-          if (setDepth > 0 || isInitializing()) return Reflect.defineProperty(target, prop, descriptor);
-          throw new Error(
-            "opshot: defineProperty is not supported on tracked state; define properties in the createMutableState input"
-          );
+          return Reflect.defineProperty(target, prop, descriptor);
         },
-        setPrototypeOf() {
-          throw new Error("opshot: setPrototypeOf is not supported on tracked state");
+        setPrototypeOf(target, proto) {
+          return Reflect.setPrototypeOf(target, proto);
+        },
+        preventExtensions(target) {
+          return Reflect.preventExtensions(target);
         }
       };
     }
@@ -1194,180 +2451,299 @@ function installBoundary() {
 }
 
 // src/createMutableState.ts
-function createMutableState(properties, group) {
+var isIgnoredWrapper = (value) => typeof value === "object" && value !== null && Object.hasOwn(value, ignoreMarker);
+var isUnsafeWrapper = (value) => typeof value === "object" && value !== null && Object.hasOwn(value, unsafeMarker);
+var consumeMarkerTree = (node, path, walk) => {
+  if (Object.isFrozen(node)) return;
+  const firstPath = walk.firstOccupancyByNode.get(node);
+  if (firstPath !== void 0) {
+    const laterOccupancies = walk.laterOccupanciesByNode.get(node);
+    if (laterOccupancies === void 0) walk.laterOccupanciesByNode.set(node, [path]);
+    else laterOccupancies.push(path);
+    return;
+  }
+  walk.firstOccupancyByNode.set(node, path);
+  for (const entry of walkDataEntries(node)) {
+    const childPath = appendOperationPath(path, segmentFor(node, entry.key));
+    const next = unwrapValue(entry.value, childPath, walk);
+    if (!Object.is(next, entry.value) && entry.writable) Reflect.set(node, entry.key, next);
+  }
+};
+var unwrapValue = (value, path, walk) => {
+  let current = value;
+  while (isIgnoredWrapper(current) || isUnsafeWrapper(current)) {
+    const node = declarationAtPath(walk.trie, path);
+    walk.marked = true;
+    if (isIgnoredWrapper(current)) {
+      node.ignored = true;
+      current = current[ignoreMarker];
+    } else {
+      node.unsafe = true;
+      current = current[unsafeMarker];
+    }
+  }
+  if (typeof current === "object" && current !== null) consumeMarkerTree(current, path, walk);
+  return current;
+};
+var trieAtPath = (trie, path) => {
+  let current = trie;
+  for (const segment of path) {
+    current = current.children.get(String(segment));
+    if (current === void 0) return void 0;
+  }
+  return current;
+};
+var applyCopiedMarkerPaths = (walk) => {
+  for (const [node, firstPath] of walk.firstOccupancyByNode) {
+    const laterOccupancies = walk.laterOccupanciesByNode.get(node);
+    if (laterOccupancies === void 0) continue;
+    const source = trieAtPath(walk.trie, firstPath);
+    if (source === void 0 || source.children.size === 0) continue;
+    for (const laterPath of laterOccupancies) {
+      graftDeclarationChildren(source, declarationAtPath(walk.trie, laterPath));
+    }
+  }
+};
+function createMutableState(properties, options) {
   installBoundary();
-  assertSafeDataPaths(properties);
-  const base = Object.create(Reflect.getPrototypeOf(properties));
-  Object.defineProperties(base, Object.getOwnPropertyDescriptors(properties));
-  const proxied = proxy(base);
-  registerTrackedRoot(base);
-  if (group !== void 0) {
-    mintGroupedEmitter(proxied, getGroupListeners(group));
+  const trie = createDeclarationTrie();
+  let marked = false;
+  let root = properties;
+  while (isIgnoredWrapper(root) || isUnsafeWrapper(root)) {
+    if (isIgnoredWrapper(root)) {
+      trie.ignored = true;
+      marked = true;
+      root = root[ignoreMarker];
+    } else {
+      trie.unsafe = true;
+      marked = true;
+      root = root[unsafeMarker];
+    }
   }
-  return proxied;
+  if (trie.ignored) return root;
+  if (typeof root !== "object" || root === null) return root;
+  if (Object.isFrozen(root)) return root;
+  if (isState(root)) {
+    const peeled = peelReadProxy(root);
+    if (typeof peeled === "object" && peeled !== null) return peeled;
+  }
+  const decision = admissionDecision(root);
+  const strict = options?.strict !== false;
+  if (decision.lane === "leaf") return root;
+  const base = Object.create(Reflect.getPrototypeOf(root));
+  Object.defineProperties(base, Object.getOwnPropertyDescriptors(root));
+  const walk = {
+    trie,
+    marked,
+    firstOccupancyByNode: /* @__PURE__ */ new Map(),
+    laterOccupanciesByNode: /* @__PURE__ */ new Map()
+  };
+  consumeMarkerTree(base, createOperationPath([]), walk);
+  applyCopiedMarkerPaths(walk);
+  const declarations = walk.marked || hasDeclarations(trie) ? trie : void 0;
+  if (decision.lane === "dangerous" && strict && declarations?.unsafe !== true) {
+    throw rejectionError(base, decision.kind);
+  }
+  assertSafeDataPaths(base, [], /* @__PURE__ */ new Set(), strict ? "admission" : "rootsOnly", [declarations]);
+  const handle = {
+    proxy: { root: base },
+    lastSnapshot: base,
+    hasPendingWrites: false,
+    isFlushScheduled: false,
+    isFlushHeld: false,
+    flushGeneration: 0,
+    subscribers: /* @__PURE__ */ new Map(),
+    groups: options?.group !== void 0 ? getGroupChain(options.group) : void 0,
+    emitOn: options?.emitOn,
+    strict,
+    declarations,
+    nodes: /* @__PURE__ */ new WeakMap(),
+    byId: /* @__PURE__ */ new Map(),
+    nextInternId: 1,
+    stamp: {},
+    version: 0,
+    replaying: false
+  };
+  registerHandle(base, handle);
+  handle.nodes.set(base, { edges: [], id: 0 });
+  handle.byId.set(0, base);
+  const instrumented = proxy({ root: base });
+  handle.proxy = instrumented;
+  handle.lastSnapshot = requireObjectSnapshot(snapshot(instrumented.root));
+  seedInEdges(handle);
+  seedOccupancies(handle);
+  armWatch(handle);
+  return instrumented.root;
 }
 
 // src/createGroup.ts
-var groupListenersByGroup = /* @__PURE__ */ new WeakMap();
+var UnknownGroupError = class extends Error {
+  constructor() {
+    super("opshot: unknown group");
+    this.name = "UnknownGroupError";
+  }
+};
+var groupChainByGroup = /* @__PURE__ */ new WeakMap();
 function isGroup(value) {
-  return typeof value === "object" && value !== null && groupListenersByGroup.has(value);
+  return typeof value === "object" && value !== null && groupChainByGroup.has(value);
 }
 function getGroupListeners(group) {
-  const listeners = groupListenersByGroup.get(group);
-  if (listeners === void 0) throw new Error("opshot: unknown group");
+  const chain = groupChainByGroup.get(group);
+  const listeners = chain?.at(-1);
+  if (listeners === void 0) throw new UnknownGroupError();
   return listeners;
 }
-function createGroup() {
+function getGroupChain(group) {
+  const chain = groupChainByGroup.get(group);
+  if (chain === void 0) throw new UnknownGroupError();
+  return chain;
+}
+function createGroup(parent) {
+  if (parent !== void 0 && !isGroup(parent)) {
+    throw new Error("opshot: parent is not a group");
+  }
   const listeners = /* @__PURE__ */ new Map();
   const group = {
-    createMutableState(properties) {
-      return createMutableState(properties, group);
+    createMutableState(properties, options) {
+      return createMutableState(properties, { ...options, group });
     }
   };
-  groupListenersByGroup.set(group, listeners);
+  const chain = parent === void 0 ? [listeners] : [...getGroupChain(parent), listeners];
+  groupChainByGroup.set(group, chain);
   return group;
 }
 
 // src/emit/emitterListeners.ts
-function addStateListener(state, listener, channelId, deliver2) {
-  const target = resolveEmitterTarget(state);
-  const record = getOrCreateEmitter(target);
-  if (record.disarm === void 0 && record.groupListeners === void 0) {
-    armWatchdog(record);
+var bindings = /* @__PURE__ */ new WeakMap();
+var dropListenerChannel = (byListener, listener, channelId, unsubscribe) => {
+  const channels = byListener.get(listener);
+  if (channels?.has(channelId) !== true) {
+    bindings.delete(unsubscribe);
+    return;
   }
-  let byChannel = record.listeners.get(listener);
+  channels.delete(channelId);
+  if (channels.size === 0) byListener.delete(listener);
+  bindings.delete(unsubscribe);
+};
+function addStateListener(state, listener, channelId, deliver) {
+  const handle = requireHandle(state, "opshot: subscribe requires a state");
+  let byChannel = handle.subscribers.get(listener);
   if (byChannel === void 0) {
     byChannel = /* @__PURE__ */ new Map();
-    record.listeners.set(listener, byChannel);
+    handle.subscribers.set(listener, byChannel);
   }
-  byChannel.set(channelId, deliver2);
-  return () => {
-    const channels = record.listeners.get(listener);
-    if (channels?.has(channelId) !== true) return;
-    settlePendingBare(record);
-    channels.delete(channelId);
-    if (channels.size === 0) record.listeners.delete(listener);
-    if (record.groupListeners === void 0 && record.listeners.size === 0) {
-      disarmWatchdog(record);
-      deleteEmitter(target);
-    }
+  byChannel.set(channelId, deliver);
+  const unsubscribe = () => {
+    const held = bindings.get(unsubscribe);
+    if (held === void 0) return;
+    dropListenerChannel(held.handle.subscribers, held.listener, held.channelId, unsubscribe);
   };
+  bindings.set(unsubscribe, { handle, listener, channelId });
+  return unsubscribe;
 }
-function addGroupListener(groupListeners, listener, channelId, deliver2) {
+function addGroupListener(groupListeners, listener, channelId, deliver) {
   let byChannel = groupListeners.get(listener);
   if (byChannel === void 0) {
     byChannel = /* @__PURE__ */ new Map();
     groupListeners.set(listener, byChannel);
   }
-  byChannel.set(channelId, deliver2);
-  return () => {
-    const channels = groupListeners.get(listener);
-    if (channels?.has(channelId) !== true) return;
-    channels.delete(channelId);
-    if (channels.size === 0) groupListeners.delete(listener);
+  byChannel.set(channelId, deliver);
+  const unsubscribe = () => {
+    const held = bindings.get(unsubscribe);
+    if (held === void 0) return;
+    dropListenerChannel(held.listeners, held.listener, held.channelId, unsubscribe);
   };
+  bindings.set(unsubscribe, { listeners: groupListeners, listener, channelId });
+  return unsubscribe;
 }
 
-// src/transact.ts
-function transact(state, mutate, meta) {
-  const record = getEmitter(state);
-  if (record === void 0) {
-    mutate();
-    return;
+// src/emit/resolveWriteProxy.ts
+var { proxyStateMap: proxyStateMap15 } = unstable_getInternalStates();
+var ExpectedStateObjectError = class extends Error {
+  constructor() {
+    super("opshot: expected a state object");
+    this.name = "ExpectedStateObjectError";
   }
-  if (record.isMutating) throw new Error("opshot: nested transact on the same state");
-  settlePendingBare(record);
-  record.isMutating = true;
-  try {
-    mutate();
-  } finally {
-    record.isMutating = false;
+};
+var isObjectLike4 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+function resolveWriteProxy(state) {
+  let current = state;
+  while (isObjectLike4(current)) {
+    if (proxyStateMap15.has(current)) return current;
+    const peeled = peelIdentityLayer(current);
+    if (peeled === void 0) break;
+    current = peeled;
   }
-  const after = snapshot(record.target);
-  const before = record.lastReported;
-  record.lastReported = after;
-  if (before === after) return;
-  if (!hasListeners(record)) return;
-  const ops = diffSnapshots(requireObjectSnapshot(before), requireObjectSnapshot(after));
-  if (ops.length === 0) return;
-  deliver(record, ops, meta);
+  if (!isObjectLike4(current) || !proxyStateMap15.has(current)) throw new ExpectedStateObjectError();
+  return current;
 }
 
-// src/ops/applyOps.ts
-var isObjectLike4 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-var sameValueZero = (first, second) => first === second || first !== first && second !== second;
-var sameIdentity = (first, second) => sameValueZero(resolveIdentity(first), resolveIdentity(second));
-var assertApplicable = (operation) => {
-  if (typeof operation === "object" && operation !== null && "do" in operation) {
-    throw new Error("opshot: applyOps applies operation halves; pass op.do or op.undo.");
-  }
-  if (!isOperation(operation)) {
-    throw new Error(
-      "opshot: this op is a copy (spread, JSON, or structuredClone) and has lost its value. Apply the op objects the listener delivered; never copy them."
-    );
-  }
+// src/transact/nest.ts
+var transactionOpen = false;
+var isTransactionOpen = () => transactionOpen;
+var openTransaction = () => {
+  transactionOpen = true;
 };
-var unresolvedError = (path) => new Error(`opshot: ${formatOperationPath(path)} does not resolve to a supported operation address`);
-var matchesAppliedValue = (current, expected) => {
-  if (isObjectLike4(current) && isObjectLike4(expected)) return sameIdentity(current, expected);
-  return Object.is(current, expected);
+var closeTransaction = () => {
+  transactionOpen = false;
 };
-var setOrThrow = (target, key, value) => {
-  const written = Reflect.set(target, key, value);
-  const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-  const current = descriptor && "value" in descriptor ? Reflect.get(target, key) : void 0;
-  if (!written || !descriptor || !("value" in descriptor) || !matchesAppliedValue(current, value)) {
-    throw new Error(`opshot: replay could not restore ${String(key)}`);
+
+// src/ops/applyMutations.ts
+var ReplayReattachError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ReplayReattachError";
   }
 };
-var deleteOrThrow = (target, key) => {
-  if (!Reflect.deleteProperty(target, key)) throw new Error(`opshot: replay could not remove ${String(key)}`);
-};
-var restoreRecordedContent = (attached, recorded, restored) => {
+var unresolvedError = (path) => new Error(`opshot: ${formatOperationPath(path)} does not resolve to a supported operation address`);
+var linkError = (path, ref, reason) => new Error(`opshot: link at ${formatOperationPath(path)} with ref ${String(ref)} ${reason}`);
+var isWritableDataDescriptor = (descriptor) => descriptor !== void 0 && "value" in descriptor && descriptor.writable === true;
+var restoreRecordedContent = (attached, recorded, restored, identity) => {
   if (restored.has(recorded)) return;
   restored.add(recorded);
-  const recordedKeys = Reflect.ownKeys(recorded);
-  const orderedKeys = Array.isArray(recorded) ? ["length", ...recordedKeys.filter((key) => key !== "length")] : recordedKeys;
-  for (const key of orderedKeys) {
-    const descriptor = Reflect.getOwnPropertyDescriptor(recorded, key);
+  for (const entry of walkDataEntries(recorded, true)) {
+    const key = entry.key;
     const attachedDescriptor = Reflect.getOwnPropertyDescriptor(attached, key);
-    if (!descriptor || !("value" in descriptor) || attachedDescriptor && !("value" in attachedDescriptor)) continue;
-    const value = descriptor.value;
-    if (isObjectLike4(value)) {
+    if (attachedDescriptor !== void 0 && !isWritableDataDescriptor(attachedDescriptor)) continue;
+    const value = entry.value;
+    if (identity === "restore" && isObjectLike3(value)) {
       const target = getRegisteredTarget(value);
       if (target !== void 0) {
-        setOrThrow(attached, key, target);
+        const present = attachedDescriptor?.value;
+        if (!isObjectLike3(present) || resolveIdentity(present) !== resolveIdentity(target)) {
+          Reflect.set(attached, key, target);
+        }
         const child = Reflect.get(attached, key);
-        if (!isObjectLike4(child)) throw new Error(`opshot: replay could not reattach ${String(key)}`);
-        restoreRecordedContent(child, value, restored);
+        if (!isObjectLike3(child)) throw new ReplayReattachError(`opshot: replay could not reattach ${key}`);
+        restoreRecordedContent(child, value, restored, identity);
         continue;
       }
     }
-    setOrThrow(attached, key, value);
+    Reflect.set(attached, key, value);
   }
-  for (const key of Reflect.ownKeys(attached)) {
-    if (Object.hasOwn(recorded, key)) continue;
-    const descriptor = Reflect.getOwnPropertyDescriptor(attached, key);
-    if (descriptor && "value" in descriptor) deleteOrThrow(attached, key);
+  for (const entry of walkDataEntries(attached)) {
+    if (!entry.writable) continue;
+    if (Object.hasOwn(recorded, entry.key)) continue;
+    Reflect.deleteProperty(attached, entry.key);
   }
 };
-var getValuePayload = (operation) => {
-  const original = getValueOriginal(operation);
-  if (original !== void 0) {
-    if (isObjectLike4(original) && getRegisteredTarget(original) !== void 0)
-      return { recorded: original, fallback: void 0 };
-    return { recorded: original, fallback: operation.value };
-  }
-  return { recorded: operation.value, fallback: operation.value };
+var getValuePayload = (operation, identity) => {
+  const original = identity === "restore" ? getValueOriginal(operation) ?? operation.value : operation.value;
+  return {
+    recorded: original,
+    fallback: isObjectLike3(original) ? cloneValue(original, /* @__PURE__ */ new WeakMap(), operation.path) : original
+  };
 };
-var restoreValue = (payload, attach, readAttached) => {
-  if (isObjectLike4(payload.recorded)) {
+var restoreValue = (payload, attach, readAttached, identity) => {
+  if (identity === "restore" && isObjectLike3(payload.recorded)) {
     const target = getRegisteredTarget(payload.recorded);
     if (target !== void 0) {
       attach(target);
       const attached = readAttached();
-      if (!isObjectLike4(attached)) throw new Error("opshot: replay could not read a reattached target");
-      restoreRecordedContent(attached, payload.recorded, /* @__PURE__ */ new WeakSet());
+      if (!isObjectLike3(attached)) {
+        throw new ReplayReattachError("opshot: replay could not read a reattached target");
+      }
+      restoreRecordedContent(attached, payload.recorded, /* @__PURE__ */ new WeakSet(), identity);
       return;
     }
   }
@@ -1382,14 +2758,9 @@ var getInheritedDescriptor = (target, key) => {
   }
   return void 0;
 };
-var isCanonicalArrayIndex2 = (segment) => Number.isInteger(segment) && typeof segment === "number" && segment >= 0 && segment < 4294967295;
-var isCanonicalArrayIndexString = (segment) => {
-  const index = Number(segment);
-  return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === segment;
-};
 var requirePlainSegment = (parent, segment, path) => {
   if (Array.isArray(parent)) {
-    if (isCanonicalArrayIndex2(segment)) return segment;
+    if (isCanonicalArrayIndex(segment)) return segment;
     if (typeof segment === "string" && !isCanonicalArrayIndexString(segment)) return segment;
     throw unresolvedError(path);
   }
@@ -1404,152 +2775,365 @@ var requirePlainProperty = (parent, segment, path) => {
   return Reflect.get(parent, key);
 };
 var resolveTraversalSegment = (parent, segment, path) => {
-  if (!isObjectLike4(parent)) throw unresolvedError(path);
+  if (!isObjectLike3(parent)) throw unresolvedError(path);
   return requirePlainProperty(parent, segment, path);
 };
 var resolveTerminal = (root, path) => {
-  assertSafePath(path);
-  if (path.length === 0) throw new Error("opshot: root operations are not supported");
+  if (path.length === 0) throw unresolvedError(path);
   let parent = root;
   for (let index = 0; index < path.length - 1; index++) parent = resolveTraversalSegment(parent, path[index], path);
-  if (!isObjectLike4(parent)) throw unresolvedError(path);
+  if (!isObjectLike3(parent)) throw unresolvedError(path);
   return { parent, segment: path[path.length - 1] };
 };
-var applyPlain = (parent, segment, operation) => {
+var applyLink = (root, operation, handle) => {
+  const path = operation.path;
+  const ref = operation.ref;
+  if (path.length === 0) throw linkError(path, ref, "does not resolve to a supported operation address");
+  const resolved = nodeOfInternedId(handle, ref, handle.transactionCapture);
+  if (resolved === void 0) throw linkError(path, ref, "does not resolve");
+  const terminal = resolveTerminal(root, path);
+  if (Array.isArray(terminal.parent) && terminal.segment === "length") {
+    throw linkError(path, ref, "cannot address array length");
+  }
+  const key = requirePlainSegment(terminal.parent, terminal.segment, path);
+  const descriptor = Reflect.getOwnPropertyDescriptor(terminal.parent, key);
+  const present = descriptor !== void 0 && descriptor.enumerable && "value" in descriptor;
+  if (descriptor !== void 0 && !present) throw unresolvedError(path);
+  if (!present) {
+    const inheritedDescriptor = getInheritedDescriptor(terminal.parent, key);
+    if (inheritedDescriptor && !("value" in inheritedDescriptor)) {
+      throw new Error(`opshot: ${formatOperationPath(path)} resolves to an inherited accessor`);
+    }
+  }
+  Reflect.set(terminal.parent, key, resolved);
+};
+var applyPlain = (parent, segment, operation, identity, handle) => {
   const path = operation.path;
   if (Array.isArray(parent) && segment === "length") {
-    if (operation.op !== "replace" || typeof operation.value !== "number" || !Number.isInteger(operation.value) || operation.value < 0 || operation.value > 4294967295) {
+    if (operation.verb !== "assign" || typeof operation.value !== "number" || !Number.isInteger(operation.value) || operation.value < 0 || operation.value > MAX_ARRAY_LENGTH) {
       throw unresolvedError(path);
     }
-    setOrThrow(parent, "length", operation.value);
+    Reflect.set(parent, "length", operation.value);
     return;
   }
   const key = requirePlainSegment(parent, segment, path);
   const descriptor = Reflect.getOwnPropertyDescriptor(parent, key);
   const present = descriptor !== void 0 && descriptor.enumerable && "value" in descriptor;
   if (descriptor !== void 0 && !present) throw unresolvedError(path);
-  if (operation.op === "add" && present) throw unresolvedError(path);
-  if (operation.op !== "add" && !present) throw unresolvedError(path);
-  if (operation.op === "add") {
+  if (operation.verb === "delete") {
+    Reflect.deleteProperty(parent, key);
+    return;
+  }
+  if (!present) {
     const inheritedDescriptor = getInheritedDescriptor(parent, key);
     if (inheritedDescriptor && !("value" in inheritedDescriptor)) {
       throw new Error(`opshot: ${formatOperationPath(path)} resolves to an inherited accessor`);
     }
   }
-  if (operation.op === "remove") {
-    deleteOrThrow(parent, key);
-    return;
-  }
-  if (!("value" in operation)) throw unresolvedError(path);
+  const payload = getValuePayload(operation, identity);
   restoreValue(
-    getValuePayload(operation),
-    (value) => setOrThrow(parent, key, value),
-    () => Reflect.get(parent, key)
+    payload,
+    (value) => Reflect.set(parent, key, value),
+    () => Reflect.get(parent, key),
+    identity
   );
+  const attached = Reflect.get(parent, key);
+  if (!isObjectLike3(attached)) return;
+  if (operation.ids !== void 0) {
+    if (isObjectLike3(payload.recorded)) {
+      bindVendedIds(handle, attached, payload.recorded, operation.ids, handle.transactionCapture, parent, key);
+    }
+  } else {
+    let chains = chainsAtRoot(handle.declarations);
+    for (const segment2 of path) chains = descendChains(chains, segment2).chains;
+    chains = nodeChainsOf(handle, attached) ?? chains;
+    internSubtree(
+      handle,
+      attached,
+      chains,
+      (parent2, parentChains, key2, entry) => isTrackedEdge(entry) ? resolveChildChains(handle, parent2, parentChains, key2, entry.value)?.chains : void 0,
+      handle.transactionCapture
+    );
+  }
+};
+var applyMutation = (root, operation, identity, handle) => {
+  if (operation.verb === "link") {
+    applyLink(root, operation, handle);
+    return;
+  }
+  const terminal = resolveTerminal(root, operation.path);
+  applyPlain(terminal.parent, terminal.segment, operation, identity, handle);
 };
-function applyOperations(root, operations) {
+function applyMutations(root, operations, direction, identity, handle) {
+  if (direction === "do") {
+    for (const operation of operations) applyMutation(root, operation.do, identity, handle);
+    return;
+  }
+  const occupantAt = (path) => {
+    let current = root;
+    for (const segment of path) {
+      if (!isObjectLike3(current)) return void 0;
+      current = Reflect.get(current, segment);
+    }
+    return current;
+  };
+  const admittedRoots = new Array();
   for (const operation of operations) {
-    const terminal = resolveTerminal(root, operation.path);
-    applyPlain(terminal.parent, terminal.segment, operation);
+    if (operation.do.verb !== "assign" || !isObjectLike3(operation.do.value)) continue;
+    const occupant = occupantAt(operation.undo.path);
+    if (isObjectLike3(occupant)) admittedRoots.push(occupant);
+  }
+  for (let index = operations.length - 1; index >= 0; index--) {
+    const operation = operations[index];
+    if (operation === void 0) continue;
+    applyMutation(root, operation.undo, identity, handle);
+  }
+  const idSet = /* @__PURE__ */ new Set();
+  for (const node of admittedRoots) {
+    for (const id of rewindAdmission(handle, node)) idSet.add(id);
+  }
+  while (idSet.has(handle.nextInternId - 1)) handle.nextInternId -= 1;
+}
+
+// src/transact/rollback.ts
+var rollbackTransaction = (handle) => {
+  const restoreTarget = handle.lastSnapshot;
+  const operations = diffObjects(snapshot(handle.proxy.root), restoreTarget, handle, void 0, createCaptureTables());
+  if (operations.length > 0) {
+    applyMutations(handle.proxy.root, operations, "do", "restore", handle);
+  }
+  handle.lastSnapshot = restoreTarget;
+  handle.hasPendingWrites = false;
+};
+
+// src/transact/transact.ts
+function transact(state, mutate, meta) {
+  runTransaction(state, mutate, meta, void 0);
+}
+var attachRollbackCause = (error, rollbackError) => {
+  if (!(error instanceof Error) || error.cause !== void 0) return;
+  Object.defineProperty(error, "cause", {
+    value: rollbackError,
+    writable: true,
+    enumerable: false,
+    configurable: true
+  });
+};
+var flattenDeliveryFailures = (error) => {
+  if (error instanceof AggregateError && error.message === "opshot: listeners failed during delivery") {
+    return error.errors;
+  }
+  return [error];
+};
+var releaseUncaught = (failures) => {
+  if (failures.length === 0) return;
+  const error = failures.length === 1 ? failures[0] : new AggregateError(failures, "opshot: listeners failed during delivery");
+  queueMicrotask(() => {
+    throw error;
+  });
+};
+function runTransaction(state, mutate, meta, channelId) {
+  if (isTransactionOpen()) {
+    throw new Error(
+      "opshot: transact cannot be nested; a transaction cannot contain another. Mutate inside the callback rather than transacting, run transactions in sequence, or call applyOperations at top level."
+    );
+  }
+  const handle = requireHandle(state, "opshot: transact requires a state");
+  handle.flushGeneration += 1;
+  handle.isFlushScheduled = false;
+  const listenerFailures = new Array();
+  const emitCollectingListeners = (emit) => {
+    const baseline = handle.lastSnapshot;
+    try {
+      emit();
+    } catch (error) {
+      if (handle.lastSnapshot === baseline) throw error;
+      listenerFailures.push(...flattenDeliveryFailures(error));
+    }
+  };
+  const deliverQuietly = (ranges) => {
+    try {
+      deliverCapturedRanges(ranges);
+    } catch (error) {
+      listenerFailures.push(...flattenDeliveryFailures(error));
+    }
+  };
+  try {
+    const starting = captureWrites(handle);
+    const previousHeld = handle.isFlushHeld;
+    handle.isFlushHeld = true;
+    handle.transactionCapture = createCaptureTables();
+    openTransaction();
+    let completed = false;
+    let mutateError;
+    try {
+      mutate();
+      completed = true;
+    } catch (error) {
+      mutateError = error;
+      throw error;
+    } finally {
+      closeTransaction();
+      if (!completed) {
+        try {
+          rollbackTransaction(handle);
+        } catch (rollbackError) {
+          attachRollbackCause(mutateError, rollbackError);
+        }
+        handle.transactionCapture = void 0;
+        handle.isFlushHeld = previousHeld;
+        deliverQuietly([starting]);
+      } else {
+        handle.isFlushHeld = previousHeld;
+      }
+    }
+    let transaction;
+    try {
+      transaction = captureTransactionWrites(handle, meta, channelId);
+    } catch (error) {
+      try {
+        rollbackTransaction(handle);
+      } catch (rollbackError) {
+        attachRollbackCause(error, rollbackError);
+      }
+      deliverQuietly([starting]);
+      throw error;
+    } finally {
+      handle.transactionCapture = void 0;
+    }
+    deliverQuietly([starting, transaction]);
+    emitCollectingListeners(() => {
+      emitWrites(handle);
+    });
+  } finally {
+    releaseUncaught(listenerFailures);
+  }
+}
+
+// src/ops/applyOperations.ts
+var originError = () => new Error("opshot: applyOperations applies a state's operations only to that state");
+var tapeError = () => new Error("opshot: applyOperations applies only the next or previous operations");
+var isFrozenCopyablePath = (value) => Array.isArray(value) && value.every((segment) => typeof segment === "string" || typeof segment === "number");
+var isNonNegativeInteger = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
+var isWellFormedLinkHalf = (value) => typeof value === "object" && value !== null && "verb" in value && value.verb === "link" && "path" in value && "ref" in value && isFrozenCopyablePath(value.path) && isNonNegativeInteger(value.ref);
+var isWellFormedDeleteHalf = (value) => typeof value === "object" && value !== null && "verb" in value && value.verb === "delete" && "path" in value && isFrozenCopyablePath(value.path);
+var isWellFormedIds = (value) => value === void 0 || Array.isArray(value) && value.every((id) => typeof id === "number" && Number.isInteger(id) && id >= 0);
+var isWellFormedAssignHalf = (value) => typeof value === "object" && value !== null && "verb" in value && value.verb === "assign" && "value" in value && "path" in value && isFrozenCopyablePath(value.path) && (!("ids" in value) || value.ids === void 0 || isWellFormedIds(value.ids));
+var isApplicableHalf = (value) => isMutation(value) || isWellFormedLinkHalf(value) || isWellFormedDeleteHalf(value) || isWellFormedAssignHalf(value);
+var assertApplicable = (operation) => {
+  if (isMutation(operation)) {
+    throw new Error("opshot: applyOperations applies operation pairs; pass the operation, with a direction");
+  }
+  if (typeof operation !== "object" || operation === null || !("do" in operation) || !("undo" in operation) || !isApplicableHalf(operation.do) || !isApplicableHalf(operation.undo)) {
+    throw new Error("opshot: applyOperations applies well-formed { do, undo } pairs");
   }
+};
+function applyOperations(state, operations, direction, meta) {
+  runOperations(state, operations, direction, meta, void 0);
 }
-function applyOps(state, operations, meta) {
+function runOperations(state, operations, direction, meta, channelId) {
   for (const operation of operations) assertApplicable(operation);
-  transact(
-    state,
-    () => {
-      applyOperations(resolveEmitterTarget(state), operations);
-    },
-    meta
-  );
+  const appliedDirection = direction;
+  if (appliedDirection !== "do" && appliedDirection !== "undo") {
+    throw new Error('opshot: applyOperations applies a direction of "do" or "undo"');
+  }
+  if (isTransactionOpen()) {
+    throw new Error(
+      "opshot: transact cannot be nested; a transaction cannot contain another. Mutate inside the callback rather than transacting, run transactions in sequence, or call applyOperations at top level."
+    );
+  }
+  const handle = requireHandle(state, "opshot: applyOperations requires a state");
+  emitWrites(handle);
+  let ownedCount = 0;
+  for (const operation of operations) {
+    const stamp = stampOf(operation);
+    if (stamp !== void 0 && stamp !== handle.stamp) throw originError();
+    if (stamp === handle.stamp) ownedCount += 1;
+  }
+  if (ownedCount > 0 && ownedCount < operations.length) throw originError();
+  const owned = operations.length > 0 && ownedCount === operations.length;
+  if (owned) {
+    let index = 0;
+    for (const operation of operations) {
+      const expected = direction === "do" ? handle.version + 1 + index : handle.version - (operations.length - 1 - index);
+      if (versionOf(operation) !== expected) throw tapeError();
+      index += 1;
+    }
+  }
+  handle.replaying = true;
+  try {
+    runTransaction(
+      state,
+      () => {
+        applyMutations(resolveWriteProxy(state), operations, direction, owned ? "restore" : "construct", handle);
+        if (owned) {
+          handle.version = direction === "do" ? handle.version + operations.length : handle.version - operations.length;
+        }
+      },
+      meta,
+      channelId
+    );
+  } finally {
+    handle.replaying = false;
+  }
 }
 
 // src/subscribe.ts
 function subscribe2(target, listener) {
   if (isGroup(target)) {
-    return addGroupListener(getGroupListeners(target), listener, void 0, (state, ops, meta) => {
-      listener(state, ops, unwrapTransportMeta(meta));
-    });
+    return addGroupListener(
+      getGroupListeners(target),
+      listener,
+      void 0,
+      (state, ops, meta) => listener(state, ops, meta)
+    );
   }
-  return addStateListener(target, listener, void 0, (ops, meta) => {
-    listener(ops, unwrapTransportMeta(meta));
-  });
-}
-var channelStampBrand = /* @__PURE__ */ Symbol.for("opshot.channelStamp");
-function stampChannelMeta(channelId, meta) {
-  return { [channelStampBrand]: channelId, meta };
-}
-function isChannelStamp(value) {
-  return typeof value === "object" && value !== null && channelStampBrand in value;
-}
-function isOwnChannelStamp(value, channelId) {
-  return isChannelStamp(value) && value[channelStampBrand] === channelId;
-}
-function unwrapTransportMeta(meta) {
-  if (isChannelStamp(meta)) return meta.meta;
-  return meta;
+  return addStateListener(target, listener, void 0, (ops, meta) => listener(ops, meta));
 }
-function toChannelContext(channelId, defaults, meta) {
-  if (isOwnChannelStamp(meta, channelId)) {
-    return { isTransaction: true, meta: { ...defaults, ...meta.meta } };
+function toChannelContext(channelId, defaults, meta, deliveredChannelId) {
+  if (deliveredChannelId === channelId) {
+    return {
+      isTransaction: true,
+      meta: { ...defaults, ...typeof meta === "object" && meta !== null ? meta : void 0 }
+    };
   }
-  return { isTransaction: false, meta: unwrapTransportMeta(meta) };
+  return { isTransaction: false, meta };
 }
 
 // src/createChannel.ts
 function createChannel(defaults) {
   const channelId = Object.freeze({});
   function transact2(state, mutate, meta) {
-    transact(state, mutate, stampChannelMeta(channelId, meta));
+    runTransaction(state, mutate, meta, channelId);
   }
   function subscribe3(target, listener) {
     if (isGroup(target)) {
-      return addGroupListener(getGroupListeners(target), listener, channelId, (state, ops, meta) => {
-        listener(
-          state,
-          ops,
-          toChannelContext(channelId, defaults, meta)
-        );
-      });
+      return addGroupListener(
+        getGroupListeners(target),
+        listener,
+        channelId,
+        (state, ops, meta, deliveredChannelId) => {
+          listener(
+            state,
+            ops,
+            toChannelContext(channelId, defaults, meta, deliveredChannelId)
+          );
+        }
+      );
     }
-    return addStateListener(target, listener, channelId, (ops, meta) => {
+    return addStateListener(target, listener, channelId, (ops, meta, deliveredChannelId) => {
       listener(
         ops,
-        toChannelContext(channelId, defaults, meta)
+        toChannelContext(channelId, defaults, meta, deliveredChannelId)
       );
     });
   }
-  function applyOps2(state, operations, meta) {
-    applyOps(state, operations, stampChannelMeta(channelId, meta));
-  }
-  return { transact: transact2, subscribe: subscribe3, applyOps: applyOps2 };
-}
-
-// src/react/resolveWrapper.ts
-var { proxyStateMap: proxyStateMap5 } = unstable_getInternalStates();
-var isObjectLike5 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-function unwrapWrapper(value) {
-  if (!isObjectLike5(value) || proxyStateMap5.has(value)) return value;
-  let current = value;
-  while (isObjectLike5(current)) {
-    const registeredTarget = getRegisteredWrapperTarget(current);
-    if (registeredTarget === void 0) break;
-    current = registeredTarget;
+  function applyOperations2(state, operations, direction, meta) {
+    runOperations(state, operations, direction, meta, channelId);
   }
-  return current;
-}
-
-// src/isState.ts
-var { proxyStateMap: proxyStateMap6 } = unstable_getInternalStates();
-function isState(value) {
-  const resolved = unwrapWrapper(value);
-  if (typeof resolved !== "object" || resolved === null) return false;
-  return proxyStateMap6.has(resolved);
+  return { transact: transact2, subscribe: subscribe3, applyOperations: applyOperations2 };
 }
 
-// src/ignore.ts
-var ignore = ref;
-
 // src/tracked/facadeGuard.ts
 var assertMutableFacade = (facade, mutationKey) => {
   const facadeSource = getUntracked(facade);
@@ -1561,11 +3145,17 @@ var assertMutableFacade = (facade, mutationKey) => {
 };
 
 // src/tracked/trackedDate.ts
+var DateSetYearError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DateSetYearError";
+  }
+};
 var setLegacyYear = (date, year) => {
   const setYear = Reflect.get(date, "setYear");
-  if (typeof setYear !== "function") throw new Error("opshot: Date.setYear is not available");
+  if (typeof setYear !== "function") throw new DateSetYearError("opshot: Date.setYear is not available");
   const epochMs = Reflect.apply(setYear, date, [year]);
-  if (typeof epochMs !== "number") throw new Error("opshot: Date.setYear returned a non-number");
+  if (typeof epochMs !== "number") throw new DateSetYearError("opshot: Date.setYear returned a non-number");
   return epochMs;
 };
 var constructDate = (args) => {
@@ -1588,6 +3178,11 @@ var constructDate = (args) => {
       return new Date(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
   }
 };
+var MAX_TIME = 864e13;
+var clipTime = (epochMs) => {
+  if (!Number.isFinite(epochMs) || Math.abs(epochMs) > MAX_TIME) return Number.NaN;
+  return Math.trunc(epochMs) + 0;
+};
 var TrackedDate = class {
   constructor(...args) {
     installBoundary();
@@ -1596,6 +3191,9 @@ var TrackedDate = class {
   readDate() {
     return new Date(this.epochMs);
   }
+  readEpochMs() {
+    return clipTime(this.epochMs);
+  }
   write(mutate) {
     assertMutableFacade(this, "epochMs");
     const epochMs = mutate(this.readDate());
@@ -1621,10 +3219,10 @@ var TrackedDate = class {
     return this.readDate().toLocaleTimeString(locales, options);
   }
   valueOf() {
-    return this.readDate().valueOf();
+    return this.readEpochMs();
   }
   getTime() {
-    return this.readDate().getTime();
+    return this.readEpochMs();
   }
   getFullYear() {
     return this.readDate().getFullYear();
@@ -1738,8 +3336,8 @@ var TrackedDate = class {
     return this.readDate().toISOString();
   }
   [Symbol.toPrimitive](hint) {
-    const date = this.readDate();
-    return hint === "number" ? date[Symbol.toPrimitive]("number") : date[Symbol.toPrimitive](hint);
+    if (hint === "number") return this.readEpochMs();
+    return this.readDate()[Symbol.toPrimitive](hint);
   }
 };
 Object.defineProperty(TrackedDate.prototype, Symbol.toStringTag, {
@@ -1750,19 +3348,11 @@ Object.defineProperty(TrackedDate.prototype, Symbol.toStringTag, {
 });
 
 // src/tracked/address.ts
-var internTable = /* @__PURE__ */ new WeakMap();
-var nextInternId = 0;
-var internIdentity = (key) => {
-  const resolved = resolveIdentity(key);
-  if (resolved === null || typeof resolved !== "object" && typeof resolved !== "function" && typeof resolved !== "symbol") {
-    throw new Error("opshot: addressOf interned a non-identity value");
+var UnsupportedKeyTypeError = class extends Error {
+  constructor(key) {
+    super(`opshot: addressOf received unsupported key type ${typeof key}`);
+    this.name = "UnsupportedKeyTypeError";
   }
-  const existing = internTable.get(resolved);
-  if (existing !== void 0) return existing;
-  const id = nextInternId;
-  nextInternId += 1;
-  internTable.set(resolved, id);
-  return id;
 };
 var addressOf = (key) => {
   if (key === null) return "z";
@@ -1785,10 +3375,59 @@ var addressOf = (key) => {
     case "function":
       return `o${internIdentity(key)}`;
     default:
-      throw new Error(`opshot: addressOf received unsupported key type ${typeof key}`);
+      throw new UnsupportedKeyTypeError(key);
   }
 };
 
+// src/tracked/slotStore.ts
+var swapChain = /* @__PURE__ */ new WeakMap();
+var compactStore = (store, addressOfEntry) => {
+  const retired = store.slots;
+  const slots = new Array();
+  const index = {};
+  for (const entry of retired) {
+    if (entry === null || entry === void 0) continue;
+    index[addressOfEntry(entry)] = slots.length;
+    slots.push(entry);
+  }
+  store.slots = slots;
+  store.index = index;
+  swapChain.set(retired, store.slots);
+};
+var translateCursor = (retired, cursor, current) => {
+  let array = retired;
+  let position = cursor;
+  while (array !== current) {
+    const successor = swapChain.get(array);
+    if (successor === void 0) return 0;
+    let survivors = 0;
+    const bound = Math.min(position, array.length);
+    for (let slot = 0; slot < bound; slot += 1) {
+      const entry = array[slot];
+      if (entry !== null && entry !== void 0) survivors += 1;
+    }
+    position = survivors;
+    array = successor;
+  }
+  return position;
+};
+var deleteFromStore = (store, addr, addressOfEntry) => {
+  const slot = store.index[addr];
+  if (slot === void 0) return false;
+  store.slots[slot] = null;
+  Reflect.deleteProperty(store.index, addr);
+  store.count -= 1;
+  if (store.slots.length >= 2 * store.count) {
+    compactStore(store, addressOfEntry);
+  }
+  return true;
+};
+var clearStore = (store) => {
+  store.slots = [];
+  store.index = {};
+  store.count = 0;
+};
+
 // src/tracked/iterateSlots.ts
 function* iterateSlots(getSlots) {
   let slots = getSlots();
@@ -1796,8 +3435,8 @@ function* iterateSlots(getSlots) {
   for (; ; ) {
     const current = getSlots();
     if (current !== slots) {
+      index = translateCursor(slots, index, current);
       slots = current;
-      index = 0;
     }
     if (index >= slots.length) return;
     const entry = slots[index];
@@ -1806,22 +3445,18 @@ function* iterateSlots(getSlots) {
   }
 }
 
-// src/tracked/slotStore.ts
-var deleteFromStore = (store, addr) => {
-  const slot = store.index[addr];
-  if (slot === void 0) return false;
-  store.slots[slot] = null;
-  Reflect.deleteProperty(store.index, addr);
-  store.count -= 1;
-  return true;
+// src/tracked/trackedMap.ts
+var EmptyMapSlotError = class extends Error {
+  constructor() {
+    super("opshot: TrackedMap resolved an empty slot");
+    this.name = "EmptyMapSlotError";
+  }
 };
-var clearStore = (store) => {
-  store.slots = [];
-  store.index = {};
-  store.count = 0;
+var isObjectLike5 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+var isStoredValue = (stored, incoming) => {
+  if (Object.is(stored, incoming)) return true;
+  return isObjectLike5(stored) && isObjectLike5(incoming) && isSameIdentity(stored, incoming);
 };
-
-// src/tracked/trackedMap.ts
 var TrackedMap = class {
   constructor(entries) {
     installBoundary();
@@ -1844,23 +3479,29 @@ var TrackedMap = class {
   }
   set(key, value) {
     assertMutableFacade(this, "count");
-    const addr = addressOf(key);
+    const stored = Object.is(key, -0) ? 0 : key;
+    const addr = addressOf(stored);
     const slot = this.index[addr];
     if (slot === void 0) {
       const newSlot = this.slots.length;
-      this.slots.push([key, value]);
+      this.slots.push([stored, value]);
       this.index[addr] = newSlot;
       this.count += 1;
     } else {
       const pair = this.slots[slot];
-      if (pair === null || pair === void 0) throw new Error("opshot: TrackedMap resolved an empty slot");
+      if (pair === null || pair === void 0) throw new EmptyMapSlotError();
+      if (isStoredValue(pair[1], value)) return this;
       this.slots[slot] = [pair[0], value];
     }
     return this;
   }
   delete(key) {
     assertMutableFacade(this, "count");
-    return deleteFromStore(this, addressOf(key));
+    return deleteFromStore(
+      this,
+      addressOf(key),
+      (pair) => addressOf(pair[0])
+    );
   }
   clear() {
     assertMutableFacade(this, "count");
@@ -1915,17 +3556,22 @@ var TrackedSet = class {
   }
   add(value) {
     assertMutableFacade(this, "count");
-    const addr = addressOf(value);
+    const stored = Object.is(value, -0) ? 0 : value;
+    const addr = addressOf(stored);
     if (this.index[addr] !== void 0) return this;
     const slot = this.slots.length;
-    this.slots.push([value]);
+    this.slots.push([stored]);
     this.index[addr] = slot;
     this.count += 1;
     return this;
   }
   delete(value) {
     assertMutableFacade(this, "count");
-    return deleteFromStore(this, addressOf(value));
+    return deleteFromStore(
+      this,
+      addressOf(value),
+      (member) => addressOf(member[0])
+    );
   }
   clear() {
     assertMutableFacade(this, "count");
@@ -1960,15 +3606,195 @@ Object.defineProperty(TrackedSet.prototype, Symbol.toStringTag, {
   writable: false
 });
 
-// src/react/boundary.ts
-var { refSet: refSet6, proxyStateMap: proxyStateMap7 } = unstable_getInternalStates();
-var KEYS_PROPERTY2 = "k";
-var HAS_KEY_PROPERTY2 = "h";
-var HAS_OWN_KEY_PROPERTY2 = "o";
-var ALL_OWN_KEYS_PROPERTY2 = "w";
+// src/react/dirtySinceSnapshot.ts
+var parentLiveOf = (root, path) => {
+  if (path.length === 0) return void 0;
+  let current = root;
+  for (const segment of path.slice(0, -1)) {
+    if (!isObjectLike3(current)) return void 0;
+    current = Reflect.get(current, segment);
+  }
+  return isObjectLike3(current) ? current : void 0;
+};
+function dirtySinceSnapshot(handle, from) {
+  const dirty = { edges: /* @__PURE__ */ new WeakMap(), nodes: /* @__PURE__ */ new WeakSet() };
+  for (const operation of diffObjects(from, snapshot(handle.proxy.root))) {
+    const path = operation.do.path;
+    markDirtyPath(dirty, handle, path, parentLiveOf(handle.proxy.root, path));
+  }
+  return dirty;
+}
+
+// src/react/propWalk.ts
+var stateKeysByContainer = /* @__PURE__ */ new WeakMap();
+var noStateKeys = /* @__PURE__ */ new Set();
+var isReactOwnNode = (value) => "$$typeof" in value || typeof Node !== "undefined" && value instanceof Node;
+var childRole = (value, writable, mode) => {
+  if (typeof value !== "object" || value === null) return "skip";
+  if (isReactOwnNode(value)) return "skip";
+  if (mode === "nested" && !writable) return "skip";
+  if (admissionLane(value) === "untracked") return "skip";
+  if (isState(value)) return "state";
+  if (admissionLane(value) === "tracked") return "descend";
+  return "skip";
+};
+var readVerdict = (container, pass) => pass.verdicts.get(container) ?? stateKeysByContainer.get(container) ?? noStateKeys;
+var createDiscoveryPass = () => ({
+  entriesByContainer: /* @__PURE__ */ new Map(),
+  verdicts: /* @__PURE__ */ new Map(),
+  inProgress: /* @__PURE__ */ new Set(),
+  relaxable: /* @__PURE__ */ new Set()
+});
+function visitContainer(container, pass, mode) {
+  if (mode === "nested" && stateKeysByContainer.has(container)) return false;
+  if (pass.inProgress.has(container)) return true;
+  if (pass.verdicts.has(container)) return pass.relaxable.has(container);
+  pass.inProgress.add(container);
+  const entries = walkDataEntries(container);
+  const keys = /* @__PURE__ */ new Set();
+  let dependedOnBackEdge = false;
+  pass.entriesByContainer.set(container, entries);
+  for (const entry of entries) {
+    const role = childRole(entry.value, entry.writable, mode);
+    if (role === "state") {
+      keys.add(entry.key);
+      continue;
+    }
+    if (role !== "descend") continue;
+    const child = entry.value;
+    if (typeof child !== "object" || child === null) continue;
+    if (visitContainer(child, pass, "nested")) dependedOnBackEdge = true;
+    if (readVerdict(child, pass).size > 0) keys.add(entry.key);
+  }
+  pass.inProgress.delete(container);
+  pass.verdicts.set(container, keys);
+  if (dependedOnBackEdge) pass.relaxable.add(container);
+  return dependedOnBackEdge;
+}
+function relaxVerdicts(pass, entryContainer) {
+  let gained = true;
+  while (gained) {
+    gained = false;
+    for (const container of pass.relaxable) {
+      const keys = pass.verdicts.get(container);
+      const entries = pass.entriesByContainer.get(container);
+      if (keys === void 0 || entries === void 0) continue;
+      for (const entry of entries) {
+        if (keys.has(entry.key)) continue;
+        if (childRole(entry.value, entry.writable, container === entryContainer ? "entry" : "nested") !== "descend")
+          continue;
+        const child = entry.value;
+        if (typeof child !== "object" || child === null) continue;
+        if (readVerdict(child, pass).size === 0) continue;
+        keys.add(entry.key);
+        gained = true;
+      }
+    }
+  }
+}
+var cacheNestedVerdicts = (pass, skip) => {
+  for (const [visited, keys] of pass.verdicts) {
+    if (visited === skip) continue;
+    stateKeysByContainer.set(visited, keys);
+  }
+};
+function discoverStateKeys(container) {
+  const cached = stateKeysByContainer.get(container);
+  if (cached !== void 0) return cached;
+  if (isReactOwnNode(container)) return noStateKeys;
+  if (admissionLane(container) !== "tracked") return noStateKeys;
+  const pass = createDiscoveryPass();
+  visitContainer(container, pass, "nested");
+  relaxVerdicts(pass);
+  cacheNestedVerdicts(pass);
+  return pass.verdicts.get(container) ?? noStateKeys;
+}
+function substituteContainer(container, substitution, wrap, mode) {
+  const rebuilt = substitution.rebuiltByContainer.get(container);
+  if (rebuilt !== void 0) return rebuilt;
+  let stateKeys;
+  if (mode === "nested") {
+    stateKeys = discoverStateKeys(container);
+  } else {
+    const pass = createDiscoveryPass();
+    visitContainer(container, pass, "entry");
+    relaxVerdicts(pass, container);
+    cacheNestedVerdicts(pass, container);
+    stateKeys = pass.verdicts.get(container) ?? noStateKeys;
+  }
+  if (stateKeys.size === 0) {
+    substitution.rebuiltByContainer.set(container, container);
+    return container;
+  }
+  const clone = Array.isArray(container) ? [] : {};
+  Reflect.setPrototypeOf(clone, Reflect.getPrototypeOf(container));
+  substitution.rebuiltByContainer.set(container, clone);
+  const descriptors = Object.getOwnPropertyDescriptors(container);
+  for (const key of stateKeys) {
+    const descriptor = descriptors[key];
+    if (descriptor === void 0 || !("value" in descriptor)) continue;
+    const value = descriptor.value;
+    const role = childRole(value, descriptor.writable === true, mode);
+    if (role === "state") {
+      const source = peelReadProxy(value);
+      if (typeof source !== "object" || source === null) continue;
+      if (!substitution.visitedSources.has(source)) {
+        substitution.visitedSources.add(source);
+        substitution.sources.push(source);
+      }
+      descriptors[key] = { ...descriptor, value: wrap(source) };
+      continue;
+    }
+    if (role !== "descend") continue;
+    if (typeof value !== "object" || value === null) continue;
+    descriptors[key] = { ...descriptor, value: substituteContainer(value, substitution, wrap, "nested") };
+  }
+  Object.defineProperties(clone, descriptors);
+  return clone;
+}
+function substituteStates(root, wrap) {
+  const substitution = {
+    rebuiltByContainer: /* @__PURE__ */ new Map(),
+    sources: [],
+    visitedSources: /* @__PURE__ */ new Set()
+  };
+  if (isReactOwnNode(root) || unfrozenAdmissionLane(root) !== "tracked") {
+    return { props: root, sources: substitution.sources };
+  }
+  return { props: substituteContainer(root, substitution, wrap, "entry"), sources: substitution.sources };
+}
+var NO_SLOT = /* @__PURE__ */ Symbol("opshot.noDispatcherSlot");
+var readDispatcher = () => {
+  const internals = React;
+  const modern = internals.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
+  if (modern !== void 0) return modern.H;
+  const legacy = internals.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED?.ReactCurrentDispatcher;
+  if (legacy !== void 0) return legacy.current;
+  return NO_SLOT;
+};
+var nonRenderDispatcher;
+var learnNonRenderDispatcher = () => {
+  const current = readDispatcher();
+  if (current === NO_SLOT || current === null || current === void 0) return;
+  nonRenderDispatcher = current;
+};
+var isRendering = () => {
+  if (nonRenderDispatcher === void 0) return false;
+  const current = readDispatcher();
+  if (current === NO_SLOT || current === null || current === void 0) return false;
+  return current !== nonRenderDispatcher;
+};
+
+// src/react/readTracker.ts
+var { proxyStateMap: proxyStateMap16 } = unstable_getInternalStates();
+var KEYS_PROPERTY = "k";
+var HAS_KEY_PROPERTY = "h";
+var HAS_OWN_KEY_PROPERTY = "o";
+var ALL_OWN_KEYS_PROPERTY = "w";
 var isObjectLike6 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-var isLiveProxy = (value) => proxyStateMap7.has(value);
-var getProxyTarget = (liveProxy) => proxyStateMap7.get(liveProxy)?.[0] ?? liveProxy;
+var isLiveProxy = (value) => proxyStateMap16.has(value);
+var getProxyTarget = (writeProxy) => proxyStateMap16.get(writeProxy)?.[0] ?? writeProxy;
+var getProxyVersion = (writeProxy) => getVersion(writeProxy) ?? 0;
 var getUsage = (affected, target) => {
   let used = affected.get(target);
   if (used === void 0) {
@@ -1997,260 +3823,173 @@ var getPrototypeMethod = (target, prop) => {
   }
   return void 0;
 };
-var wrapperBoundMethods = /* @__PURE__ */ new WeakMap();
-var bindMethodToWrapper = (wrapper, method) => {
-  let methods = wrapperBoundMethods.get(wrapper);
-  if (methods === void 0) {
-    methods = /* @__PURE__ */ new WeakMap();
-    wrapperBoundMethods.set(wrapper, methods);
+var UnregisteredReadTrackerError = class extends Error {
+  constructor() {
+    super("opshot: readsIntersectDirty received an unregistered tracker");
+    this.name = "UnregisteredReadTrackerError";
   }
-  const existing = methods.get(method);
-  if (existing !== void 0) return existing;
-  const bound = Function.prototype.bind.call(method, wrapper);
-  methods.set(method, bound);
-  return bound;
 };
-function createBoundary() {
+var trackerPartitions = /* @__PURE__ */ new WeakMap();
+var recordedKeysOf = (used) => {
+  const keySets = new Array();
+  if (used[KEYS_PROPERTY] !== void 0) keySets.push(used[KEYS_PROPERTY]);
+  if (used[HAS_KEY_PROPERTY] !== void 0) keySets.push(used[HAS_KEY_PROPERTY]);
+  if (used[HAS_OWN_KEY_PROPERTY] !== void 0) keySets.push(used[HAS_OWN_KEY_PROPERTY]);
+  return keySets;
+};
+function readsIntersectDirty(tracker, dirty) {
+  const partitions = trackerPartitions.get(tracker);
+  if (partitions === void 0) throw new UnregisteredReadTrackerError();
+  for (const partition of partitions.values()) {
+    for (const [writeProxy, used] of partition.affected) {
+      const raw = getProxyTarget(writeProxy);
+      const edges = dirty.edges.get(raw);
+      for (const keys of recordedKeysOf(used)) {
+        for (const key of keys) {
+          if (edges?.has(key) === true) return true;
+        }
+      }
+      if (used[ALL_OWN_KEYS_PROPERTY] === true && dirty.nodes.has(raw)) return true;
+    }
+    for (const writeProxy of partition.identityReads) {
+      if (partition.affected.has(writeProxy)) continue;
+      if (dirty.nodes.has(getProxyTarget(writeProxy))) return true;
+    }
+  }
+  return false;
+}
+function createReadTracker() {
   const partitions = /* @__PURE__ */ new Map();
-  const targets = /* @__PURE__ */ new Map();
   let afterRender = false;
-  const getPartition = (sourceProxy) => {
-    let partition = partitions.get(sourceProxy);
+  let releasing = false;
+  const getPartition = (writeProxy) => {
+    let partition = partitions.get(writeProxy);
     if (partition === void 0) {
       partition = {
-        sourceProxy,
-        previousRootSnapshot: void 0,
         affected: /* @__PURE__ */ new Map(),
-        baselines: /* @__PURE__ */ new Map(),
+        identityReads: /* @__PURE__ */ new Set(),
         proxyCache: /* @__PURE__ */ new WeakMap()
       };
-      partitions.set(sourceProxy, partition);
+      partitions.set(writeProxy, partition);
     }
     return partition;
   };
-  const trackUsage = (partition, liveProxy) => afterRender ? {} : getUsage(partition.affected, liveProxy);
-  const ensureBaseline = (partition, liveProxy) => {
-    if (afterRender) return snapshot(liveProxy);
-    const existing = partition.baselines.get(liveProxy);
-    if (existing !== void 0) return existing;
-    const baseline = snapshot(liveProxy);
-    partition.baselines.set(liveProxy, baseline);
-    return baseline;
-  };
-  const ensureRootBaseline = (partition) => {
-    if (afterRender) return partition.previousRootSnapshot ?? snapshot(partition.sourceProxy);
-    if (partition.previousRootSnapshot === void 0) {
-      partition.previousRootSnapshot = snapshot(partition.sourceProxy);
-      partition.baselines.set(partition.sourceProxy, partition.previousRootSnapshot);
-    }
-    return partition.previousRootSnapshot;
-  };
-  const registerTarget = (liveProxy) => {
-    if (targets.has(liveProxy)) return;
-    targets.set(liveProxy, {
-      lastIdentitySnapshot: snapshot(liveProxy)
-    });
+  const shouldRecord = () => !afterRender || isRendering();
+  const trackUsage = (partition, writeProxy) => shouldRecord() ? getUsage(partition.affected, writeProxy) : {};
+  const recordIdentity = (partition, value) => {
+    if (!shouldRecord()) return;
+    if (isObjectLike6(value) && isLiveProxy(value)) partition.identityReads.add(value);
   };
-  const wrapLive = (liveProxy, partition) => {
-    ensureBaseline(partition, liveProxy);
-    registerTarget(liveProxy);
-    const cached = partition.proxyCache.get(liveProxy);
-    if (cached !== void 0) return cached;
-    const storageTarget = getProxyTarget(liveProxy);
-    const wrapperBox = {};
+  const toReadProxy = (writeProxy, partition) => {
+    const currentVersion = getProxyVersion(writeProxy);
+    const cached = partition.proxyCache.get(writeProxy);
+    if (cached?.version === currentVersion) return cached.readProxy;
+    const target = getProxyTarget(writeProxy);
+    const readProxyBox = {};
+    const boundMethods = /* @__PURE__ */ new WeakMap();
+    const bindMethodToReadProxy = (readProxy2, method) => {
+      const existing = boundMethods.get(method);
+      if (existing !== void 0) return existing;
+      const bound = Function.prototype.bind.call(method, readProxy2);
+      boundMethods.set(method, bound);
+      return bound;
+    };
     const handler = {
       get(_target, prop) {
-        ensureRootBaseline(partition);
-        const value = Reflect.get(liveProxy, prop, liveProxy);
-        const wrapper2 = wrapperBox.current;
-        const used = trackUsage(partition, liveProxy);
-        recordKey(used, KEYS_PROPERTY2, prop);
-        ensureBaseline(partition, liveProxy);
+        const readProxy2 = readProxyBox.current;
+        const value = Reflect.get(writeProxy, prop, readProxy2 ?? writeProxy);
+        const used = trackUsage(partition, writeProxy);
+        recordKey(used, KEYS_PROPERTY, prop);
+        recordIdentity(partition, value);
         if (typeof value === "function") {
-          const method = getPrototypeMethod(storageTarget, prop);
-          if (method !== void 0 && value === method && wrapper2 !== void 0) {
-            return bindMethodToWrapper(wrapper2, method);
+          const method = getPrototypeMethod(target, prop);
+          if (method !== void 0 && value === method && readProxy2 !== void 0) {
+            return bindMethodToReadProxy(readProxy2, method);
           }
         }
         if (!isObjectLike6(value)) return value;
         if (typeof value === "function") return value;
-        if (refSet6.has(value)) return value;
         if (!isLiveProxy(value)) return value;
-        return wrapLive(value, partition);
+        return toReadProxy(value, partition);
       },
       has(_target, prop) {
-        const used = trackUsage(partition, liveProxy);
-        recordKey(used, HAS_KEY_PROPERTY2, prop);
-        ensureBaseline(partition, liveProxy);
-        return Reflect.has(liveProxy, prop);
+        const used = trackUsage(partition, writeProxy);
+        recordKey(used, HAS_KEY_PROPERTY, prop);
+        return Reflect.has(writeProxy, prop);
       },
       getOwnPropertyDescriptor(_target, prop) {
-        const used = trackUsage(partition, liveProxy);
-        recordKey(used, HAS_OWN_KEY_PROPERTY2, prop);
-        ensureBaseline(partition, liveProxy);
-        return Reflect.getOwnPropertyDescriptor(liveProxy, prop);
+        const used = trackUsage(partition, writeProxy);
+        recordKey(used, HAS_OWN_KEY_PROPERTY, prop);
+        return Reflect.getOwnPropertyDescriptor(writeProxy, prop);
       },
       ownKeys() {
-        const used = trackUsage(partition, liveProxy);
-        used[ALL_OWN_KEYS_PROPERTY2] = true;
-        ensureBaseline(partition, liveProxy);
-        return Reflect.ownKeys(liveProxy);
+        const used = trackUsage(partition, writeProxy);
+        used[ALL_OWN_KEYS_PROPERTY] = true;
+        return Reflect.ownKeys(writeProxy);
       },
       set(_target, prop, value) {
-        ensureRootBaseline(partition);
-        return Reflect.set(liveProxy, prop, value, liveProxy);
+        return Reflect.set(writeProxy, prop, value, writeProxy);
       },
       deleteProperty(_target, prop) {
-        ensureRootBaseline(partition);
-        return Reflect.deleteProperty(liveProxy, prop);
+        return Reflect.deleteProperty(writeProxy, prop);
       }
     };
-    const wrapper = new Proxy(/* @__PURE__ */ Object.create(null), handler);
-    wrapperBox.current = wrapper;
-    registerWrapperTarget(wrapper, liveProxy);
-    partition.proxyCache.set(liveProxy, wrapper);
-    return wrapper;
+    const readProxy = new Proxy(writeProxy, handler);
+    readProxyBox.current = readProxy;
+    registerReadProxyTarget(readProxy, writeProxy);
+    partition.proxyCache.set(writeProxy, { readProxy, version: currentVersion });
+    return readProxy;
   };
-  return {
-    wrap(sourceProxy) {
-      if (!isLiveProxy(sourceProxy)) {
-        throw new Error("opshot: Boundary.wrap requires a live Valtio proxy");
-      }
-      const partition = getPartition(sourceProxy);
-      ensureRootBaseline(partition);
-      return wrapLive(sourceProxy, partition);
-    },
-    readsChanged(sourceProxy) {
-      const partition = partitions.get(sourceProxy);
-      if (partition?.previousRootSnapshot === void 0) return false;
-      if (partition.affected.size === 0) return false;
-      const translated = /* @__PURE__ */ new WeakMap();
-      for (const [live, usage] of partition.affected) {
-        const baseline = partition.baselines.get(live);
-        if (baseline === void 0) {
-          throw new Error("opshot: missing baseline snapshot for affected live proxy");
-        }
-        translated.set(baseline, usage);
+  const tracker = {
+    wrap(writeProxy) {
+      if (!isLiveProxy(writeProxy)) {
+        throw new Error("opshot: ReadTracker.wrap requires a write proxy");
       }
-      const nextRoot = snapshot(sourceProxy);
-      return isChanged(partition.previousRootSnapshot, nextRoot, translated, /* @__PURE__ */ new WeakMap());
+      const partition = getPartition(writeProxy);
+      return toReadProxy(writeProxy, partition);
     },
     captureReads() {
+      learnNonRenderDispatcher();
       afterRender = true;
     },
-    evictChangedTargets() {
-      for (const [liveProxy, entry] of targets) {
-        const current = snapshot(liveProxy);
-        if (current !== entry.lastIdentitySnapshot) {
-          for (const partition of partitions.values()) {
-            partition.proxyCache.delete(liveProxy);
-          }
-        }
-        entry.lastIdentitySnapshot = current;
-      }
-    },
     resetReads() {
       afterRender = false;
       for (const partition of partitions.values()) {
-        partition.previousRootSnapshot = void 0;
         partition.affected.clear();
-        partition.baselines.clear();
+        partition.identityReads.clear();
       }
     },
-    advanceBaselines() {
-      for (const partition of partitions.values()) {
-        for (const liveProxy of [...partition.baselines.keys()]) {
-          partition.baselines.set(liveProxy, snapshot(liveProxy));
-        }
-        partition.previousRootSnapshot = snapshot(partition.sourceProxy);
-        partition.baselines.set(partition.sourceProxy, partition.previousRootSnapshot);
-      }
+    retain() {
+      releasing = false;
+    },
+    dispose() {
+      releasing = true;
+      void Promise.resolve().then(() => {
+        if (!releasing) return;
+        releasing = false;
+        partitions.clear();
+      });
     }
   };
+  trackerPartitions.set(tracker, partitions);
+  return tracker;
 }
+var useCommitEffect = typeof document === "undefined" ? useEffect : useLayoutEffect;
 
 // src/react/scope.tsx
-var isPlainPrototype = (value) => {
-  const prototype = Reflect.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-};
-var assertSubstitutableContainer = (container) => {
-  if (isPlainPrototype(container)) return;
-  const kind = classifyValue(container);
-  if (kind === "plain" || kind === "plainArray" || kind === "cleanClass") return;
-  const className = constructorName(container.constructor);
-  if (kind === "arraySubclass") {
-    throw new Error(
-      `opshot: scope found a state inside ${className}, an array subclass whose prototype can't survive substitution. Move the state to a plain array, or ignore() the ${className}.`
-    );
-  }
-  const hidden = kind === "privateClass" ? "private fields" : "internal slots";
-  throw new Error(
-    `opshot: scope found a state inside ${className}, whose ${hidden} can't survive substitution. Move the state to a plain container, or ignore() the ${className}.`
-  );
-};
-function findStatePaths(value, maxDepth, path = [], paths = [], ancestors = /* @__PURE__ */ new Set()) {
-  if (isState(value)) {
-    paths.push(path);
-    return paths;
-  }
-  if (value === null || typeof value !== "object") return paths;
-  if ("$$typeof" in value) return paths;
-  if (ancestors.has(value)) return paths;
-  if (path.length >= maxDepth) return paths;
-  ancestors.add(value);
-  if (Array.isArray(value)) {
-    const foundCount = paths.length;
-    value.forEach((item, index) => {
-      findStatePaths(item, maxDepth, [...path, index], paths, ancestors);
-    });
-    if (paths.length > foundCount) assertSubstitutableContainer(value);
-  } else {
-    const foundCount = paths.length;
-    for (const [key, propertyValue] of Object.entries(value)) {
-      if (key.startsWith("__react")) continue;
-      findStatePaths(propertyValue, maxDepth, [...path, key], paths, ancestors);
+var sourcesKey = (sources) => `${sources.length}:${sources.map((source) => addressOf(source)).join(",")}`;
+var uniqueHandlesOf = (nodes) => {
+  const unique = new Array();
+  const seen = /* @__PURE__ */ new Set();
+  for (const node of nodes) {
+    for (const handle of handlesOf(node)) {
+      if (seen.has(handle)) continue;
+      seen.add(handle);
+      unique.push(handle);
     }
-    if (paths.length > foundCount) assertSubstitutableContainer(value);
-  }
-  ancestors.delete(value);
-  return paths;
-}
-function getAtPath(object, path) {
-  let current = object;
-  for (const segment of path) {
-    if (current === null || current === void 0) return void 0;
-    current = current[segment];
-  }
-  return current;
-}
-function setAtPath(object, path, value) {
-  if (path.length === 0) return value;
-  const head = path[0];
-  if (head === void 0) throw new Error("setAtPath: non-empty path yielded no head segment");
-  const tail = path.slice(1);
-  const current = object[head];
-  const updated = setAtPath(current, tail, value);
-  if (Array.isArray(object)) {
-    const clone2 = [...object];
-    clone2[head] = updated;
-    return clone2;
-  }
-  const prototype = Reflect.getPrototypeOf(object);
-  if (prototype === Object.prototype || prototype === null) return { ...object, [head]: updated };
-  const descriptor = Object.getOwnPropertyDescriptor(object, head);
-  if (descriptor?.get !== void 0 || descriptor?.set !== void 0) {
-    const className = constructorName(object.constructor);
-    throw new Error(
-      `opshot: scope found a state behind the accessor "${String(head)}" on ${className}, which can't survive substitution. Move the state to a plain container, or ignore() the ${className}.`
-    );
   }
-  const clone = Object.create(prototype);
-  Object.defineProperties(clone, Object.getOwnPropertyDescriptors(object));
-  clone[head] = updated;
-  return clone;
-}
-var sourcesKey = (sources) => `${sources.length}:${sources.map((source) => addressOf(source)).join(",")}`;
+  return unique;
+};
 var arePropsEqual = (previous, next) => {
   const previousRecord = previous;
   const nextRecord = next;
@@ -2267,99 +4006,112 @@ var arePropsEqual = (previous, next) => {
   }
   return true;
 };
-function scope(Component, options) {
-  const maxDepth = options?.maxDepth ?? 10;
+function scope(Component) {
   const Scoped = (props) => {
-    const boundaryRef = useRef(void 0);
-    boundaryRef.current ?? (boundaryRef.current = createBoundary());
-    const boundary = boundaryRef.current;
+    const readTrackerRef = useRef(void 0);
+    const currentHandlesRef = useRef([]);
+    const [gapSnapshots] = useState(() => /* @__PURE__ */ new WeakMap());
+    readTrackerRef.current ??= createReadTracker();
+    const readTracker = readTrackerRef.current;
     const [, bump] = useReducer((value) => value + 1, 0);
-    boundary.resetReads();
-    const paths = findStatePaths(props, maxDepth);
-    const sources = [];
-    let nextProps = props;
-    let changed = false;
-    for (const path of paths) {
-      const value = getAtPath(props, path);
-      if (!isState(value)) continue;
-      const source = unwrapWrapper(value);
-      if (typeof source !== "object" || source === null) continue;
-      const wrapped = boundary.wrap(source);
-      if (!sources.includes(source)) sources.push(source);
-      if (wrapped !== value) {
-        nextProps = setAtPath(nextProps, path, wrapped);
-        changed = true;
-      }
+    readTracker.resetReads();
+    const { props: renderedProps, sources } = substituteStates(props, (source) => readTracker.wrap(source));
+    const uniqueHandles = uniqueHandlesOf(sources);
+    for (const handle of uniqueHandles) {
+      gapSnapshots.set(handle, snapshot(handle.proxy.root));
     }
-    const renderedProps = changed ? nextProps : props;
-    const versionsAtRender = sources.map((source) => getVersion(source));
-    useEffect(() => {
-      boundary.captureReads();
+    useCommitEffect(() => {
+      currentHandlesRef.current = uniqueHandles;
+      readTracker.captureReads();
     });
     useEffect(() => {
-      const unsubscribes = sources.map(
-        (source) => subscribe(
-          source,
-          () => {
-            boundary.evictChangedTargets();
-            if (boundary.readsChanged(source)) bump();
-            else boundary.advanceBaselines();
-          },
-          true
-        )
+      readTracker.retain();
+      return () => readTracker.dispose();
+    }, [readTracker]);
+    useEffect(() => {
+      let cancelled = false;
+      const subscribedHandles = uniqueHandlesOf(sources);
+      for (const handle of subscribedHandles) {
+        const from = gapSnapshots.get(handle);
+        if (from !== void 0 && readsIntersectDirty(readTracker, dirtySinceSnapshot(handle, from))) bump();
+      }
+      const unsubscribes = subscribedHandles.map(
+        (handle) => subscribe2(handle.proxy.root, () => {
+          if (cancelled) return;
+          const dirty = handle.lastDirty;
+          if (dirty !== void 0 && readsIntersectDirty(readTracker, dirty)) bump();
+        })
       );
       return () => {
+        cancelled = true;
+        const currentHandles = new Set(currentHandlesRef.current);
+        for (const handle of subscribedHandles) {
+          if (currentHandles.has(handle)) continue;
+          gapSnapshots.set(handle, snapshot(handle.proxy.root));
+        }
         for (const unsubscribe of unsubscribes) unsubscribe();
       };
-    }, [sourcesKey(sources), boundary]);
-    useEffect(() => {
-      let shouldBump = false;
-      for (let index = 0; index < sources.length; index += 1) {
-        const source = sources[index];
-        const captured = versionsAtRender[index];
-        if (source === void 0 || captured === void 0) continue;
-        if (getVersion(source) !== captured) {
-          boundary.evictChangedTargets();
-          if (boundary.readsChanged(source)) shouldBump = true;
-        }
-      }
-      if (shouldBump) bump();
-    });
+    }, [sourcesKey(sources), readTracker]);
     return createElement(Component, renderedProps);
   };
   const baseName = Component.displayName ?? Component.name;
   Scoped.displayName = `scope(${typeof baseName === "string" && baseName !== "" ? baseName : "Component"})`;
   return memo(Scoped, arePropsEqual);
 }
-function useGroup() {
-  return useState(() => createGroup())[0];
+function useGroup(parent) {
+  return useState(() => createGroup(parent))[0];
 }
-function useMutableState(properties, group) {
-  const [{ proxy: proxy2, boundary }] = useState(() => ({
-    proxy: createMutableState(typeof properties === "function" ? properties() : properties, group),
-    boundary: createBoundary()
-  }));
+var isObjectLike7 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+function useMutableState(properties, options) {
+  const [{ writeProxy, readTracker }] = useState(() => {
+    const initial = typeof properties === "function" ? properties() : properties;
+    return {
+      writeProxy: createMutableState(initial, options),
+      readTracker: createReadTracker()
+    };
+  });
   const [, bump] = useReducer((value) => value + 1, 0);
-  const versionAtRender = getVersion(proxy2);
-  boundary.resetReads();
-  const wrapper = boundary.wrap(proxy2);
-  useEffect(() => {
-    boundary.captureReads();
+  const currentHandlesRef = useRef([]);
+  const [gapSnapshots] = useState(() => /* @__PURE__ */ new WeakMap());
+  const uniqueHandles = isObjectLike7(writeProxy) ? handlesOf(writeProxy) : [];
+  readTracker.resetReads();
+  const readProxy = isObjectLike7(writeProxy) ? readTracker.wrap(writeProxy) : writeProxy;
+  for (const handle of uniqueHandles) {
+    gapSnapshots.set(handle, snapshot(handle.proxy.root));
+  }
+  useCommitEffect(() => {
+    currentHandlesRef.current = uniqueHandles;
+    readTracker.captureReads();
   });
   useEffect(() => {
-    const onSignal = () => {
-      boundary.evictChangedTargets();
-      if (boundary.readsChanged(proxy2)) bump();
-      else boundary.advanceBaselines();
-    };
-    return subscribe(proxy2, onSignal, true);
-  }, [proxy2, boundary]);
+    readTracker.retain();
+    return () => readTracker.dispose();
+  }, [readTracker]);
   useEffect(() => {
-    if (getVersion(proxy2) === versionAtRender) return;
-    boundary.evictChangedTargets();
-    if (boundary.readsChanged(proxy2)) bump();
-  });
-  return wrapper;
+    let cancelled = false;
+    const subscribedHandles = isObjectLike7(writeProxy) ? handlesOf(writeProxy) : [];
+    for (const handle of subscribedHandles) {
+      const from = gapSnapshots.get(handle);
+      if (from !== void 0 && readsIntersectDirty(readTracker, dirtySinceSnapshot(handle, from))) bump();
+    }
+    const unsubscribes = subscribedHandles.map(
+      (handle) => subscribe2(handle.proxy.root, () => {
+        if (cancelled) return;
+        const dirty = handle.lastDirty;
+        if (dirty !== void 0 && readsIntersectDirty(readTracker, dirty)) bump();
+      })
+    );
+    return () => {
+      cancelled = true;
+      const currentHandles = new Set(currentHandlesRef.current);
+      for (const handle of subscribedHandles) {
+        if (currentHandles.has(handle)) continue;
+        gapSnapshots.set(handle, snapshot(handle.proxy.root));
+      }
+      for (const unsubscribe of unsubscribes) unsubscribe();
+    };
+  }, [writeProxy, readTracker]);
+  return readProxy;
 }
 
-export { TrackedDate, TrackedMap, TrackedSet, applyOps, createChannel, createGroup, createMutableState, diffSnapshots, identify, ignore, isSameIdentity, isState, scope, subscribe2 as subscribe, transact, unsafeTrack, useGroup, useMutableState };
+export { TrackedDate, TrackedMap, TrackedSet, applyOperations, createChannel, createGroup, createMutableState, diffObjects, identify, ignore, isSameIdentity, isState, scope, subscribe2 as subscribe, transact, unsafeTrack, useGroup, useMutableState };