opshot 0.5.2 → 0.6.0

package/dist/index.js

@@ -1,694 +1,5 @@
-import * as React from 'react';
-import { memo, useState, useReducer, useRef, useEffect, createElement, useLayoutEffect } from 'react';
-
-// src/utils/constructorName.ts
-var constructorName = (candidate) => typeof candidate === "function" && candidate.name !== "" ? candidate.name : "Object";
-
-// src/boundaryErrors.ts
-var ignoreOption = "ignore(value) to store it by reference, untracked";
-var unsafeTrackDataOption = "unsafeTrack(value) to track its data anyway";
-var unsafeTrackPrivateOption = "unsafeTrack(value) tracks public fields while private methods stay untracked";
-var unsafeTrackSlotOption = "unsafeTrack(value) tracks public fields while slot methods stay untracked";
-var unsafeTrackLossyOption = "unsafeTrack(value) to track it lossily";
-var locationClause = (path) => path === void 0 || path.length === 0 ? "" : ` at /${path.join("/")}`;
-var boundaryError = (className, reason, options, path) => new Error(
-  `opshot: ${className}${locationClause(path)} cannot be tracked (${reason}). Options:
-${options.map((option) => `- ${option}`).join("\n")}`
-);
-var slotContainerError = (className, trackedName, path) => boundaryError(
-  className,
-  "its state lives in internal slots",
-  [`use ${trackedName} for a tracked equivalent`, unsafeTrackLossyOption, ignoreOption],
-  path
-);
-var arraySubclassError = (className, path) => boundaryError(className, "array subclasses are not plain arrays", [unsafeTrackDataOption, ignoreOption], path);
-var cleanClassError = (className, path) => boundaryError(className, "arrow-method writes won't be tracked", [unsafeTrackDataOption, ignoreOption], path);
-var privateClassError = (className, path) => boundaryError(className, "its state is hidden in private fields", [unsafeTrackPrivateOption, ignoreOption], path);
-var nativeClassError = (className, path) => boundaryError(className, "its state is hidden in internal slots", [unsafeTrackSlotOption, ignoreOption], path);
-var nonWritablePropertyError = (value, path) => boundaryError(
-  constructorName(value.constructor),
-  "a non-writable property's interior is silently mutable and untracked",
-  ["make the property writable", "ignore(value) to declare the escape"],
-  path
-);
-var inheritsFromPrototype = (value, prototype) => {
-  for (let current = Reflect.getPrototypeOf(value); current !== null; current = Reflect.getPrototypeOf(current))
-    if (current === prototype) return true;
-  return false;
-};
-var rejectionError = (value, kind, path) => {
-  const className = constructorName(value.constructor);
-  if (inheritsFromPrototype(value, Map.prototype)) return slotContainerError(className, "TrackedMap", path);
-  if (inheritsFromPrototype(value, Set.prototype)) return slotContainerError(className, "TrackedSet", path);
-  if (inheritsFromPrototype(value, Date.prototype)) return slotContainerError(className, "TrackedDate", path);
-  switch (kind) {
-    case "arraySubclass":
-      return arraySubclassError(className, path);
-    case "cleanClass":
-      return cleanClassError(className, path);
-    case "privateClass":
-      return privateClassError(className, path);
-    case "nativeClass":
-      return nativeClassError(className, path);
-  }
-};
-
-// 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 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);
-}
-
-// 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;
-}
-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]);
-  }
-  return memberships;
-}
-
-// 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;
-};
-
-// src/edges.ts
-var isTrackedEntry = (value, writable) => writable && typeof value === "object" && value !== null && !isIgnored(value) && !Object.isFrozen(value);
-var checkNode = (node, entries, route) => {
-  const kind = classifyValue(node);
-  if (isDangerousKind(kind)) throw rejectionError(node, kind, route);
-  for (const entry of entries) {
-    if (typeof entry.value === "function") {
-      if (kind === "cleanClass") throw rejectionError(node, "cleanClass", [...route, entry.key]);
-      continue;
-    }
-    if (typeof entry.value !== "object" || entry.value === null) continue;
-    if (isIgnored(entry.value) || Object.isFrozen(entry.value)) continue;
-    if (!entry.writable) throw nonWritablePropertyError(node, [...route, entry.key]);
-  }
-};
-var descend = (handle, node, route, checked) => {
-  const entries = walkDataEntries(node);
-  if (checked) checkNode(node, entries, route);
-  for (const entry of entries) {
-    if (isTrackedEntry(entry.value, entry.writable))
-      attach(handle, node, entry.key, entry.value, [...route, entry.key]);
-  }
-};
-var flip = (handle, node, route) => {
-  const membership = recordOf(node)?.memberships.get(handle);
-  if (!membership?.exempt) return;
-  membership.exempt = false;
-  const entries = walkDataEntries(node);
-  checkNode(node, entries, route);
-  for (const entry of entries) {
-    if (!isTrackedEntry(entry.value, entry.writable)) continue;
-    const child = rawOf(entry.value);
-    if (recordOf(child)?.memberships.has(handle) === true) flip(handle, child, [...route, entry.key]);
-  }
-};
-var cascade = (handle, node, keys) => {
-  for (const key of keys) {
-    const value = Reflect.get(node, key);
-    if (typeof value !== "object" || value === null) continue;
-    const child = rawOf(value);
-    if (recordOf(child)?.memberships.has(handle) === true) detach(handle, child);
-  }
-};
-function attach(handle, parent, key, child, route) {
-  const parentMembership = recordOf(parent)?.memberships.get(handle);
-  if (parentMembership === void 0) return;
-  parentMembership.keys.add(key);
-  const rawChild = rawOf(child);
-  proxyOf(rawChild);
-  const record = recordOf(rawChild);
-  if (record === void 0) return;
-  const edgeExempt = parentMembership.exempt || isUnsafeMarked(rawChild);
-  const membership = record.memberships.get(handle);
-  if (membership === void 0) {
-    record.memberships.set(handle, { edges: 1, exempt: edgeExempt, keys: /* @__PURE__ */ new Set() });
-    descend(handle, rawChild, route, !edgeExempt);
-    return;
-  }
-  membership.edges += 1;
-  if (membership.exempt && !edgeExempt) flip(handle, rawChild, route);
-}
-function attachRoot(handle, root, exempt) {
-  const record = recordOf(root);
-  if (record === void 0) return;
-  record.memberships.set(handle, { edges: 1, exempt, keys: /* @__PURE__ */ new Set() });
-  try {
-    descend(handle, root, [], !exempt);
-  } catch (error) {
-    evict(handle, root);
-    throw error;
-  }
-}
-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/utils/predicates.ts
-var isObjectLike = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-
-// src/identity.ts
-var readProxyTargets = /* @__PURE__ */ new WeakMap();
-var identityRecords = /* @__PURE__ */ new WeakMap();
-var nextInternId = 0;
-var registerReadProxyTarget = (readProxy, target) => {
-  readProxyTargets.set(readProxy, target);
-};
-var getRegisteredReadProxyTarget = (readProxy) => readProxyTargets.get(readProxy);
-function resolveIdentity(value) {
-  let current = value;
-  while (isObjectLike(current)) {
-    const readTarget = getRegisteredReadProxyTarget(current);
-    if (readTarget !== void 0 && readTarget !== current) {
-      current = readTarget;
-      continue;
-    }
-    const raw = rawOf(current);
-    if (raw !== current) {
-      current = raw;
-      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
-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 current;
-}
-
-// src/handle.ts
-function handleOf(state) {
-  const peeled = peelReadProxy(state);
-  if (!isObjectLike(peeled)) return void 0;
-  const raw = rawOf(peeled);
-  const record = recordOf(raw);
-  if (record === void 0) return void 0;
-  for (const handle of record.memberships.keys()) {
-    if (handle.root === raw) return handle;
-  }
-  return void 0;
-}
-function requireHandle(state, message) {
-  const handle = handleOf(state);
-  if (handle === void 0) throw new Error(message);
-  return handle;
-}
-
-// src/batch.ts
-var metaStack = [];
-function currentMeta() {
-  return metaStack.length === 0 ? void 0 : metaStack[metaStack.length - 1];
-}
-function batch(callback, meta) {
-  metaStack.push(meta);
-  try {
-    callback();
-  } finally {
-    metaStack.pop();
-  }
-}
-
-// src/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);
-    }
-  }
-};
-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);
-  }
-  raiseFailures(failures);
-};
-
-// 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;
-  }
-  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);
-  };
-  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));
-  }
-  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);
-  }
-  const dirty = { edges, nodes };
-  enqueueDelivery(prepareDelivery(handle, operations, dirty));
-  drainDeliveries();
-}
-
-// src/proxy.ts
-var prototypeFunctionOf = (target, key) => {
-  for (let holder = Reflect.getPrototypeOf(target); holder !== null; holder = Reflect.getPrototypeOf(holder)) {
-    const descriptor = Reflect.getOwnPropertyDescriptor(holder, key);
-    if (descriptor === void 0) continue;
-    const method = "value" in descriptor ? descriptor.value : void 0;
-    return typeof method === "function" ? method : void 0;
-  }
-  return void 0;
-};
-var isRideAlongKey = (target, key) => {
-  if (key === "__proto__") return true;
-  if (key === "length") return false;
-  const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-  return descriptor?.enumerable === false;
-};
-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 proxied = (value) => isObjectLike(value) ? recordOf(value)?.proxy ?? value : value;
-var truncatedOwnEntriesOf = (target, next) => {
-  if (!Array.isArray(target)) return [];
-  const coercible = next === null || typeof next !== "object" && typeof next !== "function";
-  const newLength = coercible ? Number(next) : Number.NaN;
-  if (!Number.isInteger(newLength) || newLength < 0 || newLength >= target.length) return [];
-  const truncated = new Array();
-  for (let index = newLength; index < target.length; index += 1) {
-    const key = String(index);
-    const descriptor = Reflect.getOwnPropertyDescriptor(target, key);
-    if (descriptor === void 0 || !("value" in descriptor)) continue;
-    truncated.push({
-      key,
-      value: descriptor.value,
-      writable: descriptor.writable === true
-    });
-  }
-  return truncated;
-};
-var 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;
-    }
-    return recordOf(value)?.proxy ?? value;
-  },
-  set(target, key, value, receiver) {
-    if (typeof key !== "string" || writesThroughAccessor(target, key) || isRideAlongKey(target, key)) {
-      return Reflect.set(target, key, value, receiver);
-    }
-    const { hadPrevious, previous } = ownDataDescriptor(target, key);
-    const resolved = isObjectLike(value) ? rawOf(value) : value;
-    const memberships = membershipsOf(target).map(([handle, membership]) => ({
-      handle,
-      membership,
-      hadKey: membership.keys.has(key)
-    }));
-    const truncated = key === "length" ? truncatedOwnEntriesOf(target, resolved) : [];
-    const previousLength = Array.isArray(target) ? target.length : void 0;
-    if (typeof resolved === "function" && memberships.some(({ membership }) => !membership.exempt)) {
-      const kind = classifyValue(target);
-      if (kind !== "plain" && kind !== "plainArray") throw rejectionError(target, kind, [key]);
-    }
-    const incoming = resolved !== previous && isTrackedEntry(resolved, true) ? resolved : void 0;
-    let rollBack;
-    if (incoming !== void 0) {
-      const started = new Array();
-      rollBack = () => {
-        for (const { handle, membership, hadKey } of started) {
-          detach(handle, incoming);
-          if (!hadKey) membership.keys.delete(key);
-        }
-      };
-      try {
-        for (const write of memberships) {
-          started.push(write);
-          attach(write.handle, target, key, incoming, [key]);
-        }
-      } catch (error) {
-        rollBack();
-        throw error;
-      }
-    }
-    const result = Reflect.set(target, key, resolved, receiver);
-    if (!result) {
-      rollBack?.();
-      return result;
-    }
-    const meta = currentMeta();
-    const node = proxyOf(target);
-    for (const { handle, membership, hadKey } of memberships) {
-      for (const entry of truncated) {
-        if (membership.keys.delete(entry.key) && isObjectLike(entry.value)) detach(handle, entry.value);
-        recordOperation(handle, target, {
-          node,
-          key: entry.key,
-          meta,
-          before: proxied(entry.value),
-          hasBefore: true,
-          hasAfter: false
-        });
-      }
-      if (hadKey && previous !== resolved) {
-        if (isObjectLike(previous)) detach(handle, previous);
-        if (incoming === void 0) membership.keys.delete(key);
-      }
-      recordOperation(handle, target, {
-        node,
-        key,
-        meta,
-        before: proxied(previous),
-        after: proxied(resolved),
-        hasBefore: hadPrevious,
-        hasAfter: true
-      });
-      if (key !== "length" && Array.isArray(target) && previousLength !== target.length) {
-        recordOperation(handle, target, {
-          node,
-          key: "length",
-          meta,
-          before: previousLength,
-          after: target.length,
-          hasBefore: true,
-          hasAfter: true
-        });
-      }
-    }
-    return result;
-  },
-  deleteProperty(target, key) {
-    if (typeof key !== "string" || isRideAlongKey(target, key)) return Reflect.deleteProperty(target, key);
-    const { hadPrevious, previous } = ownDataDescriptor(target, key);
-    const result = Reflect.deleteProperty(target, key);
-    if (!result || !hadPrevious) return result;
-    const meta = currentMeta();
-    const node = proxyOf(target);
-    for (const [handle, membership] of membershipsOf(target)) {
-      if (membership.keys.delete(key) && isObjectLike(previous)) detach(handle, previous);
-      recordOperation(handle, target, {
-        node,
-        key,
-        meta,
-        before: proxied(previous),
-        hasBefore: true,
-        hasAfter: false
-      });
-    }
-    return result;
-  },
-  preventExtensions(target) {
-    for (const [handle] of membershipsOf(target)) evict(handle, target);
-    return Reflect.preventExtensions(target);
-  },
-  defineProperty(target, key, descriptor) {
-    return Reflect.defineProperty(target, key, descriptor);
-  },
-  setPrototypeOf(target, prototype) {
-    return Reflect.setPrototypeOf(target, prototype);
-  },
-  has(target, key) {
-    return Reflect.has(target, key);
-  },
-  ownKeys(target) {
-    return Reflect.ownKeys(target);
-  },
-  getOwnPropertyDescriptor(target, key) {
-    return Reflect.getOwnPropertyDescriptor(target, key);
-  }
-};
-
-// src/createMutableState.ts
-installProxyHandler(handler);
-function createMutableState(properties, options) {
-  const incoming = peelReadProxy(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/isState.ts
-function isState(value) {
-  const resolved = peelReadProxy(value);
-  if (typeof resolved !== "object" || resolved === null) return false;
-  return recordOf(resolved)?.proxy === resolved;
-}
+import { addressOf, flushWindow, requireHandle, isSameIdentity } from './chunk-4JZIOHSP.js';
+export { batch, createMutableState, identify, ignore, isSameIdentity, isState, subscribe, unsafeTrack } from './chunk-4JZIOHSP.js';
 
 // src/tracked/facadeGuard.ts
 var assertMutableFacade = (facade, mutationKey) => {
@@ -900,38 +211,6 @@ Object.defineProperty(TrackedDate.prototype, Symbol.toStringTag, {
   writable: false
 });
 
-// src/tracked/address.ts
-var UnsupportedKeyTypeError = class extends Error {
-  constructor(key) {
-    super(`opshot: addressOf received unsupported key type ${typeof key}`);
-    this.name = "UnsupportedKeyTypeError";
-  }
-};
-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 UnsupportedKeyTypeError(key);
-  }
-};
-
 // src/tracked/slotStore.ts
 var swapChain = /* @__PURE__ */ new WeakMap();
 var compactStore = (store, addressOfEntry) => {
@@ -1005,10 +284,10 @@ var EmptyMapSlotError = class extends Error {
     this.name = "EmptyMapSlotError";
   }
 };
-var isObjectLike2 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+var isObjectLike = (value) => value !== null && (typeof value === "object" || typeof value === "function");
 var isStoredValue = (stored, incoming) => {
   if (Object.is(stored, incoming)) return true;
-  return isObjectLike2(stored) && isObjectLike2(incoming) && isSameIdentity(stored, incoming);
+  return isObjectLike(stored) && isObjectLike(incoming) && isSameIdentity(stored, incoming);
 };
 var TrackedMap = class {
   constructor(entries) {
@@ -1157,535 +436,9 @@ Object.defineProperty(TrackedSet.prototype, Symbol.toStringTag, {
   writable: false
 });
 
-// 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 (!isTrackedEntry(value, mode === "entry" || writable)) return "skip";
-  if (isState(value)) return "state";
-  if (canRebuild(value)) return "descend";
-  return "skip";
-};
-var readVerdict = (container, pass) => pass.verdicts.get(container) ?? stateKeysByContainer.get(container) ?? noStateKeys;
-var createDiscoveryPass = () => ({
-  entriesByContainer: /* @__PURE__ */ new Map(),
-  verdicts: /* @__PURE__ */ new Map(),
-  inProgress: /* @__PURE__ */ new Set(),
-  relaxable: /* @__PURE__ */ new Set()
-});
-function visitContainer(container, pass, mode) {
-  if (mode === "nested" && stateKeysByContainer.has(container)) return false;
-  if (pass.inProgress.has(container)) return true;
-  if (pass.verdicts.has(container)) return pass.relaxable.has(container);
-  pass.inProgress.add(container);
-  const entries = walkDataEntries(container);
-  const keys = /* @__PURE__ */ new Set();
-  let dependedOnBackEdge = false;
-  pass.entriesByContainer.set(container, entries);
-  for (const entry of entries) {
-    const role = childRole(entry.value, entry.writable, mode);
-    if (role === "state") {
-      keys.add(entry.key);
-      continue;
-    }
-    if (role !== "descend") continue;
-    const child = entry.value;
-    if (typeof child !== "object" || child === null) continue;
-    if (visitContainer(child, pass, "nested")) dependedOnBackEdge = true;
-    if (readVerdict(child, pass).size > 0) keys.add(entry.key);
-  }
-  pass.inProgress.delete(container);
-  pass.verdicts.set(container, keys);
-  if (dependedOnBackEdge) pass.relaxable.add(container);
-  return dependedOnBackEdge;
-}
-function relaxVerdicts(pass, entryContainer) {
-  let gained = true;
-  while (gained) {
-    gained = false;
-    for (const container of pass.relaxable) {
-      const keys = pass.verdicts.get(container);
-      const entries = pass.entriesByContainer.get(container);
-      if (keys === void 0 || entries === void 0) continue;
-      for (const entry of entries) {
-        if (keys.has(entry.key)) continue;
-        if (childRole(entry.value, entry.writable, container === entryContainer ? "entry" : "nested") !== "descend")
-          continue;
-        const child = entry.value;
-        if (typeof child !== "object" || child === null) continue;
-        if (readVerdict(child, pass).size === 0) continue;
-        keys.add(entry.key);
-        gained = true;
-      }
-    }
-  }
-}
-var cacheNestedVerdicts = (pass, skip) => {
-  for (const [visited, keys] of pass.verdicts) {
-    if (visited === skip) continue;
-    stateKeysByContainer.set(visited, keys);
-  }
-};
-function discoverStateKeys(container) {
-  const cached = stateKeysByContainer.get(container);
-  if (cached !== void 0) return cached;
-  if (isReactOwnNode(container)) return noStateKeys;
-  if (Object.isFrozen(container) || !canRebuild(container)) return noStateKeys;
-  const pass = createDiscoveryPass();
-  visitContainer(container, pass, "nested");
-  relaxVerdicts(pass);
-  cacheNestedVerdicts(pass);
-  return pass.verdicts.get(container) ?? noStateKeys;
-}
-function substituteContainer(container, substitution, wrap, mode) {
-  const rebuilt = substitution.rebuiltByContainer.get(container);
-  if (rebuilt !== void 0) return rebuilt;
-  let stateKeys;
-  if (mode === "nested") {
-    stateKeys = discoverStateKeys(container);
-  } else {
-    const pass = createDiscoveryPass();
-    visitContainer(container, pass, "entry");
-    relaxVerdicts(pass, container);
-    cacheNestedVerdicts(pass, container);
-    stateKeys = pass.verdicts.get(container) ?? noStateKeys;
-  }
-  if (stateKeys.size === 0) {
-    substitution.rebuiltByContainer.set(container, container);
-    return container;
-  }
-  const clone = Array.isArray(container) ? [] : {};
-  Reflect.setPrototypeOf(clone, Reflect.getPrototypeOf(container));
-  substitution.rebuiltByContainer.set(container, clone);
-  const descriptors = Object.getOwnPropertyDescriptors(container);
-  for (const key of stateKeys) {
-    const descriptor = descriptors[key];
-    if (descriptor === void 0 || !("value" in descriptor)) continue;
-    const value = descriptor.value;
-    const role = childRole(value, descriptor.writable === true, mode);
-    if (role === "state") {
-      const source = peelReadProxy(value);
-      if (typeof source !== "object" || source === null) continue;
-      if (!substitution.visitedSources.has(source)) {
-        substitution.visitedSources.add(source);
-        substitution.sources.push(source);
-      }
-      descriptors[key] = { ...descriptor, value: wrap(source) };
-      continue;
-    }
-    if (role !== "descend") continue;
-    if (typeof value !== "object" || value === null) continue;
-    descriptors[key] = { ...descriptor, value: substituteContainer(value, substitution, wrap, "nested") };
-  }
-  Object.defineProperties(clone, descriptors);
-  return clone;
-}
-function substituteStates(root, wrap) {
-  const substitution = {
-    rebuiltByContainer: /* @__PURE__ */ new Map(),
-    sources: [],
-    visitedSources: /* @__PURE__ */ new Set()
-  };
-  if (isReactOwnNode(root) || !canRebuild(root)) {
-    return { props: root, sources: substitution.sources };
-  }
-  return { props: substituteContainer(root, substitution, wrap, "entry"), sources: substitution.sources };
-}
-var NO_SLOT = /* @__PURE__ */ Symbol("opshot.noDispatcherSlot");
-var readDispatcher = () => {
-  const internals = React;
-  const modern = internals.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE;
-  if (modern !== void 0) return modern.H;
-  const legacy = internals.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED?.ReactCurrentDispatcher;
-  if (legacy !== void 0) return legacy.current;
-  return NO_SLOT;
-};
-var nonRenderDispatcher;
-var learnNonRenderDispatcher = () => {
-  const current = readDispatcher();
-  if (current === NO_SLOT || current === null || current === void 0) return;
-  nonRenderDispatcher = current;
-};
-var isRendering = () => {
-  if (nonRenderDispatcher === void 0) return false;
-  const current = readDispatcher();
-  if (current === NO_SLOT || current === null || current === void 0) return false;
-  return current !== nonRenderDispatcher;
-};
-
-// src/react/readTracker.ts
-var KEYS_PROPERTY = "k";
-var HAS_KEY_PROPERTY = "h";
-var HAS_OWN_KEY_PROPERTY = "o";
-var ALL_OWN_KEYS_PROPERTY = "w";
-var isWriteProxy = (value) => recordOf(value)?.proxy === value;
-var getUsage = (affected, target) => {
-  let used = affected.get(target);
-  if (used === void 0) {
-    used = {};
-    affected.set(target, used);
-  }
-  return used;
-};
-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);
-  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 UnregisteredReadTrackerError = class extends Error {
-  constructor() {
-    super("opshot: readsIntersectDirty received an unregistered tracker");
-    this.name = "UnregisteredReadTrackerError";
-  }
-};
-var trackerPartitions = /* @__PURE__ */ new WeakMap();
-var partitionsOf = (tracker) => {
-  const partitions = trackerPartitions.get(tracker);
-  if (partitions === void 0) throw new UnregisteredReadTrackerError();
-  return partitions;
-};
-var recordedKeysOf = (used) => {
-  const keyMaps = new Array();
-  if (used[KEYS_PROPERTY] !== void 0) keyMaps.push(used[KEYS_PROPERTY]);
-  if (used[HAS_KEY_PROPERTY] !== void 0) keyMaps.push(used[HAS_KEY_PROPERTY]);
-  if (used[HAS_OWN_KEY_PROPERTY] !== void 0) keyMaps.push(used[HAS_OWN_KEY_PROPERTY]);
-  return keyMaps;
-};
-function readsIntersectDirty(tracker, dirty) {
-  for (const partition of partitionsOf(tracker).values()) {
-    for (const [writeProxy, used] of partition.affected) {
-      const raw = rawOf(writeProxy);
-      const edges = dirty.edges.get(raw);
-      for (const keys of recordedKeysOf(used)) {
-        for (const key of keys.keys()) {
-          if (typeof key === "symbol") continue;
-          if (edges?.has(key) === true) return true;
-        }
-      }
-      if (used[ALL_OWN_KEYS_PROPERTY] !== void 0 && dirty.nodes.has(raw)) return true;
-    }
-    for (const writeProxy of partition.identityReads) {
-      if (partition.affected.has(writeProxy)) continue;
-      if (dirty.nodes.has(rawOf(writeProxy))) return true;
-    }
-  }
-  return false;
-}
-function readsChanged(tracker) {
-  for (const partition of partitionsOf(tracker).values()) {
-    for (const [writeProxy, used] of partition.affected) {
-      const gets = used[KEYS_PROPERTY];
-      if (gets !== void 0) {
-        for (const [key, stored] of gets) {
-          if (!Object.is(Reflect.get(writeProxy, key, writeProxy), stored)) return true;
-        }
-      }
-      const hasKeys = used[HAS_KEY_PROPERTY];
-      if (hasKeys !== void 0) {
-        for (const [key, stored] of hasKeys) {
-          if (!Object.is(Reflect.has(writeProxy, key), stored)) return true;
-        }
-      }
-      const ownKeys = used[HAS_OWN_KEY_PROPERTY];
-      if (ownKeys !== void 0) {
-        for (const [key, stored] of ownKeys) {
-          const present = Reflect.getOwnPropertyDescriptor(writeProxy, key) !== void 0;
-          if (!Object.is(present, stored)) return true;
-        }
-      }
-      const listed = used[ALL_OWN_KEYS_PROPERTY];
-      if (listed !== void 0) {
-        const current = Reflect.ownKeys(writeProxy);
-        if (current.length !== listed.length) return true;
-        for (let index = 0; index < listed.length; index += 1) {
-          if (!Object.is(current[index], listed[index])) return true;
-        }
-      }
-    }
-  }
-  return false;
-}
-function createReadTracker() {
-  const partitions = /* @__PURE__ */ new Map();
-  let afterRender = false;
-  let releasing = false;
-  const getPartition = (writeProxy) => {
-    let partition = partitions.get(writeProxy);
-    if (partition === void 0) {
-      partition = {
-        affected: /* @__PURE__ */ new Map(),
-        identityReads: /* @__PURE__ */ new Set(),
-        proxyCache: /* @__PURE__ */ new WeakMap()
-      };
-      partitions.set(writeProxy, partition);
-    }
-    return partition;
-  };
-  const shouldRecord = () => !afterRender || isRendering();
-  const trackUsage = (partition, writeProxy) => shouldRecord() ? getUsage(partition.affected, writeProxy) : {};
-  const recordIdentity = (partition, value) => {
-    if (!shouldRecord()) return;
-    if (isObjectLike(value) && isWriteProxy(value)) partition.identityReads.add(value);
-  };
-  const toReadProxy = (writeProxy, partition) => {
-    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) => {
-      const existing = boundMethods.get(method);
-      if (existing !== void 0) return existing;
-      const bound = Function.prototype.bind.call(method, readProxy2);
-      boundMethods.set(method, bound);
-      return bound;
-    };
-    const handler2 = {
-      get(_target, prop) {
-        const readProxy2 = readProxyBox.current;
-        const value = Reflect.get(writeProxy, prop, readProxy2 ?? writeProxy);
-        const used = trackUsage(partition, writeProxy);
-        recordGet(used, prop, value);
-        recordIdentity(partition, value);
-        if (typeof value === "function") {
-          const method = getPrototypeMethod(target, prop);
-          if (method !== void 0 && value === method && readProxy2 !== void 0) {
-            return bindMethodToReadProxy(readProxy2, method);
-          }
-        }
-        if (!isObjectLike(value)) return value;
-        if (typeof value === "function") return value;
-        if (!isWriteProxy(value)) return value;
-        return toReadProxy(value, partition);
-      },
-      has(_target, prop) {
-        const used = trackUsage(partition, writeProxy);
-        const result = Reflect.has(writeProxy, prop);
-        recordHas(used, prop, result);
-        return result;
-      },
-      getOwnPropertyDescriptor(_target, prop) {
-        const used = trackUsage(partition, writeProxy);
-        const descriptor = Reflect.getOwnPropertyDescriptor(writeProxy, prop);
-        recordOwn(used, prop, descriptor !== void 0);
-        return descriptor;
-      },
-      ownKeys() {
-        const used = trackUsage(partition, 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);
-      },
-      deleteProperty(_target, prop) {
-        return Reflect.deleteProperty(writeProxy, prop);
-      }
-    };
-    const readProxy = new Proxy(writeProxy, handler2);
-    readProxyBox.current = readProxy;
-    registerReadProxyTarget(readProxy, writeProxy);
-    partition.proxyCache.set(raw, readProxy);
-    return readProxy;
-  };
-  const tracker = {
-    wrap(writeProxy) {
-      if (!isWriteProxy(writeProxy)) {
-        throw new Error("opshot: ReadTracker.wrap requires a write proxy");
-      }
-      const partition = getPartition(writeProxy);
-      return toReadProxy(writeProxy, partition);
-    },
-    captureReads() {
-      learnNonRenderDispatcher();
-      afterRender = true;
-    },
-    resetReads() {
-      afterRender = false;
-      for (const partition of partitions.values()) {
-        partition.affected.clear();
-        partition.identityReads.clear();
-        partition.proxyCache = /* @__PURE__ */ new WeakMap();
-      }
-    },
-    retain() {
-      releasing = false;
-    },
-    dispose() {
-      releasing = true;
-      void Promise.resolve().then(() => {
-        if (!releasing) return;
-        releasing = false;
-        partitions.clear();
-      });
-    }
-  };
-  trackerPartitions.set(tracker, partitions);
-  return tracker;
-}
-var useCommitEffect = typeof document === "undefined" ? useEffect : useLayoutEffect;
-
-// src/react/scope.tsx
-var sourcesKey = (sources) => `${sources.length}:${sources.map((source) => addressOf(source)).join(",")}`;
-var uniqueHandlesOf = (nodes) => {
-  const unique = new Array();
-  const seen = /* @__PURE__ */ new Set();
-  for (const node of nodes) {
-    for (const handle of handlesOf(node)) {
-      if (seen.has(handle)) continue;
-      seen.add(handle);
-      unique.push(handle);
-    }
-  }
-  return unique;
-};
-var arePropsEqual = (previous, next) => {
-  const previousRecord = previous;
-  const nextRecord = next;
-  const keys = Object.keys(previousRecord);
-  if (keys.length !== Object.keys(nextRecord).length) return false;
-  for (const key of keys) {
-    const before = previousRecord[key];
-    const after = nextRecord[key];
-    if (Object.is(before, after)) continue;
-    if (typeof before === "object" && before !== null && typeof after === "object" && after !== null && isState(before) && isState(after) && isSameIdentity(before, after)) {
-      continue;
-    }
-    return false;
-  }
-  return true;
-};
-function scope(Component) {
-  const Scoped = (props) => {
-    const readTrackerRef = useRef(void 0);
-    const currentHandlesRef = useRef([]);
-    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);
-    useCommitEffect(() => {
-      currentHandlesRef.current = uniqueHandles;
-      readTracker.captureReads();
-    });
-    useEffect(() => {
-      readTracker.retain();
-      return () => readTracker.dispose();
-    }, [readTracker]);
-    useEffect(() => {
-      let cancelled = false;
-      const subscribedHandles = uniqueHandlesOf(sources);
-      const unsubscribes = subscribedHandles.map(
-        (handle) => subscribe(proxyOf(handle.root), () => {
-          if (cancelled) return;
-          const dirty = handle.lastDirty;
-          if (dirty !== void 0 && readsIntersectDirty(readTracker, dirty)) bump();
-        })
-      );
-      if (readsChanged(readTracker)) bump();
-      return () => {
-        cancelled = true;
-        for (const unsubscribe of unsubscribes) unsubscribe();
-      };
-    }, [sourcesKey(sources), readTracker]);
-    return createElement(Component, renderedProps);
-  };
-  const baseName = Component.displayName ?? Component.name;
-  Scoped.displayName = `scope(${typeof baseName === "string" && baseName !== "" ? baseName : "Component"})`;
-  return memo(Scoped, arePropsEqual);
-}
-var isObjectLike3 = (value) => value !== null && (typeof value === "object" || typeof value === "function");
-function useMutableState(properties, options) {
-  const [{ writeProxy, readTracker }] = useState(() => {
-    const initial = typeof properties === "function" ? properties() : properties;
-    return {
-      writeProxy: createMutableState(initial, options),
-      readTracker: createReadTracker()
-    };
-  });
-  const [, bump] = useReducer((value) => value + 1, 0);
-  const currentHandlesRef = useRef([]);
-  const uniqueHandles = isObjectLike3(writeProxy) ? handlesOf(writeProxy) : [];
-  readTracker.resetReads();
-  const readProxy = isObjectLike3(writeProxy) ? readTracker.wrap(writeProxy) : writeProxy;
-  useCommitEffect(() => {
-    currentHandlesRef.current = uniqueHandles;
-    readTracker.captureReads();
-  });
-  useEffect(() => {
-    readTracker.retain();
-    return () => readTracker.dispose();
-  }, [readTracker]);
-  useEffect(() => {
-    let cancelled = false;
-    const subscribedHandles = isObjectLike3(writeProxy) ? handlesOf(writeProxy) : [];
-    const unsubscribes = subscribedHandles.map(
-      (handle) => subscribe(proxyOf(handle.root), () => {
-        if (cancelled) return;
-        const dirty = handle.lastDirty;
-        if (dirty !== void 0 && readsIntersectDirty(readTracker, dirty)) bump();
-      })
-    );
-    if (readsChanged(readTracker)) bump();
-    return () => {
-      cancelled = true;
-      for (const unsubscribe of unsubscribes) unsubscribe();
-    };
-  }, [writeProxy, readTracker]);
-  return readProxy;
+function flush(state, ...states) {
+  for (const target of [state, ...states]) flushWindow(requireHandle(target, "opshot: flush requires a state"));
 }
 
-export { TrackedDate, TrackedMap, TrackedSet, batch, createMutableState, flush, identify, ignore, isSameIdentity, isState, scope, subscribe, unsafeTrack, useMutableState };
+export { TrackedDate, TrackedMap, TrackedSet, flush };