opshot 0.2.1 → 0.3.1

package/dist/index.js

@@ -1,155 +1,2297 @@
-import { unstable_getInternalStates, ref, proxy, snapshot } from 'valtio/vanilla';
-export { ref } from 'valtio/vanilla';
-
-// src/index.ts
-var { refSet } = unstable_getInternalStates();
-var isPlainArray = (value) => Array.isArray(value) && !refSet.has(value);
-var isPlainObject = (value) => {
-  if (typeof value !== "object" || value === null || Array.isArray(value) || refSet.has(value)) return false;
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
+import { memo, useState, useReducer, useEffect, useRef, createElement } from 'react';
+
+// node_modules/proxy-compare/dist/index.js
+var GET_ORIGINAL_SYMBOL = /* @__PURE__ */ Symbol();
+var HAS_KEY_PROPERTY = "h";
+var ALL_OWN_KEYS_PROPERTY = "w";
+var HAS_OWN_KEY_PROPERTY = "o";
+var KEYS_PROPERTY = "k";
+var getProto = Object.getPrototypeOf;
+var objectsToTrack = /* @__PURE__ */ new WeakMap();
+var isObjectToTrack = (obj) => obj && (objectsToTrack.has(obj) ? objectsToTrack.get(obj) : getProto(obj) === Object.prototype || getProto(obj) === Array.prototype);
+var isObject = (x) => typeof x === "object" && x !== null;
+var getOriginalObject = (obj) => (
+  // unwrap proxy
+  obj[GET_ORIGINAL_SYMBOL] || // otherwise
+  obj
+);
+var isAllOwnKeysChanged = (prevObj, nextObj) => {
+  const prevKeys = Reflect.ownKeys(prevObj);
+  const nextKeys = Reflect.ownKeys(nextObj);
+  return prevKeys.length !== nextKeys.length || prevKeys.some((k, i) => k !== nextKeys[i]);
 };
-var isCloneable = (value) => isPlainObject(value) || isPlainArray(value);
-var cloneValue = (value) => {
-  if (isPlainArray(value)) return value.map(cloneValue);
-  if (isPlainObject(value)) {
-    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, cloneValue(child)]));
+var isChanged = (prevObj, nextObj, affected, cache, isEqual = Object.is) => {
+  if (isEqual(prevObj, nextObj)) {
+    return false;
   }
-  return value;
+  if (!isObject(prevObj) || !isObject(nextObj))
+    return true;
+  const used = affected.get(getOriginalObject(prevObj));
+  if (!used)
+    return true;
+  if (cache) {
+    const hit = cache.get(prevObj);
+    if (hit === nextObj) {
+      return false;
+    }
+    cache.set(prevObj, nextObj);
+  }
+  let changed = null;
+  for (const key of used[HAS_KEY_PROPERTY] || []) {
+    changed = Reflect.has(prevObj, key) !== Reflect.has(nextObj, key);
+    if (changed)
+      return changed;
+  }
+  if (used[ALL_OWN_KEYS_PROPERTY] === true) {
+    changed = isAllOwnKeysChanged(prevObj, nextObj);
+    if (changed)
+      return changed;
+  } else {
+    for (const key of used[HAS_OWN_KEY_PROPERTY] || []) {
+      const hasPrev = !!Reflect.getOwnPropertyDescriptor(prevObj, key);
+      const hasNext = !!Reflect.getOwnPropertyDescriptor(nextObj, key);
+      changed = hasPrev !== hasNext;
+      if (changed)
+        return changed;
+    }
+  }
+  for (const key of used[KEYS_PROPERTY] || []) {
+    changed = isChanged(prevObj[key], nextObj[key], affected, cache, isEqual);
+    if (changed)
+      return changed;
+  }
+  if (changed === null)
+    throw new Error("invalid used");
+  return changed;
 };
