opshot 0.3.4 → 0.5.0

package/dist/index.js

@@ -1,355 +1,62 @@
-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
+// src/utils/constructorName.ts
+var constructorName = (candidate) => typeof candidate === "function" && candidate.name !== "" ? candidate.name : "Object";
+
+// src/boundaryErrors.ts
+var ignoreOption = "ignore(value) to store it by reference, untracked";
+var unsafeTrackDataOption = "unsafeTrack(value) to track its data anyway";
+var unsafeTrackPrivateOption = "unsafeTrack(value) tracks public fields while private methods stay untracked";
+var unsafeTrackSlotOption = "unsafeTrack(value) tracks public fields while slot methods stay untracked";
+var unsafeTrackLossyOption = "unsafeTrack(value) to track it lossily";
+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 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 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 are not plain arrays", [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 inheritsFromPrototype = (value, prototype) => {
+  for (let current = Reflect.getPrototypeOf(value); current !== null; current = Reflect.getPrototypeOf(current))
+    if (current === prototype) return true;
+  return false;
 };
-var getUntracked = (obj) => {
-  if (isObjectToTrack(obj)) {
-    return obj[GET_ORIGINAL_SYMBOL] || null;
+var rejectionError = (value, kind, path) => {
+  const className = constructorName(value.constructor);
+  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, path);
+    case "cleanClass":
+      return cleanClassError(className, path);
+    case "privateClass":
+      return privateClassError(className, path);
+    case "nativeClass":
+      return nativeClassError(className, path);
   }
-  return null;
-};
-var markToTrack = (obj, mark = true) => {
-  objectsToTrack.set(obj, mark);
 };
 
-// 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 createSnapshotDefault = (target, version) => {
-  const cache = snapCache.get(target);
-  if ((cache == null ? void 0 : cache[0]) === version) {
-    return cache[1];
-  }
-  const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
-  markToTrack(snap, true);
-  snapCache.set(target, [version, snap]);
-  Reflect.ownKeys(target).forEach((key) => {
-    if (Object.getOwnPropertyDescriptor(snap, key)) {
-      return;
-    }
-    const value = Reflect.get(target, key);
-    const { enumerable } = Reflect.getOwnPropertyDescriptor(
-      target,
-      key
-    );
-    const desc = {
-      value,
-      enumerable,
-      // This is intentional to avoid copying with proxy-compare.
-      // It's still non-writable, so it avoids assigning a value.
-      configurable: true
-    };
-    if (refSet.has(value)) {
-      markToTrack(value, false);
-    } else if (proxyStateMap.has(value)) {
-      const [target2, ensureVersion] = proxyStateMap.get(
-        value
-      );
-      desc.value = createSnapshotDefault(target2, ensureVersion());
-    }
-    Object.defineProperty(snap, key, desc);
-  });
-  return snap;
-};
-var createHandlerDefault = (isInitializing, addPropListener, removePropListener, notifyUpdate) => ({
-  deleteProperty(target, prop) {
-    Reflect.get(target, prop);
-    removePropListener(prop);
-    const deleted = Reflect.deleteProperty(target, prop);
-    if (deleted) {
-      notifyUpdate(void 0 );
-    }
-    return deleted;
-  },
-  set(target, prop, value, receiver) {
-    const hasPrevValue = !isInitializing() && Reflect.has(target, prop);
-    const prevValue = Reflect.get(target, prop, receiver);
-    if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) {
-      return true;
-    }
-    removePropListener(prop);
-    if (isObject2(value)) {
-      value = getUntracked(value) || value;
-    }
-    const nextValue = !proxyStateMap.has(value) && canProxy(value) ? proxy(value) : value;
-    addPropListener(prop, nextValue);
-    Reflect.set(target, prop, nextValue, receiver);
-    notifyUpdate(void 0 );
-    return true;
-  }
-});
-var proxyStateMap = /* @__PURE__ */ new WeakMap();
-var refSet = /* @__PURE__ */ new WeakSet();
-var snapCache = /* @__PURE__ */ new WeakMap();
-var versionHolder = [1];
-var proxyCache = /* @__PURE__ */ new WeakMap();
-var objectIs = Object.is;
-var newProxy = (target, handler) => new Proxy(target, handler);
-var canProxy = canProxyDefault;
-var createSnapshot = createSnapshotDefault;
-var createHandler = createHandlerDefault;
-function proxy(baseObject = {}) {
-  if (!isObject2(baseObject)) {
-    throw new Error("object required");
-  }
-  const found = proxyCache.get(baseObject);
-  if (found) {
-    return found;
-  }
-  let version = versionHolder[0];
-  const listeners = /* @__PURE__ */ new Set();
-  const notifyUpdate = (op, nextVersion = ++versionHolder[0]) => {
-    if (version !== nextVersion) {
-      checkVersion = version = nextVersion;
-      listeners.forEach((listener) => listener(op, nextVersion));
-    }
-  };
-  let checkVersion = version;
-  const ensureVersion = (nextCheckVersion = versionHolder[0]) => {
-    if (checkVersion !== nextCheckVersion) {
-      checkVersion = nextCheckVersion;
-      propProxyStates.forEach(([propProxyState]) => {
-        const propVersion = propProxyState[1](nextCheckVersion);
-        if (propVersion > version) {
-          version = propVersion;
-        }
-      });
-    }
-    return version;
-  };
-  const createPropListener = (prop) => (op, nextVersion) => {
-    let newOp;
-    if (op) {
-      newOp = [...op];
-      newOp[1] = [prop, ...newOp[1]];
-    }
-    notifyUpdate(newOp, nextVersion);
-  };
-  const propProxyStates = /* @__PURE__ */ new Map();
-  const addPropListener = (prop, propValue) => {
-    const propProxyState = !refSet.has(propValue) && proxyStateMap.get(propValue);
-    if (propProxyState) {
-      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && propProxyStates.has(prop)) {
-        throw new Error("prop listener already exists");
-      }
-      if (listeners.size) {
-        const remove = propProxyState[2](createPropListener(prop));
-        propProxyStates.set(prop, [propProxyState, remove]);
-      } else {
-        propProxyStates.set(prop, [propProxyState]);
-      }
-    }
-  };
-  const removePropListener = (prop) => {
-    var _a;
-    const entry = propProxyStates.get(prop);
-    if (entry) {
-      propProxyStates.delete(prop);
-      (_a = entry[1]) == null ? void 0 : _a.call(entry);
-    }
-  };
-  const addListener = (listener) => {
-    listeners.add(listener);
-    if (listeners.size === 1) {
-      propProxyStates.forEach(([propProxyState, prevRemove], prop) => {
-        if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && prevRemove) {
-          throw new Error("remove already exists");
-        }
-        const remove = propProxyState[2](createPropListener(prop));
-        propProxyStates.set(prop, [propProxyState, remove]);
-      });
-    }
-    const removeListener = () => {
-      listeners.delete(listener);
-      if (listeners.size === 0) {
-        propProxyStates.forEach(([propProxyState, remove], prop) => {
-          if (remove) {
-            remove();
-            propProxyStates.set(prop, [propProxyState]);
-          }
-        });
-      }
-    };
-    return removeListener;
-  };
-  let initializing = true;
-  const handler = createHandler(
-    () => initializing,
-    addPropListener,
-    removePropListener,
-    notifyUpdate
-  );
-  const proxyObject = newProxy(baseObject, handler);
-  proxyCache.set(baseObject, proxyObject);
-  const proxyState = [baseObject, ensureVersion, addListener];
-  proxyStateMap.set(proxyObject, proxyState);
-  Reflect.ownKeys(baseObject).forEach((key) => {
-    const desc = Object.getOwnPropertyDescriptor(
-      baseObject,
-      key
-    );
-    if ("value" in desc && desc.writable) {
-      proxyObject[key] = baseObject[key];
-    }
-  });
-  initializing = false;
-  return proxyObject;
-}
-function getVersion(proxyObject) {
-  const proxyState = proxyStateMap.get(proxyObject);
-  return proxyState == null ? void 0 : proxyState[1]();
-}
-function subscribe(proxyObject, callback, notifyInSync) {
-  const proxyState = proxyStateMap.get(proxyObject);
-  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();
-  };
-}
-function snapshot(proxyObject) {
-  const proxyState = proxyStateMap.get(proxyObject);
-  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !proxyState) {
-    console.warn("Please use proxy object");
-  }
-  const [target, ensureVersion] = proxyState;
-  return createSnapshot(target, ensureVersion());
-}
-function ref(obj) {
-  refSet.add(obj);
-  return obj;
-}
-function unstable_getInternalStates() {
-  return {
-    proxyStateMap,
-    refSet,
-    snapCache,
-    versionHolder,
-    proxyCache
-  };
-}
-function unstable_replaceInternalFunction(name, fn) {
-  switch (name) {
-    case "objectIs":
-      objectIs = fn(objectIs);
-      break;
-    case "newProxy":
-      newProxy = fn(newProxy);
-      break;
-    case "canProxy":
-      canProxy = fn(canProxy);
-      break;
-    case "createSnapshot":
-      createSnapshot = fn(createSnapshot);
-      break;
-    case "createHandler":
-      createHandler = fn(createHandler);
-      break;
-    default:
-      throw new Error("unknown function");
-  }
-}
-
-// src/unsafeTrack.ts
-var unsafeTrackedSet = /* @__PURE__ */ new WeakSet();
-function unsafeTrack(value) {
-  unsafeTrackedSet.add(value);
-  return value;
-}
-function isUnsafeTracked(value) {
-  return typeof value === "object" && value !== null && unsafeTrackedSet.has(value);
-}
-
-// src/valtio/classify.ts
-var { refSet: refSet2 } = unstable_getInternalStates();
+// src/classify.ts
+var isDangerousKind = (kind) => kind !== "plain" && kind !== "plainArray" && kind !== "cleanClass";
 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 +64,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,1164 +97,581 @@ 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;
