opshot 0.5.2 → 0.6.0

package/dist/chunk-4JZIOHSP.js

@@ -0,0 +1,768 @@
+// src/readProxyRegistry.ts
+var readProxyTargets = /* @__PURE__ */ new WeakMap();
+var registerReadProxyTarget = (readProxy, target) => {
+  readProxyTargets.set(readProxy, target);
+};
+var getRegisteredReadProxyTarget = (readProxy) => readProxyTargets.get(readProxy);
+
+// src/utils/predicates.ts
+var isObjectLike = (value) => value !== null && (typeof value === "object" || typeof value === "function");
+
+// 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/node.ts
+var byRaw = /* @__PURE__ */ new WeakMap();
+var byProxy = /* @__PURE__ */ new WeakMap();
+var versions = /* @__PURE__ */ new WeakMap();
+var versionOf = (raw) => versions.get(raw) ?? 0;
+var bumpVersion = (raw) => {
+  versions.set(raw, versionOf(raw) + 1);
+};
+var proxyHandler;
+function installProxyHandler(handler2) {
+  proxyHandler = handler2;
+}
+function recordOf(value) {
+  const peeled = peelReadProxy(value);
+  return byRaw.get(peeled) ?? byProxy.get(peeled);
+}
+function rawOf(value) {
+  return recordOf(value)?.raw ?? peelReadProxy(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/batch.ts
+var metaStack = [];
+function currentMeta() {
+  return metaStack.length === 0 ? void 0 : metaStack[metaStack.length - 1];
+}
+var isThenable = (value) => isObjectLike(value) && "then" in value && typeof value.then === "function";
+function batch(callback, meta) {
+  metaStack.push(meta);
+  let result;
+  try {
+    result = callback();
+  } finally {
+    metaStack.pop();
+  }
+  if (isThenable(result))
+    throw new TypeError("opshot: batch requires a synchronous callback; writes after an await would carry no meta");
+}
+
+// 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/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, node, 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);
+  const rawParent = rawOf(parent);
+  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(),
+      parents: /* @__PURE__ */ new Map([[rawParent, 1]])
+    });
+    descend(handle, rawChild, route, !edgeExempt);
+    return;
+  }
+  membership.edges += 1;
+  membership.parents.set(rawParent, (membership.parents.get(rawParent) ?? 0) + 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(), parents: /* @__PURE__ */ new Map() });
+  try {
+    descend(handle, root, [], !exempt);
+  } catch (error) {
+    evict(handle, root);
+    throw error;
+  }
+}
+function detach(handle, parent, 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;
+  const rawParent = rawOf(parent);
+  const parentEdges = membership.parents.get(rawParent);
+  if (parentEdges === 1) membership.parents.delete(rawParent);
+  else if (parentEdges !== void 0) membership.parents.set(rawParent, parentEdges - 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/handle.ts
+function handleOf(state) {
+  const raw = rawOf(state);
+  const record = recordOf(raw);
+  if (record === void 0) return void 0;
+  for (const handle of record.memberships.keys()) {
+    if (handle.root === raw) return handle;
+  }
+  return void 0;
+}
+function requireHandle(state, message) {
+  const handle = handleOf(state);
+  if (handle === void 0) throw new Error(message);
+  return handle;
+}
+
+// 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 node = item.node;
+    const operation = item.hasBefore ? item.hasAfter ? { node, key: item.key, meta: item.meta, kind: "change", before: item.before, after: item.after } : { node, key: item.key, meta: item.meta, kind: "delete", before: item.before } : { node, key: item.key, meta: item.meta, kind: "add", 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 };
+  const pendingNodes = [...dirty.nodes];
+  const visited = /* @__PURE__ */ new Set();
+  while (pendingNodes.length > 0) {
+    const raw = pendingNodes.pop();
+    if (raw === void 0 || visited.has(raw)) continue;
+    visited.add(raw);
+    bumpVersion(raw);
+    const parents = recordOf(raw)?.memberships.get(handle)?.parents;
+    if (parents !== void 0) pendingNodes.push(...parents.keys());
+  }
+  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, target, 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, target, 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, target, 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, target, 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/identity.ts
+var identityRecords = /* @__PURE__ */ new WeakMap();
+var nextInternId = 0;
+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/isState.ts
+function isState(value) {
+  const resolved = peelReadProxy(value);
+  if (typeof resolved !== "object" || resolved === null) return false;
+  return recordOf(resolved)?.proxy === resolved;
+}
+
+// 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/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);
+  }
+};
+
+export { addressOf, batch, classifyValue, createMutableState, flushWindow, handlesOf, identify, ignore, isDangerousKind, isObjectLike, isSameIdentity, isState, isTrackedEntry, peelReadProxy, proxyOf, rawOf, recordOf, registerReadProxyTarget, requireHandle, subscribe, unsafeTrack, versionOf, walkDataEntries };