opshot 0.4.0 → 0.5.1

package/dist/index.js

@@ -1,2019 +1,14 @@
 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 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 getUntracked = (obj) => {
-  if (isObjectToTrack(obj)) {
-    return obj[GET_ORIGINAL_SYMBOL] || null;
-  }
-  return null;
-};
-var markToTrack = (obj, mark = true) => {
-  objectsToTrack.set(obj, mark);
-};
-
-// node_modules/valtio/esm/vanilla.mjs
-var isObject = (x) => typeof x === "object" && x !== null;
-var canProxyDefault = (x) => isObject(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer) && !(x instanceof Promise);
-var createSnapshotDefault = (target, version) => {
-  const cache = snapCache.get(target);
-  if ((cache == null ? void 0 : cache[0]) === version) {
-    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 (isObject(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 (!isObject(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");
-  }
-  const ops = [];
-  const addListener = proxyState[2];
-  const listener = (op) => {
-    if (op) {
-      ops.push(op);
-    }
-    {
-      callback(ops.splice(0));
-      return;
-    }
-  };
-  const removeListener = addListener(listener);
-  return () => {
-    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 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/declarations.ts
-function createDeclarationTrie() {
-  return { ignored: false, unsafe: false, children: /* @__PURE__ */ new Map() };
-}
-function declarationChild(trie, key) {
-  return trie?.children.get(String(key));
-}
-function ensureDeclarationChild(trie, key) {
-  const name = String(key);
-  const existing = trie.children.get(name);
-  if (existing !== void 0) return existing;
-  const child = createDeclarationTrie();
-  trie.children.set(name, child);
-  return child;
-}
-function declarationAtPath(trie, path) {
-  let current = trie;
-  for (const segment of path) current = ensureDeclarationChild(current, segment);
-  return current;
-}
-function graftDeclarationChildren(source, target) {
-  for (const [key, sourceChild] of source.children) {
-    const targetChild = ensureDeclarationChild(target, key);
-    if (sourceChild.ignored) targetChild.ignored = true;
-    if (sourceChild.unsafe) targetChild.unsafe = true;
-    graftDeclarationChildren(sourceChild, targetChild);
-  }
-}
-function hasDeclarations(trie) {
-  if (trie.ignored || trie.unsafe) return true;
-  for (const child of trie.children.values()) {
-    if (hasDeclarations(child)) return true;
-  }
-  return false;
-}
-
-// src/identity.ts
-var isObjectLike = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-var targetRegistry = /* @__PURE__ */ new WeakMap();
-var readProxyTargets = /* @__PURE__ */ new WeakMap();
-var identityRecords = /* @__PURE__ */ new WeakMap();
-var nextInternId = 0;
-var { proxyStateMap: proxyStateMap2 } = unstable_getInternalStates();
-function registerSnapshotCopy(copy, target) {
-  targetRegistry.set(copy, target);
-}
-function getRegisteredTarget(copy) {
-  return targetRegistry.get(copy);
-}
-var registerReadProxyTarget = (readProxy, target) => {
-  readProxyTargets.set(readProxy, target);
-};
-var getRegisteredReadProxyTarget = (readProxy) => readProxyTargets.get(readProxy);
-function peelIdentityLayer(current) {
-  const untracked = getUntracked(current);
-  if (untracked !== null && untracked !== current) return untracked;
-  const readProxyTarget = getRegisteredReadProxyTarget(current);
-  if (readProxyTarget !== void 0 && readProxyTarget !== current) return readProxyTarget;
-  const registeredTarget = targetRegistry.get(current);
-  if (registeredTarget !== void 0 && registeredTarget !== current) return registeredTarget;
-  return void 0;
-}
-function resolveIdentity(value) {
-  let current = value;
-  while (isObjectLike(current)) {
-    const peeled = peelIdentityLayer(current);
-    if (peeled !== void 0) {
-      current = peeled;
-      continue;
-    }
-    const entry = proxyStateMap2.get(current);
-    if (entry !== void 0) {
-      const target = entry[0];
-      if (target !== current) {
-        current = target;
-        continue;
-      }
-    }
-    break;
-  }
-  return current;
-}
-var recordFor = (key) => {
-  let record = identityRecords.get(key);
-  if (record === void 0) {
-    record = {};
-    identityRecords.set(key, record);
-  }
-  return record;
-};
-function identify(value) {
-  const target = resolveIdentity(value);
-  if (!isObjectLike(target)) return value;
-  const record = recordFor(target);
-  if (record.token !== void 0) return record.token;
-  const token = Object.freeze({});
-  record.token = token;
-  return token;
-}
-var internIdentity = (key) => {
-  const resolved = resolveIdentity(key);
-  const record = recordFor(resolved);
-  if (record.id !== void 0) return record.id;
-  const id = nextInternId;
-  nextInternId += 1;
-  record.id = id;
-  return id;
-};
-function isSameIdentity(first, second) {
-  const resolvedFirst = resolveIdentity(first);
-  const resolvedSecond = resolveIdentity(second);
-  return resolvedFirst === resolvedSecond;
-}
-
-// src/peelReadProxy.ts
-var { proxyStateMap: proxyStateMap3 } = unstable_getInternalStates();
-var isObjectLike2 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-function peelReadProxy(value) {
-  if (!isObjectLike2(value) || proxyStateMap3.has(value)) return value;
-  let current = value;
-  while (isObjectLike2(current)) {
-    const registeredTarget = getRegisteredReadProxyTarget(current);
-    if (registeredTarget === void 0) break;
-    current = registeredTarget;
-  }
-  return current;
-}
-
-// src/handle.ts
-var occupancies = /* @__PURE__ */ new WeakMap();
-var { proxyStateMap: proxyStateMap4 } = unstable_getInternalStates();
-var rawTargetOf = (value) => proxyStateMap4.get(value)?.[0] ?? value;
-function registerHandle(target, handle) {
-  let occupants = occupancies.get(target);
-  if (occupants === void 0) {
-    occupants = /* @__PURE__ */ new Set();
-    occupancies.set(target, occupants);
-  }
-  for (const reference of occupants) {
-    if (reference.deref() === handle) return;
-  }
-  occupants.add(new WeakRef(handle));
-}
-var rawOf = (node) => {
-  const peeled = peelReadProxy(node);
-  return rawTargetOf(typeof peeled === "object" && peeled !== null ? peeled : node);
-};
-function handlesOf(node) {
-  const target = rawOf(node);
-  const occupants = occupancies.get(target);
-  if (occupants === void 0) return [];
-  const handles = new Array();
-  for (const reference of occupants) {
-    const handle = reference.deref();
-    if (handle === void 0) {
-      occupants.delete(reference);
-      continue;
-    }
-    handles.push(handle);
-  }
-  return handles;
-}
-function handleOf(node) {
-  const target = rawOf(node);
-  for (const handle of handlesOf(node)) {
-    if (rawTargetOf(handle.proxy.root) === target) return handle;
-  }
-  return void 0;
-}
-function requireHandle(state, message) {
-  const handle = handleOf(state);
-  if (handle === void 0) throw new Error(message);
-  return handle;
-}
-
-// src/ops/predicates.ts
-var MAX_ARRAY_LENGTH = 4294967295;
-var isObjectLike3 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-var isCanonicalArrayIndex = (segment) => Number.isInteger(segment) && typeof segment === "number" && segment >= 0 && segment < MAX_ARRAY_LENGTH;
-var isCanonicalArrayIndexString = (key) => {
-  const index = Number(key);
-  return Number.isInteger(index) && index >= 0 && index < MAX_ARRAY_LENGTH && String(index) === key;
-};
-
-// src/utils/dataEntries.ts
-var walkDataEntries = (value, includeArrayLength = false) => {
-  const entries = new Array();
-  for (const key of Object.keys(value)) {
-    if (key === "__proto__") continue;
-    const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
-    if (!descriptor || !("value" in descriptor)) continue;
-    entries.push({ key, value: descriptor.value, writable: descriptor.writable === true });
-  }
-  if (includeArrayLength && Array.isArray(value)) {
-    const lengthDescriptor = Reflect.getOwnPropertyDescriptor(value, "length");
-    entries.push({
-      key: "length",
-      value: value.length,
-      writable: lengthDescriptor?.writable === true
-    });
-  }
-  return entries;
-};
-var segmentFor = (parent, key) => Array.isArray(parent) && isCanonicalArrayIndexString(key) ? Number(key) : key;
-var dataEntryValuesOf = (value) => {
-  const entries = /* @__PURE__ */ new Map();
-  for (const entry of walkDataEntries(value)) {
-    entries.set(entry.key, entry.value);
-  }
-  return entries;
-};
-var carriedOwnKeysOf = (value) => Reflect.ownKeys(value).filter((key) => key !== "__proto__");
-
-// src/valtio/classify.ts
-var sourceCache = /* @__PURE__ */ new WeakMap();
-var kindCache = /* @__PURE__ */ new WeakMap();
-var readSource = (constructor) => {
-  const cached = sourceCache.get(constructor);
-  if (cached !== void 0) return cached;
-  const source = Function.prototype.toString.call(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 (hasPrivateName(source)) {
-      kind = "privateClass";
-      break;
-    }
-    if (source.includes("[native code]")) sawNativeSource = true;
-    current = Reflect.getPrototypeOf(current);
-  }
-  if (kind !== "privateClass") kind = sawNativeSource ? "nativeClass" : "cleanClass";
-  kindCache.set(initialConstructor, kind);
-  return kind;
-};
-function classifyValue(value) {
-  const prototype = Object.getPrototypeOf(value);
-  if (Array.isArray(value))
-    return prototype === Array.prototype || prototype === null ? "plainArray" : "arraySubclass";
-  if (prototype === Object.prototype || prototype === null) return "plain";
-  return classifyChain(value.constructor);
-}
-function unfrozenAdmissionDecision(value) {
-  if (typeof value !== "object" || value === null) return { lane: "leaf" };
-  const kind = classifyValue(value);
-  if (kind === "plain" || kind === "plainArray" || kind === "cleanClass") return { lane: "tracked" };
-  return { lane: "dangerous", kind };
-}
-function admissionDecision(value) {
-  if (typeof value !== "object" || value === null) return { lane: "leaf" };
-  if (Object.isFrozen(value)) return { lane: "untracked" };
-  return unfrozenAdmissionDecision(value);
-}
-function admissionLane(value) {
-  return admissionDecision(value).lane;
-}
-function unfrozenAdmissionLane(value) {
-  return unfrozenAdmissionDecision(value).lane;
-}
-
-// src/ops/cloneValue.ts
-var { proxyStateMap: proxyStateMap5 } = unstable_getInternalStates();
-var MissingOwnDescriptorError = class extends Error {
-  constructor() {
-    super("opshot: carried own key has no property descriptor");
-    this.name = "MissingOwnDescriptorError";
-  }
-};
-var isInstrumented = (value) => proxyStateMap5.has(value) || getRegisteredTarget(value) !== void 0;
-var isPlainArray = (value) => Array.isArray(value);
-var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && (admissionLane(value) === "tracked" || isInstrumented(value));
-var isStructurallyCloneableFrozen = (value) => {
-  if (!Object.isFrozen(value)) return false;
-  if (Array.isArray(value)) return true;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-};
-var isCloneable = (value) => typeof value === "object" && value !== null && (admissionLane(value) === "tracked" || isInstrumented(value) || isStructurallyCloneableFrozen(value));
-var cloneValue = (value, memo2, path) => {
-  if (!isCloneable(value)) return value;
-  const cached = memo2.get(value);
-  if (cached !== void 0) return cached;
-  const array = isPlainArray(value);
-  const clone = array ? [] : {};
-  Reflect.setPrototypeOf(clone, Reflect.getPrototypeOf(value));
-  memo2.set(value, clone);
-  for (const key of carriedOwnKeysOf(value)) {
-    const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
-    if (descriptor === void 0) throw new MissingOwnDescriptorError();
-    if ("value" in descriptor) {
-      Object.defineProperty(clone, key, {
-        ...descriptor,
-        value: cloneValue(descriptor.value, memo2)
-      });
-    } else {
-      Object.defineProperty(clone, key, descriptor);
-    }
-  }
-  if (Object.isFrozen(value)) Object.freeze(clone);
-  return clone;
-};
-
-// src/ops/path.ts
-var createOperationPath = (segments) => Array.isArray(segments) && Object.isFrozen(segments) ? segments : Object.freeze([...segments]);
-var appendOperationPath = (path, segment) => Object.freeze([...path, segment]);
-var formatSegment = (segment) => String(segment);
-var formatOperationPath = (path) => path.length === 0 ? "/" : `/${path.map(formatSegment).join("/")}`;
-
-// src/ops/operation.ts
-var operationBrand = /* @__PURE__ */ Symbol.for("opshot.operation");
-var valueOriginals = /* @__PURE__ */ new WeakMap();
-var OperationHalf = class {
-  constructor(path) {
-    this.path = createOperationPath(path);
-  }
-};
-Object.defineProperty(OperationHalf.prototype, operationBrand, { value: true });
-var AssignHalf = class extends OperationHalf {
-  constructor(path, value, original = value, ids) {
-    super(path);
-    this.verb = "assign";
-    valueOriginals.set(this, original);
-    this.value = cloneValue(value, /* @__PURE__ */ new WeakMap(), this.path);
-    if (ids !== void 0) this.ids = ids;
-  }
-};
-var DeleteHalf = class extends OperationHalf {
-  constructor() {
-    super(...arguments);
-    this.verb = "delete";
-  }
-};
-var LinkHalf = class extends OperationHalf {
-  constructor(path, ref) {
-    super(path);
-    this.verb = "link";
-    this.ref = ref;
-  }
-};
-var stampOf = (operation) => {
-  const value = Object.getOwnPropertyDescriptor(operation, "stamp")?.value;
-  return typeof value === "object" && value !== null ? value : void 0;
-};
-var versionOf = (operation) => {
-  const value = Reflect.get(operation, "version");
-  return typeof value === "number" && Number.isInteger(value) ? value : void 0;
-};
-var stampOperation = (handle, operation) => {
-  handle.version += 1;
-  Object.defineProperty(operation, "stamp", { value: handle.stamp, enumerable: false });
-  Object.defineProperty(operation, "version", { value: handle.version, enumerable: true });
-};
-var isMutation = (value) => typeof value === "object" && value !== null && operationBrand in value;
-var getValueOriginal = (half) => valueOriginals.get(half);
-var createAssignMutation = (path, value, original = value, ids) => new AssignHalf(path, value, original, ids);
-var createDeleteMutation = (path) => new DeleteHalf(path);
-var createLinkMutation = (path, ref) => new LinkHalf(path, ref);
-
-// src/intern.ts
-var { proxyStateMap: proxyStateMap6, proxyCache: proxyCache2 } = unstable_getInternalStates();
-var rawTargetOf2 = (value) => proxyStateMap6.get(value)?.[0] ?? value;
-var occupancyNodeOf = (node) => {
-  const peeled = peelReadProxy(node);
-  const object = typeof peeled === "object" && peeled !== null ? peeled : node;
-  return rawTargetOf2(getRegisteredTarget(object) ?? object);
-};
-var liveOfInterned = (raw) => proxyCache2.get(raw) ?? raw;
-var departingNodes = /* @__PURE__ */ new WeakMap();
-var committedIdOf = (handle, raw) => handle.nodes.get(raw)?.id;
-var writeId = (handle, raw, id) => {
-  const record = handle.nodes.get(raw);
-  if (record === void 0) handle.nodes.set(raw, { edges: [], id });
-  else {
-    if (record.id !== void 0 && record.id !== id) handle.byId.delete(record.id);
-    record.id = id;
-  }
-  handle.byId.set(id, raw);
-};
-function internNode(handle, node) {
-  const raw = occupancyNodeOf(node);
-  const existing = committedIdOf(handle, raw);
-  if (existing !== void 0) return existing;
-  const id = handle.nextInternId;
-  handle.nextInternId += 1;
-  writeId(handle, raw, id);
-  return id;
-}
-var stagedBindIdOf = (capture, raw) => capture.bindIdByNode.get(raw);
-var stagedMintIdOf = (capture, raw) => capture.mintIdByNode.get(raw);
-var stagedNodeOf = (capture, id) => capture.bindNodeById.get(id) ?? capture.mintNodeById.get(id);
-var nextStagedIdOf = (handle, capture) => Math.max(handle.nextInternId, capture.nextStagedId);
-var stageMint = (capture, raw, id) => {
-  capture.mints.push({ node: raw, id });
-  capture.mintIdByNode.set(raw, id);
-  capture.mintNodeById.set(id, raw);
-  if (id + 1 > capture.nextStagedId) capture.nextStagedId = id + 1;
-};
-var stageBind = (capture, raw, id) => {
-  capture.binds.push({ node: raw, id });
-  capture.bindIdByNode.set(raw, id);
-  capture.bindNodeById.set(id, raw);
-  if (id + 1 > capture.nextStagedId) capture.nextStagedId = id + 1;
-};
-var namedRawOf = (handle, id, capture) => {
-  const staged = capture === void 0 ? void 0 : stagedNodeOf(capture, id);
-  return staged ?? handle.byId.get(id);
-};
-function internedIdOf(handle, node, capture) {
-  const raw = occupancyNodeOf(node);
-  const bound = capture === void 0 ? void 0 : stagedBindIdOf(capture, raw);
-  if (bound !== void 0) return bound;
-  const committed = committedIdOf(handle, raw);
-  if (committed !== void 0) return committed;
-  if (capture === void 0) return void 0;
-  return stagedMintIdOf(capture, raw);
-}
-function stageVend(handle, capture, node) {
-  const raw = occupancyNodeOf(node);
-  const bound = stagedBindIdOf(capture, raw);
-  if (bound !== void 0) return bound;
-  const committed = committedIdOf(handle, raw);
-  if (committed !== void 0) return committed;
-  const staged = stagedMintIdOf(capture, raw);
-  if (staged !== void 0) return staged;
-  const id = nextStagedIdOf(handle, capture);
-  stageMint(capture, raw, id);
-  return id;
-}
-var commitName = (handle, raw, id) => {
-  writeId(handle, raw, id);
-  if (id >= handle.nextInternId) handle.nextInternId = id + 1;
-};
-function commitVends(handle, capture) {
-  for (const { node, id } of capture.mints) commitName(handle, node, id);
-  capture.mints.length = 0;
-  for (const { node, id } of capture.binds) commitName(handle, node, id);
-  capture.binds.length = 0;
-  capture.bindIdByNode.clear();
-  capture.bindNodeById.clear();
-  capture.mintIdByNode.clear();
-  capture.mintNodeById.clear();
-  capture.nextStagedId = 0;
-}
-function nodeOfInternedId(handle, id, capture) {
-  const raw = namedRawOf(handle, id, capture);
-  if (raw === void 0) return void 0;
-  return liveOfInterned(raw);
-}
-var walkTracked = (node, visits, chains, resolve, visit) => {
-  const walk = (current, currentChains, parent, key) => {
-    const raw = occupancyNodeOf(current);
-    if (visits.has(raw)) return;
-    visits.add(raw);
-    if (admissionLane(current) === "untracked") return;
-    if (!visit(current, raw, parent, key)) return;
-    const source = getRegisteredTarget(current) ?? current;
-    for (const entry of walkDataEntries(source)) {
-      if (typeof entry.value !== "object" || entry.value === null) continue;
-      if (currentChains === void 0 || resolve === void 0) {
-        walk(entry.value, currentChains, current, entry.key);
-        continue;
-      }
-      const childChains = resolve(source, currentChains, segmentFor(source, entry.key), entry);
-      if (childChains === void 0) continue;
-      walk(entry.value, childChains, current, entry.key);
-    }
-  };
-  walk(node, chains);
-};
-function internSubtree(handle, node, chains, resolve, capture) {
-  walkTracked(node, /* @__PURE__ */ new Set(), chains, resolve, (current) => {
-    if (capture === void 0) internNode(handle, current);
-    else stageVend(handle, capture, current);
-    return true;
-  });
-}
-function queueDeparture(handle, node) {
-  const raw = occupancyNodeOf(node);
-  let queued = departingNodes.get(handle);
-  if (queued === void 0) {
-    queued = /* @__PURE__ */ new Set();
-    departingNodes.set(handle, queued);
-  }
-  queued.add(raw);
-}
-var parentOfEdge = (parent) => occupancyNodeOf(parent);
-var isOccupiedMember = (handle, node) => {
-  const root = rawTargetOf2(handle.proxy.root);
-  const raw = occupancyNodeOf(node);
-  if (raw === root) return true;
-  const seen = /* @__PURE__ */ new Set();
-  const walk = (current) => {
-    if (current === root) return true;
-    if (seen.has(current)) return false;
-    seen.add(current);
-    const edges = handle.nodes.get(current)?.edges;
-    if (edges === void 0) return false;
-    for (const edge of edges) {
-      if (walk(parentOfEdge(edge.parent))) return true;
-    }
-    return false;
-  };
-  return walk(raw);
-};
-var walkUnoccupiedCluster = (handle, node, visit) => {
-  walkTracked(node, /* @__PURE__ */ new Set(), void 0, void 0, (_current, raw) => {
-    if (isOccupiedMember(handle, raw)) return false;
-    visit(raw, committedIdOf(handle, raw));
-    return true;
-  });
-};
-var isNamedSlot = (handle, raw, evicted) => handle.nodes.has(raw) || evicted?.has(raw) === true;
-var walkSlots = (carried, node, isTracked, visit) => {
-  const visits = /* @__PURE__ */ new Set();
-  const walk = (carriedCurrent, current, parent, key) => {
-    const raw = occupancyNodeOf(current);
-    const looping = visits.has(raw);
-    if (!looping) visits.add(raw);
-    if (admissionLane(current) === "untracked") return;
-    if (!isTracked(raw)) return;
-    if (!visit(raw, parent, key) || looping) return;
-    for (const entry of walkDataEntries(carriedCurrent)) {
-      if (typeof entry.value !== "object" || entry.value === null) continue;
-      const child = Reflect.get(current, entry.key);
-      if (typeof child !== "object" || child === null) continue;
-      walk(entry.value, child, current, entry.key);
-    }
-  };
-  walk(carried, node);
-};
-function evictDepartedClusters(handle) {
-  const evicted = /* @__PURE__ */ new Map();
-  const queued = departingNodes.get(handle);
-  if (queued === void 0) return evicted;
-  const ungrounded = new Array();
-  for (const node of queued) {
-    if (!isOccupiedMember(handle, node)) ungrounded.push(node);
-  }
-  queued.clear();
-  const members = new Array();
-  for (const node of ungrounded) {
-    walkUnoccupiedCluster(handle, node, (raw, id) => {
-      members.push(raw);
-      if (id !== void 0) evicted.set(raw, id);
-    });
-  }
-  for (const raw of members) handle.nodes.delete(raw);
-  for (const id of evicted.values()) handle.byId.delete(id);
-  return evicted;
-}
-function bindVendedIds(handle, node, carried, ids, capture, parent, key) {
-  let index = 0;
-  walkSlots(
-    carried,
-    node,
-    (raw) => isNamedSlot(handle, raw),
-    (raw, walkParent, walkKey) => {
-      const id = ids[index];
-      if (id === void 0) return true;
-      index += 1;
-      const held = namedRawOf(handle, id, capture);
-      const slotParent = walkParent ?? parent;
-      const slotKey = walkKey ?? key;
-      if (held !== void 0) {
-        if (occupancyNodeOf(held) !== raw && slotParent !== void 0 && slotKey !== void 0) {
-          Reflect.set(slotParent, slotKey, liveOfInterned(held));
-        }
-        return false;
-      }
-      if (capture === void 0) commitName(handle, raw, id);
-      else stageBind(capture, raw, id);
-      return true;
-    }
-  );
-}
-function rewindAdmission(handle, node) {
-  const ids = new Array();
-  walkUnoccupiedCluster(handle, node, (raw, id) => {
-    if (id === void 0) return;
-    ids.push(id);
-    const record = handle.nodes.get(raw);
-    if (record !== void 0) record.id = void 0;
-    handle.byId.delete(id);
-  });
-  return ids;
-}
-function annotateDepartureUndos(handle, ops, evicted) {
-  if (evicted.size === 0) return;
-  const claimedMembers = /* @__PURE__ */ new Set();
-  for (let index = ops.length - 1; index >= 0; index--) {
-    const operation = ops[index];
-    if (operation === void 0) continue;
-    const undo = operation.undo;
-    if (undo.verb !== "assign") continue;
-    const original = getValueOriginal(undo) ?? undo.value;
-    if (typeof original !== "object" || original === null) continue;
-    const restoredId = evicted.get(occupancyNodeOf(original));
-    if (restoredId === void 0) continue;
-    const ids = new Array();
-    const claimsBefore = claimedMembers.size;
-    walkSlots(
-      original,
-      original,
-      (raw) => isNamedSlot(handle, raw, evicted),
-      (raw) => {
-        const retiredId = evicted.get(raw);
-        const id = retiredId ?? committedIdOf(handle, raw);
-        if (id !== void 0) ids.push(id);
-        if (retiredId === void 0 || claimedMembers.has(raw)) return false;
-        claimedMembers.add(raw);
-        return true;
-      }
-    );
-    operation.undo = claimedMembers.size > claimsBefore ? createAssignMutation(undo.path, undo.value, original, ids) : createLinkMutation(undo.path, restoredId);
-  }
-}
-
-// src/edges.ts
-var { proxyStateMap: proxyStateMap7 } = unstable_getInternalStates();
-var rawTargetOf3 = (value) => proxyStateMap7.get(value)?.[0] ?? value;
-var rawOf2 = (node) => {
-  const peeled = peelReadProxy(node);
-  return rawTargetOf3(typeof peeled === "object" && peeled !== null ? peeled : node);
-};
-var occupancyRootOf = (handle) => rawTargetOf3(handle.proxy.root);
-var edgesOf = (handle, node) => handle.nodes.get(node)?.edges;
-var pathHasIgnored = (trie, path) => {
-  if (trie.ignored) return true;
-  let current = trie;
-  for (const key of path) {
-    current = declarationChild(current, key);
-    if (current === void 0) return false;
-    if (current.ignored) return true;
-  }
-  return false;
-};
-var pathIsTainted = (trie, path) => {
-  if (trie.unsafe) return true;
-  let current = trie;
-  for (const key of path) {
-    current = declarationChild(current, key);
-    if (current === void 0) return false;
-    if (current.unsafe) return true;
-  }
-  return false;
-};
-var walkGroundedChains = (handle, node, onGround) => {
-  const root = occupancyRootOf(handle);
-  const walk = (current, reverseKeys, pathVisited) => {
-    if (current === root) return onGround([...reverseKeys].reverse());
-    if (pathVisited.has(current)) return false;
-    pathVisited.add(current);
-    const edges = edgesOf(handle, current);
-    if (edges !== void 0) {
-      for (const edge of edges) {
-        if (walk(rawOf2(edge.parent), [...reverseKeys, edge.key], pathVisited)) {
-          pathVisited.delete(current);
-          return true;
-        }
-      }
-    }
-    pathVisited.delete(current);
-    return false;
-  };
-  walk(rawOf2(node), [], /* @__PURE__ */ new Set());
-};
-function addInEdge(handle, node, parent, key) {
-  const rawNode = rawOf2(node);
-  const rawParent = rawOf2(parent);
-  let record = handle.nodes.get(rawNode);
-  if (record === void 0) {
-    record = { edges: [], id: void 0 };
-    handle.nodes.set(rawNode, record);
-  }
-  if (record.edges.some((edge) => rawOf2(edge.parent) === rawParent && edge.key === key)) return;
-  record.edges.push({ parent: rawParent, key });
-  registerHandle(rawNode, handle);
-}
-function hasOtherRoutes(handle, node, parent, key) {
-  const edges = handle.nodes.get(rawOf2(node))?.edges;
-  if (edges === void 0) return false;
-  const rawParent = rawOf2(parent);
-  return edges.some((edge) => rawOf2(edge.parent) !== rawParent || edge.key !== key);
-}
-function removeInEdge(handle, node, parent, key) {
-  const rawNode = rawOf2(node);
-  const rawParent = rawOf2(parent);
-  const record = handle.nodes.get(rawNode);
-  if (record === void 0) return;
-  const index = record.edges.findIndex((edge) => rawOf2(edge.parent) === rawParent && edge.key === key);
-  if (index === -1) return;
-  record.edges.splice(index, 1);
-  if (rawNode !== occupancyRootOf(handle)) queueDeparture(handle, rawNode);
-}
-function edgeStatusOf(handle, node) {
-  const rawNode = rawOf2(node);
-  const root = occupancyRootOf(handle);
-  if (rawNode === root) {
-    return { occupied: true, unsafe: handle.declarations?.unsafe === true };
-  }
-  if (handle.declarations === void 0) {
-    let occupied = false;
-    walkGroundedChains(handle, rawNode, () => {
-      occupied = true;
-      return true;
-    });
-    return { occupied, unsafe: false };
-  }
-  const declarations = handle.declarations;
-  const status = { occupied: false, hasClean: false };
-  walkGroundedChains(handle, rawNode, (pathFromRoot) => {
-    status.occupied = true;
-    if (!pathIsTainted(declarations, pathFromRoot)) {
-      status.hasClean = true;
-      return true;
-    }
-    return false;
-  });
-  return { occupied: status.occupied, unsafe: status.occupied && !status.hasClean };
-}
-function isIgnoredFrontier(handle, parent, key) {
-  const trie = handle.declarations;
-  if (trie === void 0) return false;
-  let hit = false;
-  walkGroundedChains(handle, parent, (pathFromRoot) => {
-    if (pathHasIgnored(trie, [...pathFromRoot, key])) {
-      hit = true;
-      return true;
-    }
-    return false;
-  });
-  return hit;
-}
-var uniqueNodeChains = (entries) => {
-  const unique = new Array();
-  const undefinedFlags = /* @__PURE__ */ new Set();
-  const definedFlags = /* @__PURE__ */ new WeakMap();
-  for (const entry of entries) {
-    const flags = `${entry.tainted ? "1" : "0"}${entry.ignored ? "1" : "0"}`;
-    if (entry.residual === void 0) {
-      if (undefinedFlags.has(flags)) continue;
-      undefinedFlags.add(flags);
-      unique.push(entry);
-      continue;
-    }
-    let seen = definedFlags.get(entry.residual);
-    if (seen === void 0) {
-      seen = /* @__PURE__ */ new Set();
-      definedFlags.set(entry.residual, seen);
-    }
-    if (seen.has(flags)) continue;
-    seen.add(flags);
-    unique.push(entry);
-  }
-  return unique;
-};
-var uniqueResiduals = (residuals) => {
-  const unique = new Array();
-  let sawUndefined = false;
-  const seen = /* @__PURE__ */ new Set();
-  for (const residual of residuals) {
-    if (residual === void 0) {
-      if (sawUndefined) continue;
-      sawUndefined = true;
-      unique.push(void 0);
-      continue;
-    }
-    if (seen.has(residual)) continue;
-    seen.add(residual);
-    unique.push(residual);
-  }
-  return unique;
-};
-var chainsAtNode = (handle, node, memo2, computing) => {
-  const raw = rawOf2(node);
-  const cached = memo2.get(raw);
-  if (cached !== void 0) return cached;
-  if (computing.has(raw)) return { occupied: false, entries: [], cut: true };
-  if (raw === occupancyRootOf(handle)) {
-    const trie = handle.declarations;
-    const result2 = {
-      occupied: true,
-      entries: [
-        {
-          residual: trie,
-          tainted: trie?.unsafe === true,
-          ignored: trie?.ignored === true
-        }
-      ],
-      cut: false
-    };
-    memo2.set(raw, result2);
-    return result2;
-  }
-  computing.add(raw);
-  const aggregated = new Array();
-  let occupied = false;
-  let cut = false;
-  const edges = edgesOf(handle, raw);
-  if (edges !== void 0) {
-    for (const edge of edges) {
-      const parent = chainsAtNode(handle, edge.parent, memo2, computing);
-      if (parent.cut) cut = true;
-      if (!parent.occupied) continue;
-      occupied = true;
-      for (const entry of parent.entries) {
-        const child = entry.residual === void 0 ? void 0 : declarationChild(entry.residual, edge.key);
-        aggregated.push({
-          residual: child,
-          tainted: entry.tainted || child?.unsafe === true,
-          ignored: entry.ignored || child?.ignored === true
-        });
-      }
-    }
-  }
-  computing.delete(raw);
-  const result = { occupied, entries: uniqueNodeChains(aggregated), cut };
-  if (!cut) memo2.set(raw, result);
-  return result;
-};
-function descendChains(chains, key) {
-  const next = new Array();
-  let ignored = false;
-  for (const residual of chains) {
-    if (residual === void 0) {
-      next.push(void 0);
-      continue;
-    }
-    const child = declarationChild(residual, key);
-    if (child?.ignored === true) ignored = true;
-    if (child?.unsafe === true) continue;
-    next.push(child);
-  }
-  return {
-    ignored,
-    unsafe: chains.length > 0 && next.length === 0,
-    chains: uniqueResiduals(next)
-  };
-}
-var childChainsOf = (chains, key) => descendChains(chains, key).chains;
-var isChainsIgnored = (chains) => chains.some((chain) => chain?.ignored === true);
-var isChainsUnsafe = (chains) => chains.length === 0;
-var chainsAtRoot = (declarations) => declarations?.unsafe === true ? [] : [declarations];
-function nodeChainsOf(handle, node) {
-  const nodeChains = chainsAtNode(handle, node, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
-  if (!nodeChains.occupied) return void 0;
-  const chains = new Array();
-  for (const entry of nodeChains.entries) {
-    if (entry.tainted) continue;
-    chains.push(entry.residual);
-  }
-  return uniqueResiduals(chains);
-}
-function slotStatusOf(handle, parent, key) {
-  const parentChains = chainsAtNode(handle, parent, /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
-  if (!parentChains.occupied) {
-    return { occupied: false, unsafe: false, ignored: false, chains: [] };
-  }
-  const chains = new Array();
-  let ignored = false;
-  for (const entry of parentChains.entries) {
-    const child = entry.residual === void 0 ? void 0 : declarationChild(entry.residual, key);
-    const slotIgnored = entry.ignored || child?.ignored === true;
-    const tainted = entry.tainted || child?.unsafe === true;
-    if (slotIgnored) ignored = true;
-    if (!tainted) chains.push(child);
-  }
-  return {
-    ignored,
-    occupied: true,
-    unsafe: chains.length === 0,
-    chains: uniqueResiduals(chains)
-  };
-}
-var isTrackedEdge = (entry) => {
-  const value = entry.value;
-  const target = isObjectLike3(value) ? getRegisteredTarget(value) ?? value : value;
-  return entry.writable && admissionLane(target) === "tracked";
-};
-var graphNodeOf = (value) => rawOf2(getRegisteredTarget(value) ?? value);
-function resolveChildChains(handle, parent, parentChains, key, child) {
-  const descended = descendChains(parentChains, key).chains;
-  const ignoredResidual = isChainsIgnored(parentChains) || isChainsIgnored(descended);
-  if (!isObjectLike3(parent) || !isObjectLike3(child)) {
-    if (ignoredResidual) return void 0;
-    return { chains: descended, descended, otherRoutes: false };
-  }
-  const graphParent = graphNodeOf(parent);
-  const graphChild = graphNodeOf(child);
-  const otherRoutes = hasOtherRoutes(handle, graphChild, graphParent, key);
-  const ignored = ignoredResidual || otherRoutes && isIgnoredFrontier(handle, graphParent, key);
-  if (ignored) return void 0;
-  const chains = otherRoutes ? nodeChainsOf(handle, graphChild) ?? descended : descended;
-  return { chains, descended, otherRoutes };
-}
-var seedFrom = (handle, node, chains, visits) => {
-  if (isChainsIgnored(chains)) return;
-  const raw = rawOf2(node);
-  if (visits.has(raw)) return;
-  visits.add(raw);
-  for (const entry of walkDataEntries(raw)) {
-    if (!isTrackedEdge(entry)) continue;
-    if (typeof entry.value !== "object" || entry.value === null) continue;
-    const key = segmentFor(raw, entry.key);
-    const resolved = resolveChildChains(handle, raw, chains, key, entry.value);
-    if (resolved === void 0) continue;
-    addInEdge(handle, entry.value, raw, key);
-    seedFrom(handle, entry.value, resolved.chains, visits);
-  }
-};
-function seedInEdges(handle) {
-  seedFrom(handle, handle.proxy.root, chainsAtRoot(handle.declarations), /* @__PURE__ */ new Set());
-}
-function seedInEdgesUnder(handle, node, chains) {
-  seedFrom(handle, node, chains, /* @__PURE__ */ new Set());
-}
-
-// src/occupancy.ts
-var { proxyStateMap: proxyStateMap8 } = unstable_getInternalStates();
-var rawTargetOf4 = (value) => proxyStateMap8.get(value)?.[0] ?? value;
-var liveOf = (value) => getRegisteredTarget(value) ?? rawTargetOf4(value);
-var createCaptureTables = () => ({
-  mints: [],
-  binds: [],
-  bindIdByNode: /* @__PURE__ */ new Map(),
-  bindNodeById: /* @__PURE__ */ new Map(),
-  mintIdByNode: /* @__PURE__ */ new Map(),
-  mintNodeById: /* @__PURE__ */ new Map(),
-  nextStagedId: 0
-});
-var occupancyKeyOf = (key) => typeof key === "number" ? String(key) : key;
-function bindVisitedOccupancy(handle, path, parent, key, child, unsafe = false, ignoredFrontier) {
-  if (path.length === 0) return "continue";
-  if (ignoredFrontier ?? isIgnoredFrontier(handle, parent, key)) return "skip";
-  const parentRaw = liveOf(parent);
-  const occupancyKey = occupancyKeyOf(key);
-  const admitted = unsafe || !handle.strict;
-  if (typeof child === "function") {
-    const parentKind = classifyValue(parentRaw);
-    if (parentKind === "plain" || parentKind === "plainArray") return "continue";
-    if (admitted) return "continue";
-    return "skip";
-  }
-  const stored = Reflect.get(parentRaw, occupancyKey);
-  const occupantSource = isObjectLike3(stored) ? stored : child;
-  if (typeof occupantSource !== "object" || occupantSource === null) return "continue";
-  const childLive = liveOf(occupantSource);
-  const descriptor = Reflect.getOwnPropertyDescriptor(parentRaw, occupancyKey);
-  if (descriptor !== void 0 && descriptor.writable !== true && admissionDecision(childLive).lane !== "untracked")
-    return "skip";
-  const decision = admissionDecision(childLive);
-  if (decision.lane === "untracked") return "skip";
-  if (decision.lane === "dangerous") {
-    if (admitted) return "continue";
-    return "skip";
-  }
-  if (!admitted && classifyValue(childLive) === "cleanClass") {
-    for (const entry of walkDataEntries(childLive)) {
-      if (typeof entry.value !== "function") continue;
-      return "skip";
-    }
-  }
-  return "continue";
-}
-function markDirtyPath(dirty, handle, path, parentLive) {
-  let current = handle.proxy.root;
-  if (isObjectLike3(current)) dirty.nodes.add(rawTargetOf4(current));
-  for (const segment of path) {
-    if (!isObjectLike3(current)) break;
-    current = Reflect.get(current, segment);
-    if (isObjectLike3(current)) dirty.nodes.add(rawTargetOf4(current));
-  }
-  if (parentLive === void 0 || path.length === 0) return;
-  const lastSegment = path[path.length - 1];
-  if (lastSegment === void 0) return;
-  const edge = typeof lastSegment === "number" ? String(lastSegment) : lastSegment;
-  const parentRaw = rawTargetOf4(parentLive);
-  let edges = dirty.edges.get(parentRaw);
-  if (edges === void 0) {
-    edges = /* @__PURE__ */ new Set();
-    dirty.edges.set(parentRaw, edges);
-  }
-  edges.add(edge);
-}
-var walkLiveOccupancies = (handle, capture) => {
-  const root = handle.proxy.root;
-  const visits = /* @__PURE__ */ new Set();
-  const rootChains = handle.declarations?.unsafe === true ? [] : [handle.declarations];
-  const walk = (node, path, chains) => {
-    if (chains.some((residual) => residual?.ignored === true)) return;
-    stageVend(handle, capture, node);
-    const nodeRaw = rawTargetOf4(node);
-    if (visits.has(nodeRaw)) return;
-    visits.add(nodeRaw);
-    for (const entry of walkDataEntries(node)) {
-      const key = segmentFor(node, entry.key);
-      const childPath = appendOperationPath(path, key);
-      const slot = slotStatusOf(handle, node, key);
-      const descended = descendChains(chains, key);
-      const ignored = slot.ignored || descended.ignored;
-      const unsafe = slot.occupied ? slot.unsafe : descended.unsafe;
-      const childChains = slot.occupied ? slot.chains : descended.chains;
-      if (ignored) continue;
-      const visit = bindVisitedOccupancy(handle, childPath, node, entry.key, entry.value, unsafe);
-      if (visit !== "continue") continue;
-      if (typeof entry.value === "object" && entry.value !== null) walk(entry.value, childPath, childChains);
-    }
-  };
-  walk(root, createOperationPath([]), rootChains);
-};
-function seedOccupancies(handle) {
-  const capture = createCaptureTables();
-  walkLiveOccupancies(handle, capture);
-  commitVends(handle, capture);
-}
-function syncHandleTables(handle, capture) {
-  walkLiveOccupancies(handle, capture);
-}
-
-// src/ops/admission.ts
-var { proxyStateMap: proxyStateMap9 } = unstable_getInternalStates();
-var rawTargetOf5 = (value) => proxyStateMap9.get(value)?.[0] ?? value;
-var MissingDiffParentError = class extends Error {
-  constructor() {
-    super("opshot: admitStep could not resolve a live parent");
-    this.name = "MissingDiffParentError";
-  }
-};
-var admitStep = (handle, dirty, path, liveParent, residual) => {
-  if (path.length === 0) {
-    return { visit: "continue", ignored: isChainsIgnored(residual), liveChild: liveParent, chains: residual };
-  }
-  const key = path[path.length - 1];
-  const liveChild = isObjectLike3(liveParent) && key !== void 0 ? Reflect.get(liveParent, key) : void 0;
-  if (handle === void 0) {
-    const childChains = key === void 0 ? residual : childChainsOf(residual, key);
-    return { visit: "continue", ignored: isChainsIgnored(childChains), liveChild, chains: childChains };
-  }
-  if (key === void 0) {
-    return { visit: "continue", ignored: isChainsIgnored(residual), liveChild: liveParent, chains: residual };
-  }
-  const resolved = resolveChildChains(handle, liveParent, residual, key, liveChild);
-  const ignored = resolved === void 0;
-  const chains = resolved?.chains ?? childChainsOf(residual, key);
-  if (dirty === void 0) return { visit: "continue", ignored, liveChild, chains };
-  if (ignored) return { visit: "skip", ignored, liveChild, chains };
-  if (resolved.otherRoutes) {
-    if (!isObjectLike3(liveParent) || !isObjectLike3(liveChild)) throw new MissingDiffParentError();
-    const slot = slotStatusOf(handle, liveParent, key);
-    let unsafe = slot.occupied ? slot.unsafe : isChainsUnsafe(resolved.descended);
-    const status = edgeStatusOf(handle, liveChild);
-    if (status.occupied) unsafe = status.unsafe;
-    return {
-      visit: bindVisitedOccupancy(handle, path, liveParent, key, liveChild, unsafe, false),
-      ignored,
-      liveChild,
-      chains
-    };
-  }
-  if (!isObjectLike3(liveParent)) throw new MissingDiffParentError();
-  return {
-    visit: bindVisitedOccupancy(handle, path, liveParent, key, liveChild, isChainsUnsafe(resolved.descended), false),
-    ignored,
-    liveChild,
-    chains
-  };
-};
-var admitDescendants = (handle, path, visits, residual, liveNode, unsafe = false) => {
-  if (handle === void 0) return;
-  if (!isObjectLike3(liveNode)) return;
-  const nodeKey = rawTargetOf5(liveNode);
-  if (visits.has(nodeKey)) return;
-  visits.add(nodeKey);
-  if (isChainsIgnored(residual)) return;
-  const nodeUnsafe = unsafe || isChainsUnsafe(residual);
-  for (const entry of walkDataEntries(liveNode)) {
-    if (typeof entry.value !== "object" || entry.value === null) continue;
-    const key = segmentFor(liveNode, entry.key);
-    const childPath = appendOperationPath(path, key);
-    const descended = descendChains(residual, key);
-    let ignored;
-    let childChains;
-    let childUnsafe;
-    let ignoredFrontier;
-    if (hasOtherRoutes(handle, entry.value, liveNode, key)) {
-      const slot = slotStatusOf(handle, liveNode, key);
-      ignored = slot.ignored || descended.ignored;
-      childChains = nodeChainsOf(handle, entry.value) ?? descended.chains;
-      childUnsafe = slot.occupied ? slot.unsafe : nodeUnsafe || descended.unsafe;
-      ignoredFrontier = void 0;
-    } else {
-      ignored = descended.ignored || isChainsIgnored(descended.chains);
-      childChains = descended.chains;
-      childUnsafe = nodeUnsafe || descended.unsafe;
-      ignoredFrontier = false;
-    }
-    if (ignored) continue;
-    const visit = bindVisitedOccupancy(
-      handle,
-      childPath,
-      liveNode,
-      entry.key,
-      entry.value,
-      childUnsafe,
-      ignoredFrontier
-    );
-    if (visit !== "continue") continue;
-    admitDescendants(handle, childPath, visits, childChains, Reflect.get(liveNode, key), childUnsafe);
-  }
-};
-var markChangedPath = (handle, dirty, path, liveParent) => {
-  if (handle === void 0 || dirty === void 0 || path.length === 0) return;
-  if (!isObjectLike3(liveParent)) return;
-  markDirtyPath(dirty, handle, path, liveParent);
-};
-var emitsSkippedOccupancy = (value) => isObjectLike3(value) && admissionLane(value) === "untracked";
-
-// src/ops/ancestorPairs.ts
-var MissingAncestorPairError = class extends Error {
-  constructor() {
-    super("opshot: exitAncestorPair without matching enterAncestorPair");
-    this.name = "MissingAncestorPairError";
-  }
-};
-var hasAncestorPair = (ancestors, before, after) => ancestors.get(before)?.has(after) ?? false;
-var enterAncestorPair = (ancestors, before, after) => {
-  const afterSet = ancestors.get(before) ?? /* @__PURE__ */ new Set();
-  afterSet.add(after);
-  ancestors.set(before, afterSet);
-};
-var exitAncestorPair = (ancestors, before, after) => {
-  const afterSet = ancestors.get(before);
-  if (afterSet === void 0) throw new MissingAncestorPairError();
-  afterSet.delete(after);
-  if (afterSet.size === 0) ancestors.delete(before);
-};
-var walkContainer = (ancestors, before, after, walk) => {
-  if (hasAncestorPair(ancestors, before, after)) return;
-  enterAncestorPair(ancestors, before, after);
-  try {
-    walk();
-  } finally {
-    exitAncestorPair(ancestors, before, after);
-  }
-};
-
-// src/ops/internedOccupancy.ts
-var { proxyStateMap: proxyStateMap10 } = unstable_getInternalStates();
-var rawTargetOf6 = (value) => proxyStateMap10.get(value)?.[0] ?? value;
-var liveOf2 = (node) => getRegisteredTarget(node) ?? node;
-var occupancyNodeOf2 = (node) => rawTargetOf6(liveOf2(node));
-var internedOccupied = (handle, node, capture) => internedIdOf(handle, node, capture) !== void 0 && edgeStatusOf(handle, occupancyNodeOf2(node)).occupied;
-
-// src/ops/mintPairs.ts
-var additionPair = (path, after, ids) => ({
-  do: createAssignMutation(path, after, after, ids),
-  undo: createDeleteMutation(path)
-});
-var removalPair = (path, before) => ({
-  do: createDeleteMutation(path),
-  undo: createAssignMutation(path, before)
-});
-var linkUndo = (path, before, beforePresent, handle, capture) => {
-  if (!beforePresent) return createDeleteMutation(path);
-  if (handle !== void 0 && isObjectLike3(before) && internedOccupied(handle, before, capture)) {
-    const id = internedIdOf(handle, before, capture);
-    if (id !== void 0) return createLinkMutation(path, id);
-  }
-  return createAssignMutation(path, before);
-};
-var linkOperation = (path, ref, before, beforePresent, handle, capture) => ({
-  do: createLinkMutation(path, ref),
-  undo: linkUndo(path, before, beforePresent, handle, capture)
-});
-var changePair = (path, before, after, handle, capture, ids) => ({
-  do: createAssignMutation(path, after, after, ids),
-  undo: linkUndo(path, before, true, handle, capture)
-});
-
-// src/ops/diff.ts
-var IncompatibleObjectRootsError = class extends Error {
-  constructor() {
-    super("opshot: diffObjects requires compatible supported object roots");
-    this.name = "IncompatibleObjectRootsError";
-  }
-};
-var commitOperation = (context, pair) => {
-  context.ops.push(pair);
-};
-var commitLink = (context, path, ref, before, beforePresent) => {
-  commitOperation(context, linkOperation(path, ref, before, beforePresent, context.handle, context.capture));
-};
-var emptyContainerOf = (value) => isPlainArray(value) ? [] : {};
-var namedArrayEntriesOf = (value) => {
-  const named = /* @__PURE__ */ new Map();
-  for (const key of Object.keys(value)) {
-    if (key === "__proto__" || isCanonicalArrayIndexString(key)) continue;
-    const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
-    if (!descriptor || !("value" in descriptor)) continue;
-    named.set(key, descriptor.value);
-  }
-  return named;
-};
-var mintDecomposedContents = (context, path, after, verdict) => {
-  const residual = verdict.chains;
-  const liveNode = verdict.liveChild;
-  if (isPlainArray(after)) {
-    if (after.length > 0)
-      commitOperation(
-        context,
-        changePair(appendOperationPath(path, "length"), 0, after.length, context.handle, context.capture)
-      );
-    for (let index = 0; index < after.length; index++) {
-      if (!Object.hasOwn(after, index)) continue;
-      const nextPath = appendOperationPath(path, index);
-      const childVerdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
-      pushAddition(context, nextPath, after[index], childVerdict, liveNode);
-    }
-    for (const [key, value] of namedArrayEntriesOf(after)) {
-      const nextPath = appendOperationPath(path, key);
-      const childVerdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
-      pushAddition(context, nextPath, value, childVerdict, liveNode);
-    }
-  } else {
-    for (const entry of walkDataEntries(after)) {
-      const nextPath = appendOperationPath(path, entry.key);
-      const childVerdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
-      pushAddition(context, nextPath, entry.value, childVerdict, liveNode);
-    }
-  }
-};
-var mintDecomposedAddition = (context, path, after, verdict) => {
-  commitOperation(context, {
-    do: createAssignMutation(path, emptyContainerOf(after), after),
-    undo: createDeleteMutation(path)
-  });
-  mintDecomposedContents(context, path, after, verdict);
-};
-var mintDecomposedChange = (context, path, before, after, verdict) => {
-  commitOperation(context, {
-    do: createAssignMutation(path, emptyContainerOf(after), after),
-    undo: linkUndo(path, before, true, context.handle, context.capture)
-  });
-  mintDecomposedContents(context, path, after, verdict);
-};
-var surveyAssignedSubtree = (handle, capture, node, residual, stopAtInternedOccupied) => {
-  const visits = /* @__PURE__ */ new Set();
-  const pending = new Array();
-  const visit = (current, currentResidual) => {
-    const raw = occupancyNodeOf2(current);
-    if (visits.has(raw)) return false;
-    visits.add(raw);
-    if (admissionLane(current) === "untracked") return false;
-    if (stopAtInternedOccupied) {
-      if (current !== node) pending.push(current);
-    } else stageVend(handle, capture, current);
-    const source = liveOf2(current);
-    for (const entry of walkDataEntries(source)) {
-      if (typeof entry.value !== "object" || entry.value === null) continue;
-      if (!isTrackedEdge(entry)) continue;
-      const key = segmentFor(source, entry.key);
-      const resolved = resolveChildChains(handle, source, currentResidual, key, entry.value);
-      if (resolved === void 0) continue;
-      const child = entry.value;
-      if (stopAtInternedOccupied && internedOccupied(handle, child, capture)) return true;
-      if (visit(child, resolved.chains)) return true;
-    }
-    return false;
-  };
-  if (stopAtInternedOccupied) stageVend(handle, capture, node);
-  const reachesInternedOccupied = visit(node, residual);
-  if (stopAtInternedOccupied && !reachesInternedOccupied) {
-    for (const pendingNode of pending) stageVend(handle, capture, pendingNode);
-  }
-  return { reachesInternedOccupied };
-};
-var internIdsOfSubtree = (handle, node, capture) => {
-  const seen = /* @__PURE__ */ new Set();
-  const ids = new Array();
-  const walk = (current) => {
-    const id = internedIdOf(handle, current, capture);
-    if (id === void 0 || seen.has(id)) return;
-    seen.add(id);
-    ids.push(id);
-    for (const entry of walkDataEntries(liveOf2(current))) {
-      if (typeof entry.value === "object" && entry.value !== null) walk(entry.value);
-    }
-  };
-  walk(node);
-  return ids.length === 0 ? void 0 : ids;
-};
-var mintAssignment = (context, path, before, after, beforePresent, verdict) => {
-  if (verdict.ignored) return;
-  const handle = context.handle;
-  if (isObjectLike3(after) && handle !== void 0) {
-    const internedId = internedIdOf(handle, after, context.capture);
-    if (internedId !== void 0 && internedOccupied(handle, after, context.capture)) {
-      const sameOccupant = isObjectLike3(before) && occupancyNodeOf2(before) === occupancyNodeOf2(after);
-      const beforeInterned = isObjectLike3(before) && internedIdOf(handle, before, context.capture) !== void 0;
-      const uninternedTrackedBefore = isObjectLike3(before) && !beforeInterned && admissionLane(before) !== "untracked";
-      if (!sameOccupant && !uninternedTrackedBefore) {
-        commitLink(context, path, internedId, before, beforePresent);
-        return;
-      }
-      surveyAssignedSubtree(handle, context.capture, after, verdict.chains, false);
-    } else if (admissionLane(after) !== "untracked" && (isPlainObject(after) || isPlainArray(after))) {
-      const { reachesInternedOccupied } = surveyAssignedSubtree(
-        handle,
-        context.capture,
-        after,
-        verdict.chains,
-        true
-      );
-      if (reachesInternedOccupied) {
-        if (!beforePresent) {
-          mintDecomposedAddition(context, path, after, verdict);
-          return;
-        }
-        mintDecomposedChange(context, path, before, after, verdict);
-        return;
-      }
-    } else {
-      admitDescendants(handle, path, /* @__PURE__ */ new Set(), verdict.chains, verdict.liveChild);
-      internSubtree(
-        handle,
-        after,
-        verdict.chains,
-        (parent, parentChains, key, entry) => isTrackedEdge(entry) ? resolveChildChains(handle, parent, parentChains, key, entry.value)?.chains : void 0,
-        context.capture
-      );
-    }
-  } else if (isObjectLike3(after)) admitDescendants(context.handle, path, /* @__PURE__ */ new Set(), verdict.chains, verdict.liveChild);
-  const ids = isObjectLike3(after) && handle !== void 0 ? internIdsOfSubtree(handle, after, context.capture) : void 0;
-  if (beforePresent) commitOperation(context, changePair(path, before, after, handle, context.capture, ids));
-  else commitOperation(context, additionPair(path, after, ids));
-};
-var pushAddition = (context, path, after, verdict, liveParent) => {
-  const { visit, ignored } = verdict;
-  if (visit === "skip") {
-    if (ignored || !emitsSkippedOccupancy(after)) return;
-  } else if (ignored) return;
-  markChangedPath(context.handle, context.dirty, path, liveParent);
-  mintAssignment(context, path, void 0, after, false, verdict);
-};
-var pushRemoval = (context, path, before, verdict, liveParent) => {
-  if (verdict.ignored) return;
-  markChangedPath(context.handle, context.dirty, path, liveParent);
-  const handle = context.handle;
-  if (isObjectLike3(before) && handle !== void 0) {
-    const id = internedIdOf(handle, before, context.capture);
-    if (id !== void 0 && internedOccupied(handle, before, context.capture)) {
-      commitOperation(context, {
-        do: createDeleteMutation(path),
-        undo: createLinkMutation(path, id)
-      });
-      return;
-    }
-  }
-  commitOperation(context, removalPair(path, before));
-};
-var pushChange = (context, path, before, after, verdict, liveParent) => {
-  markChangedPath(context.handle, context.dirty, path, liveParent);
-  mintAssignment(context, path, before, after, true, verdict);
-};
-var sharesStorageIdentity = (before, after) => isObjectLike3(before) && isObjectLike3(after) && isSameIdentity(before, after);
-var diffCollectedProperties = (context, before, after, path, residual, liveNode, beforeEntries, afterEntries) => {
-  const keys = /* @__PURE__ */ new Set([...beforeEntries.keys(), ...afterEntries.keys()]);
-  for (const key of keys) {
-    const nextPath = appendOperationPath(path, key);
-    const beforePresent = beforeEntries.has(key);
-    const afterPresent = afterEntries.has(key);
-    if (beforePresent && afterPresent) {
-      diffValue(context, beforeEntries.get(key), afterEntries.get(key), nextPath, residual, liveNode);
-    } else if (beforePresent && !Object.hasOwn(after, key)) {
-      const verdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
-      pushRemoval(context, nextPath, beforeEntries.get(key), verdict, liveNode);
-    } else if (afterPresent && !Object.hasOwn(before, key)) {
-      const verdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
-      pushAddition(context, nextPath, afterEntries.get(key), verdict, liveNode);
-    }
-  }
-};
-var diffObjectProperties = (context, before, after, path, residual, liveNode) => {
-  diffCollectedProperties(
-    context,
-    before,
-    after,
-    path,
-    residual,
-    liveNode,
-    dataEntryValuesOf(before),
-    dataEntryValuesOf(after)
-  );
-};
-var diffArray = (context, before, after, path, residual, liveNode) => {
-  const overlap = Math.min(before.length, after.length);
-  for (let index = 0; index < overlap; index++) {
-    const beforePresent = Object.hasOwn(before, index);
-    const afterPresent = Object.hasOwn(after, index);
-    if (!beforePresent && !afterPresent) continue;
-    const nextPath = appendOperationPath(path, index);
-    if (!beforePresent) {
-      const verdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
-      pushAddition(context, nextPath, after[index], verdict, liveNode);
-    } else if (!afterPresent) {
-      const verdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
-      pushRemoval(context, nextPath, before[index], verdict, liveNode);
-    } else diffValue(context, before[index], after[index], nextPath, residual, liveNode);
-  }
-  if (after.length > before.length) {
-    const lengthPath = appendOperationPath(path, "length");
-    const lengthVerdict = admitStep(context.handle, context.dirty, lengthPath, liveNode, residual);
-    pushChange(context, lengthPath, before.length, after.length, lengthVerdict, liveNode);
-    for (let index = before.length; index < after.length; index++) {
-      if (!Object.hasOwn(after, index)) continue;
-      const nextPath = appendOperationPath(path, index);
-      const verdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
-      pushAddition(context, nextPath, after[index], verdict, liveNode);
-    }
-  } else if (after.length < before.length) {
-    for (let index = after.length; index < before.length; index++) {
-      if (!Object.hasOwn(before, index)) continue;
-      const nextPath = appendOperationPath(path, index);
-      const verdict = admitStep(context.handle, context.dirty, nextPath, liveNode, residual);
-      pushRemoval(context, nextPath, before[index], verdict, liveNode);
-    }
-    const lengthPath = appendOperationPath(path, "length");
-    const lengthVerdict = admitStep(context.handle, context.dirty, lengthPath, liveNode, residual);
-    pushChange(context, lengthPath, before.length, after.length, lengthVerdict, liveNode);
-  }
-  diffCollectedProperties(
-    context,
-    before,
-    after,
-    path,
-    residual,
-    liveNode,
-    namedArrayEntriesOf(before),
-    namedArrayEntriesOf(after)
-  );
-};
-var diffValue = (context, before, after, path, residual, liveParent) => {
-  const replacing = path.length > 0 && isObjectLike3(before) && isObjectLike3(after) && !sharesStorageIdentity(before, after);
-  const verdict = admitStep(context.handle, context.dirty, path, liveParent, residual);
-  const { visit, ignored, liveChild, chains } = verdict;
-  if (visit === "skip" || ignored) {
-    if (Object.is(before, after)) return;
-    if (isObjectLike3(before) && isObjectLike3(after) && sharesStorageIdentity(before, after)) return;
-    if (ignored || !emitsSkippedOccupancy(after)) return;
-    pushChange(context, path, before, after, verdict, liveParent);
-    return;
-  }
-  if (Object.is(before, after)) return;
-  if (replacing) {
-    pushChange(context, path, before, after, verdict, liveParent);
-    return;
-  }
-  if (isPlainArray(before) && isPlainArray(after)) {
-    walkContainer(context.ancestors, before, after, () => diffArray(context, before, after, path, chains, liveChild));
-    return;
-  }
-  if (isPlainObject(before) && isPlainObject(after)) {
-    walkContainer(
-      context.ancestors,
-      before,
-      after,
-      () => diffObjectProperties(context, before, after, path, chains, liveChild)
-    );
-    return;
-  }
-  pushChange(context, path, before, after, verdict, liveParent);
-};
-var getRootKind = (value) => {
-  if (isPlainArray(value)) return "plainArray";
-  if (isPlainObject(value)) return "plainObject";
-  return void 0;
-};
-function diffObjects(before, after, handle, dirty, capture) {
-  const beforeKind = getRootKind(before);
-  const afterKind = getRootKind(after);
-  if (beforeKind === void 0 || beforeKind !== afterKind) throw new IncompatibleObjectRootsError();
-  const ops = new Array();
-  const context = {
-    ops,
-    ancestors: /* @__PURE__ */ new Map(),
-    handle,
-    dirty,
-    capture: capture ?? createCaptureTables()
-  };
-  diffValue(
-    context,
-    before,
-    after,
-    createOperationPath([]),
-    handle === void 0 ? [void 0] : chainsAtRoot(handle.declarations),
-    handle?.proxy.root
-  );
-  return ops;
-}
-
-// src/emit/emitterDeliver.ts
-var collectDeliveries = (handle) => {
-  const deliveries = [];
-  for (const groupListeners of handle.groups ?? []) {
-    for (const byChannel of groupListeners.values()) {
-      for (const deliverToListener of byChannel.values()) {
-        deliveries.push({ kind: "group", deliver: deliverToListener });
-      }
-    }
-  }
-  for (const byChannel of handle.subscribers.values()) {
-    for (const deliverToListener of byChannel.values()) {
-      deliveries.push({ kind: "own", deliver: deliverToListener });
-    }
-  }
-  return deliveries;
-};
-var runDelivery = (pending, failures) => {
-  const handle = handleOf(pending.writeProxy);
-  if (handle !== void 0) handle.lastDirty = pending.dirty;
-  for (const delivery of pending.deliveries) {
-    try {
-      if (delivery.kind === "group") {
-        delivery.deliver(pending.writeProxy, pending.ops, pending.meta, pending.channelId);
-      } else {
-        delivery.deliver(pending.ops, pending.meta, pending.channelId);
-      }
-    } catch (error) {
-      failures.push(error);
-    }
-  }
-};
-var raiseFailures = (failures) => {
-  if (failures.length === 0) return;
-  if (failures.length > 1) throw new AggregateError(failures, "opshot: listeners failed during delivery");
-  throw failures[0];
-};
-var queuedDeliveries = [];
-var deliveryFailures = [];
-var isDraining = false;
-var prepareDelivery = (handle, ops, meta, channelId, dirty) => ({
-  writeProxy: handle.proxy.root,
-  deliveries: collectDeliveries(handle),
-  ops,
-  meta,
-  channelId,
-  dirty
-});
-var enqueueDelivery = (pending) => {
-  queuedDeliveries.push(pending);
-};
-var drainDeliveries = () => {
-  if (isDraining) return;
-  isDraining = true;
-  let failures = [];
-  try {
-    while (queuedDeliveries.length > 0) {
-      for (const queued of queuedDeliveries.splice(0, queuedDeliveries.length)) {
-        runDelivery(queued, deliveryFailures);
-      }
-    }
-  } finally {
-    isDraining = false;
-    failures = deliveryFailures.splice(0, deliveryFailures.length);
-  }
-  raiseFailures(failures);
-};
-
-// src/emit/emitterRegistry.ts
-var { proxyStateMap: proxyStateMap11 } = unstable_getInternalStates();
-var targetOf = (writeProxy) => proxyStateMap11.get(writeProxy)?.[0] ?? writeProxy;
-
-// src/emit/emitter.ts
-function scheduleFlush(handle) {
-  if (handle.isFlushScheduled) return;
-  handle.isFlushScheduled = true;
-  const generation = handle.flushGeneration;
-  const run = () => {
-    if (generation !== handle.flushGeneration) return;
-    handle.isFlushScheduled = false;
-    emitWrites(handle);
-  };
-  void Promise.resolve().then(() => {
-    const emitOn = handle.emitOn;
-    if (emitOn === void 0) {
-      run();
-      return;
-    }
-    emitOn(run);
-  });
-}
-function armWatch(handle) {
-  handle.disarmWatch = subscribe(
-    handle.proxy.root,
-    () => {
-      handle.hasPendingWrites = true;
-      if (handle.isFlushHeld) return;
-      scheduleFlush(handle);
-    });
-}
-var cloneSnapshotNode = (snap) => {
-  const clone = Array.isArray(snap) ? [] : Object.create(Reflect.getPrototypeOf(snap));
-  for (const key of carriedOwnKeysOf(snap)) {
-    const descriptor = Reflect.getOwnPropertyDescriptor(snap, key);
-    if (descriptor !== void 0) Object.defineProperty(clone, key, descriptor);
-  }
-  if (Array.isArray(snap)) clone.length = snap.length;
-  registerSnapshotCopy(clone, getRegisteredTarget(snap) ?? targetOf(snap));
-  return clone;
-};
-var reconcileUntracked = (snap, live, seen) => {
-  if (seen.has(live)) return snap;
-  seen.add(live);
-  let result;
-  const written = () => {
-    result ??= cloneSnapshotNode(snap);
-    return result;
-  };
-  for (const key of carriedOwnKeysOf(live)) {
-    const liveValue = Reflect.get(live, key);
-    if (typeof liveValue !== "object" || liveValue === null) continue;
-    if (admissionLane(liveValue) === "untracked") {
-      if (Reflect.get(snap, key) === liveValue) continue;
-      const snapChild2 = Reflect.get(snap, key);
-      if (typeof snapChild2 !== "object" || snapChild2 === null) continue;
-      if (getRegisteredTarget(snapChild2) !== targetOf(liveValue)) continue;
-      const descriptor = Reflect.getOwnPropertyDescriptor(live, key);
-      if (descriptor === void 0 || descriptor.get !== void 0 || descriptor.set !== void 0) continue;
-      Object.defineProperty(written(), key, {
-        value: liveValue,
-        enumerable: descriptor.enumerable,
-        configurable: true
-      });
-      continue;
-    }
-    const snapChild = Reflect.get(snap, key);
-    if (typeof snapChild !== "object" || snapChild === null) continue;
-    const reconciled = reconcileUntracked(snapChild, liveValue, seen);
-    if (reconciled === snapChild) continue;
-    Object.defineProperty(written(), key, {
-      value: reconciled,
-      enumerable: true,
-      configurable: true
-    });
-  }
-  return result ?? snap;
-};
-var captureDiffOf = (handle, from, capture) => {
-  const to = snapshot(handle.proxy.root);
-  const dirty = { edges: /* @__PURE__ */ new WeakMap(), nodes: /* @__PURE__ */ new WeakSet() };
-  if (from === to) {
-    syncHandleTables(handle, capture);
-    return { to, ops: [], dirty, capture };
-  }
-  return {
-    to,
-    ops: diffObjects(reconcileUntracked(from, handle.proxy.root, /* @__PURE__ */ new WeakSet()), to, handle, dirty, capture),
-    dirty,
-    capture
-  };
-};
-var captureRange = (handle, meta, channelId) => {
-  handle.hasPendingWrites = false;
-  const from = handle.lastSnapshot;
-  const capture = handle.transactionCapture ?? createCaptureTables();
-  const committed = captureDiffOf(handle, from, capture);
-  const ops = committed.ops;
-  commitVends(handle, committed.capture);
-  handle.lastSnapshot = committed.to;
-  const evicted = evictDepartedClusters(handle);
-  if (ops.length > 0) annotateDepartureUndos(handle, ops, evicted);
-  if (ops.length > 0 && !handle.replaying) {
-    for (const operation of ops) stampOperation(handle, operation);
-  }
-  return ops.length > 0 ? prepareDelivery(handle, ops, meta, channelId, committed.dirty) : void 0;
-};
-function deliverCapturedRanges(ranges) {
-  for (const captured of ranges) {
-    if (captured !== void 0) enqueueDelivery(captured);
-  }
-  drainDeliveries();
-}
-var emitRange = (handle, meta, channelId) => {
-  const captured = captureRange(handle, meta, channelId);
-  if (captured !== void 0) enqueueDelivery(captured);
-  drainDeliveries();
-};
-function captureWrites(handle) {
-  return captureRange(handle, void 0, void 0);
-}
-function captureTransactionWrites(handle, meta, channelId) {
-  return captureRange(handle, meta, channelId);
-}
-function emitWrites(handle) {
-  emitRange(handle, void 0, void 0);
-}
-
-// src/emit/requireObjectSnapshot.ts
-var ObjectRootSnapshotError = class extends Error {
-  constructor() {
-    super("opshot: state snapshots must have an object root");
-    this.name = "ObjectRootSnapshotError";
-  }
-};
-var requireObjectSnapshot = (value) => {
-  if (value !== null && (typeof value === "object" || typeof value === "function")) return value;
-  throw new ObjectRootSnapshotError();
-};
-
-// src/ignore.ts
-var ignoreMarker = /* @__PURE__ */ Symbol("opshot.ignore");
-function ignore(value) {
-  return { [ignoreMarker]: value };
-}
-
-// src/isState.ts
-var { proxyStateMap: proxyStateMap12 } = unstable_getInternalStates();
-function isState(value) {
-  const resolved = peelReadProxy(value);
-  if (typeof resolved !== "object" || resolved === null) return false;
-  return proxyStateMap12.has(resolved);
-}
-
-// src/unsafeTrack.ts
-var unsafeMarker = /* @__PURE__ */ Symbol("opshot.unsafe");
-function unsafeTrack(value) {
-  return { [unsafeMarker]: value };
-}
-
 // src/utils/constructorName.ts
 var constructorName = (candidate) => typeof candidate === "function" && candidate.name !== "" ? candidate.name : "Object";
 
-// src/valtio/boundaryErrors.ts
+// 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 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 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(
@@ -2026,12 +21,7 @@ var slotContainerError = (className, trackedName, path) => boundaryError(
   [`use ${trackedName} for a tracked equivalent`, unsafeTrackLossyOption, ignoreOption],
   path
 );
-var arraySubclassError = (className, path) => boundaryError(
-  className,
-  "array subclasses lose their prototype in snapshots",
-  [unsafeTrackDataOption, ignoreOption],
-  path
-);
+var 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);
@@ -2041,9 +31,6 @@ var nonWritablePropertyError = (value, path) => boundaryError(
   ["make the property writable", "ignore(value) to declare the escape"],
   path
 );
-var snapshotDonationError = (key) => new Error(
-  `opshot: cannot assign a snapshot generation at "${String(key)}": a snapshot generation is a read-view, and assigning it creates a dead region. Clone the value, or replay through applyOperations.`
-);
 var inheritsFromPrototype = (value, prototype) => {
   for (let current = Reflect.getPrototypeOf(value); current !== null; current = Reflect.getPrototypeOf(current))
     if (current === prototype) return true;
@@ -2066,1081 +53,646 @@ var rejectionError = (value, kind, path) => {
   }
 };
 
-// src/valtio/snapshotAccessors.ts
-var { proxyStateMap: proxyStateMap13, snapCache: snapCache2 } = unstable_getInternalStates();
-var MissingOwnDescriptorError2 = class extends Error {
-  constructor() {
-    super("opshot: carried own key has no property descriptor");
-    this.name = "MissingOwnDescriptorError";
-  }
+// 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;
+  const source = Function.prototype.toString.call(constructor);
+  sourceCache.set(constructor, source);
+  return source;
 };
-var createSnapshotPreservingAccessors = (target, version) => {
-  const cached = snapCache2.get(target);
-  if (cached?.[0] === version) {
-    const cachedSnapshot = cached[1];
-    for (const key of carriedOwnKeysOf(target)) {
-      const value = Reflect.get(target, key);
-      if (typeof value !== "object" || value === null) continue;
-      if (admissionLane(value) !== "untracked") continue;
-      if (Reflect.get(cachedSnapshot, key) === value) continue;
-      const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-      if (descriptor === void 0 || descriptor.get !== void 0 || descriptor.set !== void 0) continue;
-      Object.defineProperty(cachedSnapshot, key, {
-        value,
-        enumerable: descriptor.enumerable,
-        configurable: true
-      });
-      markToTrack(value, false);
-    }
-    if (getRegisteredTarget(cachedSnapshot) === void 0) {
-      registerSnapshotCopy(cachedSnapshot, target);
-    }
-    return cachedSnapshot;
-  }
-  const snap = Array.isArray(target) ? [] : Object.create(Reflect.getPrototypeOf(target));
-  registerSnapshotCopy(snap, target);
-  markToTrack(snap, true);
-  snapCache2.set(target, [version, snap]);
-  for (const key of carriedOwnKeysOf(target)) {
-    if (Object.getOwnPropertyDescriptor(snap, key)) continue;
-    const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-    if (descriptor === void 0) throw new MissingOwnDescriptorError2();
-    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 (admissionLane(value) === "untracked") {
-        markToTrack(value, false);
-      } else {
-        const childState = proxyStateMap13.get(value);
-        if (childState)
-          snapshotDescriptor.value = createSnapshotPreservingAccessors(childState[0], childState[1]());
-      }
+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 (hasPrivateName(source)) {
+      kind = "privateClass";
+      break;
     }
-    Object.defineProperty(snap, key, snapshotDescriptor);
-  }
-  if (Array.isArray(target) && snap.length !== target.length) {
-    snap.length = target.length;
+    if (source.includes("[native code]")) sawNativeSource = true;
+    current = Reflect.getPrototypeOf(current);
   }
-  return snap;
+  if (kind !== "privateClass") kind = sawNativeSource ? "nativeClass" : "cleanClass";
+  kindCache.set(initialConstructor, kind);
+  return kind;
 };
+function classifyValue(value) {
+  const prototype = Object.getPrototypeOf(value);
+  if (Array.isArray(value))
+    return prototype === Array.prototype || prototype === null ? "plainArray" : "arraySubclass";
+  if (prototype === Object.prototype || prototype === null) return "plain";
+  return classifyChain(value.constructor);
+}
 
-// src/valtio/boundary.ts
-var { proxyStateMap: proxyStateMap14, proxyCache: proxyCache3 } = unstable_getInternalStates();
-var rawTargetOf7 = (value) => proxyStateMap14.get(value)?.[0] ?? value;
-var handleOwning = (target) => {
-  const handles = handlesOf(target);
-  const raw = rawTargetOf7(target);
-  for (const handle of handles) {
-    if (rawTargetOf7(handle.proxy.root) === raw) return handle;
-  }
-  return handles[0];
-};
-var segmentForProp = (parent, prop) => isPlainArray(parent) && isCanonicalArrayIndexString(prop) ? Number(prop) : prop;
-var setFrameStack = new Array();
-var currentSetParentOf = () => setFrameStack[setFrameStack.length - 1]?.target;
-var currentStatuses = () => setFrameStack[setFrameStack.length - 1]?.statuses;
-var heldStatusesOf = (target, prop) => {
-  const key = segmentForProp(target, prop);
-  const statuses = new Array();
-  for (const handle of handlesOf(target)) {
-    const slot = slotStatusOf(handle, target, key);
-    if (!slot.occupied) continue;
-    statuses.push({ handle, ignored: slot.ignored, unsafe: slot.unsafe, chains: slot.chains });
-  }
-  return statuses.length === 0 ? void 0 : statuses;
-};
-var inheritedStatusesOf = (target, prop) => {
-  const parent = setFrameStack[setFrameStack.length - 1];
-  if (parent?.statuses === void 0) return void 0;
-  const key = segmentForProp(target, prop);
-  return parent.statuses.map((status) => {
-    const descended = descendChains(status.chains, key);
-    return {
-      handle: status.handle,
-      ignored: status.ignored || descended.ignored,
-      unsafe: status.unsafe || descended.unsafe,
-      chains: descended.chains
-    };
-  });
-};
-var statusesForFrame = (target, prop, initializing) => {
-  if (typeof prop !== "string") return void 0;
-  if (!initializing) return heldStatusesOf(target, prop);
-  return inheritedStatusesOf(target, prop) ?? heldStatusesOf(target, prop);
-};
-var certifyAdmission = (value, path, unsafe = false) => {
-  const decision = admissionDecision(value);
-  if (decision.lane === "dangerous" && !unsafe) throw rejectionError(value, decision.kind, path);
-  return decision.lane;
-};
-var peelSnapshotsAndReadProxies = (value) => {
-  let current = value;
-  while (typeof current === "object" && current !== null) {
-    const untracked = getUntracked(current);
-    const next = peelReadProxy(untracked ?? current);
-    if (next === current) break;
-    current = next;
-  }
-  return current;
-};
-var walkDataPaths = (value, path, visits, mode, chains, ignored, unsafe) => {
-  const node = mode === "admission" ? rawTargetOf7(value) : value;
-  if (visits.has(node)) return;
-  visits.add(node);
-  if (ignored) return;
-  for (const entry of walkDataEntries(node)) {
-    const childPath = [...path, entry.key];
-    const descended = descendChains(chains, segmentForProp(node, entry.key));
-    const childIgnored = descended.ignored;
-    const childUnsafe = unsafe || descended.unsafe;
-    const childChains = descended.chains;
-    const child = entry.value;
-    if (mode === "admission" && classifyValue(node) === "cleanClass" && !unsafe && typeof child === "function")
-      throw rejectionError(node, "cleanClass", childPath);
-    if (typeof child !== "object" || child === null) continue;
-    if (!entry.writable) {
-      if (mode === "admission" && !childIgnored && !childUnsafe && admissionLane(child) !== "untracked")
-        throw nonWritablePropertyError(child, childPath);
-      continue;
-    }
-    if (childIgnored) continue;
-    let childNode = child;
-    if (proxyStateMap14.has(childNode)) {
-      if (mode !== "admission") continue;
-      childNode = rawTargetOf7(childNode);
-    }
-    if (mode === "admission") {
-      if (childUnsafe) {
-        walkDataPaths(childNode, childPath, visits, mode, childChains, childIgnored, childUnsafe);
-        continue;
-      }
-      if (certifyAdmission(childNode, childPath, childUnsafe) === "tracked")
-        walkDataPaths(childNode, childPath, visits, mode, childChains, childIgnored, childUnsafe);
-      continue;
-    }
-    if (admissionLane(childNode) === "untracked") continue;
-    walkDataPaths(childNode, childPath, visits, mode, childChains, childIgnored, childUnsafe);
-  }
-};
-var assertSafeDataPaths = (value, path, visits, mode = "admission", chains = []) => {
-  walkDataPaths(
-    value,
-    path,
-    visits,
-    mode,
-    chains,
-    chains.some((residual) => residual?.ignored === true),
-    chains.some((residual) => residual?.unsafe === true)
-  );
-};
-var certifyCurrentAssignment = (target, prop, resolved) => {
-  if (typeof prop !== "string") return;
-  const assignments = currentStatuses();
-  if (assignments === void 0) return;
-  const path = [prop];
-  for (const assignment of assignments) {
-    if (!assignment.handle.strict || assignment.ignored || assignment.unsafe) continue;
-    if (typeof resolved === "function") {
-      const parentKind = classifyValue(rawTargetOf7(target));
-      if (parentKind !== "plain" && parentKind !== "plainArray")
-        throw rejectionError(rawTargetOf7(target), parentKind, path);
-      continue;
-    }
-    const decision = admissionDecision(resolved);
-    if (decision.lane === "dangerous") throw rejectionError(resolved, decision.kind, path);
-    if (decision.lane === "tracked")
-      walkDataPaths(
-        resolved,
-        path,
-        /* @__PURE__ */ new Set(),
-        "admission",
-        assignment.chains,
-        assignment.ignored,
-        assignment.unsafe
-      );
-  }
-};
-var writesThroughAccessor = (target, property) => {
-  let holder = target;
-  while (holder !== null) {
-    const descriptor = Reflect.getOwnPropertyDescriptor(holder, property);
-    if (descriptor !== void 0) return !("value" in descriptor);
-    holder = Reflect.getPrototypeOf(holder);
-  }
-  return false;
-};
-var refusesWrite = (target, property, value) => {
-  if (Array.isArray(target)) {
-    if (property === "length") {
-      const coercible = value === null || typeof value !== "object" && typeof value !== "function";
-      const newLength = coercible ? Number(value) : Number.NaN;
-      if (Number.isInteger(newLength) && newLength >= 0 && newLength < target.length) {
-        for (const key of Reflect.ownKeys(target)) {
-          if (typeof key !== "string") continue;
-          const index = Number(key);
-          if (Number.isInteger(index) && index >= newLength && index < 2 ** 32 - 1 && String(index) === key && Reflect.getOwnPropertyDescriptor(target, key)?.configurable !== true)
-            return true;
-        }
-      }
-    } else if (typeof property === "string") {
-      const index = Number(property);
-      if (Number.isInteger(index) && index >= 0 && index < 2 ** 32 - 1 && String(index) === property && index >= target.length && Reflect.getOwnPropertyDescriptor(target, "length")?.writable === false)
-        return true;
-    }
-  }
-  let holder = target;
-  while (holder !== null) {
-    const descriptor = Reflect.getOwnPropertyDescriptor(holder, property);
-    if (descriptor !== void 0) {
-      if ("value" in descriptor) {
-        if (descriptor.writable !== true) return true;
-        return holder !== target && !Object.isExtensible(target);
-      }
-      return descriptor.set === void 0;
-    }
-    holder = Reflect.getPrototypeOf(holder);
-  }
-  return !Object.isExtensible(target);
-};
-function canProxy2(value, parentTarget, unsafe = false) {
-  if (typeof value !== "object" || value === null) return false;
-  if (admissionLane(value) === "tracked") return true;
-  if (unsafe) return true;
-  if (proxyStateMap14.has(value)) return true;
-  const rootHandle = handleOwning(value);
-  if (rootHandle !== void 0 && rawTargetOf7(rootHandle.proxy.root) === rawTargetOf7(value) && (!rootHandle.strict || rootHandle.declarations?.unsafe === true))
-    return true;
-  if (parentTarget === void 0) return false;
-  const handles = handlesOf(parentTarget);
-  return handles.length === 1 && handles[0]?.strict === false && admissionLane(value) === "dangerous";
+// src/node.ts
+var byRaw = /* @__PURE__ */ new WeakMap();
+var byProxy = /* @__PURE__ */ new WeakMap();
+var proxyHandler;
+function installProxyHandler(handler2) {
+  proxyHandler = handler2;
+}
+function recordOf(value) {
+  return byRaw.get(value) ?? byProxy.get(value);
+}
+function rawOf(value) {
+  return recordOf(value)?.raw ?? value;
+}
+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;
 }
-var MissingMutationTrapError = class extends Error {
-  constructor() {
-    super("opshot: valtio default handler is missing a mutation trap");
-    this.name = "MissingMutationTrapError";
-  }
-};
-var canProxyCurrentAssignment = (value) => {
-  const assignments = currentStatuses();
-  if (assignments === void 0) return canProxy2(value, currentSetParentOf());
-  const judging = assignments.filter((assignment) => !assignment.ignored);
-  if (judging.length === 0) return false;
-  return canProxy2(
-    value,
-    currentSetParentOf(),
-    judging.every((assignment) => assignment.unsafe || !assignment.handle.strict)
-  );
-};
-var truncatedOccupantsOf = (target, prop, next) => {
-  if (!Array.isArray(target) || prop !== "length") return void 0;
-  const coercible = next === null || typeof next !== "object" && typeof next !== "function";
-  const newLength = coercible ? Number(next) : Number.NaN;
-  if (!Number.isInteger(newLength) || newLength < 0 || newLength >= target.length) return void 0;
-  const truncated = new Array();
-  for (let index = newLength; index < target.length; index++) {
-    const occupant = Reflect.get(target, index);
-    if (typeof occupant === "object" && occupant !== null) truncated.push({ index, occupant });
-  }
-  return truncated;
-};
-var commitSetInEdges = (target, prop, previous, next, truncated) => {
-  const handles = handlesOf(target);
-  if (handles.length === 0) return;
-  if (truncated !== void 0) {
-    for (const { index, occupant } of truncated) {
-      for (const handle of handles) removeInEdge(handle, occupant, target, index);
-    }
-    return;
-  }
-  if (typeof prop !== "string") return;
-  const key = segmentForProp(target, prop);
-  const previousObject = typeof previous === "object" && previous !== null ? previous : void 0;
-  const nextObject = typeof next === "object" && next !== null && admissionLane(next) !== "untracked" ? next : void 0;
-  for (const handle of handles) {
-    if (isIgnoredFrontier(handle, target, key)) {
-      if (previousObject !== void 0) removeInEdge(handle, previousObject, target, key);
-      continue;
-    }
-    if (previousObject !== void 0) removeInEdge(handle, previousObject, target, key);
-    if (nextObject === void 0) continue;
-    const rawNext = rawTargetOf7(nextObject);
-    const wasOccupied = rawNext === rawTargetOf7(handle.proxy.root) || (handle.nodes.get(rawNext)?.edges.length ?? 0) > 0;
-    addInEdge(handle, nextObject, target, key);
-    if (wasOccupied) continue;
-    const slot = slotStatusOf(handle, target, key);
-    seedInEdgesUnder(handle, nextObject, slot.chains);
+function handlesOf(node) {
+  return membershipsOf(node).map(([handle]) => handle);
+}
+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]);
   }
-};
-var commitDeleteInEdges = (target, prop, previous) => {
-  if (typeof prop !== "string") return;
-  if (typeof previous !== "object" || previous === null) return;
-  const key = segmentForProp(target, prop);
-  for (const handle of handlesOf(target)) removeInEdge(handle, previous, target, key);
-};
-var installed = false;
-function installBoundary() {
-  if (installed) return;
-  installed = true;
-  unstable_replaceInternalFunction("canProxy", () => (value) => canProxyCurrentAssignment(value));
-  unstable_replaceInternalFunction("createSnapshot", () => createSnapshotPreservingAccessors);
-  unstable_replaceInternalFunction(
-    "createHandler",
-    (createHandler2) => (isInitializing, addPropListener, removePropListener, notifyUpdate) => {
-      const handler = createHandler2(isInitializing, addPropListener, removePropListener, notifyUpdate);
-      const defaultDelete = handler.deleteProperty;
-      const defaultSet = handler.set;
-      if (!defaultDelete || !defaultSet) throw new MissingMutationTrapError();
-      return {
-        ...handler,
-        set(target, prop, value, receiver) {
-          const assigned = value;
-          const resolved = peelSnapshotsAndReadProxies(assigned);
-          const truncated = truncatedOccupantsOf(target, prop, resolved);
-          const previous = typeof prop === "string" ? Reflect.get(target, prop) : void 0;
-          const initializing = isInitializing();
-          setFrameStack.push({ target, prop, statuses: statusesForFrame(target, prop, initializing) });
-          try {
-            if (typeof resolved === "object" && resolved !== null) {
-              if (getRegisteredTarget(resolved) !== void 0) throw snapshotDonationError(prop);
-              if (refusesWrite(target, prop, resolved)) return false;
-              if (!initializing && !writesThroughAccessor(target, prop))
-                certifyCurrentAssignment(target, prop, resolved);
-              const alreadyTracked = proxyStateMap14.has(resolved) || proxyCache3.has(resolved);
-              const instrumented = !alreadyTracked && canProxyCurrentAssignment(resolved) ? proxy(resolved) : resolved;
-              const result2 = defaultSet(target, prop, instrumented, receiver);
-              if (result2 && !initializing) commitSetInEdges(target, prop, previous, instrumented, truncated);
-              return result2;
-            }
-            if (refusesWrite(target, prop, resolved)) return false;
-            if (!initializing && typeof resolved === "function" && !writesThroughAccessor(target, prop))
-              certifyCurrentAssignment(target, prop, resolved);
-            const result = defaultSet(target, prop, resolved, receiver);
-            if (result && !initializing) commitSetInEdges(target, prop, previous, resolved, truncated);
-            return result;
-          } finally {
-            setFrameStack.pop();
-          }
-        },
-        deleteProperty(target, prop) {
-          const previous = typeof prop === "string" ? Reflect.get(target, prop) : void 0;
-          const result = defaultDelete(target, prop);
-          if (result && !isInitializing()) commitDeleteInEdges(target, prop, previous);
-          return result;
-        },
-        defineProperty(target, prop, descriptor) {
-          return Reflect.defineProperty(target, prop, descriptor);
-        },
-        setPrototypeOf(target, proto) {
-          return Reflect.setPrototypeOf(target, proto);
-        },
-        preventExtensions(target) {
-          return Reflect.preventExtensions(target);
-        }
-      };
-    }
-  );
+  return memberships;
 }
 
-// src/createMutableState.ts
-var isIgnoredWrapper = (value) => typeof value === "object" && value !== null && Object.hasOwn(value, ignoreMarker);
-var isUnsafeWrapper = (value) => typeof value === "object" && value !== null && Object.hasOwn(value, unsafeMarker);
-var consumeMarkerTree = (node, path, walk) => {
-  if (Object.isFrozen(node)) return;
-  const firstPath = walk.firstOccupancyByNode.get(node);
-  if (firstPath !== void 0) {
-    const laterOccupancies = walk.laterOccupanciesByNode.get(node);
-    if (laterOccupancies === void 0) walk.laterOccupanciesByNode.set(node, [path]);
-    else laterOccupancies.push(path);
-    return;
-  }
-  walk.firstOccupancyByNode.set(node, path);
-  for (const entry of walkDataEntries(node)) {
-    const childPath = appendOperationPath(path, segmentFor(node, entry.key));
-    const next = unwrapValue(entry.value, childPath, walk);
-    if (!Object.is(next, entry.value) && entry.writable) Reflect.set(node, entry.key, next);
+// 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;
+}
+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/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 unwrapValue = (value, path, walk) => {
-  let current = value;
-  while (isIgnoredWrapper(current) || isUnsafeWrapper(current)) {
-    const node = declarationAtPath(walk.trie, path);
-    walk.marked = true;
-    if (isIgnoredWrapper(current)) {
-      node.ignored = true;
-      current = current[ignoreMarker];
-    } else {
-      node.unsafe = true;
-      current = current[unsafeMarker];
+
+// 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]);
   }
-  if (typeof current === "object" && current !== null) consumeMarkerTree(current, path, walk);
-  return current;
 };
-var trieAtPath = (trie, path) => {
-  let current = trie;
-  for (const segment of path) {
-    current = current.children.get(String(segment));
-    if (current === void 0) return void 0;
+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]);
   }
-  return current;
 };
-var applyCopiedMarkerPaths = (walk) => {
-  for (const [node, firstPath] of walk.firstOccupancyByNode) {
-    const laterOccupancies = walk.laterOccupanciesByNode.get(node);
-    if (laterOccupancies === void 0) continue;
-    const source = trieAtPath(walk.trie, firstPath);
-    if (source === void 0 || source.children.size === 0) continue;
-    for (const laterPath of laterOccupancies) {
-      graftDeclarationChildren(source, declarationAtPath(walk.trie, laterPath));
-    }
+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]);
   }
 };
-function createMutableState(properties, options) {
-  installBoundary();
-  const trie = createDeclarationTrie();
-  let marked = false;
-  let root = properties;
-  while (isIgnoredWrapper(root) || isUnsafeWrapper(root)) {
-    if (isIgnoredWrapper(root)) {
-      trie.ignored = true;
-      marked = true;
-      root = root[ignoreMarker];
-    } else {
-      trie.unsafe = true;
-      marked = true;
-      root = root[unsafeMarker];
-    }
-  }
-  if (trie.ignored) return root;
-  if (typeof root !== "object" || root === null) return root;
-  if (Object.isFrozen(root)) return root;
-  if (isState(root)) {
-    const peeled = peelReadProxy(root);
-    if (typeof peeled === "object" && peeled !== null) return peeled;
+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);
   }
-  const decision = admissionDecision(root);
-  const strict = options?.strict !== false;
-  if (decision.lane === "leaf") return root;
-  const base = Object.create(Reflect.getPrototypeOf(root));
-  Object.defineProperties(base, Object.getOwnPropertyDescriptors(root));
-  const walk = {
-    trie,
-    marked,
-    firstOccupancyByNode: /* @__PURE__ */ new Map(),
-    laterOccupanciesByNode: /* @__PURE__ */ new Map()
-  };
-  consumeMarkerTree(base, createOperationPath([]), walk);
-  applyCopiedMarkerPaths(walk);
-  const declarations = walk.marked || hasDeclarations(trie) ? trie : void 0;
-  if (decision.lane === "dangerous" && strict && declarations?.unsafe !== true) {
-    throw rejectionError(base, decision.kind);
+};
+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;
   }
-  assertSafeDataPaths(base, [], /* @__PURE__ */ new Set(), strict ? "admission" : "rootsOnly", [declarations]);
-  const handle = {
-    proxy: { root: base },
-    lastSnapshot: base,
-    hasPendingWrites: false,
-    isFlushScheduled: false,
-    isFlushHeld: false,
-    flushGeneration: 0,
-    subscribers: /* @__PURE__ */ new Map(),
-    groups: options?.group !== void 0 ? getGroupChain(options.group) : void 0,
-    emitOn: options?.emitOn,
-    strict,
-    declarations,
-    nodes: /* @__PURE__ */ new WeakMap(),
-    byId: /* @__PURE__ */ new Map(),
-    nextInternId: 1,
-    stamp: {},
-    version: 0,
-    replaying: false
-  };
-  registerHandle(base, handle);
-  handle.nodes.set(base, { edges: [], id: 0 });
-  handle.byId.set(0, base);
-  const instrumented = proxy({ root: base });
-  handle.proxy = instrumented;
-  handle.lastSnapshot = requireObjectSnapshot(snapshot(instrumented.root));
-  seedInEdges(handle);
-  seedOccupancies(handle);
-  armWatch(handle);
-  return instrumented.root;
+  membership.edges += 1;
+  if (membership.exempt && !edgeExempt) flip(handle, rawChild, route);
 }
-
-// src/createGroup.ts
-var UnknownGroupError = class extends Error {
-  constructor() {
-    super("opshot: unknown group");
-    this.name = "UnknownGroupError";
+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 {
+    descend(handle, root, [], !exempt);
+  } catch (error) {
+    evict(handle, root);
+    throw error;
   }
-};
-var groupChainByGroup = /* @__PURE__ */ new WeakMap();
-function isGroup(value) {
-  return typeof value === "object" && value !== null && groupChainByGroup.has(value);
-}
-function getGroupListeners(group) {
-  const chain = groupChainByGroup.get(group);
-  const listeners = chain?.at(-1);
-  if (listeners === void 0) throw new UnknownGroupError();
-  return listeners;
-}
-function getGroupChain(group) {
-  const chain = groupChainByGroup.get(group);
-  if (chain === void 0) throw new UnknownGroupError();
-  return chain;
 }
-function createGroup(parent) {
-  if (parent !== void 0 && !isGroup(parent)) {
-    throw new Error("opshot: parent is not a group");
-  }
-  const listeners = /* @__PURE__ */ new Map();
-  const group = {
-    createMutableState(properties, options) {
-      return createMutableState(properties, { ...options, group });
-    }
-  };
-  const chain = parent === void 0 ? [listeners] : [...getGroupChain(parent), listeners];
-  groupChainByGroup.set(group, chain);
-  return group;
+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);
+}
+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/emitterListeners.ts
-var bindings = /* @__PURE__ */ new WeakMap();
-var dropListenerChannel = (byListener, listener, channelId, unsubscribe) => {
-  const channels = byListener.get(listener);
-  if (channels?.has(channelId) !== true) {
-    bindings.delete(unsubscribe);
-    return;
-  }
-  channels.delete(channelId);
-  if (channels.size === 0) byListener.delete(listener);
-  bindings.delete(unsubscribe);
-};
-function addStateListener(state, listener, channelId, deliver) {
-  const handle = requireHandle(state, "opshot: subscribe requires a state");
-  let byChannel = handle.subscribers.get(listener);
-  if (byChannel === void 0) {
-    byChannel = /* @__PURE__ */ new Map();
-    handle.subscribers.set(listener, byChannel);
+// 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;
   }
-  byChannel.set(channelId, deliver);
-  const unsubscribe = () => {
-    const held = bindings.get(unsubscribe);
-    if (held === void 0) return;
-    dropListenerChannel(held.handle.subscribers, held.listener, held.channelId, unsubscribe);
-  };
-  bindings.set(unsubscribe, { handle, listener, channelId });
-  return unsubscribe;
+  return void 0;
 }
-function addGroupListener(groupListeners, listener, channelId, deliver) {
-  let byChannel = groupListeners.get(listener);
-  if (byChannel === void 0) {
-    byChannel = /* @__PURE__ */ new Map();
-    groupListeners.set(listener, byChannel);
-  }
-  byChannel.set(channelId, deliver);
-  const unsubscribe = () => {
-    const held = bindings.get(unsubscribe);
-    if (held === void 0) return;
-    dropListenerChannel(held.listeners, held.listener, held.channelId, unsubscribe);
-  };
-  bindings.set(unsubscribe, { listeners: groupListeners, listener, channelId });
-  return unsubscribe;
+function requireHandle(state, message) {
+  const handle = handleOf(state);
+  if (handle === void 0) throw new Error(message);
+  return handle;
 }
 
-// src/emit/resolveWriteProxy.ts
-var { proxyStateMap: proxyStateMap15 } = unstable_getInternalStates();
-var ExpectedStateObjectError = class extends Error {
-  constructor() {
-    super("opshot: expected a state object");
-    this.name = "ExpectedStateObjectError";
-  }
-};
-var isObjectLike4 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-function resolveWriteProxy(state) {
-  let current = state;
-  while (isObjectLike4(current)) {
-    if (proxyStateMap15.has(current)) return current;
-    const peeled = peelIdentityLayer(current);
-    if (peeled === void 0) break;
-    current = peeled;
-  }
-  if (!isObjectLike4(current) || !proxyStateMap15.has(current)) throw new ExpectedStateObjectError();
-  return current;
+// src/batch.ts
+var metaStack = [];
+function currentMeta() {
+  return metaStack.length === 0 ? void 0 : metaStack[metaStack.length - 1];
 }
-
-// src/transact/nest.ts
-var transactionOpen = false;
-var isTransactionOpen = () => transactionOpen;
-var openTransaction = () => {
-  transactionOpen = true;
-};
-var closeTransaction = () => {
-  transactionOpen = false;
-};
-
-// src/ops/applyMutations.ts
-var ReplayReattachError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ReplayReattachError";
-  }
-};
-var unresolvedError = (path) => new Error(`opshot: ${formatOperationPath(path)} does not resolve to a supported operation address`);
-var linkError = (path, ref, reason) => new Error(`opshot: link at ${formatOperationPath(path)} with ref ${String(ref)} ${reason}`);
-var isWritableDataDescriptor = (descriptor) => descriptor !== void 0 && "value" in descriptor && descriptor.writable === true;
-var restoreRecordedContent = (attached, recorded, restored, identity) => {
-  if (restored.has(recorded)) return;
-  restored.add(recorded);
-  for (const entry of walkDataEntries(recorded, true)) {
-    const key = entry.key;
-    const attachedDescriptor = Reflect.getOwnPropertyDescriptor(attached, key);
-    if (attachedDescriptor !== void 0 && !isWritableDataDescriptor(attachedDescriptor)) continue;
-    const value = entry.value;
-    if (identity === "restore" && isObjectLike3(value)) {
-      const target = getRegisteredTarget(value);
-      if (target !== void 0) {
-        const present = attachedDescriptor?.value;
-        if (!isObjectLike3(present) || resolveIdentity(present) !== resolveIdentity(target)) {
-          Reflect.set(attached, key, target);
-        }
-        const child = Reflect.get(attached, key);
-        if (!isObjectLike3(child)) throw new ReplayReattachError(`opshot: replay could not reattach ${key}`);
-        restoreRecordedContent(child, value, restored, identity);
-        continue;
-      }
-    }
-    Reflect.set(attached, key, value);
-  }
-  for (const entry of walkDataEntries(attached)) {
-    if (!entry.writable) continue;
-    if (Object.hasOwn(recorded, entry.key)) continue;
-    Reflect.deleteProperty(attached, entry.key);
-  }
-};
-var getValuePayload = (operation, identity) => {
-  const original = identity === "restore" ? getValueOriginal(operation) ?? operation.value : operation.value;
-  return {
-    recorded: original,
-    fallback: isObjectLike3(original) ? cloneValue(original, /* @__PURE__ */ new WeakMap(), operation.path) : original
-  };
-};
-var restoreValue = (payload, attach, readAttached, identity) => {
-  if (identity === "restore" && isObjectLike3(payload.recorded)) {
-    const target = getRegisteredTarget(payload.recorded);
-    if (target !== void 0) {
-      attach(target);
-      const attached = readAttached();
-      if (!isObjectLike3(attached)) {
-        throw new ReplayReattachError("opshot: replay could not read a reattached target");
-      }
-      restoreRecordedContent(attached, payload.recorded, /* @__PURE__ */ new WeakSet(), identity);
-      return;
-    }
-  }
-  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);
-  }
-  return void 0;
-};
-var requirePlainSegment = (parent, segment, path) => {
-  if (Array.isArray(parent)) {
-    if (isCanonicalArrayIndex(segment)) return segment;
-    if (typeof segment === "string" && !isCanonicalArrayIndexString(segment)) return segment;
-    throw unresolvedError(path);
-  }
-  if (typeof segment === "string") return segment;
-  throw unresolvedError(path);
-};
-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 resolveTraversalSegment = (parent, segment, path) => {
-  if (!isObjectLike3(parent)) throw unresolvedError(path);
-  return requirePlainProperty(parent, segment, path);
-};
-var resolveTerminal = (root, path) => {
-  if (path.length === 0) throw unresolvedError(path);
-  let parent = root;
-  for (let index = 0; index < path.length - 1; index++) parent = resolveTraversalSegment(parent, path[index], path);
-  if (!isObjectLike3(parent)) throw unresolvedError(path);
-  return { parent, segment: path[path.length - 1] };
-};
-var applyLink = (root, operation, handle) => {
-  const path = operation.path;
-  const ref = operation.ref;
-  if (path.length === 0) throw linkError(path, ref, "does not resolve to a supported operation address");
-  const resolved = nodeOfInternedId(handle, ref, handle.transactionCapture);
-  if (resolved === void 0) throw linkError(path, ref, "does not resolve");
-  const terminal = resolveTerminal(root, path);
-  if (Array.isArray(terminal.parent) && terminal.segment === "length") {
-    throw linkError(path, ref, "cannot address array length");
-  }
-  const key = requirePlainSegment(terminal.parent, terminal.segment, path);
-  const descriptor = Reflect.getOwnPropertyDescriptor(terminal.parent, key);
-  const present = descriptor !== void 0 && descriptor.enumerable && "value" in descriptor;
-  if (descriptor !== void 0 && !present) throw unresolvedError(path);
-  if (!present) {
-    const inheritedDescriptor = getInheritedDescriptor(terminal.parent, key);
-    if (inheritedDescriptor && !("value" in inheritedDescriptor)) {
-      throw new Error(`opshot: ${formatOperationPath(path)} resolves to an inherited accessor`);
-    }
-  }
-  Reflect.set(terminal.parent, key, resolved);
-};
-var applyPlain = (parent, segment, operation, identity, handle) => {
-  const path = operation.path;
-  if (Array.isArray(parent) && segment === "length") {
-    if (operation.verb !== "assign" || typeof operation.value !== "number" || !Number.isInteger(operation.value) || operation.value < 0 || operation.value > MAX_ARRAY_LENGTH) {
-      throw unresolvedError(path);
-    }
-    Reflect.set(parent, "length", operation.value);
-    return;
-  }
-  const key = requirePlainSegment(parent, segment, path);
-  const descriptor = Reflect.getOwnPropertyDescriptor(parent, key);
-  const present = descriptor !== void 0 && descriptor.enumerable && "value" in descriptor;
-  if (descriptor !== void 0 && !present) throw unresolvedError(path);
-  if (operation.verb === "delete") {
-    Reflect.deleteProperty(parent, key);
-    return;
-  }
-  if (!present) {
-    const inheritedDescriptor = getInheritedDescriptor(parent, key);
-    if (inheritedDescriptor && !("value" in inheritedDescriptor)) {
-      throw new Error(`opshot: ${formatOperationPath(path)} resolves to an inherited accessor`);
-    }
+function batch(callback, meta) {
+  metaStack.push(meta);
+  try {
+    callback();
+  } finally {
+    metaStack.pop();
   }
-  const payload = getValuePayload(operation, identity);
-  restoreValue(
-    payload,
-    (value) => Reflect.set(parent, key, value),
-    () => Reflect.get(parent, key),
-    identity
-  );
-  const attached = Reflect.get(parent, key);
-  if (!isObjectLike3(attached)) return;
-  if (operation.ids !== void 0) {
-    if (isObjectLike3(payload.recorded)) {
-      bindVendedIds(handle, attached, payload.recorded, operation.ids, handle.transactionCapture, parent, key);
+}
+
+// src/emit/emitterDeliver.ts
+var runDelivery = (pending, failures) => {
+  pending.handle.lastDirty = pending.dirty;
+  for (const deliver of pending.deliveries) {
+    try {
+      deliver(pending.operations);
+    } catch (error) {
+      failures.push(error);
     }
-  } else {
-    let chains = chainsAtRoot(handle.declarations);
-    for (const segment2 of path) chains = descendChains(chains, segment2).chains;
-    chains = nodeChainsOf(handle, attached) ?? chains;
-    internSubtree(
-      handle,
-      attached,
-      chains,
-      (parent2, parentChains, key2, entry) => isTrackedEdge(entry) ? resolveChildChains(handle, parent2, parentChains, key2, entry.value)?.chains : void 0,
-      handle.transactionCapture
-    );
   }
 };
-var applyMutation = (root, operation, identity, handle) => {
-  if (operation.verb === "link") {
-    applyLink(root, operation, handle);
-    return;
+var raiseFailures = (failures) => {
+  if (failures.length === 0) return;
+  if (failures.length > 1) throw new AggregateError(failures, "opshot: listeners failed during delivery");
+  throw failures[0];
+};
+var queuedDeliveries = [];
+var deliveryFailures = [];
+var isDraining = false;
+var prepareDelivery = (handle, operations, dirty) => ({
+  deliveries: [...handle.subscribers.values()],
+  operations,
+  handle,
+  dirty
+});
+var enqueueDelivery = (pending) => {
+  queuedDeliveries.push(pending);
+};
+var drainDeliveries = () => {
+  if (isDraining) return;
+  isDraining = true;
+  let failures = [];
+  try {
+    while (queuedDeliveries.length > 0) {
+      for (const queued of queuedDeliveries.splice(0, queuedDeliveries.length)) {
+        runDelivery(queued, deliveryFailures);
+      }
+    }
+  } finally {
+    isDraining = false;
+    failures = deliveryFailures.splice(0, deliveryFailures.length);
   }
-  const terminal = resolveTerminal(root, operation.path);
-  applyPlain(terminal.parent, terminal.segment, operation, identity, handle);
+  raiseFailures(failures);
 };
-function applyMutations(root, operations, direction, identity, handle) {
-  if (direction === "do") {
-    for (const operation of operations) applyMutation(root, operation.do, identity, handle);
+
+// 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;
   }
-  const occupantAt = (path) => {
-    let current = root;
-    for (const segment of path) {
-      if (!isObjectLike3(current)) return void 0;
-      current = Reflect.get(current, segment);
-    }
-    return current;
+  handle.pending.push(pending);
+  byKey.set(pending.key, handle.pending.length - 1);
+  if (handle.scheduledFlush !== void 0) return;
+  const run = () => {
+    if (handle.scheduledFlush !== run) return;
+    flushWindow(handle);
   };
-  const admittedRoots = new Array();
-  for (const operation of operations) {
-    if (operation.do.verb !== "assign" || !isObjectLike3(operation.do.value)) continue;
-    const occupant = occupantAt(operation.undo.path);
-    if (isObjectLike3(occupant)) admittedRoots.push(occupant);
-  }
-  for (let index = operations.length - 1; index >= 0; index--) {
-    const operation = operations[index];
-    if (operation === void 0) continue;
-    applyMutation(root, operation.undo, identity, handle);
+  handle.scheduledFlush = run;
+  void Promise.resolve().then(() => {
+    if (handle.scheduledFlush !== run) return;
+    const emitOn = handle.emitOn;
+    if (emitOn === void 0) run();
+    else emitOn(run);
+  });
+}
+function flushWindow(handle) {
+  handle.scheduledFlush = void 0;
+  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));
   }
-  const idSet = /* @__PURE__ */ new Set();
-  for (const node of admittedRoots) {
-    for (const id of rewindAdmission(handle, node)) idSet.add(id);
+  if (operations.length === 0) 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);
+    }
+    keys.add(operation.key);
+    nodes.add(raw);
   }
-  while (idSet.has(handle.nextInternId - 1)) handle.nextInternId -= 1;
+  const dirty = { edges, nodes };
+  enqueueDelivery(prepareDelivery(handle, operations, dirty));
+  drainDeliveries();
 }
 
-// src/transact/rollback.ts
-var rollbackTransaction = (handle) => {
-  const restoreTarget = handle.lastSnapshot;
-  const operations = diffObjects(snapshot(handle.proxy.root), restoreTarget, handle, void 0, createCaptureTables());
-  if (operations.length > 0) {
-    applyMutations(handle.proxy.root, operations, "do", "restore", handle);
+// 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;
   }
-  handle.lastSnapshot = restoreTarget;
-  handle.hasPendingWrites = false;
+  return void 0;
 };
-
-// src/transact/transact.ts
-function transact(state, mutate, meta) {
-  runTransaction(state, mutate, meta, void 0);
-}
-var attachRollbackCause = (error, rollbackError) => {
-  if (!(error instanceof Error) || error.cause !== void 0) return;
-  Object.defineProperty(error, "cause", {
-    value: rollbackError,
-    writable: true,
-    enumerable: false,
-    configurable: true
-  });
+var isRideAlongKey = (target, key) => {
+  if (key === "__proto__") return true;
+  if (key === "length") return false;
+  const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+  return descriptor?.enumerable === false;
 };
-var flattenDeliveryFailures = (error) => {
-  if (error instanceof AggregateError && error.message === "opshot: listeners failed during delivery") {
-    return error.errors;
+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 [error];
-};
-var releaseUncaught = (failures) => {
-  if (failures.length === 0) return;
-  const error = failures.length === 1 ? failures[0] : new AggregateError(failures, "opshot: listeners failed during delivery");
-  queueMicrotask(() => {
-    throw error;
-  });
+  return false;
 };
-function runTransaction(state, mutate, meta, channelId) {
-  if (isTransactionOpen()) {
-    throw new Error(
-      "opshot: transact cannot be nested; a transaction cannot contain another. Mutate inside the callback rather than transacting, run transactions in sequence, or call applyOperations at top level."
-    );
+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
+    });
   }
-  const handle = requireHandle(state, "opshot: transact requires a state");
-  handle.flushGeneration += 1;
-  handle.isFlushScheduled = false;
-  const listenerFailures = new Array();
-  const emitCollectingListeners = (emit) => {
-    const baseline = handle.lastSnapshot;
-    try {
-      emit();
-    } catch (error) {
-      if (handle.lastSnapshot === baseline) throw error;
-      listenerFailures.push(...flattenDeliveryFailures(error));
+  return truncated;
+};
+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 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;
     }
-  };
-  const deliverQuietly = (ranges) => {
-    try {
-      deliverCapturedRanges(ranges);
-    } catch (error) {
-      listenerFailures.push(...flattenDeliveryFailures(error));
+    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);
     }
-  };
-  try {
-    const starting = captureWrites(handle);
-    const previousHeld = handle.isFlushHeld;
-    handle.isFlushHeld = true;
-    handle.transactionCapture = createCaptureTables();
-    openTransaction();
-    let completed = false;
-    let mutateError;
-    try {
-      mutate();
-      completed = true;
-    } catch (error) {
-      mutateError = error;
-      throw error;
-    } finally {
-      closeTransaction();
-      if (!completed) {
-        try {
-          rollbackTransaction(handle);
-        } catch (rollbackError) {
-          attachRollbackCause(mutateError, rollbackError);
+    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]);
         }
-        handle.transactionCapture = void 0;
-        handle.isFlushHeld = previousHeld;
-        deliverQuietly([starting]);
-      } else {
-        handle.isFlushHeld = previousHeld;
+      } catch (error) {
+        rollBack();
+        throw error;
       }
     }
-    let transaction;
-    try {
-      transaction = captureTransactionWrites(handle, meta, channelId);
-    } catch (error) {
-      try {
-        rollbackTransaction(handle);
-      } catch (rollbackError) {
-        attachRollbackCause(error, rollbackError);
+    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
+        });
       }