+
+// src/node.ts
+var byRaw = /* @__PURE__ */ new WeakMap();
+var byProxy = /* @__PURE__ */ new WeakMap();
+var proxyHandler;
+function installProxyHandler(handler2) {
+  proxyHandler = handler2;
 }
-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";
+function recordOf(value) {
+  return byRaw.get(value) ?? byProxy.get(value);
 }
-function isTrackable(value) {
-  return admissionLane(value) === "track";
+function rawOf(value) {
+  return recordOf(value)?.raw ?? value;
 }
-
-// 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 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 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)) {
-    const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
-    if (!descriptor) continue;
-    if ("value" in descriptor) {
-      Object.defineProperty(clone, key, {
-        ...descriptor,
-        value: cloneValue(descriptor.value, memo2, path)
-      });
-    } else {
-      Object.defineProperty(clone, key, descriptor);
-    }
-  }
-  memo2.set(value, clone);
-  if (isUnsafeTracked(value)) unsafeTrack(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 proxyOf(raw) {
+  const existing = recordOf(raw);
+  if (existing !== void 0) return existing.proxy;
+  if (proxyHandler === void 0) throw new Error("opshot: proxy handler is not installed");
+  const proxy = new Proxy(raw, proxyHandler);
+  const record = { raw, proxy, memberships: /* @__PURE__ */ new Map() };
+  byRaw.set(raw, record);
+  byProxy.set(proxy, record);
+  return proxy;
 }
-function getRegisteredTarget(copy) {
-  return targetRegistry.get(copy);
+function handlesOf(node) {
+  return membershipsOf(node).map(([handle]) => handle);
 }
-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 membershipsOf(node) {
+  const record = recordOf(rawOf(node));
+  if (record === void 0) return [];
+  const memberships = new Array();
+  for (const [handle, membership] of record.memberships) {
+    if (membership.edges > 0) memberships.push([handle, membership]);
+  }
+  return memberships;
 }
-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;
+
+// src/ignore.ts
+var ignored = /* @__PURE__ */ new WeakSet();
+function ignore(value, on = true) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return value;
+  if (on) ignored.add(rawOf(value));
+  else ignored.delete(rawOf(value));
+  return value;
 }
-function isSameIdentity(first, second) {
-  const resolvedFirst = resolveIdentity(first);
-  const resolvedSecond = resolveIdentity(second);
-  return resolvedFirst === resolvedSecond || resolvedFirst !== resolvedFirst && resolvedSecond !== resolvedSecond;
+var isIgnored = (value) => ignored.has(rawOf(value));
+
+// src/unsafeTrack.ts
+var unsafeMarked = /* @__PURE__ */ new WeakSet();
+function unsafeTrack(value, on = true) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") return value;
+  if (on) unsafeMarked.add(rawOf(value));
+  else unsafeMarked.delete(rawOf(value));
+  return value;
 }
+var isUnsafeMarked = (value) => unsafeMarked.has(rawOf(value));
 
-// src/ops/operation.ts
-var operationBrand = /* @__PURE__ */ Symbol.for("opshot.operation");
-var valueOriginals = /* @__PURE__ */ new WeakMap();
-var OperationHalf = class {
-  constructor(path) {
-    this.path = createOperationPath(path);
-  }
-};
-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) {
-    super(path);
-    valueOriginals.set(this, value);
-    if (!isCloneable(value)) Object.defineProperty(this, "value", { value, enumerable: true });
-  }
-};
-var AddHalf = class extends ValueHalf {
-  constructor() {
-    super(...arguments);
-    this.op = "add";
-  }
-};
-var ReplaceHalf = class extends ValueHalf {
-  constructor() {
-    super(...arguments);
-    this.op = "replace";
-  }
-};
-var RemoveHalf = class extends OperationHalf {
-  constructor() {
-    super(...arguments);
-    this.op = "remove";
+// src/utils/dataEntries.ts
+var walkDataEntries = (value) => {
+  const entries = new Array();
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key !== "string" || key === "__proto__") continue;
+    const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+    if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor)) continue;
+    entries.push({ key, value: descriptor.value, writable: descriptor.writable === true });
   }