-var toPointer = (path) => {
-  if (path.length === 0) return "";
-  return `/${path.map((segment) => String(segment).replaceAll("~", "~0").replaceAll("/", "~1")).join("/")}`;
+var getUntracked = (obj) => {
+  if (isObjectToTrack(obj)) {
+    return obj[GET_ORIGINAL_SYMBOL] || null;
+  }
+  return null;
 };
-var removing = (pointer) => ({ op: "remove", path: pointer });
-var carrying = (op, pointer, value) => {
-  if (!isCloneable(value)) return { op, path: pointer, value };
-  return {
-    op,
-    path: pointer,
-    get value() {
-      return cloneValue(value);
+var markToTrack = (obj, mark = true) => {
+  objectsToTrack.set(obj, mark);
+};
+
+// node_modules/valtio/esm/vanilla.mjs
+var isObject2 = (x) => typeof x === "object" && x !== null;
+var canProxyDefault = (x) => isObject2(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer) && !(x instanceof Promise);
+var createSnapshotDefault = (target, version) => {
+  const cache = snapCache.get(target);
+  if ((cache == null ? void 0 : cache[0]) === version) {
+    return cache[1];
+  }
+  const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
+  markToTrack(snap, true);
+  snapCache.set(target, [version, snap]);
+  Reflect.ownKeys(target).forEach((key) => {
+    if (Object.getOwnPropertyDescriptor(snap, key)) {
+      return;
     }
-  };
+    const value = Reflect.get(target, key);
+    const { enumerable } = Reflect.getOwnPropertyDescriptor(
+      target,
+      key
+    );
+    const desc = {
+      value,
+      enumerable,
+      // This is intentional to avoid copying with proxy-compare.
+      // It's still non-writable, so it avoids assigning a value.
+      configurable: true
+    };
+    if (refSet.has(value)) {
+      markToTrack(value, false);
+    } else if (proxyStateMap.has(value)) {
+      const [target2, ensureVersion] = proxyStateMap.get(
+        value
+      );
+      desc.value = createSnapshotDefault(target2, ensureVersion());
+    }
+    Object.defineProperty(snap, key, desc);
+  });
+  return snap;
 };
-var addPair = (pointer, after) => ({ do: carrying("add", pointer, after), undo: removing(pointer) });
-var removePair = (pointer, before) => ({ do: removing(pointer), undo: carrying("add", pointer, before) });
-var replacePair = (pointer, before, after) => ({
-  do: carrying("replace", pointer, after),
-  undo: carrying("replace", pointer, before)
+var createHandlerDefault = (isInitializing, addPropListener, removePropListener, notifyUpdate) => ({
+  deleteProperty(target, prop) {
+    Reflect.get(target, prop);
+    removePropListener(prop);
+    const deleted = Reflect.deleteProperty(target, prop);
+    if (deleted) {
+      notifyUpdate(void 0 );
+    }
+    return deleted;
+  },
+  set(target, prop, value, receiver) {
+    const hasPrevValue = !isInitializing() && Reflect.has(target, prop);
+    const prevValue = Reflect.get(target, prop, receiver);
+    if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) {
+      return true;
+    }
+    removePropListener(prop);
+    if (isObject2(value)) {
+      value = getUntracked(value) || value;
+    }
+    const nextValue = !proxyStateMap.has(value) && canProxy(value) ? proxy(value) : value;
+    addPropListener(prop, nextValue);
+    Reflect.set(target, prop, nextValue, receiver);
+    notifyUpdate(void 0 );
+    return true;
+  }
 });
-var diffValue = (before, after, path, ops) => {
-  if (Object.is(before, after)) return;
-  if (isPlainArray(before) && isPlainArray(after)) {
-    if (before.length !== after.length) {
-      ops.push(replacePair(toPointer(path), before, after));
+var proxyStateMap = /* @__PURE__ */ new WeakMap();
+var refSet = /* @__PURE__ */ new WeakSet();
+var snapCache = /* @__PURE__ */ new WeakMap();
+var versionHolder = [1];
+var proxyCache = /* @__PURE__ */ new WeakMap();
+var objectIs = Object.is;
+var newProxy = (target, handler) => new Proxy(target, handler);
+var canProxy = canProxyDefault;
+var createSnapshot = createSnapshotDefault;
+var createHandler = createHandlerDefault;
+function proxy(baseObject = {}) {
+  if (!isObject2(baseObject)) {
+    throw new Error("object required");
+  }
+  const found = proxyCache.get(baseObject);
+  if (found) {
+    return found;
+  }
+  let version = versionHolder[0];
+  const listeners = /* @__PURE__ */ new Set();
+  const notifyUpdate = (op, nextVersion = ++versionHolder[0]) => {
+    if (version !== nextVersion) {
+      checkVersion = version = nextVersion;
+      listeners.forEach((listener) => listener(op, nextVersion));
+    }
+  };
+  let checkVersion = version;
+  const ensureVersion = (nextCheckVersion = versionHolder[0]) => {
+    if (checkVersion !== nextCheckVersion) {
+      checkVersion = nextCheckVersion;
+      propProxyStates.forEach(([propProxyState]) => {
+        const propVersion = propProxyState[1](nextCheckVersion);
+        if (propVersion > version) {
+          version = propVersion;
+        }
+      });
+    }
+    return version;
+  };
+  const createPropListener = (prop) => (op, nextVersion) => {
+    let newOp;
+    if (op) {
+      newOp = [...op];
+      newOp[1] = [prop, ...newOp[1]];
+    }
+    notifyUpdate(newOp, nextVersion);
+  };
+  const propProxyStates = /* @__PURE__ */ new Map();
+  const addPropListener = (prop, propValue) => {
+    const propProxyState = !refSet.has(propValue) && proxyStateMap.get(propValue);
+    if (propProxyState) {
+      if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && propProxyStates.has(prop)) {
+        throw new Error("prop listener already exists");
+      }
+      if (listeners.size) {
+        const remove = propProxyState[2](createPropListener(prop));
+        propProxyStates.set(prop, [propProxyState, remove]);
+      } else {
+        propProxyStates.set(prop, [propProxyState]);
+      }
+    }
+  };
+  const removePropListener = (prop) => {
+    var _a;
+    const entry = propProxyStates.get(prop);
+    if (entry) {
+      propProxyStates.delete(prop);
+      (_a = entry[1]) == null ? void 0 : _a.call(entry);
+    }
+  };
+  const addListener = (listener) => {
+    listeners.add(listener);
+    if (listeners.size === 1) {
+      propProxyStates.forEach(([propProxyState, prevRemove], prop) => {
+        if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && prevRemove) {
+          throw new Error("remove already exists");
+        }
+        const remove = propProxyState[2](createPropListener(prop));
+        propProxyStates.set(prop, [propProxyState, remove]);
+      });
+    }
+    const removeListener = () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        propProxyStates.forEach(([propProxyState, remove], prop) => {
+          if (remove) {
+            remove();
+            propProxyStates.set(prop, [propProxyState]);
+          }
+        });
+      }
+    };
+    return removeListener;
+  };
+  let initializing = true;
+  const handler = createHandler(
+    () => initializing,
+    addPropListener,
+    removePropListener,
+    notifyUpdate
+  );
+  const proxyObject = newProxy(baseObject, handler);
+  proxyCache.set(baseObject, proxyObject);
+  const proxyState = [baseObject, ensureVersion, addListener];
+  proxyStateMap.set(proxyObject, proxyState);
+  Reflect.ownKeys(baseObject).forEach((key) => {
+    const desc = Object.getOwnPropertyDescriptor(
+      baseObject,
+      key
+    );
+    if ("value" in desc && desc.writable) {
+      proxyObject[key] = baseObject[key];
+    }
+  });
+  initializing = false;
+  return proxyObject;
+}
+function getVersion(proxyObject) {
+  const proxyState = proxyStateMap.get(proxyObject);
+  return proxyState == null ? void 0 : proxyState[1]();
+}
+function subscribe(proxyObject, callback, notifyInSync) {
+  const proxyState = proxyStateMap.get(proxyObject);
+  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !proxyState) {
+    console.warn("Please use proxy object");
+  }
+  let promise;
+  const ops = [];
+  const addListener = proxyState[2];
+  let isListenerActive = false;
+  const listener = (op) => {
+    if (op) {
+      ops.push(op);
+    }
+    if (notifyInSync) {
+      callback(ops.splice(0));
       return;
     }
-    for (let index = 0; index < after.length; index++) diffValue(before[index], after[index], [...path, index], ops);
-    return;
+    if (!promise) {
+      promise = Promise.resolve().then(() => {
+        promise = void 0;
+        if (isListenerActive) {
+          callback(ops.splice(0));
+        }
+      });
+    }
+  };
+  const removeListener = addListener(listener);
+  isListenerActive = true;
+  return () => {
+    isListenerActive = false;
+    removeListener();
+  };
+}
+function snapshot(proxyObject) {
+  const proxyState = proxyStateMap.get(proxyObject);
+  if ((import.meta.env ? import.meta.env.MODE : void 0) !== "production" && !proxyState) {
+    console.warn("Please use proxy object");
   }
-  if (isPlainObject(before) && isPlainObject(after)) {
-    for (const key of /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])) {
-      if (!Object.hasOwn(before, key)) ops.push(addPair(toPointer([...path, key]), after[key]));
-      else if (!Object.hasOwn(after, key)) ops.push(removePair(toPointer([...path, key]), before[key]));
-      else diffValue(before[key], after[key], [...path, key], ops);
+  const [target, ensureVersion] = proxyState;
+  return createSnapshot(target, ensureVersion());
+}
+function ref(obj) {
+  refSet.add(obj);
+  return obj;
+}
+function unstable_getInternalStates() {
+  return {
+    proxyStateMap,
+    refSet,
+    snapCache,
+    versionHolder,
+    proxyCache
+  };
+}
+function unstable_replaceInternalFunction(name, fn) {
+  switch (name) {
+    case "objectIs":
+      objectIs = fn(objectIs);
+      break;
+    case "newProxy":
+      newProxy = fn(newProxy);
+      break;
+    case "canProxy":
+      canProxy = fn(canProxy);
+      break;
+    case "createSnapshot":
+      createSnapshot = fn(createSnapshot);
+      break;
+    case "createHandler":
+      createHandler = fn(createHandler);
+      break;
+    default:
+      throw new Error("unknown function");
+  }
+}
+
+// src/react/wrapperRegistry.ts
+var wrapperTargets = /* @__PURE__ */ new WeakMap();
+var registerWrapperTarget = (wrapper, target) => {
+  wrapperTargets.set(wrapper, target);
+};
+var getRegisteredWrapperTarget = (wrapper) => wrapperTargets.get(wrapper);
+
+// src/identity.ts
+var isObjectLike = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+var targetRegistry = /* @__PURE__ */ new WeakMap();
+var identityTokenRegistry = /* @__PURE__ */ new WeakMap();
+var { proxyStateMap: proxyStateMap2 } = unstable_getInternalStates();
+function registerSnapshotCopy(copy, target) {
+  targetRegistry.set(copy, target);
+}
+function getRegisteredTarget(copy) {
+  return targetRegistry.get(copy);
+}
+function peelIdentityLayer(current) {
+  const untracked = getUntracked(current);
+  if (untracked !== null && untracked !== current) return untracked;
+  const wrapperTarget = getRegisteredWrapperTarget(current);
+  if (wrapperTarget !== void 0 && wrapperTarget !== current) return wrapperTarget;
+  const registeredTarget = targetRegistry.get(current);
+  if (registeredTarget !== void 0 && registeredTarget !== current) return registeredTarget;
+  return void 0;
+}
+function resolveIdentity(value) {
+  let current = value;
+  while (isObjectLike(current)) {
+    const peeled = peelIdentityLayer(current);
+    if (peeled !== void 0) {
+      current = peeled;
+      continue;
+    }
+    const proxyState = proxyStateMap2.get(current);
+    if (proxyState !== void 0 && proxyState[0] !== current) {
+      current = proxyState[0];
+      continue;
+    }
+    break;
+  }
+  return current;
+}
+function identify(value) {
+  const target = resolveIdentity(value);
+  if (!isObjectLike(target)) return value;
+  const existing = identityTokenRegistry.get(target);
+  if (existing !== void 0) return existing;
+  const token = Object.freeze({});
+  identityTokenRegistry.set(target, token);
+  return token;
+}
+function isSameIdentity(first, second) {
+  const resolvedFirst = resolveIdentity(first);
+  const resolvedSecond = resolveIdentity(second);
+  return resolvedFirst === resolvedSecond || resolvedFirst !== resolvedFirst && resolvedSecond !== resolvedSecond;
+}
+
+// src/unsafeTrack.ts
+var unsafeTrackedSet = /* @__PURE__ */ new WeakSet();
+function unsafeTrack(value) {
+  unsafeTrackedSet.add(value);
+  return value;
+}
+function isUnsafeTracked(value) {
+  return typeof value === "object" && value !== null && unsafeTrackedSet.has(value);
+}
+
+// src/valtio/classify.ts
+var { refSet: refSet2 } = unstable_getInternalStates();
+var sourceCache = /* @__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 classifyChain = (initialConstructor) => {
+  let sawNativeSource = false;
+  let current = initialConstructor;
+  while (typeof current === "function" && current !== Object && current !== Array && current !== Function.prototype) {
+    const source = readSource(current);
+    if (source.includes("#")) return "privateClass";
+    if (source.includes("[native code]")) sawNativeSource = true;
+    current = Reflect.getPrototypeOf(current);
+  }
+  return sawNativeSource ? "nativeClass" : "cleanClass";
+};
+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 hasOwnEnumerableFunction(value) {
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor?.enumerable || !("value" in descriptor)) continue;
+    if (typeof descriptor.value === "function") return true;
+  }
+  return false;
+}
+function admissionLane(value) {
+  if (typeof value !== "object" || value === null) return "leaf";
+  if (refSet2.has(value)) return "leaf";
+  if (isUnsafeTracked(value)) return "track";
+  const kind = classifyValue(value);
+  if ((kind === "plain" || kind === "plainArray" || kind === "cleanClass") && Object.isFrozen(value)) return "leaf";
+  if (kind === "plain" || kind === "plainArray") return "track";
+  if (kind === "cleanClass" && !hasOwnEnumerableFunction(value)) return "track";
+  return "reject";
+}
+function isTrackable(value) {
+  return admissionLane(value) === "track";
+}
+
+// src/ops/path.ts
+var createOperationPath = (segments) => Object.freeze([...segments]);
+var appendOperationPath = (path, segment) => Object.freeze([...path, segment]);
+var escapeSegment = (segment) => segment.replaceAll("~", "~0").replaceAll("/", "~1");
+var formatSegment = (segment) => typeof segment === "string" ? escapeSegment(segment) : String(segment);
+var formatOperationPath = (path) => path.length === 0 ? "" : `/${path.map(formatSegment).join("/")}`;
+var assertSafePath = (path) => {
+  for (let index = 0; index < path.length; index++) {
+    const segment = path[index];
+    if (segment === "__proto__" || segment === "prototype" && path[index - 1] === "constructor") {
+      throw new Error(`opshot: reserved operation path ${formatOperationPath(path)}`);
+    }
+  }
+};
+
+// src/ops/cloneValue.ts
+var { refSet: refSet3 } = unstable_getInternalStates();
+var isPlainArray = (value) => Array.isArray(value) && !refSet3.has(value);
+var isPlainObject = (value) => isTrackable(value) && !Array.isArray(value);
+var isCloneable = (value) => isTrackable(value);
+var CyclicValueError = class extends Error {
+  constructor(path) {
+    super(`opshot: cyclic value at ${formatOperationPath(path)}; use ignore() for back-linked structures, or ids`);
+    this.name = "CyclicValueError";
+    this.path = createOperationPath(path);
+  }
+};
+var cyclicError = (path) => new CyclicValueError(path);
+var getCyclicPath = (error) => error instanceof CyclicValueError ? error.path : void 0;
+var CLONE_IN_PROGRESS = /* @__PURE__ */ Symbol("opshot.cloneValue.inProgress");
+var cloneValue = (value, memo2, path) => {
+  if (!isCloneable(value)) return value;
+  const cached = memo2.get(value);
+  if (cached === CLONE_IN_PROGRESS) throw cyclicError(path);
+  if (cached !== void 0) return cached;
+  memo2.set(value, CLONE_IN_PROGRESS);
+  const array = isPlainArray(value);
+  const clone = array ? [] : {};
+  Reflect.setPrototypeOf(clone, Reflect.getPrototypeOf(value));
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+    if (!descriptor) continue;
+    if ("value" in descriptor) {
+      Object.defineProperty(clone, key, {
+        ...descriptor,
+        value: cloneValue(descriptor.value, memo2, path)
+      });
+    } else {
+      Object.defineProperty(clone, key, descriptor);
     }
+  }
+  memo2.set(value, clone);
+  if (isUnsafeTracked(value)) unsafeTrack(clone);
+  return clone;
+};
+
+// src/ops/operation.ts
+var operationBrand = /* @__PURE__ */ Symbol.for("opshot.operation");
+var valueOriginals = /* @__PURE__ */ new WeakMap();
+var OperationHalf = class {
+  constructor(path) {
+    this.path = createOperationPath(path);
+  }
+};
+Object.defineProperty(OperationHalf.prototype, operationBrand, { value: true });
+var ValueHalf = class extends OperationHalf {
+  get value() {
+    return cloneValue(valueOriginals.get(this), /* @__PURE__ */ new WeakMap(), this.path);
+  }
+  constructor(path, value) {
+    super(path);
+    valueOriginals.set(this, value);
+    if (!isCloneable(value)) Object.defineProperty(this, "value", { value, enumerable: true });
+  }
+};
+var AddHalf = class extends ValueHalf {
+  constructor() {
+    super(...arguments);
+    this.op = "add";
+  }
+};
+var ReplaceHalf = class extends ValueHalf {
+  constructor() {
+    super(...arguments);
+    this.op = "replace";
+  }
+};
+var RemoveHalf = class extends OperationHalf {
+  constructor() {
+    super(...arguments);
+    this.op = "remove";
+  }
+};
+var isOperation = (value) => typeof value === "object" && value !== null && operationBrand in value;
+var getValueOriginal = (half) => valueOriginals.get(half);
+var createAddOperation = (path, value) => new AddHalf(path, value);
+var createReplaceOperation = (path, value) => new ReplaceHalf(path, value);
+var createRemoveOperation = (path) => new RemoveHalf(path);
+
+// src/ops/weight.ts
+var NODE_WEIGHT = 32;
+var KEY_WEIGHT = 16;
+var CHARACTER_WEIGHT = 2;
+var LEAF_WEIGHT = 16;
+var OPERATION_WEIGHT = 512;
+var addWeight = (state, amount) => {
+  state.weight += amount;
+  return state.weight <= state.budget;
+};
+var weigh = (value, state) => {
+  if (state.weight > state.budget) return;
+  if (typeof value === "string") {
+    addWeight(state, LEAF_WEIGHT + CHARACTER_WEIGHT * value.length);
     return;
   }
-  ops.push(replacePair(toPointer(path), before, after));
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    addWeight(state, LEAF_WEIGHT);
+    return;
+  }
+  if (state.seen.has(value)) return;
+  if (isCloneable(value)) {
+    state.seen.add(value);
+    if (!addWeight(state, NODE_WEIGHT)) return;
+    for (const key of Object.keys(value)) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || !("value" in descriptor)) continue;
+      if (!addWeight(state, KEY_WEIGHT)) return;
+      weigh(descriptor.value, state);
+      if (state.weight > state.budget) return;
+    }
+  }
+};
+var weighValue = (value, budget) => {
+  const state = { weight: 0, budget, seen: /* @__PURE__ */ new WeakSet() };
+  weigh(value, state);
+  return state.weight;
+};
+
+// src/ops/diff.ts
+var UNCAPPED_WEIGHT = Number.MAX_SAFE_INTEGER;
+var IncompatibleSnapshotRootsError = class extends Error {
+  constructor() {
+    super("opshot: diffSnapshots requires compatible supported object roots");
+    this.name = "IncompatibleSnapshotRootsError";
+  }
+};
+var addPair = (path, after) => ({
+  do: createAddOperation(path, after),
+  undo: createRemoveOperation(path)
+});
+var removePair = (path, before) => ({
+  do: createRemoveOperation(path),
+  undo: createAddOperation(path, before)
+});
+var replacePair = (path, before, after) => ({
+  do: createReplaceOperation(path, after),
+  undo: createReplaceOperation(path, before)
+});
+var weighCarried = (value) => weighValue(value, UNCAPPED_WEIGHT);
+var pushAdd = (ops, path, after) => {
+  ops.push(addPair(path, after));
+  return OPERATION_WEIGHT + weighCarried(after);
+};
+var pushRemove = (ops, path, before) => {
+  ops.push(removePair(path, before));
+  return OPERATION_WEIGHT + weighCarried(before);
+};
+var pushReplace = (ops, path, before, after) => {
+  ops.push(replacePair(path, before, after));
+  return OPERATION_WEIGHT + weighCarried(before) + weighCarried(after);
+};
+var tryCollapse = (before, after, path, ops, opsStart, atomicWeight) => {
+  if (atomicWeight === 0) return 0;
+  const beforeWeight = weighValue(before, atomicWeight);
+  const afterWeight = weighValue(after, atomicWeight - beforeWeight);
+  const collapsedWeight = OPERATION_WEIGHT + beforeWeight + afterWeight;
+  if (collapsedWeight < atomicWeight) {
+    assertSafeSubtree(before, path);
+    assertSafeSubtree(after, path);
+    ops.splice(opsStart, ops.length - opsStart, replacePair(path, before, after));
+    return collapsedWeight;
+  }
+  return atomicWeight;
+};
+var hasAncestorPair = (ancestors, before, after) => ancestors.get(before)?.has(after) ?? false;
+var enterAncestorPair = (ancestors, before, after) => {
+  const afterSet = ancestors.get(before) ?? /* @__PURE__ */ new Set();
+  afterSet.add(after);
+  ancestors.set(before, afterSet);
+};
+var exitAncestorPair = (ancestors, before, after) => {
+  const afterSet = ancestors.get(before);
+  if (!afterSet) return;
+  afterSet.delete(after);
+  if (afterSet.size === 0) ancestors.delete(before);
+};
+var isObjectLike2 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+var sharesStorageIdentity = (before, after) => isObjectLike2(before) && isObjectLike2(after) && isSameIdentity(before, after);
+var assertSafeSubtree = (value, path, activeAncestors = /* @__PURE__ */ new WeakSet()) => {
+  if (!isPlainArray(value) && !isPlainObject(value)) return;
+  if (activeAncestors.has(value)) return;
+  activeAncestors.add(value);
+  try {
+    for (const key of Object.keys(value)) {
+      const nextPath = appendOperationPath(path, key);
+      assertSafePath(nextPath);
+      const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+      if (descriptor && "value" in descriptor) assertSafeSubtree(descriptor.value, nextPath, activeAncestors);
+    }
+  } finally {
+    activeAncestors.delete(value);
+  }
+};
+var isCanonicalArrayIndex = (key) => {
+  const index = Number(key);
+  return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === key;
+};
+var diffObjectProperties = (before, after, path, ops, ancestors, ignoreArrayIndexes) => {
+  let weight = 0;
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)])) {
+    if (ignoreArrayIndexes && isCanonicalArrayIndex(key)) continue;
+    const nextPath = appendOperationPath(path, key);
+    assertSafePath(nextPath);
+    const beforeDescriptor = Reflect.getOwnPropertyDescriptor(before, key);
+    const afterDescriptor = Reflect.getOwnPropertyDescriptor(after, key);
+    if (beforeDescriptor?.get || afterDescriptor?.get) continue;
+    if (!beforeDescriptor) {
+      assertSafeSubtree(Reflect.get(after, key), nextPath);
+      weight += pushAdd(ops, nextPath, Reflect.get(after, key));
+    } else if (!afterDescriptor) {
+      assertSafeSubtree(Reflect.get(before, key), nextPath);
+      weight += pushRemove(ops, nextPath, Reflect.get(before, key));
+    } else {
+      weight += diffValue(Reflect.get(before, key), Reflect.get(after, key), nextPath, ops, ancestors);
+    }
+  }
+  return weight;
+};
+var diffArray = (before, after, path, ops, ancestors) => {
+  const overlap = Math.min(before.length, after.length);
+  let weight = 0;
+  for (let index = 0; index < overlap; index++) {
+    const beforePresent = Object.hasOwn(before, index);
+    const afterPresent = Object.hasOwn(after, index);
+    const nextPath = appendOperationPath(path, index);
+    if (!beforePresent && !afterPresent) continue;
+    if (!beforePresent) weight += pushAdd(ops, nextPath, after[index]);
+    else if (!afterPresent) weight += pushRemove(ops, nextPath, before[index]);
+    else weight += diffValue(before[index], after[index], nextPath, ops, ancestors);
+  }
+  if (after.length > before.length) {
+    weight += pushReplace(ops, appendOperationPath(path, "length"), before.length, after.length);
+    for (let index = before.length; index < after.length; index++) {
+      if (Object.hasOwn(after, index)) weight += pushAdd(ops, appendOperationPath(path, index), after[index]);
+    }
+  } else if (after.length < before.length) {
+    for (let index = after.length; index < before.length; index++) {
+      if (Object.hasOwn(before, index)) weight += pushRemove(ops, appendOperationPath(path, index), before[index]);
+    }
+    weight += pushReplace(ops, appendOperationPath(path, "length"), before.length, after.length);
+  }
+  weight += diffObjectProperties(before, after, path, ops, ancestors, true);
+  return weight;
+};
+var walkContainer = (before, after, path, ops, ancestors, walk) => {
+  if (hasAncestorPair(ancestors, before, after)) throw cyclicError(path);
+  enterAncestorPair(ancestors, before, after);
+  try {
+    if (path.length === 0) {
+      walk();
+      return 0;
+    }
+    const opsStart = ops.length;
+    const atomicWeight = walk();
+    return tryCollapse(before, after, path, ops, opsStart, atomicWeight);
+  } finally {
+    exitAncestorPair(ancestors, before, after);
+  }
+};
+var diffValue = (before, after, path, ops, ancestors) => {
+  if (Object.is(before, after)) return 0;
+  if (path.length > 0 && isObjectLike2(before) && isObjectLike2(after) && !sharesStorageIdentity(before, after)) {
+    assertSafeSubtree(before, path);
+    assertSafeSubtree(after, path);
+    return pushReplace(ops, path, before, after);
+  }
+  if (isPlainArray(before) && isPlainArray(after)) {
+    return walkContainer(before, after, path, ops, ancestors, () => diffArray(before, after, path, ops, ancestors));
+  }
+  if (isPlainObject(before) && isPlainObject(after)) {
+    return walkContainer(
+      before,
+      after,
+      path,
+      ops,
+      ancestors,
+      () => diffObjectProperties(before, after, path, ops, ancestors, false)
+    );
+  }
+  assertSafeSubtree(before, path);
+  assertSafeSubtree(after, path);
+  return pushReplace(ops, path, before, after);
+};
+var getRootKind = (value) => {
+  if (isPlainArray(value)) return "plainArray";
+  if (isPlainObject(value)) return "plainObject";
+  return void 0;
 };
 function diffSnapshots(before, after) {
-  const ops = [];
-  diffValue(before, after, [], ops);
+  const beforeKind = getRootKind(before);
+  const afterKind = getRootKind(after);
+  if (beforeKind === void 0 || beforeKind !== afterKind) throw new IncompatibleSnapshotRootsError();
+  const ops = new Array();
+  diffValue(before, after, createOperationPath([]), ops, /* @__PURE__ */ new Map());
   return ops;
 }
 