-      deliverQuietly([starting]);
-      throw error;
-    } finally {
-      handle.transactionCapture = void 0;
     }
-    deliverQuietly([starting, transaction]);
-    emitCollectingListeners(() => {
-      emitWrites(handle);
-    });
-  } finally {
-    releaseUncaught(listenerFailures);
+    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);
   }
+};
+
+// 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()
+  };
+  const proxy = proxyOf(root);
+  attachRoot(handle, root, exempt);
+  return proxy;
 }
 
-// src/ops/applyOperations.ts
-var originError = () => new Error("opshot: applyOperations applies a state's operations only to that state");
-var tapeError = () => new Error("opshot: applyOperations applies only the next or previous operations");
-var isFrozenCopyablePath = (value) => Array.isArray(value) && value.every((segment) => typeof segment === "string" || typeof segment === "number");
-var isNonNegativeInteger = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
-var isWellFormedLinkHalf = (value) => typeof value === "object" && value !== null && "verb" in value && value.verb === "link" && "path" in value && "ref" in value && isFrozenCopyablePath(value.path) && isNonNegativeInteger(value.ref);
-var isWellFormedDeleteHalf = (value) => typeof value === "object" && value !== null && "verb" in value && value.verb === "delete" && "path" in value && isFrozenCopyablePath(value.path);
-var isWellFormedIds = (value) => value === void 0 || Array.isArray(value) && value.every((id) => typeof id === "number" && Number.isInteger(id) && id >= 0);
-var isWellFormedAssignHalf = (value) => typeof value === "object" && value !== null && "verb" in value && value.verb === "assign" && "value" in value && "path" in value && isFrozenCopyablePath(value.path) && (!("ids" in value) || value.ids === void 0 || isWellFormedIds(value.ids));
-var isApplicableHalf = (value) => isMutation(value) || isWellFormedLinkHalf(value) || isWellFormedDeleteHalf(value) || isWellFormedAssignHalf(value);
-var assertApplicable = (operation) => {
-  if (isMutation(operation)) {
-    throw new Error("opshot: applyOperations applies operation pairs; pass the operation, with a direction");
-  }
-  if (typeof operation !== "object" || operation === null || !("do" in operation) || !("undo" in operation) || !isApplicableHalf(operation.do) || !isApplicableHalf(operation.undo)) {
-    throw new Error("opshot: applyOperations applies well-formed { do, undo } pairs");
-  }
+// src/identity.ts
+var readProxyTargets = /* @__PURE__ */ new WeakMap();
+var identityRecords = /* @__PURE__ */ new WeakMap();
+var nextInternId = 0;
+var registerReadProxyTarget = (readProxy, target) => {
+  readProxyTargets.set(readProxy, target);
 };
-function applyOperations(state, operations, direction, meta) {
-  runOperations(state, operations, direction, meta, void 0);
-}
-function runOperations(state, operations, direction, meta, channelId) {
-  for (const operation of operations) assertApplicable(operation);
-  const appliedDirection = direction;
-  if (appliedDirection !== "do" && appliedDirection !== "undo") {
-    throw new Error('opshot: applyOperations applies a direction of "do" or "undo"');
-  }
-  if (isTransactionOpen()) {
-    throw new Error(
-      "opshot: transact cannot be nested; a transaction cannot contain another. Mutate inside the callback rather than transacting, run transactions in sequence, or call applyOperations at top level."
-    );
-  }
-  const handle = requireHandle(state, "opshot: applyOperations requires a state");
-  emitWrites(handle);
-  let ownedCount = 0;
-  for (const operation of operations) {
-    const stamp = stampOf(operation);
-    if (stamp !== void 0 && stamp !== handle.stamp) throw originError();
-    if (stamp === handle.stamp) ownedCount += 1;
-  }
-  if (ownedCount > 0 && ownedCount < operations.length) throw originError();
-  const owned = operations.length > 0 && ownedCount === operations.length;
-  if (owned) {
-    let index = 0;
-    for (const operation of operations) {
-      const expected = direction === "do" ? handle.version + 1 + index : handle.version - (operations.length - 1 - index);
-      if (versionOf(operation) !== expected) throw tapeError();
-      index += 1;
+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;
     }
+    const raw = rawOf(current);
+    if (raw !== current) {
+      current = raw;
+      continue;
+    }
+    break;
   }
-  handle.replaying = true;
-  try {
-    runTransaction(
-      state,
-      () => {
-        applyMutations(resolveWriteProxy(state), operations, direction, owned ? "restore" : "construct", handle);
-        if (owned) {
-          handle.version = direction === "do" ? handle.version + operations.length : handle.version - operations.length;
-        }
-      },
-      meta,
-      channelId
-    );
-  } finally {
-    handle.replaying = false;
-  }
+  return current;
 }
-
-// src/subscribe.ts
-function subscribe2(target, listener) {
-  if (isGroup(target)) {
-    return addGroupListener(
-      getGroupListeners(target),
-      listener,
-      void 0,
-      (state, ops, meta) => listener(state, ops, meta)
-    );
+var recordFor = (key) => {
+  let record = identityRecords.get(key);
+  if (record === void 0) {
+    record = {};
+    identityRecords.set(key, record);
   }
-  return addStateListener(target, listener, void 0, (ops, meta) => listener(ops, meta));
+  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;
 }
-function toChannelContext(channelId, defaults, meta, deliveredChannelId) {
-  if (deliveredChannelId === channelId) {
-    return {
-      isTransaction: true,
-      meta: { ...defaults, ...typeof meta === "object" && meta !== null ? meta : void 0 }
-    };
-  }
-  return { isTransaction: false, meta };
+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/createChannel.ts
-function createChannel(defaults) {
-  const channelId = Object.freeze({});
-  function transact2(state, mutate, meta) {
-    runTransaction(state, mutate, meta, channelId);
-  }
-  function subscribe3(target, listener) {
-    if (isGroup(target)) {
-      return addGroupListener(
-        getGroupListeners(target),
-        listener,
-        channelId,
-        (state, ops, meta, deliveredChannelId) => {
-          listener(
-            state,
-            ops,
-            toChannelContext(channelId, defaults, meta, deliveredChannelId)
-          );
-        }
-      );
-    }
-    return addStateListener(target, listener, channelId, (ops, meta, deliveredChannelId) => {
-      listener(
-        ops,
-        toChannelContext(channelId, defaults, meta, deliveredChannelId)
-      );
-    });
-  }
-  function applyOperations2(state, operations, direction, meta) {
-    runOperations(state, operations, direction, meta, channelId);
+// src/peelReadProxy.ts
+function peelReadProxy(value) {
+  if (!isObjectLike(value)) return value;
+  let current = value;
+  while (isObjectLike(current)) {
+    const registeredTarget = getRegisteredReadProxyTarget(current);
+    if (registeredTarget === void 0) break;
+    current = registeredTarget;
   }
-  return { transact: transact2, subscribe: subscribe3, applyOperations: applyOperations2 };
+  return current;
+}
+
+// src/isState.ts
+function isState(value) {
+  const resolved = peelReadProxy(value);
+  if (typeof resolved !== "object" || resolved === null) return false;
+  return recordOf(resolved)?.proxy === resolved;
 }
 
 // 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");
   }
 };
 
@@ -3185,7 +737,6 @@ var clipTime = (epochMs) => {
 };
 var TrackedDate = class {
   constructor(...args) {
-    installBoundary();
     this.epochMs = constructDate(args).getTime();
   }
   readDate() {
@@ -3452,14 +1003,13 @@ var EmptyMapSlotError = class extends Error {
     this.name = "EmptyMapSlotError";
   }
 };
-var isObjectLike5 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+var isObjectLike2 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
 var isStoredValue = (stored, incoming) => {
   if (Object.is(stored, incoming)) return true;
-  return isObjectLike5(stored) && isObjectLike5(incoming) && isSameIdentity(stored, incoming);
+  return isObjectLike2(stored) && isObjectLike2(incoming) && isSameIdentity(stored, incoming);
 };
 var TrackedMap = class {
   constructor(entries) {
-    installBoundary();
     this.slots = [];
     this.index = {};
     this.count = 0;
@@ -3542,7 +1092,6 @@ Object.defineProperty(TrackedMap.prototype, Symbol.toStringTag, {
 // src/tracked/trackedSet.ts
 var TrackedSet = class {
   constructor(values) {
-    installBoundary();
     this.slots = [];
     this.index = {};
     this.count = 0;
@@ -3606,36 +1155,42 @@ Object.defineProperty(TrackedSet.prototype, Symbol.toStringTag, {
   writable: false
 });
 
-// src/react/dirtySinceSnapshot.ts
-var parentLiveOf = (root, path) => {
-  if (path.length === 0) return void 0;
-  let current = root;
-  for (const segment of path.slice(0, -1)) {
-    if (!isObjectLike3(current)) return void 0;
-    current = Reflect.get(current, segment);
-  }
-  return isObjectLike3(current) ? current : void 0;
-};
-function dirtySinceSnapshot(handle, from) {
-  const dirty = { edges: /* @__PURE__ */ new WeakMap(), nodes: /* @__PURE__ */ new WeakSet() };
-  for (const operation of diffObjects(from, snapshot(handle.proxy.root))) {
-    const path = operation.do.path;
-    markDirtyPath(dirty, handle, path, parentLiveOf(handle.proxy.root, path));
-  }
-  return dirty;
+// src/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/flush.ts
+function flush(state) {
+  flushWindow(requireHandle(state, "opshot: flush requires a state"));
 }
 
 // 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 (mode === "nested" && !writable) return "skip";
-  if (admissionLane(value) === "untracked") return "skip";
+  if (!isTrackedEntry(value, mode === "entry" || writable)) return "skip";
   if (isState(value)) return "state";
-  if (admissionLane(value) === "tracked") return "descend";
+  if (canRebuild(value)) return "descend";
   return "skip";
 };
 var readVerdict = (container, pass) => pass.verdicts.get(container) ?? stateKeysByContainer.get(container) ?? noStateKeys;
@@ -3702,7 +1257,7 @@ function discoverStateKeys(container) {
   const cached = stateKeysByContainer.get(container);
   if (cached !== void 0) return cached;
   if (isReactOwnNode(container)) return noStateKeys;
-  if (admissionLane(container) !== "tracked") return noStateKeys;
+  if (Object.isFrozen(container) || !canRebuild(container)) return noStateKeys;
   const pass = createDiscoveryPass();
   visitContainer(container, pass, "nested");
   relaxVerdicts(pass);
@@ -3758,7 +1313,7 @@ function substituteStates(root, wrap) {
     sources: [],
     visitedSources: /* @__PURE__ */ new Set()
   };
-  if (isReactOwnNode(root) || unfrozenAdmissionLane(root) !== "tracked") {
+  if (isReactOwnNode(root) || !canRebuild(root)) {
     return { props: root, sources: substitution.sources };
   }
   return { props: substituteContainer(root, substitution, wrap, "entry"), sources: substitution.sources };
@@ -3786,15 +1341,11 @@ var isRendering = () => {
 };
 
 // src/react/readTracker.ts
-var { proxyStateMap: proxyStateMap16 } = unstable_getInternalStates();
 var KEYS_PROPERTY = "k";
 var HAS_KEY_PROPERTY = "h";
 var HAS_OWN_KEY_PROPERTY = "o";
 var ALL_OWN_KEYS_PROPERTY = "w";
-var isObjectLike6 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-var isLiveProxy = (value) => proxyStateMap16.has(value);
-var getProxyTarget = (writeProxy) => proxyStateMap16.get(writeProxy)?.[0] ?? writeProxy;
-var getProxyVersion = (writeProxy) => getVersion(writeProxy) ?? 0;
+var isWriteProxy = (value) => recordOf(value)?.proxy === value;
 var getUsage = (affected, target) => {
   let used = affected.get(target);
   if (used === void 0) {
@@ -3803,13 +1354,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);
@@ -3830,30 +1387,68 @@ var UnregisteredReadTrackerError = class extends Error {
   }
 };
 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 keySets = new Array();
-  if (used[KEYS_PROPERTY] !== void 0) keySets.push(used[KEYS_PROPERTY]);
-  if (used[HAS_KEY_PROPERTY] !== void 0) keySets.push(used[HAS_KEY_PROPERTY]);
-  if (used[HAS_OWN_KEY_PROPERTY] !== void 0) keySets.push(used[HAS_OWN_KEY_PROPERTY]);
-  return keySets;
+  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) {
-  const partitions = trackerPartitions.get(tracker);
-  if (partitions === void 0) throw new UnregisteredReadTrackerError();
-  for (const partition of partitions.values()) {
+  for (const partition of partitionsOf(tracker).values()) {
     for (const [writeProxy, used] of partition.affected) {
-      const raw = getProxyTarget(writeProxy);
+      const raw = rawOf(writeProxy);
       const edges = dirty.edges.get(raw);
       for (const keys of recordedKeysOf(used)) {
-        for (const key of keys) {
+        for (const key of keys.keys()) {
+          if (typeof key === "symbol") continue;
           if (edges?.has(key) === true) return true;
         }
       }
-      if (used[ALL_OWN_KEYS_PROPERTY] === true && dirty.nodes.has(raw)) 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(getProxyTarget(writeProxy))) return true;
+      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;
@@ -3878,13 +1473,13 @@ function createReadTracker() {
   const trackUsage = (partition, writeProxy) => shouldRecord() ? getUsage(partition.affected, writeProxy) : {};
   const recordIdentity = (partition, value) => {
     if (!shouldRecord()) return;
-    if (isObjectLike6(value) && isLiveProxy(value)) partition.identityReads.add(value);
+    if (isObjectLike(value) && isWriteProxy(value)) partition.identityReads.add(value);
   };
   const toReadProxy = (writeProxy, partition) => {
-    const currentVersion = getProxyVersion(writeProxy);
-    const cached = partition.proxyCache.get(writeProxy);
-    if (cached?.version === currentVersion) return cached.readProxy;
-    const target = getProxyTarget(writeProxy);
+    const raw = rawOf(writeProxy);
+    const cached = partition.proxyCache.get(raw);
+    if (cached !== void 0) return cached;
+    const target = raw;
     const readProxyBox = {};
     const boundMethods = /* @__PURE__ */ new WeakMap();
     const bindMethodToReadProxy = (readProxy2, method) => {
@@ -3894,12 +1489,12 @@ function createReadTracker() {
       boundMethods.set(method, bound);
       return bound;
     };
-    const handler = {
+    const handler2 = {
       get(_target, prop) {
         const readProxy2 = readProxyBox.current;
         const value = Reflect.get(writeProxy, prop, readProxy2 ?? writeProxy);
         const used = trackUsage(partition, writeProxy);
-        recordKey(used, KEYS_PROPERTY, prop);
+        recordGet(used, prop, value);
         recordIdentity(partition, value);
         if (typeof value === "function") {
           const method = getPrototypeMethod(target, prop);
@@ -3907,25 +1502,28 @@ function createReadTracker() {
             return bindMethodToReadProxy(readProxy2, method);
           }
         }
-        if (!isObjectLike6(value)) return value;
+        if (!isObjectLike(value)) return value;
         if (typeof value === "function") return value;
-        if (!isLiveProxy(value)) return value;
+        if (!isWriteProxy(value)) return value;
         return toReadProxy(value, partition);
       },
       has(_target, prop) {
         const used = trackUsage(partition, writeProxy);
-        recordKey(used, HAS_KEY_PROPERTY, prop);
-        return Reflect.has(writeProxy, prop);
+        const result = Reflect.has(writeProxy, prop);
+        recordHas(used, prop, result);
+        return result;
       },
       getOwnPropertyDescriptor(_target, prop) {
         const used = trackUsage(partition, writeProxy);
-        recordKey(used, HAS_OWN_KEY_PROPERTY, prop);
-        return Reflect.getOwnPropertyDescriptor(writeProxy, prop);
+        const descriptor = Reflect.getOwnPropertyDescriptor(writeProxy, prop);
+        recordOwn(used, prop, descriptor !== void 0);
+        return descriptor;
       },
       ownKeys() {
         const used = trackUsage(partition, writeProxy);
-        used[ALL_OWN_KEYS_PROPERTY] = true;
-        return Reflect.ownKeys(writeProxy);
+        const keys = Reflect.ownKeys(writeProxy);
+        used[ALL_OWN_KEYS_PROPERTY] ??= keys;
+        return keys;
       },
       set(_target, prop, value) {
         return Reflect.set(writeProxy, prop, value, writeProxy);
@@ -3934,15 +1532,15 @@ function createReadTracker() {
         return Reflect.deleteProperty(writeProxy, prop);
       }
     };
-    const readProxy = new Proxy(writeProxy, handler);
+    const readProxy = new Proxy(writeProxy, handler2);
     readProxyBox.current = readProxy;
     registerReadProxyTarget(readProxy, writeProxy);
-    partition.proxyCache.set(writeProxy, { readProxy, version: currentVersion });
+    partition.proxyCache.set(raw, readProxy);
     return readProxy;
   };
   const tracker = {
     wrap(writeProxy) {
-      if (!isLiveProxy(writeProxy)) {
+      if (!isWriteProxy(writeProxy)) {
         throw new Error("opshot: ReadTracker.wrap requires a write proxy");
       }
       const partition = getPartition(writeProxy);
@@ -3957,6 +1555,7 @@ function createReadTracker() {
       for (const partition of partitions.values()) {
         partition.affected.clear();
         partition.identityReads.clear();
+        partition.proxyCache = /* @__PURE__ */ new WeakMap();
       }
     },
     retain() {
@@ -4010,16 +1609,12 @@ function scope(Component) {
   const Scoped = (props) => {
     const readTrackerRef = useRef(void 0);
     const currentHandlesRef = useRef([]);
-    const [gapSnapshots] = useState(() => /* @__PURE__ */ new WeakMap());
     readTrackerRef.current ??= createReadTracker();
     const readTracker = readTrackerRef.current;
     const [, bump] = useReducer((value) => value + 1, 0);
     readTracker.resetReads();
     const { props: renderedProps, sources } = substituteStates(props, (source) => readTracker.wrap(source));
     const uniqueHandles = uniqueHandlesOf(sources);
-    for (const handle of uniqueHandles) {
-      gapSnapshots.set(handle, snapshot(handle.proxy.root));
-    }
     useCommitEffect(() => {
       currentHandlesRef.current = uniqueHandles;
       readTracker.captureReads();
@@ -4031,24 +1626,16 @@ function scope(Component) {
     useEffect(() => {
       let cancelled = false;
       const subscribedHandles = uniqueHandlesOf(sources);
-      for (const handle of subscribedHandles) {
-        const from = gapSnapshots.get(handle);
-        if (from !== void 0 && readsIntersectDirty(readTracker, dirtySinceSnapshot(handle, from))) bump();
-      }
       const unsubscribes = subscribedHandles.map(
-        (handle) => subscribe2(handle.proxy.root, () => {
+        (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;
-        const currentHandles = new Set(currentHandlesRef.current);
-        for (const handle of subscribedHandles) {
-          if (currentHandles.has(handle)) continue;
-          gapSnapshots.set(handle, snapshot(handle.proxy.root));
-        }
         for (const unsubscribe of unsubscribes) unsubscribe();
       };
     }, [sourcesKey(sources), readTracker]);
@@ -4058,10 +1645,7 @@ function scope(Component) {
   Scoped.displayName = `scope(${typeof baseName === "string" && baseName !== "" ? baseName : "Component"})`;
   return memo(Scoped, arePropsEqual);
 }
-function useGroup(parent) {
-  return useState(() => createGroup(parent))[0];
-}
-var isObjectLike7 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+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;
@@ -4072,13 +1656,9 @@ function useMutableState(properties, options) {
   });
   const [, bump] = useReducer((value) => value + 1, 0);
   const currentHandlesRef = useRef([]);
-  const [gapSnapshots] = useState(() => /* @__PURE__ */ new WeakMap());
-  const uniqueHandles = isObjectLike7(writeProxy) ? handlesOf(writeProxy) : [];
+  const uniqueHandles = isObjectLike3(writeProxy) ? handlesOf(writeProxy) : [];
   readTracker.resetReads();
-  const readProxy = isObjectLike7(writeProxy) ? readTracker.wrap(writeProxy) : writeProxy;
-  for (const handle of uniqueHandles) {
-    gapSnapshots.set(handle, snapshot(handle.proxy.root));
-  }
+  const readProxy = isObjectLike3(writeProxy) ? readTracker.wrap(writeProxy) : writeProxy;
   useCommitEffect(() => {
     currentHandlesRef.current = uniqueHandles;
     readTracker.captureReads();
@@ -4089,29 +1669,21 @@ function useMutableState(properties, options) {
   }, [readTracker]);
   useEffect(() => {
     let cancelled = false;
-    const subscribedHandles = isObjectLike7(writeProxy) ? handlesOf(writeProxy) : [];
-    for (const handle of subscribedHandles) {
-      const from = gapSnapshots.get(handle);
-      if (from !== void 0 && readsIntersectDirty(readTracker, dirtySinceSnapshot(handle, from))) bump();
-    }
+    const subscribedHandles = isObjectLike3(writeProxy) ? handlesOf(writeProxy) : [];
     const unsubscribes = subscribedHandles.map(
-      (handle) => subscribe2(handle.proxy.root, () => {
+      (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;
-      const currentHandles = new Set(currentHandlesRef.current);
-      for (const handle of subscribedHandles) {
-        if (currentHandles.has(handle)) continue;
-        gapSnapshots.set(handle, snapshot(handle.proxy.root));
-      }
       for (const unsubscribe of unsubscribes) unsubscribe();
     };
   }, [writeProxy, readTracker]);
   return readProxy;
 }
 
-export { TrackedDate, TrackedMap, TrackedSet, applyOperations, createChannel, createGroup, createMutableState, diffObjects, identify, ignore, isSameIdentity, isState, scope, subscribe2 as subscribe, transact, unsafeTrack, useGroup, useMutableState };
+export { TrackedDate, TrackedMap, TrackedSet, batch, createMutableState, flush, identify, ignore, isSameIdentity, isState, scope, subscribe, unsafeTrack, useMutableState };