+  return entries;
 };
-var isOperation = (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);
 
-// 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/edges.ts
+var isTrackedEntry = (value, writable) => writable && typeof value === "object" && value !== null && !isIgnored(value) && !Object.isFrozen(value);
+var checkNode = (node, entries, route) => {
+  const kind = classifyValue(node);
+  if (isDangerousKind(kind)) throw rejectionError(node, kind, route);
+  for (const entry of entries) {
+    if (typeof entry.value === "function") {
+      if (kind === "cleanClass") throw rejectionError(node, "cleanClass", [...route, entry.key]);
+      continue;
     }
+    if (typeof entry.value !== "object" || entry.value === null) continue;
+    if (isIgnored(entry.value) || Object.isFrozen(entry.value)) continue;
+    if (!entry.writable) throw nonWritablePropertyError(node, [...route, entry.key]);
   }
 };
-var weighValue = (value, budget) => {
-  const state = { weight: 0, budget, seen: /* @__PURE__ */ new WeakSet() };
-  weigh(value, state);
-  return state.weight;
-};
-
-// 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";
+var descend = (handle, node, route, checked) => {
+  const entries = walkDataEntries(node);
+  if (checked) checkNode(node, entries, route);
+  for (const entry of entries) {
+    if (isTrackedEntry(entry.value, entry.writable))
+      attach(handle, node, entry.key, entry.value, [...route, entry.key]);
   }
 };
-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 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) return;
-  afterSet.delete(after);
-  if (afterSet.size === 0) ancestors.delete(before);
-};
-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);
-    }
-  } finally {
-    activeAncestors.delete(value);
+var flip = (handle, node, route) => {
+  const membership = recordOf(node)?.memberships.get(handle);
+  if (!membership?.exempt) return;
+  membership.exempt = false;
+  const entries = walkDataEntries(node);
+  checkNode(node, entries, route);
+  for (const entry of entries) {
+    if (!isTrackedEntry(entry.value, entry.writable)) continue;
+    const child = rawOf(entry.value);
+    if (recordOf(child)?.memberships.has(handle) === true) flip(handle, child, [...route, entry.key]);
   }
 };
-var isCanonicalArrayIndex = (key) => {
-  const index = Number(key);
-  return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key;
-};
-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);
-    }
-  }
-  return weight;
-};
-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);
-  }
-  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]);
-    }
-  } 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]);
-    }
-    weight += pushReplace(ops, appendOperationPath(path, "length"), before.length, after.length);
+var cascade = (handle, node, keys) => {
+  for (const key of keys) {
+    const value = Reflect.get(node, key);
+    if (typeof value !== "object" || value === null) continue;
+    const child = rawOf(value);
+    if (recordOf(child)?.memberships.has(handle) === true) detach(handle, child);
+  }
+};
+function attach(handle, parent, key, child, route) {
+  const parentMembership = recordOf(parent)?.memberships.get(handle);
+  if (parentMembership === void 0) return;
+  parentMembership.keys.add(key);
+  const rawChild = rawOf(child);
+  proxyOf(rawChild);
+  const record = recordOf(rawChild);
+  if (record === void 0) return;
+  const edgeExempt = parentMembership.exempt || isUnsafeMarked(rawChild);
+  const membership = record.memberships.get(handle);
+  if (membership === void 0) {
+    record.memberships.set(handle, { edges: 1, exempt: edgeExempt, keys: /* @__PURE__ */ new Set() });
+    descend(handle, rawChild, route, !edgeExempt);
+    return;
   }
-  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);
-  enterAncestorPair(ancestors, before, after);
+  membership.edges += 1;
+  if (membership.exempt && !edgeExempt) flip(handle, rawChild, route);
+}
+function attachRoot(handle, root, exempt) {
+  const record = recordOf(root);
+  if (record === void 0) return;
+  record.memberships.set(handle, { edges: 1, exempt, keys: /* @__PURE__ */ new Set() });
   try {
-    if (path.length === 0) {
-      walk();
-      return 0;
-    }
-    const opsStart = ops.length;
-    const atomicWeight = walk();
-    return tryCollapse(before, after, path, ops, opsStart, atomicWeight);
-  } 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);
-  }
-  if (isPlainArray(before) && isPlainArray(after)) {
-    return walkContainer(before, after, path, ops, ancestors, () => diffArray(before, after, path, ops, ancestors));
-  }
-  if (isPlainObject(before) && isPlainObject(after)) {
-    return walkContainer(
-      before,
-      after,
-      path,
-      ops,
-      ancestors,
-      () => diffObjectProperties(before, after, path, ops, ancestors, false)
-    );
+    descend(handle, root, [], !exempt);
+  } catch (error) {
+    evict(handle, root);
+    throw error;
   }
-  assertSafeSubtree(before, path);
-  assertSafeSubtree(after, path);
-  return pushReplace(ops, path, before, after);
-};
-var getRootKind = (value) => {
-  if (isPlainArray(value)) return "plainArray";
-  if (isPlainObject(value)) return "plainObject";
-  return void 0;
-};
-function diffSnapshots(before, after) {
-  const beforeKind = getRootKind(before);
-  const afterKind = getRootKind(after);
-  if (beforeKind === void 0 || beforeKind !== afterKind) throw new IncompatibleSnapshotRootsError();
-  const ops = new Array();
-  diffValue(before, after, createOperationPath([]), ops, /* @__PURE__ */ new Map());
-  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);
-};
-
-// 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;
-  }
-  if (!isObjectLike3(current) || !proxyStateMap3.has(current)) throw new Error("opshot: expected a state object");
-  return current;
+function detach(handle, child) {
+  const rawChild = rawOf(child);
+  const record = recordOf(rawChild);
+  const membership = record?.memberships.get(handle);
+  if (record === void 0 || membership === void 0) return;
+  membership.edges -= 1;
+  if (membership.edges > 0) return;
+  record.memberships.delete(handle);
+  cascade(handle, rawChild, membership.keys);
 }