-// src/createState.ts
-var stateBrand = /* @__PURE__ */ Symbol.for("opshot.state");
-var metaBrand = /* @__PURE__ */ Symbol.for("opshot.meta");
-var hasOwn = (value, key) => Object.hasOwn(value, key);
-function createMeta(defaults) {
-  const token = defaults === void 0 ? { [metaBrand]: true } : { defaults, [metaBrand]: true };
-  return token;
+// src/emitter.ts
+var emitters = /* @__PURE__ */ new WeakMap();
+var { proxyStateMap: proxyStateMap3 } = unstable_getInternalStates();
+var isObjectLike3 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+var augmentBareCycleError = (error) => {
+  const path = getCyclicPath(error);
+  if (path === void 0) return void 0;
+  return new Error(
+    `opshot: a bare write created a cyclic value at ${formatOperationPath(path)}. Cycles cannot be tracked. This surfaced asynchronously because the write was not inside transact. Use transact for catchable cycle errors, ignore() for back-linked structures, or ids.`
+  );
+};
+function resolveEmitterTarget(state) {
+  let current = state;
+  while (isObjectLike3(current)) {
+    if (proxyStateMap3.has(current)) return current;
+    const peeled = peelIdentityLayer(current);
+    if (peeled === void 0) break;
+    current = peeled;
+  }
+  if (!isObjectLike3(current) || !proxyStateMap3.has(current)) throw new Error("opshot: expected a state object");
+  return current;
 }
-function createState(define, meta) {
-  return createGroupState(define, void 0, meta);
+function getEmitter(state) {
+  return emitters.get(resolveEmitterTarget(state));
 }
-function createGroupState(define, groupListeners, metaToken) {
-  const callback = typeof define === "function" ? define : () => define;
-  const listeners = /* @__PURE__ */ new Set();
-  const created = {};
-  const requireProxy = () => {
-    const { proxied } = created;
-    if (!proxied) throw new Error("opshot: called during createState definition");
-    return proxied;
-  };
-  const get = () => snapshot(requireProxy());
-  const mutate = (callback2, ...metaArgs) => {
-    const [meta] = metaArgs;
-    const proxied = requireProxy();
-    if (handle.isMutating) throw new Error("opshot: nested mutate on the same state");
-    handle.isMutating = true;
-    const before = snapshot(proxied);
-    try {
-      callback2(proxied);
-    } finally {
-      handle.isMutating = false;
-    }
-    const after = snapshot(proxied);
-    if (before === after) return;
-    if (listeners.size === 0 && (groupListeners?.size ?? 0) === 0) return;
-    const ops = diffSnapshots(before, after);
+var hasListeners = (record) => record.listeners.size > 0 || (record.groupListeners?.size ?? 0) > 0;
+var armWatchdog = (record) => {
+  if (record.disarm !== void 0) return;
+  record.lastReported = snapshot(record.target);
+  record.disarm = subscribe(record.target, () => {
+    emitBareFlush(record.target);
+  });
+};
+var disarmWatchdog = (record) => {
+  record.disarm?.();
+  record.disarm = void 0;
+};
+var deliver = (record, ops, meta) => {
+  for (const listener of [...record.groupListeners ?? []]) listener(record.target, ops, meta);
+  for (const listener of [...record.listeners]) listener(ops, meta);
+};
+var requireObjectSnapshot = (value) => {
+  if (value !== null && (typeof value === "object" || typeof value === "function")) return value;
+  throw new Error("opshot: state snapshots must have an object root");
+};
+var reportBareDiff = (record) => {
+  const current = snapshot(record.target);
+  if (current === record.lastReported) return;
+  const previous = record.lastReported;
+  record.lastReported = current;
+  if (!hasListeners(record)) return;
+  try {
+    const ops = diffSnapshots(requireObjectSnapshot(previous), requireObjectSnapshot(current));
     if (ops.length === 0) return;
-    const emittedMeta = metaToken?.defaults !== void 0 ? { ...metaToken.defaults, ...meta } : meta ?? {};
-    for (const listener of [...groupListeners ?? []]) listener(after, ops, emittedMeta);
-    for (const listener of [...listeners]) listener(after, ops, emittedMeta);
+    deliver(record, ops, void 0);
+  } catch (error) {
+    throw augmentBareCycleError(error) ?? error;
+  }
+};
+var settlePendingBare = (record) => {
+  reportBareDiff(record);
+};
+function getOrCreateEmitter(target, groupListeners) {
+  const resolved = resolveEmitterTarget(target);
+  const existing = emitters.get(resolved);
+  if (existing !== void 0) return existing;
+  const record = {
+    listeners: /* @__PURE__ */ new Set(),
+    groupListeners,
+    lastReported: snapshot(resolved),
+    isMutating: false,
+    target: resolved
   };
-  const subscribe = (listener) => {
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-    };
+  emitters.set(resolved, record);
+  return record;
+}
+function mintGroupedEmitter(target, groupListeners) {
+  const record = getOrCreateEmitter(target, groupListeners);
+  armWatchdog(record);
+  return record;
+}
+function emitBareFlush(target) {
+  const record = getEmitter(target);
+  if (record === void 0) return;
+  reportBareDiff(record);
+}
+function addStateListener(state, listener) {
+  const target = resolveEmitterTarget(state);
+  let record = emitters.get(target);
+  if (record === void 0) {
+    record = getOrCreateEmitter(target);
+    armWatchdog(record);
+  } else if (record.disarm === void 0 && record.groupListeners === void 0) {
+    armWatchdog(record);
+  }
+  record.listeners.add(listener);
+  return () => {
+    if (!record.listeners.delete(listener)) return;
+    if (record.groupListeners === void 0 && record.listeners.size === 0) {
+      disarmWatchdog(record);
+      emitters.delete(target);
+    }
   };
-  const isSameState = (other) => isState(other) && other.op === handle;
-  const unwrap = () => {
-    const { op, mutate: mutate2, ...rest } = get();
-    return rest;
+}
+function addGroupListener(groupListeners, listener) {
+  groupListeners.add(listener);
+  return () => {
+    groupListeners.delete(listener);
   };
-  const literal = callback(mutate, get);
-  for (const key of ["op", "mutate"]) {
-    if (Object.hasOwn(literal, key)) throw new Error(`opshot: "${key}" is a reserved key on a state`);
+}
+
+// src/utils/constructorName.ts
+var constructorName = (candidate) => typeof candidate === "function" && candidate.name !== "" ? candidate.name : "Object";
+
+// src/valtio/boundaryErrors.ts
+var ignoreOption = "ignore(value) to store it by reference, untracked";
+var unsafeTrackDataOption = "unsafeTrack(value) to track its data anyway";
+var unsafeTrackPrivateOption = "unsafeTrack(value) tracks public fields while private methods throw on snapshots and undo drops that state";
+var unsafeTrackSlotOption = "unsafeTrack(value) tracks public fields while slot methods throw on snapshots and undo drops that state";
+var unsafeTrackLossyOption = "unsafeTrack(value) to track it lossily";
+var boundaryError = (className, reason, options) => new Error(
+  `opshot: ${className} cannot be tracked (${reason}). Options:
+${options.map((option) => `- ${option}`).join("\n")}`
+);
+var slotContainerError = (className, trackedName) => boundaryError(className, "its state lives in internal slots", [
+  `use ${trackedName} for a tracked equivalent`,
+  unsafeTrackLossyOption,
+  ignoreOption
+]);
+var arraySubclassError = (className) => boundaryError(className, "array subclasses lose their prototype in snapshots", [
+  unsafeTrackDataOption,
+  ignoreOption
+]);
+var cleanClassError = (className) => boundaryError(className, "arrow-method writes won't be tracked", [unsafeTrackDataOption, ignoreOption]);
+var privateClassError = (className) => boundaryError(className, "its state is hidden in private fields", [unsafeTrackPrivateOption, ignoreOption]);
+var nativeClassError = (className) => boundaryError(className, "its state is hidden in internal slots", [unsafeTrackSlotOption, ignoreOption]);
+var snapshotDonationError = (key) => new Error(
+  `opshot: cannot assign a snapshot generation at "${String(key)}": a snapshot generation is a read-view, and assigning it creates a dead region. Clone the value, or replay through applyOps.`
+);
+var reservedDataPathError = (path) => new Error(`opshot: reserved data path /${path.join("/")}`);
+var inheritsFromPrototype = (value, prototype) => {
+  for (let current = Reflect.getPrototypeOf(value); current !== null; current = Reflect.getPrototypeOf(current))
+    if (current === prototype) return true;
+  return false;
+};
+var rejectionError = (value, kind) => {
+  const className = constructorName(value.constructor);
+  if (inheritsFromPrototype(value, Map.prototype)) return slotContainerError(className, "TrackedMap");
+  if (inheritsFromPrototype(value, Set.prototype)) return slotContainerError(className, "TrackedSet");
+  if (inheritsFromPrototype(value, Date.prototype)) return slotContainerError(className, "TrackedDate");
+  switch (kind) {
+    case "arraySubclass":
+      return arraySubclassError(className);
+    case "cleanClass":
+      return cleanClassError(className);
+    case "privateClass":
+      return privateClassError(className);
+    case "nativeClass":
+      return nativeClassError(className);
   }
-  const base = Object.create(Reflect.getPrototypeOf(literal));
-  Object.defineProperties(base, Object.getOwnPropertyDescriptors(literal));
-  const handle = { unsafeMutable: base, isMutating: false, subscribe, isSameState, unwrap, [stateBrand]: true };
-  Object.defineProperty(base, "op", { value: ref(handle), enumerable: true, writable: false, configurable: false });
-  Object.defineProperty(base, "mutate", { value: mutate, enumerable: true, writable: false, configurable: false });
-  created.proxied = proxy(base);
-  handle.unsafeMutable = created.proxied;
-  return get();
+};
+
+// src/valtio/constructorPathGuard.ts
+var { refSet: refSet4 } = unstable_getInternalStates();
+var constructorPathTargetCounts = /* @__PURE__ */ new WeakMap();
+var rootGraphsByRoot = /* @__PURE__ */ new WeakMap();
+var rootGraphReferences = /* @__PURE__ */ new WeakMap();
+var rootGraphsByTarget = /* @__PURE__ */ new WeakMap();
+var getRawObject = (value) => {
+  const resolved = resolveIdentity(value);
+  return typeof resolved === "object" && resolved !== null ? resolved : void 0;
+};
+var getTrackedRawObject = (value) => {
+  const target = getRawObject(value);
+  if (!target || refSet4.has(target) || Object.isFrozen(target)) return void 0;
+  return isTrackable(target) ? target : void 0;
+};
+var getEnumerableDataChild = (target, key) => {
+  if (typeof key !== "string") return void 0;
+  const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+  if (!descriptor?.enumerable || !("value" in descriptor)) return void 0;
+  return getTrackedRawObject(descriptor.value);
+};
+var adjustConstructorPathTarget = (target, change) => {
+  const next = (constructorPathTargetCounts.get(target) ?? 0) + change;
+  if (next > 0) constructorPathTargetCounts.set(target, next);
+  else constructorPathTargetCounts.delete(target);
+};
+var constructorPathTargetCount = (target) => constructorPathTargetCounts.get(target) ?? 0;
+var releaseFinalizationState = (state) => {
+  if (!state.active) return;
+  state.active = false;
+  for (const { target, count } of state.constructorTargets) {
+    const resolved = target.deref();
+    if (resolved) adjustConstructorPathTarget(resolved, -count);
+  }
+  state.constructorTargets = [];
+};
+var rootGraphFinalizer = new FinalizationRegistry(releaseFinalizationState);
+var getRootGraphReference = (graph) => {
+  const existing = rootGraphReferences.get(graph);
+  if (existing) return existing;
+  const reference = new WeakRef(graph);
+  rootGraphReferences.set(graph, reference);
+  return reference;
+};
+var releaseRootGraph = (graph) => {
+  const reference = getRootGraphReference(graph);
+  for (const target of graph.targets) {
+    const references = rootGraphsByTarget.get(target);
+    references?.delete(reference);
+    if (references?.size === 0) rootGraphsByTarget.delete(target);
+  }
+  const root = graph.root.deref();
+  if (root) rootGraphsByRoot.delete(root);
+  releaseFinalizationState(graph.finalizationState);
+  rootGraphFinalizer.unregister(graph.finalizationState);
+  graph.targets.clear();
+  graph.constructorTargets.clear();
+};
+var getRootGraphs = (target) => {
+  const references = rootGraphsByTarget.get(target);
+  if (!references) return [];
+  const graphs = new Array();
+  for (const reference of references) {
+    const graph = reference.deref();
+    if (!graph) {
+      references.delete(reference);
+      continue;
+    }
+    if (!graph.root.deref()) {
+      releaseRootGraph(graph);
+      continue;
+    }
+    graphs.push(graph);
+  }
+  if (references.size === 0) rootGraphsByTarget.delete(target);
+  return graphs;
+};
+var recomputeRootGraph = (graph) => {
+  const root = graph.root.deref();
+  if (!root) {
+    releaseRootGraph(graph);
+    return;
+  }
+  const targets = /* @__PURE__ */ new Set();
+  const constructorTargets = /* @__PURE__ */ new Map();
+  const visit = (target) => {
+    if (targets.has(target)) return;
+    targets.add(target);
+    const constructorTarget = getEnumerableDataChild(target, "constructor");
+    if (constructorTarget)
+      constructorTargets.set(constructorTarget, (constructorTargets.get(constructorTarget) ?? 0) + 1);
+    for (const key of Object.keys(target)) {
+      const child = getEnumerableDataChild(target, key);
+      if (child) visit(child);
+    }
+  };
+  visit(root);
+  for (const [target, count] of graph.constructorTargets) adjustConstructorPathTarget(target, -count);
+  for (const [target, count] of constructorTargets) adjustConstructorPathTarget(target, count);
+  for (const target of graph.targets) {
+    if (targets.has(target)) continue;
+    const references = rootGraphsByTarget.get(target);
+    references?.delete(getRootGraphReference(graph));
+    if (references?.size === 0) rootGraphsByTarget.delete(target);
+  }
+  for (const target of targets) {
+    if (graph.targets.has(target)) continue;
+    const references = rootGraphsByTarget.get(target) ?? /* @__PURE__ */ new Set();
+    references.add(getRootGraphReference(graph));
+    rootGraphsByTarget.set(target, references);
+  }
+  graph.targets = targets;
+  graph.constructorTargets = constructorTargets;
+  graph.finalizationState.constructorTargets = [...constructorTargets].map(([target, count]) => ({
+    target: new WeakRef(target),
+    count
+  }));
+};
+var registerTrackedRoot = (value) => {
+  const root = getTrackedRawObject(value);
+  if (!root || rootGraphsByRoot.has(root)) return;
+  const finalizationState = { active: true, constructorTargets: [] };
+  const graph = {
+    root: new WeakRef(root),
+    finalizationState,
+    targets: /* @__PURE__ */ new Set(),
+    constructorTargets: /* @__PURE__ */ new Map()
+  };
+  rootGraphsByRoot.set(root, graph);
+  rootGraphFinalizer.register(root, finalizationState, finalizationState);
+  recomputeRootGraph(graph);
+};
+
+// src/valtio/snapshotAccessors.ts
+var { refSet: refSet5, proxyStateMap: proxyStateMap4, snapCache: snapCache2 } = unstable_getInternalStates();
+var createSnapshotPreservingAccessors = (target, version) => {
+  const cached = snapCache2.get(target);
+  if (cached?.[0] === version) {
+    const cachedSnapshot = cached[1];
+    registerSnapshotCopy(cachedSnapshot, target);
+    return cachedSnapshot;
+  }
+  const snap = Array.isArray(target) ? [] : Object.create(Reflect.getPrototypeOf(target));
+  registerSnapshotCopy(snap, target);
+  markToTrack(snap, true);
+  snapCache2.set(target, [version, snap]);
+  for (const key of Reflect.ownKeys(target)) {
+    if (Object.getOwnPropertyDescriptor(snap, key)) continue;
+    const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+    if (!descriptor) continue;
+    if (descriptor.get || descriptor.set) {
+      Object.defineProperty(snap, key, {
+        get: descriptor.get,
+        set: descriptor.set,
+        enumerable: descriptor.enumerable,
+        configurable: true
+      });
+      continue;
+    }
+    const value = Reflect.get(target, key);
+    const snapshotDescriptor = { value, enumerable: descriptor.enumerable, configurable: true };
+    if (typeof value === "object" && value !== null) {
+      if (refSet5.has(value)) {
+        markToTrack(value, false);
+      } else {
+        const childState = proxyStateMap4.get(value);
+        if (childState)
+          snapshotDescriptor.value = createSnapshotPreservingAccessors(childState[0], childState[1]());
+      }
+    }
+    Object.defineProperty(snap, key, snapshotDescriptor);
+  }
+  if (Array.isArray(target) && snap.length !== target.length) {
+    snap.length = target.length;
+  }
+  if (isUnsafeTracked(target)) unsafeTrack(snap);
+  return snap;
+};
+
+// src/valtio/boundary.ts
+var assertSafeDataPaths = (value, path = new Array(), activeAncestors = /* @__PURE__ */ new WeakSet()) => {
+  if (typeof value !== "object" || value === null || activeAncestors.has(value)) return;
+  activeAncestors.add(value);
+  try {
+    for (const key of Object.keys(value)) {
+      const nextPath = [...path, key];
+      if (key === "__proto__" || key === "prototype" && path[path.length - 1] === "constructor")
+        throw reservedDataPathError(nextPath);
+      const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+      if (descriptor && "value" in descriptor) assertSafeDataPaths(descriptor.value, nextPath, activeAncestors);
+    }
+  } finally {
+    activeAncestors.delete(value);
+  }
+};
+var installed = false;
+function installBoundary() {
+  if (installed) return;
+  installed = true;
+  unstable_replaceInternalFunction("canProxy", () => (value) => {
+    if (typeof value !== "object" || value === null) return false;
+    const lane = admissionLane(value);
+    if (lane !== "reject") return lane === "track";
+    const kind = classifyValue(value);
+    if (kind === "plain" || kind === "plainArray") return true;
+    throw rejectionError(value, kind);
+  });
+  unstable_replaceInternalFunction("createSnapshot", () => createSnapshotPreservingAccessors);
+  unstable_replaceInternalFunction(
+    "createHandler",
+    (createHandler2) => (isInitializing, addPropListener, removePropListener, notifyUpdate) => {
+      let setDepth = 0;
+      const handler = createHandler2(isInitializing, addPropListener, removePropListener, notifyUpdate);
+      const defaultDelete = handler.deleteProperty;
+      const defaultSet = handler.set;
+      if (!defaultDelete || !defaultSet)
+        throw new Error("opshot: valtio default handler is missing a mutation trap");
+      return {
+        ...handler,
+        deleteProperty(target, prop) {
+          const rootGraphs = getRootGraphs(target);
+          const previousChild = rootGraphs.length > 0 ? getEnumerableDataChild(target, prop) : void 0;
+          const hadOwn = Object.hasOwn(target, prop);
+          const deleted = defaultDelete(target, prop);
+          if (deleted && hadOwn && previousChild && !Object.hasOwn(target, prop))
+            for (const graph of rootGraphs) recomputeRootGraph(graph);
+          return deleted;
+        },
+        set(target, prop, value, receiver) {
+          const assigned = value;
+          if (prop === "__proto__") throw reservedDataPathError(["__proto__"]);
+          if (prop === "prototype" && constructorPathTargetCount(target) > 0)
+            throw reservedDataPathError(["constructor", "prototype"]);
+          if (prop === "constructor" && typeof assigned === "object" && assigned !== null) {
+            const prototypeDescriptor = Reflect.getOwnPropertyDescriptor(assigned, "prototype");
+            if (prototypeDescriptor?.enumerable) throw reservedDataPathError(["constructor", "prototype"]);
+          }
+          assertSafeDataPaths(assigned, typeof prop === "string" ? [prop] : []);
+          if (typeof assigned === "object" && assigned !== null) {
+            const untracked = getUntracked(assigned) ?? assigned;
+            if (getRegisteredTarget(untracked) !== void 0) throw snapshotDonationError(prop);
+          }
+          const rootGraphs = getRootGraphs(target);
+          const previousChild = rootGraphs.length > 0 ? getEnumerableDataChild(target, prop) : void 0;
+          const previousLength = rootGraphs.length > 0 && Array.isArray(target) && prop === "length" ? Reflect.get(target, "length") : void 0;
+          setDepth += 1;
+          try {
+            const written = defaultSet(target, prop, value, receiver);
+            const currentChild = rootGraphs.length > 0 ? getEnumerableDataChild(target, prop) : void 0;
+            const currentLength = previousLength === void 0 ? void 0 : Reflect.get(target, "length");
+            if (previousChild !== currentChild || previousLength !== currentLength)
+              for (const graph of rootGraphs) recomputeRootGraph(graph);
+            return written;
+          } finally {
+            setDepth -= 1;
+          }
+        },
+        defineProperty(target, prop, descriptor) {
+          if (setDepth > 0 || isInitializing()) return Reflect.defineProperty(target, prop, descriptor);
+          throw new Error(
+            "opshot: defineProperty is not supported on tracked state; define properties in the createMutableState input"
+          );
+        },
+        setPrototypeOf() {
+          throw new Error("opshot: setPrototypeOf is not supported on tracked state");
+        }
+      };
+    }
+  );
 }
-function isState(value) {
-  if (typeof value !== "object" || value === null || !hasOwn(value, "op")) return false;
-  const handle = value.op;
-  if (typeof handle !== "object" || handle === null || !hasOwn(handle, stateBrand)) return false;
-  return handle[stateBrand] === true;
+
+// src/createMutableState.ts
+function createMutableState(properties, group) {
+  installBoundary();
+  assertSafeDataPaths(properties);
+  const base = Object.create(Reflect.getPrototypeOf(properties));
+  Object.defineProperties(base, Object.getOwnPropertyDescriptors(properties));
+  const proxied = proxy(base);
+  registerTrackedRoot(base);
+  if (group !== void 0) {
+    mintGroupedEmitter(proxied, getGroupListeners(group));
+  }
+  return proxied;
 }
 
 // src/createGroup.ts
-function createGroup(meta) {
+var groupListenersByGroup = /* @__PURE__ */ new WeakMap();
+function isGroup(value) {
+  return typeof value === "object" && value !== null && groupListenersByGroup.has(value);
+}
+function getGroupListeners(group) {
+  const listeners = groupListenersByGroup.get(group);
+  if (listeners === void 0) throw new Error("opshot: unknown group");
+  return listeners;
+}
+function createGroup() {
   const listeners = /* @__PURE__ */ new Set();
+  const group = {
+    createMutableState(properties) {
+      return createMutableState(properties, group);
+    }
+  };
+  groupListenersByGroup.set(group, listeners);
+  return group;
+}
+
+// src/transact.ts
+function transact(state, mutate, meta) {
+  const record = getEmitter(state);
+  if (record === void 0) {
+    mutate();
+    return;
+  }
+  if (record.isMutating) throw new Error("opshot: nested transact on the same state");
+  settlePendingBare(record);
+  record.isMutating = true;
+  try {
+    mutate();
+  } finally {
+    record.isMutating = false;
+  }
+  const after = snapshot(record.target);
+  const before = record.lastReported;
+  record.lastReported = after;
+  if (before === after) return;
+  if (!hasListeners(record)) return;
+  const ops = diffSnapshots(requireObjectSnapshot(before), requireObjectSnapshot(after));
+  if (ops.length === 0) return;
+  deliver(record, ops, meta);
+}
+
+// src/ops/applyOps.ts
+var isObjectLike4 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+var sameValueZero = (first, second) => first === second || first !== first && second !== second;
+var sameIdentity = (first, second) => sameValueZero(resolveIdentity(first), resolveIdentity(second));
+var assertApplicable = (operation) => {
+  if (typeof operation === "object" && operation !== null && "do" in operation) {
+    throw new Error("opshot: applyOps applies operation halves; pass op.do or op.undo.");
+  }
+  if (!isOperation(operation)) {
+    throw new Error(
+      "opshot: this op is a copy (spread, JSON, or structuredClone) and has lost its value. Apply the op objects the listener delivered; never copy them."
+    );
+  }
+};
+var unresolvedError = (path) => new Error(`opshot: ${formatOperationPath(path)} does not resolve to a supported operation address`);
+var matchesAppliedValue = (current, expected) => {
+  if (isObjectLike4(current) && isObjectLike4(expected)) return sameIdentity(current, expected);
+  return Object.is(current, expected);
+};
+var setOrThrow = (target, key, value) => {
+  const written = Reflect.set(target, key, value);
+  const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
+  const current = descriptor && "value" in descriptor ? Reflect.get(target, key) : void 0;
+  if (!written || !descriptor || !("value" in descriptor) || !matchesAppliedValue(current, value)) {
+    throw new Error(`opshot: replay could not restore ${String(key)}`);
+  }
+};
+var deleteOrThrow = (target, key) => {
+  if (!Reflect.deleteProperty(target, key)) throw new Error(`opshot: replay could not remove ${String(key)}`);
+};
+var restoreRecordedContent = (attached, recorded, restored) => {
+  if (restored.has(recorded)) return;
+  restored.add(recorded);
+  const recordedKeys = Reflect.ownKeys(recorded);
+  const orderedKeys = Array.isArray(recorded) ? ["length", ...recordedKeys.filter((key) => key !== "length")] : recordedKeys;
+  for (const key of orderedKeys) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(recorded, key);
+    const attachedDescriptor = Reflect.getOwnPropertyDescriptor(attached, key);
+    if (!descriptor || !("value" in descriptor) || attachedDescriptor && !("value" in attachedDescriptor)) continue;
+    const value = descriptor.value;
+    if (isObjectLike4(value)) {
+      const target = getRegisteredTarget(value);
+      if (target !== void 0) {
+        setOrThrow(attached, key, target);
+        const child = Reflect.get(attached, key);
+        if (!isObjectLike4(child)) throw new Error(`opshot: replay could not reattach ${String(key)}`);
+        restoreRecordedContent(child, value, restored);
+        continue;
+      }
+    }
+    setOrThrow(attached, key, value);
+  }
+  for (const key of Reflect.ownKeys(attached)) {
+    if (Object.hasOwn(recorded, key)) continue;
+    const descriptor = Reflect.getOwnPropertyDescriptor(attached, key);
+    if (descriptor && "value" in descriptor) deleteOrThrow(attached, key);
+  }
+};
+var getValuePayload = (operation) => {
+  const original = getValueOriginal(operation);
+  if (original !== void 0) {
+    if (isObjectLike4(original) && getRegisteredTarget(original) !== void 0)
+      return { recorded: original, fallback: void 0 };
+    return { recorded: original, fallback: operation.value };
+  }
+  return { recorded: operation.value, fallback: operation.value };
+};
+var restoreValue = (payload, attach, readAttached) => {
+  if (isObjectLike4(payload.recorded)) {
+    const target = getRegisteredTarget(payload.recorded);
+    if (target !== void 0) {
+      attach(target);
+      const attached = readAttached();
+      if (!isObjectLike4(attached)) throw new Error("opshot: replay could not read a reattached target");
+      restoreRecordedContent(attached, payload.recorded, /* @__PURE__ */ new WeakSet());
+      return;
+    }
+  }
+  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 isCanonicalArrayIndex2 = (segment) => Number.isInteger(segment) && typeof segment === "number" && segment >= 0 && segment < 4294967295;
+var isCanonicalArrayIndexString = (segment) => {
+  const index = Number(segment);
+  return Number.isInteger(index) && index >= 0 && index < 4294967295 && String(index) === segment;
+};
+var requirePlainSegment = (parent, segment, path) => {
+  if (Array.isArray(parent)) {
+    if (isCanonicalArrayIndex2(segment)) return segment;
+    if (typeof segment === "string" && !isCanonicalArrayIndexString(segment)) return segment;
+    throw unresolvedError(path);
+  }
+  if (typeof segment === "string") return segment;
+  throw unresolvedError(path);
+};
+var 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 (!isObjectLike4(parent)) throw unresolvedError(path);
+  return requirePlainProperty(parent, segment, path);
+};
+var resolveTerminal = (root, path) => {
+  assertSafePath(path);
+  if (path.length === 0) throw new Error("opshot: root operations are not supported");
+  let parent = root;
+  for (let index = 0; index < path.length - 1; index++) parent = resolveTraversalSegment(parent, path[index], path);
+  if (!isObjectLike4(parent)) throw unresolvedError(path);
+  return { parent, segment: path[path.length - 1] };
+};
+var applyPlain = (parent, segment, operation) => {
+  const path = operation.path;
+  if (Array.isArray(parent) && segment === "length") {
+    if (operation.op !== "replace" || typeof operation.value !== "number" || !Number.isInteger(operation.value) || operation.value < 0 || operation.value > 4294967295) {
+      throw unresolvedError(path);
+    }
+    setOrThrow(parent, "length", operation.value);
+    return;
+  }
+  const key = requirePlainSegment(parent, segment, path);
+  const descriptor = Reflect.getOwnPropertyDescriptor(parent, key);
+  const present = descriptor !== void 0 && descriptor.enumerable && "value" in descriptor;
+  if (descriptor !== void 0 && !present) throw unresolvedError(path);
+  if (operation.op === "add" && present) throw unresolvedError(path);
+  if (operation.op !== "add" && !present) throw unresolvedError(path);
+  if (operation.op === "add") {
+    const inheritedDescriptor = getInheritedDescriptor(parent, key);
+    if (inheritedDescriptor && !("value" in inheritedDescriptor)) {
+      throw new Error(`opshot: ${formatOperationPath(path)} resolves to an inherited accessor`);
+    }
+  }
+  if (operation.op === "remove") {
+    deleteOrThrow(parent, key);
+    return;
+  }
+  if (!("value" in operation)) throw unresolvedError(path);
+  restoreValue(
+    getValuePayload(operation),
+    (value) => setOrThrow(parent, key, value),
+    () => Reflect.get(parent, key)
+  );
+};
+function applyOperations(root, operations) {
+  for (const operation of operations) {
+    const terminal = resolveTerminal(root, operation.path);
+    applyPlain(terminal.parent, terminal.segment, operation);
+  }
+}
+function applyOps(state, operations, meta) {
+  for (const operation of operations) assertApplicable(operation);
+  transact(
+    state,
+    () => {
+      applyOperations(resolveEmitterTarget(state), operations);
+    },
+    meta
+  );
+}
+
+// src/subscribe.ts
+function subscribe2(target, listener) {
+  if (isGroup(target)) {
+    return addGroupListener(getGroupListeners(target), (state, ops, meta) => {
+      listener(state, ops, unwrapTransportMeta(meta));
+    });
+  }
+  return addStateListener(target, (ops, meta) => {
+    listener(ops, unwrapTransportMeta(meta));
+  });
+}
+var channelStampBrand = /* @__PURE__ */ Symbol.for("opshot.channelStamp");
+function stampChannelMeta(channelId, meta) {
+  return { [channelStampBrand]: channelId, meta };
+}
+function isChannelStamp(value) {
+  return typeof value === "object" && value !== null && channelStampBrand in value;
+}
+function isOwnChannelStamp(value, channelId) {
+  return isChannelStamp(value) && value[channelStampBrand] === channelId;
+}
+function unwrapTransportMeta(meta) {
+  if (isChannelStamp(meta)) return meta.meta;
+  return meta;
+}
+function toChannelContext(channelId, defaults, meta) {
+  if (isOwnChannelStamp(meta, channelId)) {
+    return { isTransaction: true, meta: { ...defaults, ...meta.meta } };
+  }
+  return { isTransaction: false, meta: unwrapTransportMeta(meta) };
+}
+
+// src/createChannel.ts
+function createChannel(defaults) {
+  const channelId = Object.freeze({});
+  function transact2(state, mutate, meta) {
+    transact(state, mutate, stampChannelMeta(channelId, meta));
+  }
+  function subscribe3(target, listener) {
+    if (isGroup(target)) {
+      return addGroupListener(getGroupListeners(target), (state, ops, meta) => {
+        listener(
+          state,
+          ops,
+          toChannelContext(channelId, defaults, meta)
+        );
+      });
+    }
+    return addStateListener(target, (ops, meta) => {
+      listener(
+        ops,
+        toChannelContext(channelId, defaults, meta)
+      );
+    });
+  }
+  function applyOps2(state, operations, meta) {
+    applyOps(state, operations, stampChannelMeta(channelId, meta));
+  }
+  return { transact: transact2, subscribe: subscribe3, applyOps: applyOps2 };
+}
+
+// src/react/resolveWrapper.ts
+var { proxyStateMap: proxyStateMap5 } = unstable_getInternalStates();
+var isObjectLike5 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+function unwrapWrapper(value) {
+  if (!isObjectLike5(value) || proxyStateMap5.has(value)) return value;
+  let current = value;
+  while (isObjectLike5(current)) {
+    const registeredTarget = getRegisteredWrapperTarget(current);
+    if (registeredTarget === void 0) break;
+    current = registeredTarget;
+  }
+  return current;
+}
+
+// src/isState.ts
+var { proxyStateMap: proxyStateMap6 } = unstable_getInternalStates();
+function isState(value) {
+  const resolved = unwrapWrapper(value);
+  if (typeof resolved !== "object" || resolved === null) return false;
+  return proxyStateMap6.has(resolved);
+}
+
+// src/ignore.ts
+var ignore = ref;
+
+// src/tracked/facadeGuard.ts
+var assertMutableFacade = (facade, mutationKey) => {
+  const facadeSource = getUntracked(facade);
+  const isRegisteredCopy = getRegisteredTarget(facade) !== void 0 || facadeSource !== null && getRegisteredTarget(facadeSource) !== void 0;
+  const descriptor = Reflect.getOwnPropertyDescriptor(facade, mutationKey);
+  if (isRegisteredCopy || descriptor !== void 0 && "writable" in descriptor && !descriptor.writable) {
+    throw new Error("opshot: cannot mutate a tracked collection snapshot");
+  }
+};
+
+// src/tracked/trackedDate.ts
+var setLegacyYear = (date, year) => {
+  const setYear = Reflect.get(date, "setYear");
+  if (typeof setYear !== "function") throw new Error("opshot: Date.setYear is not available");
+  const epochMs = Reflect.apply(setYear, date, [year]);
+  if (typeof epochMs !== "number") throw new Error("opshot: Date.setYear returned a non-number");
+  return epochMs;
+};
+var constructDate = (args) => {
+  switch (args.length) {
+    case 0:
+      return /* @__PURE__ */ new Date();
+    case 1:
+      return new Date(args[0]);
+    case 2:
+      return new Date(args[0], args[1]);
+    case 3:
+      return new Date(args[0], args[1], args[2]);
+    case 4:
+      return new Date(args[0], args[1], args[2], args[3]);
+    case 5:
+      return new Date(args[0], args[1], args[2], args[3], args[4]);
+    case 6:
+      return new Date(args[0], args[1], args[2], args[3], args[4], args[5]);
+    case 7:
+      return new Date(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
+  }
+};
+var TrackedDate = class {
+  constructor(...args) {
+    installBoundary();
+    this.epochMs = constructDate(args).getTime();
+  }
+  readDate() {
+    return new Date(this.epochMs);
+  }
+  write(mutate) {
+    assertMutableFacade(this, "epochMs");
+    const epochMs = mutate(this.readDate());
+    this.epochMs = epochMs;
+    return epochMs;
+  }
+  toString() {
+    return this.readDate().toString();
+  }
+  toDateString() {
+    return this.readDate().toDateString();
+  }
+  toTimeString() {
+    return this.readDate().toTimeString();
+  }
+  toLocaleString(locales, options) {
+    return this.readDate().toLocaleString(locales, options);
+  }
+  toLocaleDateString(locales, options) {
+    return this.readDate().toLocaleDateString(locales, options);
+  }
+  toLocaleTimeString(locales, options) {
+    return this.readDate().toLocaleTimeString(locales, options);
+  }
+  valueOf() {
+    return this.readDate().valueOf();
+  }
+  getTime() {
+    return this.readDate().getTime();
+  }
+  getFullYear() {
+    return this.readDate().getFullYear();
+  }
+  getYear() {
+    return this.readDate().getFullYear() - 1900;
+  }
+  getUTCFullYear() {
+    return this.readDate().getUTCFullYear();
+  }
+  getMonth() {
+    return this.readDate().getMonth();
+  }
+  getUTCMonth() {
+    return this.readDate().getUTCMonth();
+  }
+  getDate() {
+    return this.readDate().getDate();
+  }
+  getUTCDate() {
+    return this.readDate().getUTCDate();
+  }
+  getDay() {
+    return this.readDate().getDay();
+  }
+  getUTCDay() {
+    return this.readDate().getUTCDay();
+  }
+  getHours() {
+    return this.readDate().getHours();
+  }
+  getUTCHours() {
+    return this.readDate().getUTCHours();
+  }
+  getMinutes() {
+    return this.readDate().getMinutes();
+  }
+  getUTCMinutes() {
+    return this.readDate().getUTCMinutes();
+  }
+  getSeconds() {
+    return this.readDate().getSeconds();
+  }
+  getUTCSeconds() {
+    return this.readDate().getUTCSeconds();
+  }
+  getMilliseconds() {
+    return this.readDate().getMilliseconds();
+  }
+  getUTCMilliseconds() {
+    return this.readDate().getUTCMilliseconds();
+  }
+  getTimezoneOffset() {
+    return this.readDate().getTimezoneOffset();
+  }
+  setYear(year) {
+    return this.write((date) => setLegacyYear(date, year));
+  }
+  setTime(...args) {
+    return this.write((date) => date.setTime(...args));
+  }
+  setMilliseconds(...args) {
+    return this.write((date) => date.setMilliseconds(...args));
+  }
+  setUTCMilliseconds(...args) {
+    return this.write((date) => date.setUTCMilliseconds(...args));
+  }
+  setSeconds(...args) {
+    return this.write((date) => date.setSeconds(...args));
+  }
+  setUTCSeconds(...args) {
+    return this.write((date) => date.setUTCSeconds(...args));
+  }
+  setMinutes(...args) {
+    return this.write((date) => date.setMinutes(...args));
+  }
+  setUTCMinutes(...args) {
+    return this.write((date) => date.setUTCMinutes(...args));
+  }
+  setHours(...args) {
+    return this.write((date) => date.setHours(...args));
+  }
+  setUTCHours(...args) {
+    return this.write((date) => date.setUTCHours(...args));
+  }
+  setDate(...args) {
+    return this.write((date) => date.setDate(...args));
+  }
+  setUTCDate(...args) {
+    return this.write((date) => date.setUTCDate(...args));
+  }
+  setMonth(...args) {
+    return this.write((date) => date.setMonth(...args));
+  }
+  setUTCMonth(...args) {
+    return this.write((date) => date.setUTCMonth(...args));
+  }
+  setFullYear(...args) {
+    return this.write((date) => date.setFullYear(...args));
+  }
+  setUTCFullYear(...args) {
+    return this.write((date) => date.setUTCFullYear(...args));
+  }
+  toUTCString() {
+    return this.readDate().toUTCString();
+  }
+  toGMTString() {
+    return this.readDate().toUTCString();
+  }
+  toISOString() {
+    return this.readDate().toISOString();
+  }
+  [Symbol.toPrimitive](hint) {
+    const date = this.readDate();
+    return hint === "number" ? date[Symbol.toPrimitive]("number") : date[Symbol.toPrimitive](hint);
+  }
+};
+Object.defineProperty(TrackedDate.prototype, Symbol.toStringTag, {
+  value: "TrackedDate",
+  enumerable: false,
+  configurable: false,
+  writable: false
+});
+
+// src/tracked/address.ts
+var internTable = /* @__PURE__ */ new WeakMap();
+var nextInternId = 0;
+var internIdentity = (key) => {
+  const resolved = resolveIdentity(key);
+  if (resolved === null || typeof resolved !== "object" && typeof resolved !== "function" && typeof resolved !== "symbol") {
+    throw new Error("opshot: addressOf interned a non-identity value");
+  }
+  const existing = internTable.get(resolved);
+  if (existing !== void 0) return existing;
+  const id = nextInternId;
+  nextInternId += 1;
+  internTable.set(resolved, id);
+  return id;
+};
+var addressOf = (key) => {
+  if (key === null) return "z";
+  if (key === void 0) return "u";
+  switch (typeof key) {
+    case "string":
+      return `s${key}`;
+    case "number":
+      return `n${String(key)}`;
+    case "bigint":
+      return `i${String(key)}`;
+    case "boolean":
+      return key ? "b1" : "b0";
+    case "symbol": {
+      const registered = Symbol.keyFor(key);
+      if (registered !== void 0) return `r${registered}`;
+      return `o${internIdentity(key)}`;
+    }
+    case "object":
+    case "function":
+      return `o${internIdentity(key)}`;
+    default:
+      throw new Error(`opshot: addressOf received unsupported key type ${typeof key}`);
+  }
+};
+
+// src/tracked/iterateSlots.ts
+function* iterateSlots(getSlots) {
+  let slots = getSlots();
+  let index = 0;
+  for (; ; ) {
+    const current = getSlots();
+    if (current !== slots) {
+      slots = current;
+      index = 0;
+    }
+    if (index >= slots.length) return;
+    const entry = slots[index];
+    index += 1;
+    if (entry !== null && entry !== void 0) yield entry;
+  }
+}
+
+// src/tracked/slotStore.ts
+var deleteFromStore = (store, addr) => {
+  const slot = store.index[addr];
+  if (slot === void 0) return false;
+  store.slots[slot] = null;
+  Reflect.deleteProperty(store.index, addr);
+  store.count -= 1;
+  return true;
+};
+var clearStore = (store) => {
+  store.slots = [];
+  store.index = {};
+  store.count = 0;
+};
+
+// src/tracked/trackedMap.ts
+var TrackedMap = class {
+  constructor(entries) {
+    installBoundary();
+    this.slots = [];
+    this.index = {};
+    this.count = 0;
+    if (entries !== void 0) for (const [key, value] of entries) this.set(key, value);
+  }
+  get size() {
+    return this.count;
+  }
+  has(key) {
+    return this.index[addressOf(key)] !== void 0;
+  }
+  get(key) {
+    const slot = this.index[addressOf(key)];
+    if (slot === void 0) return void 0;
+    const pair = this.slots[slot];
+    return pair === null || pair === void 0 ? void 0 : pair[1];
+  }
+  set(key, value) {
+    assertMutableFacade(this, "count");
+    const addr = addressOf(key);
+    const slot = this.index[addr];
+    if (slot === void 0) {
+      const newSlot = this.slots.length;
+      this.slots.push([key, value]);
+      this.index[addr] = newSlot;
+      this.count += 1;
+    } else {
+      const pair = this.slots[slot];
+      if (pair === null || pair === void 0) throw new Error("opshot: TrackedMap resolved an empty slot");
+      this.slots[slot] = [pair[0], value];
+    }
+    return this;
+  }
+  delete(key) {
+    assertMutableFacade(this, "count");
+    return deleteFromStore(this, addressOf(key));
+  }
+  clear() {
+    assertMutableFacade(this, "count");
+    clearStore(this);
+  }
+  entries() {
+    const pairs = iterateSlots(() => this.slots);
+    return (function* () {
+      for (const pair of pairs) yield [pair[0], pair[1]];
+    })();
+  }
+  keys() {
+    const pairs = iterateSlots(() => this.slots);
+    return (function* () {
+      for (const pair of pairs) yield pair[0];
+    })();
+  }
+  values() {
+    const pairs = iterateSlots(() => this.slots);
+    return (function* () {
+      for (const pair of pairs) yield pair[1];
+    })();
+  }
+  forEach(callback) {
+    for (const pair of iterateSlots(() => this.slots)) callback(pair[1], pair[0], this);
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+};
+Object.defineProperty(TrackedMap.prototype, Symbol.toStringTag, {
+  value: "TrackedMap",
+  enumerable: false,
+  configurable: false,
+  writable: false
+});
+
+// src/tracked/trackedSet.ts
+var TrackedSet = class {
+  constructor(values) {
+    installBoundary();
+    this.slots = [];
+    this.index = {};
+    this.count = 0;
+    if (values !== void 0) for (const value of values) this.add(value);
+  }
+  get size() {
+    return this.count;
+  }
+  has(value) {
+    return this.index[addressOf(value)] !== void 0;
+  }
+  add(value) {
+    assertMutableFacade(this, "count");
+    const addr = addressOf(value);
+    if (this.index[addr] !== void 0) return this;
+    const slot = this.slots.length;
+    this.slots.push([value]);
+    this.index[addr] = slot;
+    this.count += 1;
+    return this;
+  }
+  delete(value) {
+    assertMutableFacade(this, "count");
+    return deleteFromStore(this, addressOf(value));
+  }
+  clear() {
+    assertMutableFacade(this, "count");
+    clearStore(this);
+  }
+  entries() {
+    const members = iterateSlots(() => this.slots);
+    return (function* () {
+      for (const member of members) yield [member[0], member[0]];
+    })();
+  }
+  keys() {
+    return this.values();
+  }
+  values() {
+    const members = iterateSlots(() => this.slots);
+    return (function* () {
+      for (const member of members) yield member[0];
+    })();
+  }
+  forEach(callback) {
+    for (const member of iterateSlots(() => this.slots)) callback(member[0], member[0], this);
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+};
+Object.defineProperty(TrackedSet.prototype, Symbol.toStringTag, {
+  value: "TrackedSet",
+  enumerable: false,
+  configurable: false,
+  writable: false
+});
+
+// src/react/boundary.ts
+var { refSet: refSet6, proxyStateMap: proxyStateMap7 } = unstable_getInternalStates();
+var KEYS_PROPERTY2 = "k";
+var HAS_KEY_PROPERTY2 = "h";
+var HAS_OWN_KEY_PROPERTY2 = "o";
+var ALL_OWN_KEYS_PROPERTY2 = "w";
+var isObjectLike6 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+var isLiveProxy = (value) => proxyStateMap7.has(value);
+var getProxyTarget = (liveProxy) => proxyStateMap7.get(liveProxy)?.[0] ?? liveProxy;
+var getUsage = (affected, target) => {
+  let used = affected.get(target);
+  if (used === void 0) {
+    used = {};
+    affected.set(target, used);
+  }
+  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 getPrototypeMethod = (target, prop) => {
+  let prototype = Reflect.getPrototypeOf(target);
+  while (prototype !== null) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(prototype, prop);
+    if (descriptor !== void 0) {
+      const descriptorValue = "value" in descriptor ? descriptor.value : void 0;
+      return typeof descriptorValue === "function" ? descriptorValue : void 0;
+    }
+    prototype = Reflect.getPrototypeOf(prototype);
+  }
+  return void 0;
+};
+var wrapperBoundMethods = /* @__PURE__ */ new WeakMap();
+var bindMethodToWrapper = (wrapper, method) => {
+  let methods = wrapperBoundMethods.get(wrapper);
+  if (methods === void 0) {
+    methods = /* @__PURE__ */ new WeakMap();
+    wrapperBoundMethods.set(wrapper, methods);
+  }
+  const existing = methods.get(method);
+  if (existing !== void 0) return existing;
+  const bound = Function.prototype.bind.call(method, wrapper);
+  methods.set(method, bound);
+  return bound;
+};
+function createBoundary() {
+  const partitions = /* @__PURE__ */ new Map();
+  const targets = /* @__PURE__ */ new Map();
+  const getPartition = (sourceProxy) => {
+    let partition = partitions.get(sourceProxy);
+    if (partition === void 0) {
+      partition = {
+        sourceProxy,
+        previousRootSnapshot: void 0,
+        affected: /* @__PURE__ */ new Map(),
+        baselines: /* @__PURE__ */ new Map(),
+        proxyCache: /* @__PURE__ */ new WeakMap()
+      };
+      partitions.set(sourceProxy, partition);
+    }
+    return partition;
+  };
+  const ensureBaseline = (partition, liveProxy) => {
+    const existing = partition.baselines.get(liveProxy);
+    if (existing !== void 0) return existing;
+    const baseline = snapshot(liveProxy);
+    partition.baselines.set(liveProxy, baseline);
+    return baseline;
+  };
+  const ensureRootBaseline = (partition) => {
+    if (partition.previousRootSnapshot === void 0) {
+      partition.previousRootSnapshot = snapshot(partition.sourceProxy);
+      partition.baselines.set(partition.sourceProxy, partition.previousRootSnapshot);
+    }
+    return partition.previousRootSnapshot;
+  };
+  const registerTarget = (liveProxy) => {
+    if (targets.has(liveProxy)) return;
+    targets.set(liveProxy, {
+      lastIdentitySnapshot: snapshot(liveProxy)
+    });
+  };
+  const wrapLive = (liveProxy, partition) => {
+    ensureBaseline(partition, liveProxy);
+    registerTarget(liveProxy);
+    const cached = partition.proxyCache.get(liveProxy);
+    if (cached !== void 0) return cached;
+    const storageTarget = getProxyTarget(liveProxy);
+    const wrapperBox = {};
+    const handler = {
+      get(_target, prop) {
+        ensureRootBaseline(partition);
+        const value = Reflect.get(liveProxy, prop, liveProxy);
+        const wrapper2 = wrapperBox.current;
+        const used = getUsage(partition.affected, liveProxy);
+        recordKey(used, KEYS_PROPERTY2, prop);
+        ensureBaseline(partition, liveProxy);
+        if (typeof value === "function") {
+          const method = getPrototypeMethod(storageTarget, prop);
+          if (method !== void 0 && value === method && wrapper2 !== void 0) {
+            return bindMethodToWrapper(wrapper2, method);
+          }
+        }
+        if (!isObjectLike6(value)) return value;
+        if (typeof value === "function") return value;
+        if (refSet6.has(value)) return value;
+        if (!isLiveProxy(value)) return value;
+        return wrapLive(value, partition);
+      },
+      has(_target, prop) {
+        const used = getUsage(partition.affected, liveProxy);
+        recordKey(used, HAS_KEY_PROPERTY2, prop);
+        ensureBaseline(partition, liveProxy);
+        return Reflect.has(liveProxy, prop);
+      },
+      getOwnPropertyDescriptor(_target, prop) {
+        const used = getUsage(partition.affected, liveProxy);
+        recordKey(used, HAS_OWN_KEY_PROPERTY2, prop);
+        ensureBaseline(partition, liveProxy);
+        return Reflect.getOwnPropertyDescriptor(liveProxy, prop);
+      },
+      ownKeys() {
+        const used = getUsage(partition.affected, liveProxy);
+        used[ALL_OWN_KEYS_PROPERTY2] = true;
+        ensureBaseline(partition, liveProxy);
+        return Reflect.ownKeys(liveProxy);
+      },
+      set(_target, prop, value) {
+        ensureRootBaseline(partition);
+        return Reflect.set(liveProxy, prop, value, liveProxy);
+      },
+      deleteProperty(_target, prop) {
+        ensureRootBaseline(partition);
+        return Reflect.deleteProperty(liveProxy, prop);
+      }
+    };
+    const wrapper = new Proxy(/* @__PURE__ */ Object.create(null), handler);
+    wrapperBox.current = wrapper;
+    registerWrapperTarget(wrapper, liveProxy);
+    partition.proxyCache.set(liveProxy, wrapper);
+    return wrapper;
+  };
   return {
-    createState(define) {
-      return createGroupState(define, listeners, meta);
+    wrap(sourceProxy) {
+      if (!isLiveProxy(sourceProxy)) {
+        throw new Error("opshot: Boundary.wrap requires a live Valtio proxy");
+      }
+      const partition = getPartition(sourceProxy);
+      ensureRootBaseline(partition);
+      return wrapLive(sourceProxy, partition);
+    },
+    readsChanged(sourceProxy) {
+      const partition = partitions.get(sourceProxy);
+      if (partition?.previousRootSnapshot === void 0) return false;
+      if (partition.affected.size === 0) return false;
+      const translated = /* @__PURE__ */ new WeakMap();
+      for (const [live, usage] of partition.affected) {
+        const baseline = partition.baselines.get(live);
+        if (baseline === void 0) {
+          throw new Error("opshot: missing baseline snapshot for affected live proxy");
+        }
+        translated.set(baseline, usage);
+      }
+      const nextRoot = snapshot(sourceProxy);
+      return isChanged(partition.previousRootSnapshot, nextRoot, translated, /* @__PURE__ */ new WeakMap());
+    },
+    evictChangedTargets() {
+      for (const [liveProxy, entry] of targets) {
+        const current = snapshot(liveProxy);
+        if (current !== entry.lastIdentitySnapshot) {
+          for (const partition of partitions.values()) {
+            partition.proxyCache.delete(liveProxy);
+          }
+        }
+        entry.lastIdentitySnapshot = current;
+      }
     },
-    subscribe(listener) {
-      listeners.add(listener);
+    resetReads() {
+      for (const partition of partitions.values()) {
+        partition.previousRootSnapshot = void 0;
+        partition.affected.clear();
+        partition.baselines.clear();
+      }
+    }
+  };
+}
+
+// src/react/scope.tsx
+var isPlainPrototype = (value) => {
+  const prototype = Reflect.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+var assertSubstitutableContainer = (container) => {
+  if (isPlainPrototype(container)) return;
+  const kind = classifyValue(container);
+  if (kind === "plain" || kind === "plainArray" || kind === "cleanClass") return;
+  const className = constructorName(container.constructor);
+  if (kind === "arraySubclass") {
+    throw new Error(
+      `opshot: scope found a state inside ${className}, an array subclass whose prototype can't survive substitution. Move the state to a plain array, or ignore() the ${className}.`
+    );
+  }
+  const hidden = kind === "privateClass" ? "private fields" : "internal slots";
+  throw new Error(
+    `opshot: scope found a state inside ${className}, whose ${hidden} can't survive substitution. Move the state to a plain container, or ignore() the ${className}.`
+  );
+};
+function findStatePaths(value, maxDepth, path = [], paths = [], ancestors = /* @__PURE__ */ new Set()) {
+  if (isState(value)) {
+    paths.push(path);
+    return paths;
+  }
+  if (value === null || typeof value !== "object") return paths;
+  if ("$$typeof" in value) return paths;
+  if (ancestors.has(value)) return paths;
+  if (path.length >= maxDepth) return paths;
+  ancestors.add(value);
+  if (Array.isArray(value)) {
+    const foundCount = paths.length;
+    value.forEach((item, index) => {
+      findStatePaths(item, maxDepth, [...path, index], paths, ancestors);
+    });
+    if (paths.length > foundCount) assertSubstitutableContainer(value);
+  } else {
+    const foundCount = paths.length;
+    for (const [key, propertyValue] of Object.entries(value)) {
+      if (key.startsWith("__react")) continue;
+      findStatePaths(propertyValue, maxDepth, [...path, key], paths, ancestors);
+    }
+    if (paths.length > foundCount) assertSubstitutableContainer(value);
+  }
+  ancestors.delete(value);
+  return paths;
+}
+function getAtPath(object, path) {
+  let current = object;
+  for (const segment of path) {
+    if (current === null || current === void 0) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
+function setAtPath(object, path, value) {
+  if (path.length === 0) return value;
+  const head = path[0];
+  if (head === void 0) throw new Error("setAtPath: non-empty path yielded no head segment");
+  const tail = path.slice(1);
+  const current = object[head];
+  const updated = setAtPath(current, tail, value);
+  if (Array.isArray(object)) {
+    const clone2 = [...object];
+    clone2[head] = updated;
+    return clone2;
+  }
+  const prototype = Reflect.getPrototypeOf(object);
+  if (prototype === Object.prototype || prototype === null) return { ...object, [head]: updated };
+  const descriptor = Object.getOwnPropertyDescriptor(object, head);
+  if (descriptor?.get !== void 0 || descriptor?.set !== void 0) {
+    const className = constructorName(object.constructor);
+    throw new Error(
+      `opshot: scope found a state behind the accessor "${String(head)}" on ${className}, which can't survive substitution. Move the state to a plain container, or ignore() the ${className}.`
+    );
+  }
+  const clone = Object.create(prototype);
+  Object.defineProperties(clone, Object.getOwnPropertyDescriptors(object));
+  clone[head] = updated;
+  return clone;
+}
+var sourcesKey = (sources) => `${sources.length}:${sources.map((source) => addressOf(source)).join(",")}`;
+function scope(Component, options) {
+  const maxDepth = options?.maxDepth ?? 10;
+  const Scoped = (props) => {
+    const boundaryRef = useRef(void 0);
+    boundaryRef.current ?? (boundaryRef.current = createBoundary());
+    const boundary = boundaryRef.current;
+    const [, bump] = useReducer((value) => value + 1, 0);
+    boundary.resetReads();
+    const paths = findStatePaths(props, maxDepth);
+    const sources = [];
+    let nextProps = props;
+    let changed = false;
+    for (const path of paths) {
+      const value = getAtPath(props, path);
+      if (!isState(value)) continue;
+      const source = unwrapWrapper(value);
+      if (typeof source !== "object" || source === null) continue;
+      const wrapped = boundary.wrap(source);
+      if (!sources.includes(source)) sources.push(source);
+      if (wrapped !== value) {
+        nextProps = setAtPath(nextProps, path, wrapped);
+        changed = true;
+      }
+    }
+    const renderedProps = changed ? nextProps : props;
+    const versionsAtRender = sources.map((source) => getVersion(source));
+    useEffect(() => {
+      const unsubscribes = sources.map(
+        (source) => subscribe(
+          source,
+          () => {
+            boundary.evictChangedTargets();
+            if (boundary.readsChanged(source)) bump();
+          },
+          true
+        )
+      );
       return () => {
-        listeners.delete(listener);
+        for (const unsubscribe of unsubscribes) unsubscribe();
       };
-    }
+    }, [sourcesKey(sources), boundary]);
+    useEffect(() => {
+      let shouldBump = false;
+      for (let index = 0; index < sources.length; index += 1) {
+        const source = sources[index];
+        const captured = versionsAtRender[index];
+        if (source === void 0 || captured === void 0) continue;
+        if (getVersion(source) !== captured) {
+          boundary.evictChangedTargets();
+          if (boundary.readsChanged(source)) shouldBump = true;
+        }
+      }
+      if (shouldBump) bump();
+    });
+    return createElement(Component, renderedProps);
   };
+  const baseName = Component.displayName ?? Component.name;
+  Scoped.displayName = `scope(${typeof baseName === "string" && baseName !== "" ? baseName : "Component"})`;
+  return memo(Scoped);
+}
+function useGroup() {
+  return useState(() => createGroup())[0];
+}
+function useMutableState(properties, group) {
+  const [{ proxy: proxy2, boundary }] = useState(() => ({
+    proxy: createMutableState(properties, group),
+    boundary: createBoundary()
+  }));
+  const [, bump] = useReducer((value) => value + 1, 0);
+  const versionAtRender = getVersion(proxy2);
+  boundary.resetReads();
+  const wrapper = boundary.wrap(proxy2);
+  useEffect(() => {
+    const onSignal = () => {
+      boundary.evictChangedTargets();
+      if (boundary.readsChanged(proxy2)) bump();
+    };
+    return subscribe(proxy2, onSignal, true);
+  }, [proxy2, boundary]);
+  useEffect(() => {
+    if (getVersion(proxy2) === versionAtRender) return;
+    boundary.evictChangedTargets();
+    if (boundary.readsChanged(proxy2)) bump();
+  });
+  return wrapper;
 }
 
-export { createGroup, createMeta, createState, diffSnapshots, isState };
+export { TrackedDate, TrackedMap, TrackedSet, applyOps, createChannel, createGroup, createMutableState, diffSnapshots, identify, ignore, isSameIdentity, isState, scope, subscribe2 as subscribe, transact, unsafeTrack, useGroup, useMutableState };