-
-// 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
-  };
-  emitters.set(resolved, record);
-  return record;
-}
-function deleteEmitter(target) {
-  emitters.delete(target);
+function evict(handle, node) {
+  const rawNode = rawOf(node);
+  const record = recordOf(rawNode);
+  const membership = record?.memberships.get(handle);
+  if (record === void 0 || membership === void 0) return;
+  record.memberships.delete(handle);
+  cascade(handle, rawNode, membership.keys);
 }
 
-// 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 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 armWatchdog = (record) => {
-  if (record.disarm !== void 0) return;
-  record.lastReported = snapshot(record.target);
-  record.disarm = subscribe(record.target, () => {
-    emitBareFlush(record.target);
-  });
-};
-var disarmWatchdog = (record) => {
-  record.disarm?.();
-  record.disarm = 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;
+// src/handle.ts
+function handleOf(state) {
+  const raw = rawOf(state);
+  const record = recordOf(raw);
+  if (record === void 0) return void 0;
+  for (const handle of record.memberships.keys()) {
+    if (handle.root === raw) return handle;
   }
-};
-var settlePendingBare = (record) => {
-  reportBareDiff(record);
-};
-function emitBareFlush(target) {
-  const record = getEmitter(target);
-  if (record === void 0) return;
-  reportBareDiff(record);
+  return void 0;
 }
-function mintGroupedEmitter(target, groupListeners) {
-  const record = getOrCreateEmitter(target, groupListeners);
-  armWatchdog(record);
-  return record;
+function requireHandle(state, message) {
+  const handle = handleOf(state);
+  if (handle === void 0) throw new Error(message);
+  return handle;
 }
 
-// src/utils/constructorName.ts
-var constructorName = (candidate) => typeof candidate === "function" && candidate.name !== "" ? candidate.name : "Object";
-
-// src/valtio/boundaryErrors.ts
-var ignoreOption = "ignore(value) to store it by reference, untracked";
-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:
-${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 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.`
-);
-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) => {
-  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");
-  switch (kind) {
-    case "arraySubclass":
-      return arraySubclassError(className);
-    case "cleanClass":
-      return cleanClassError(className);
-    case "privateClass":
-      return privateClassError(className);
-    case "nativeClass":
-      return nativeClassError(className);
+// src/batch.ts
+var metaStack = [];
+function currentMeta() {
+  return metaStack.length === 0 ? void 0 : metaStack[metaStack.length - 1];
+}
+function batch(callback, meta) {
+  metaStack.push(meta);
+  try {
+    callback();
+  } finally {
+    metaStack.pop();
   }
-};
+}
 
-// 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;
+// src/emit/emitterDeliver.ts
+var runDelivery = (pending, failures) => {
+  for (const deliver of pending.deliveries) {
+    try {
+      deliver(pending.operations);
+    } catch (error) {
+      failures.push(error);
     }
-    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;
-  }
-  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);
+var raiseFailures = (failures) => {
+  if (failures.length === 0) return;
+  if (failures.length > 1) throw new AggregateError(failures, "opshot: listeners failed during delivery");
+  throw failures[0];
 };
-
-// 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);
-    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)) {
-    if (Object.getOwnPropertyDescriptor(snap, key)) continue;
-    const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-    if (!descriptor) continue;
-    if (descriptor.get || descriptor.set) {
-      Object.defineProperty(snap, key, {
-        get: descriptor.get,
-        set: descriptor.set,
-        enumerable: descriptor.enumerable,
-        configurable: true
-      });
-      continue;
-    }
-    const value = Reflect.get(target, key);
-    const snapshotDescriptor = { value, enumerable: descriptor.enumerable, configurable: true };
-    if (typeof value === "object" && value !== null) {
-      if (refSet5.has(value)) {
-        markToTrack(value, false);
-      } else {
-        const childState = proxyStateMap4.get(value);
-        if (childState)
-          snapshotDescriptor.value = createSnapshotPreservingAccessors(childState[0], childState[1]());
-      }
-    }
-    Object.defineProperty(snap, key, snapshotDescriptor);
-  }
-  if (Array.isArray(target) && snap.length !== target.length) {
-    snap.length = target.length;
-  }
-  if (isUnsafeTracked(target)) unsafeTrack(snap);
-  return snap;
+var queuedDeliveries = [];
+var deliveryFailures = [];
+var isDraining = false;
+var prepareDelivery = (handle, operations) => ({
+  deliveries: [...handle.subscribers.values()],
+  operations
+});
+var enqueueDelivery = (pending) => {
+  queuedDeliveries.push(pending);
 };
-
-// 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);
+var drainDeliveries = () => {
+  if (isDraining) return;
+  isDraining = true;
+  let failures = [];
   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);
+    while (queuedDeliveries.length > 0) {
+      for (const queued of queuedDeliveries.splice(0, queuedDeliveries.length)) {
+        runDelivery(queued, deliveryFailures);
+      }
     }
   } finally {
-    activeAncestors.delete(value);
+    isDraining = false;
+    failures = deliveryFailures.splice(0, deliveryFailures.length);
   }
+  raiseFailures(failures);
 };
-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("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");
-      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;
-          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;
-          } finally {
-            setDepth -= 1;
-          }
-        },
-        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"
-          );
-        },
-        setPrototypeOf() {
-          throw new Error("opshot: setPrototypeOf is not supported on tracked state");
-        }
-      };
-    }
-  );
-}
 
-// src/createMutableState.ts
-function createMutableState(properties, group) {
-  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));
-  }
-  return proxied;
-}
-
-// src/createGroup.ts
-var groupListenersByGroup = /* @__PURE__ */ new WeakMap();
-function isGroup(value) {
-  return typeof value === "object" && value !== null && groupListenersByGroup.has(value);
-}
-function getGroupListeners(group) {
-  const listeners = groupListenersByGroup.get(group);
-  if (listeners === void 0) throw new Error("opshot: unknown group");
-  return listeners;
-}
-function createGroup() {
-  const listeners = /* @__PURE__ */ new Map();
-  const group = {
-    createMutableState(properties) {
-      return createMutableState(properties, group);
-    }
-  };
-  groupListenersByGroup.set(group, listeners);
-  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);
-  }
-  let byChannel = record.listeners.get(listener);
-  if (byChannel === void 0) {
-    byChannel = /* @__PURE__ */ new Map();
-    record.listeners.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);
-    }
-  };
-}
-function addGroupListener(groupListeners, listener, channelId, deliver2) {
-  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);
-  };
-}
-
-// src/transact.ts
-function transact(state, mutate, meta) {
-  const record = getEmitter(state);
-  if (record === void 0) {
-    mutate();
+// src/emit/window.ts
+function recordOperation(handle, raw, pending) {
+  let byKey = handle.pendingIndex.get(raw);
+  if (byKey === void 0) {
+    byKey = /* @__PURE__ */ new Map();
+    handle.pendingIndex.set(raw, byKey);
+  }
+  const index = byKey.get(pending.key);
+  const existing = index === void 0 ? void 0 : handle.pending[index];
+  if (existing !== void 0 && Object.is(existing.meta, pending.meta)) {
+    existing.after = pending.after;
+    existing.hasAfter = pending.hasAfter;
     return;
   }
-  if (record.isMutating) throw new Error("opshot: nested transact on the same state");
-  settlePendingBare(record);
-  record.isMutating = true;
-  try {
-    mutate();
-  } finally {
-    record.isMutating = false;
-  }
-  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);
+  handle.pending.push(pending);
+  byKey.set(pending.key, handle.pending.length - 1);
+  if (handle.isFlushScheduled) return;
+  handle.isFlushScheduled = true;
+  const run = () => {
+    flush(handle);
+  };
+  void Promise.resolve().then(() => {
+    const emitOn = handle.emitOn;
+    if (emitOn === void 0) run();
+    else emitOn(run);
+  });
 }
-
-// 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."
-    );
-  }
-};
-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 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)}`);
-  }
-};
-var deleteOrThrow = (target, key) => {
-  if (!Reflect.deleteProperty(target, key)) throw new Error(`opshot: replay could not remove ${String(key)}`);
-};
-var restoreRecordedContent = (attached, recorded, restored) => {
-  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);
-    const attachedDescriptor = Reflect.getOwnPropertyDescriptor(attached, key);
-    if (!descriptor || !("value" in descriptor) || attachedDescriptor && !("value" in attachedDescriptor)) continue;
-    const value = descriptor.value;
-    if (isObjectLike4(value)) {
-      const target = getRegisteredTarget(value);
-      if (target !== void 0) {
-        setOrThrow(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);
-        continue;
-      }
-    }
-    setOrThrow(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);
+function flush(handle) {
+  handle.isFlushScheduled = false;
+  const pending = handle.pending.splice(0);
+  handle.pendingIndex.clear();
+  const operations = new Array();
+  for (const item of pending) {
+    if (item.hasBefore === item.hasAfter && (!item.hasBefore || Object.is(item.before, item.after))) continue;
+    const operation = {
+      node: item.node,
+      key: item.key,
+      meta: item.meta,
+      ...item.hasBefore ? { before: item.before } : {},
+      ...item.hasAfter ? { after: item.after } : {}
+    };
+    operations.push(Object.freeze(operation));
   }
-};
-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 restoreValue = (payload, attach, readAttached) => {
-  if (isObjectLike4(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());
-      return;
+  const edges = /* @__PURE__ */ new Map();
+  const nodes = /* @__PURE__ */ new Set();
+  for (const operation of operations) {
+    const raw = rawOf(operation.node);
+    let keys = edges.get(raw);
+    if (keys === void 0) {
+      keys = /* @__PURE__ */ new Set();
+      edges.set(raw, keys);
     }
-  }
-  attach(payload.fallback);
-};
-var getInheritedDescriptor = (target, key) => {
-  let prototype = Reflect.getPrototypeOf(target);
-  while (prototype !== null) {
-    const descriptor = Reflect.getOwnPropertyDescriptor(prototype, key);
-    if (descriptor) return descriptor;
-    prototype = Reflect.getPrototypeOf(prototype);
+    keys.add(operation.key);
+    nodes.add(raw);
+  }
+  const dirty = { edges, nodes };
+  handle.lastDirty = dirty;
+  if (operations.length === 0) return;
+  enqueueDelivery(prepareDelivery(handle, operations));
+  drainDeliveries();
+}
+
+// src/utils/predicates.ts
+var isObjectLike = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+
+// src/proxy.ts
+var prototypeFunctionOf = (target, key) => {
+  for (let holder = Reflect.getPrototypeOf(target); holder !== null; holder = Reflect.getPrototypeOf(holder)) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(holder, key);
+    if (descriptor === void 0) continue;
+    const method = "value" in descriptor ? descriptor.value : void 0;
+    return typeof method === "function" ? method : void 0;
   }
   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 (typeof segment === "string" && !isCanonicalArrayIndexString(segment)) return segment;
-    throw unresolvedError(path);
-  }
-  if (typeof segment === "string") return segment;
-  throw unresolvedError(path);
+var isRideAlongKey = (target, key) => {
+  if (key === "__proto__") return true;
+  if (key === "length") return false;
+  const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+  return descriptor?.enumerable === false;
 };
-var requirePlainProperty = (parent, segment, path) => {
-  if (Array.isArray(parent) && segment === "length") return parent.length;
-  const key = requirePlainSegment(parent, segment, path);
-  const descriptor = Reflect.getOwnPropertyDescriptor(parent, key);
-  if (!descriptor || !descriptor.enumerable || !("value" in descriptor)) throw unresolvedError(path);
-  return Reflect.get(parent, key);
+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 resolveTraversalSegment = (parent, segment, path) => {
-  if (!isObjectLike4(parent)) throw unresolvedError(path);
-  return requirePlainProperty(parent, segment, path);
+var proxied = (value) => isObjectLike(value) ? recordOf(value)?.proxy ?? value : value;
+var truncatedOwnEntriesOf = (target, next) => {
+  if (!Array.isArray(target)) return [];
+  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 [];
+  const truncated = new Array();
+  for (let index = newLength; index < target.length; index += 1) {
+    const key = String(index);
+    const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+    if (descriptor === void 0 || !("value" in descriptor)) continue;
+    truncated.push({
+      key,
+      value: descriptor.value,
+      writable: descriptor.writable === true
+    });
+  }
+  return truncated;
 };
-var resolveTerminal = (root, path) => {
-  assertSafePath(path);
-  if (path.length === 0) throw new Error("opshot: root operations are not supported");
-  let parent = root;
-  for (let index = 0; index < path.length - 1; index++) parent = resolveTraversalSegment(parent, path[index], path);
-  if (!isObjectLike4(parent)) throw unresolvedError(path);
-  return { parent, segment: path[path.length - 1] };
+var ownDataDescriptor = (target, key) => {
+  const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+  if (descriptor === void 0 || !("value" in descriptor)) return { hadPrevious: false, previous: void 0 };
+  return { hadPrevious: true, previous: descriptor.value };
 };
-var applyPlain = (parent, segment, operation) => {
-  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) {
-      throw unresolvedError(path);
+var handler = {
+  get(target, key, receiver) {
+    const value = Reflect.get(target, key, receiver);
+    const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+    const locked = descriptor?.writable === false && descriptor.configurable === false;
+    if (locked || !isObjectLike(value)) return value;
+    if (typeof value === "function") {
+      const method = prototypeFunctionOf(target, key);
+      const kind = classifyValue(target);
+      if (method !== void 0 && value === method && (kind === "nativeClass" || kind === "privateClass")) {
+        const bound = Function.prototype.bind.call(method, target);
+        return typeof bound === "function" ? bound : value;
+      }
+      return value;
     }
-    setOrThrow(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") {
-    const inheritedDescriptor = getInheritedDescriptor(parent, key);
-    if (inheritedDescriptor && !("value" in inheritedDescriptor)) {
-      throw new Error(`opshot: ${formatOperationPath(path)} resolves to an inherited accessor`);
+    return recordOf(value)?.proxy ?? value;
+  },
+  set(target, key, value, receiver) {
+    if (typeof key !== "string" || writesThroughAccessor(target, key) || isRideAlongKey(target, key)) {
+      return Reflect.set(target, key, value, receiver);
     }
+    const { hadPrevious, previous } = ownDataDescriptor(target, key);
+    const resolved = isObjectLike(value) ? rawOf(value) : value;
+    const memberships = membershipsOf(target).map(([handle, membership]) => ({
+      handle,
+      membership,
+      hadKey: membership.keys.has(key)
+    }));
+    const truncated = key === "length" ? truncatedOwnEntriesOf(target, resolved) : [];
+    const previousLength = Array.isArray(target) ? target.length : void 0;
+    if (typeof resolved === "function" && memberships.some(({ membership }) => !membership.exempt)) {
+      const kind = classifyValue(target);
+      if (kind !== "plain" && kind !== "plainArray") throw rejectionError(target, kind, [key]);
+    }
+    const incoming = resolved !== previous && isTrackedEntry(resolved, true) ? resolved : void 0;
+    let rollBack;
+    if (incoming !== void 0) {
+      const started = new Array();
+      rollBack = () => {
+        for (const { handle, membership, hadKey } of started) {
+          detach(handle, incoming);
+          if (!hadKey) membership.keys.delete(key);
+        }
+      };
+      try {
+        for (const write of memberships) {
+          started.push(write);
+          attach(write.handle, target, key, incoming, [key]);
+        }
+      } catch (error) {
+        rollBack();
+        throw error;
+      }
+    }
+    const result = Reflect.set(target, key, resolved, receiver);
+    if (!result) {
+      rollBack?.();
+      return result;
+    }
+    const meta = currentMeta();
+    const node = proxyOf(target);
+    for (const { handle, membership, hadKey } of memberships) {
+      for (const entry of truncated) {
+        if (membership.keys.delete(entry.key) && isObjectLike(entry.value)) detach(handle, entry.value);
+        recordOperation(handle, target, {
+          node,
+          key: entry.key,
+          meta,
+          before: proxied(entry.value),
+          hasBefore: true,
+          hasAfter: false
+        });
+      }
+      if (hadKey && previous !== resolved) {
+        if (isObjectLike(previous)) detach(handle, previous);
+        if (incoming === void 0) membership.keys.delete(key);
+      }
+      recordOperation(handle, target, {
+        node,
+        key,
+        meta,
+        before: proxied(previous),
+        after: proxied(resolved),
+        hasBefore: hadPrevious,
+        hasAfter: true
+      });
+      if (key !== "length" && Array.isArray(target) && previousLength !== target.length) {
+        recordOperation(handle, target, {
+          node,
+          key: "length",
+          meta,
+          before: previousLength,
+          after: target.length,
+          hasBefore: true,
+          hasAfter: true
+        });
+      }
+    }
+    return result;
+  },
+  deleteProperty(target, key) {
+    if (typeof key !== "string" || isRideAlongKey(target, key)) return Reflect.deleteProperty(target, key);
+    const { hadPrevious, previous } = ownDataDescriptor(target, key);
+    const result = Reflect.deleteProperty(target, key);
+    if (!result || !hadPrevious) return result;
+    const meta = currentMeta();
+    const node = proxyOf(target);
+    for (const [handle, membership] of membershipsOf(target)) {
+      if (membership.keys.delete(key) && isObjectLike(previous)) detach(handle, previous);
+      recordOperation(handle, target, {
+        node,
+        key,
+        meta,
+        before: proxied(previous),
+        hasBefore: true,
+        hasAfter: false
+      });
+    }
+    return result;
+  },
+  preventExtensions(target) {
+    for (const [handle] of membershipsOf(target)) evict(handle, target);
+    return Reflect.preventExtensions(target);
+  },
+  defineProperty(target, key, descriptor) {
+    return Reflect.defineProperty(target, key, descriptor);
+  },
+  setPrototypeOf(target, prototype) {
+    return Reflect.setPrototypeOf(target, prototype);
+  },
+  has(target, key) {
+    return Reflect.has(target, key);
+  },
+  ownKeys(target) {
+    return Reflect.ownKeys(target);
+  },
+  getOwnPropertyDescriptor(target, key) {
+    return Reflect.getOwnPropertyDescriptor(target, key);
   }
-  if (operation.op === "remove") {
-    deleteOrThrow(parent, key);
-    return;
-  }
-  if (!("value" in operation)) throw unresolvedError(path);
-  restoreValue(
-    getValuePayload(operation),
-    (value) => setOrThrow(parent, key, value),
-    () => Reflect.get(parent, key)
-  );
 };
-function applyOperations(root, operations) {
-  for (const operation of operations) {
-    const terminal = resolveTerminal(root, operation.path);
-    applyPlain(terminal.parent, terminal.segment, operation);
-  }
-}
-function applyOps(state, operations, meta) {
-  for (const operation of operations) assertApplicable(operation);
-  transact(
-    state,
-    () => {
-      applyOperations(resolveEmitterTarget(state), operations);
-    },
-    meta
-  );
-}
 
-// 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 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;
-}
-function toChannelContext(channelId, defaults, meta) {
-  if (isOwnChannelStamp(meta, channelId)) {
-    return { isTransaction: true, meta: { ...defaults, ...meta.meta } };
-  }
-  return { isTransaction: false, meta: unwrapTransportMeta(meta) };
+// src/createMutableState.ts
+installProxyHandler(handler);
+function createMutableState(properties, options) {
+  const incoming = properties;
+  if (typeof incoming !== "object" || incoming === null) return properties;
+  if (isIgnored(incoming)) return properties;
+  if (Object.isFrozen(incoming)) return properties;
+  const root = rawOf(incoming);
+  if (handleOf(incoming) !== void 0) return proxyOf(incoming);
+  const strict = options?.strict !== false;
+  const exempt = !strict || isUnsafeMarked(root);
+  const handle = {
+    root,
+    strict,
+    emitOn: options?.emitOn,
+    subscribers: /* @__PURE__ */ new Map(),
+    pending: [],
+    pendingIndex: /* @__PURE__ */ new Map(),
+    isFlushScheduled: false
+  };
+  const proxy = proxyOf(root);
+  attachRoot(handle, root, exempt);
+  return proxy;
 }
 
-// src/createChannel.ts
-function createChannel(defaults) {
-  const channelId = Object.freeze({});
-  function transact2(state, mutate, meta) {
-    transact(state, mutate, stampChannelMeta(channelId, meta));
-  }
-  function subscribe3(target, listener) {
-    if (isGroup(target)) {
-      return addGroupListener(getGroupListeners(target), listener, channelId, (state, ops, meta) => {
-        listener(
-          state,
-          ops,
-          toChannelContext(channelId, defaults, meta)
-        );
-      });
+// src/identity.ts
+var readProxyTargets = /* @__PURE__ */ new WeakMap();
+var identityRecords = /* @__PURE__ */ new WeakMap();
+var nextInternId = 0;
+var registerReadProxyTarget = (readProxy, target) => {
+  readProxyTargets.set(readProxy, target);
+};
+var getRegisteredReadProxyTarget = (readProxy) => readProxyTargets.get(readProxy);
+function resolveIdentity(value) {
+  let current = value;
+  while (isObjectLike(current)) {
+    const readTarget = getRegisteredReadProxyTarget(current);
+    if (readTarget !== void 0 && readTarget !== current) {
+      current = readTarget;
+      continue;
     }
-    return addStateListener(target, listener, channelId, (ops, meta) => {
-      listener(
-        ops,
-        toChannelContext(channelId, defaults, meta)
-      );
-    });
+    const raw = rawOf(current);
+    if (raw !== current) {
+      current = raw;
+      continue;
+    }
+    break;
   }
-  function applyOps2(state, operations, meta) {
-    applyOps(state, operations, stampChannelMeta(channelId, meta));
+  return current;
+}
+var recordFor = (key) => {
+  let record = identityRecords.get(key);
+  if (record === void 0) {
+    record = {};
+    identityRecords.set(key, record);
   }
-  return { transact: transact2, subscribe: subscribe3, applyOps: applyOps2 };
+  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/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;
+// src/peelReadProxy.ts
+function peelReadProxy(value) {
+  if (!isObjectLike(value)) return value;
   let current = value;
-  while (isObjectLike5(current)) {
-    const registeredTarget = getRegisteredWrapperTarget(current);
+  while (isObjectLike(current)) {
+    const registeredTarget = getRegisteredReadProxyTarget(current);
     if (registeredTarget === void 0) break;
     current = registeredTarget;
   }
@@ -1540,32 +679,32 @@ function unwrapWrapper(value) {
 }
 
 // src/isState.ts
-var { proxyStateMap: proxyStateMap6 } = unstable_getInternalStates();
 function isState(value) {
-  const resolved = unwrapWrapper(value);
+  const resolved = peelReadProxy(value);
   if (typeof resolved !== "object" || resolved === null) return false;
-  return proxyStateMap6.has(resolved);
+  return recordOf(resolved)?.proxy === resolved;
 }
 
-// src/ignore.ts
-var ignore = ref;
-
 // src/tracked/facadeGuard.ts
 var assertMutableFacade = (facade, mutationKey) => {
-  const facadeSource = getUntracked(facade);
-  const isRegisteredCopy = getRegisteredTarget(facade) !== void 0 || facadeSource !== null && getRegisteredTarget(facadeSource) !== void 0;
   const descriptor = Reflect.getOwnPropertyDescriptor(facade, mutationKey);
-  if (isRegisteredCopy || descriptor !== void 0 && "writable" in descriptor && !descriptor.writable) {
-    throw new Error("opshot: cannot mutate a tracked collection snapshot");
+  if (descriptor !== void 0 && "writable" in descriptor && !descriptor.writable) {
+    throw new Error("opshot: cannot mutate a non-writable tracked collection");
   }
 };
 
 // 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,14 +727,21 @@ 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();
     this.epochMs = constructDate(args).getTime();
   }
   readDate() {
     return new Date(this.epochMs);
   }
+  readEpochMs() {
+    return clipTime(this.epochMs);
+  }
   write(mutate) {
     assertMutableFacade(this, "epochMs");
     const epochMs = mutate(this.readDate());
@@ -1621,10 +767,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 +884,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 +896,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,8 +923,57 @@ 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
@@ -1796,8 +983,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,25 +993,20 @@ 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 isObjectLike2 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+var isStoredValue = (stored, incoming) => {
+  if (Object.is(stored, incoming)) return true;
+  return isObjectLike2(stored) && isObjectLike2(incoming) && isSameIdentity(stored, incoming);
 };
-
-// src/tracked/trackedMap.ts
 var TrackedMap = class {
   constructor(entries) {
-    installBoundary();
     this.slots = [];
     this.index = {};
     this.count = 0;
@@ -1844,23 +1026,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");
@@ -1901,7 +1089,6 @@ Object.defineProperty(TrackedMap.prototype, Symbol.toStringTag, {
 // src/tracked/trackedSet.ts
 var TrackedSet = class {
   constructor(values) {
-    installBoundary();
     this.slots = [];
     this.index = {};
     this.count = 0;
@@ -1915,17 +1102,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 +1152,192 @@ 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";
-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;
+// src/emit/emitterListeners.ts
+var bindings = /* @__PURE__ */ new WeakMap();
+function addStateListener(state, listener, deliver) {
+  const handle = requireHandle(state, "opshot: subscribe requires a state");
+  handle.subscribers.set(listener, deliver);
+  const unsubscribe = () => {
+    const held = bindings.get(unsubscribe);
+    if (held === void 0) return;
+    held.handle.subscribers.delete(held.listener);
+    bindings.delete(unsubscribe);
+  };
+  bindings.set(unsubscribe, { handle, listener });
+  return unsubscribe;
+}
+
+// src/subscribe.ts
+function subscribe(state, listener) {
+  return addStateListener(state, listener, listener);
+}
+
+// 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 canRebuild = (container) => !isDangerousKind(classifyValue(container));
+var childRole = (value, writable, mode) => {
+  if (typeof value !== "object" || value === null) return "skip";
+  if (isReactOwnNode(value)) return "skip";
+  if (!isTrackedEntry(value, mode === "entry" || writable)) return "skip";
+  if (isState(value)) return "state";
+  if (canRebuild(value)) 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 (Object.isFrozen(container) || !canRebuild(container)) 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) || !canRebuild(root)) {
+    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 KEYS_PROPERTY = "k";
+var HAS_KEY_PROPERTY = "h";
+var HAS_OWN_KEY_PROPERTY = "o";
+var ALL_OWN_KEYS_PROPERTY = "w";
+var isWriteProxy = (value) => recordOf(value)?.proxy === value;
 var getUsage = (affected, target) => {
   let used = affected.get(target);
   if (used === void 0) {
@@ -1977,13 +1346,19 @@ var getUsage = (affected, target) => {
   }
   return used;
 };
-var recordKey = (used, type, key) => {
-  let set = used[type];
-  if (set === void 0) {
-    set = /* @__PURE__ */ new Set();
-    used[type] = set;
-  }
-  set.add(key);
+var recordIn = (slot, key, value) => {
+  const map = slot ?? /* @__PURE__ */ new Map();
+  if (!map.has(key)) map.set(key, value);
+  return map;
+};
+var recordGet = (used, key, value) => {
+  used[KEYS_PROPERTY] = recordIn(used[KEYS_PROPERTY], key, value);
+};
+var recordHas = (used, key, value) => {
+  used[HAS_KEY_PROPERTY] = recordIn(used[HAS_KEY_PROPERTY], key, value);
+};
+var recordOwn = (used, key, value) => {
+  used[HAS_OWN_KEY_PROPERTY] = recordIn(used[HAS_OWN_KEY_PROPERTY], key, value);
 };
 var getPrototypeMethod = (target, prop) => {
   let prototype = Reflect.getPrototypeOf(target);
@@ -1997,260 +1372,215 @@ 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);
-  }
-  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 UnregisteredReadTrackerError = class extends Error {
+  constructor() {
+    super("opshot: readsIntersectDirty received an unregistered tracker");
+    this.name = "UnregisteredReadTrackerError";
+  }
+};
+var trackerPartitions = /* @__PURE__ */ new WeakMap();
+var partitionsOf = (tracker) => {
+  const partitions = trackerPartitions.get(tracker);
+  if (partitions === void 0) throw new UnregisteredReadTrackerError();
+  return partitions;
+};
+var recordedKeysOf = (used) => {
+  const keyMaps = new Array();
+  if (used[KEYS_PROPERTY] !== void 0) keyMaps.push(used[KEYS_PROPERTY]);
+  if (used[HAS_KEY_PROPERTY] !== void 0) keyMaps.push(used[HAS_KEY_PROPERTY]);
+  if (used[HAS_OWN_KEY_PROPERTY] !== void 0) keyMaps.push(used[HAS_OWN_KEY_PROPERTY]);
+  return keyMaps;
+};
+function readsIntersectDirty(tracker, dirty) {
+  for (const partition of partitionsOf(tracker).values()) {
+    for (const [writeProxy, used] of partition.affected) {
+      const raw = rawOf(writeProxy);
+      const edges = dirty.edges.get(raw);
+      for (const keys of recordedKeysOf(used)) {
+        for (const key of keys.keys()) {
+          if (typeof key === "symbol") continue;
+          if (edges?.has(key) === true) return true;
+        }
+      }
+      if (used[ALL_OWN_KEYS_PROPERTY] !== void 0 && dirty.nodes.has(raw)) return true;
+    }
+    for (const writeProxy of partition.identityReads) {
+      if (partition.affected.has(writeProxy)) continue;
+      if (dirty.nodes.has(rawOf(writeProxy))) return true;
+    }
+  }
+  return false;
+}
+function readsChanged(tracker) {
+  for (const partition of partitionsOf(tracker).values()) {
+    for (const [writeProxy, used] of partition.affected) {
+      const gets = used[KEYS_PROPERTY];
+      if (gets !== void 0) {
+        for (const [key, stored] of gets) {
+          if (!Object.is(Reflect.get(writeProxy, key, writeProxy), stored)) return true;
+        }
+      }
+      const hasKeys = used[HAS_KEY_PROPERTY];
+      if (hasKeys !== void 0) {
+        for (const [key, stored] of hasKeys) {
+          if (!Object.is(Reflect.has(writeProxy, key), stored)) return true;
+        }
+      }
+      const ownKeys = used[HAS_OWN_KEY_PROPERTY];
+      if (ownKeys !== void 0) {
+        for (const [key, stored] of ownKeys) {
+          const present = Reflect.getOwnPropertyDescriptor(writeProxy, key) !== void 0;
+          if (!Object.is(present, stored)) return true;
+        }
+      }
+      const listed = used[ALL_OWN_KEYS_PROPERTY];
+      if (listed !== void 0) {
+        const current = Reflect.ownKeys(writeProxy);
+        if (current.length !== listed.length) return true;
+        for (let index = 0; index < listed.length; index += 1) {
+          if (!Object.is(current[index], listed[index])) 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 (isObjectLike(value) && isWriteProxy(value)) partition.identityReads.add(value);
   };
-  const wrapLive = (liveProxy, partition) => {
-    ensureBaseline(partition, liveProxy);
-    registerTarget(liveProxy);
-    const cached = partition.proxyCache.get(liveProxy);
+  const toReadProxy = (writeProxy, partition) => {
+    const raw = rawOf(writeProxy);
+    const cached = partition.proxyCache.get(raw);
     if (cached !== void 0) return cached;
-    const storageTarget = getProxyTarget(liveProxy);
-    const wrapperBox = {};
-    const handler = {
+    const target = raw;
+    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 handler2 = {
       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);
+        recordGet(used, prop, value);
+        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 (!isObjectLike(value)) return value;
         if (typeof value === "function") return value;
-        if (refSet6.has(value)) return value;
-        if (!isLiveProxy(value)) return value;
-        return wrapLive(value, partition);
+        if (!isWriteProxy(value)) return value;
+        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);
+        const result = Reflect.has(writeProxy, prop);
+        recordHas(used, prop, result);
+        return result;
       },
       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);
+        const descriptor = Reflect.getOwnPropertyDescriptor(writeProxy, prop);
+        recordOwn(used, prop, descriptor !== void 0);
+        return descriptor;
       },
       ownKeys() {
-        const used = trackUsage(partition, liveProxy);
-        used[ALL_OWN_KEYS_PROPERTY2] = true;
-        ensureBaseline(partition, liveProxy);
-        return Reflect.ownKeys(liveProxy);
+        const used = trackUsage(partition, writeProxy);
+        const keys = Reflect.ownKeys(writeProxy);
+        used[ALL_OWN_KEYS_PROPERTY] ??= keys;
+        return keys;
       },
       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, handler2);
+    readProxyBox.current = readProxy;
+    registerReadProxyTarget(readProxy, writeProxy);
+    partition.proxyCache.set(raw, readProxy);
+    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 (!isWriteProxy(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();
+        partition.proxyCache = /* @__PURE__ */ new WeakMap();
       }
     },
-    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 +1597,85 @@ 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([]);
+    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;
-      }
-    }
-    const renderedProps = changed ? nextProps : props;
-    const versionsAtRender = sources.map((source) => getVersion(source));
-    useEffect(() => {
-      boundary.captureReads();
+    readTracker.resetReads();
+    const { props: renderedProps, sources } = substituteStates(props, (source) => readTracker.wrap(source));
+    const uniqueHandles = uniqueHandlesOf(sources);
+    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);
+      const unsubscribes = subscribedHandles.map(
+        (handle) => subscribe(proxyOf(handle.root), () => {
+          if (cancelled) return;
+          const dirty = handle.lastDirty;
+          if (dirty !== void 0 && readsIntersectDirty(readTracker, dirty)) bump();
+        })
       );
+      if (readsChanged(readTracker)) bump();
       return () => {
+        cancelled = true;
         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 useMutableState(properties, group) {
-  const [{ proxy: proxy2, boundary }] = useState(() => ({
-    proxy: createMutableState(typeof properties === "function" ? properties() : properties, group),
-    boundary: createBoundary()
-  }));
+var isObjectLike3 = (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 uniqueHandles = isObjectLike3(writeProxy) ? handlesOf(writeProxy) : [];
+  readTracker.resetReads();
+  const readProxy = isObjectLike3(writeProxy) ? readTracker.wrap(writeProxy) : writeProxy;
+  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 = isObjectLike3(writeProxy) ? handlesOf(writeProxy) : [];
+    const unsubscribes = subscribedHandles.map(
+      (handle) => subscribe(proxyOf(handle.root), () => {
+        if (cancelled) return;
+        const dirty = handle.lastDirty;
+        if (dirty !== void 0 && readsIntersectDirty(readTracker, dirty)) bump();
+      })
+    );
+    if (readsChanged(readTracker)) bump();
+    return () => {
+      cancelled = true;
+      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, batch, createMutableState, identify, ignore, isSameIdentity, isState, scope, subscribe, unsafeTrack, useMutableState };