jotai-state-tree 1.4.4 → 1.5.0

package/dist/chunk-MEX2M3XM.mjs

@@ -0,0 +1,3984 @@
+// src/primitives.ts
+function createSimpleType(name, validator, defaultValue) {
+  return {
+    name,
+    _kind: "simple",
+    _C: void 0,
+    _S: void 0,
+    _T: void 0,
+    create(snapshot) {
+      if (snapshot === void 0) {
+        if (defaultValue !== void 0) {
+          return defaultValue;
+        }
+        throw new Error(`[jotai-state-tree] A value of type '${name}' is required`);
+      }
+      if (!validator(snapshot)) {
+        throw new Error(
+          `[jotai-state-tree] Value '${String(snapshot)}' is not a valid '${name}'`
+        );
+      }
+      return snapshot;
+    },
+    is(value) {
+      return validator(value);
+    },
+    validate(value, context) {
+      if (validator(value)) {
+        return { valid: true, errors: [] };
+      }
+      return {
+        valid: false,
+        errors: [
+          {
+            context,
+            value,
+            message: `Value '${String(value)}' is not a valid '${name}'`
+          }
+        ]
+      };
+    }
+  };
+}
+var string = createSimpleType(
+  "string",
+  (value) => typeof value === "string"
+);
+var number = createSimpleType(
+  "number",
+  (value) => typeof value === "number" && !isNaN(value)
+);
+var integer = createSimpleType(
+  "integer",
+  (value) => typeof value === "number" && !isNaN(value) && Number.isInteger(value)
+);
+var boolean = createSimpleType(
+  "boolean",
+  (value) => typeof value === "boolean"
+);
+var DatePrimitive = {
+  name: "Date",
+  _kind: "simple",
+  _C: void 0,
+  _S: void 0,
+  _T: void 0,
+  create(snapshot) {
+    if (snapshot === void 0) {
+      return /* @__PURE__ */ new Date();
+    }
+    if (snapshot instanceof Date) {
+      return snapshot;
+    }
+    if (typeof snapshot === "number") {
+      return new Date(snapshot);
+    }
+    throw new Error(`[jotai-state-tree] Value is not a valid Date`);
+  },
+  is(value) {
+    return value instanceof Date;
+  },
+  validate(value, context) {
+    if (value instanceof Date || typeof value === "number") {
+      return { valid: true, errors: [] };
+    }
+    return {
+      valid: false,
+      errors: [
+        {
+          context,
+          value,
+          message: "Value is not a valid Date"
+        }
+      ]
+    };
+  }
+};
+var nullType = createSimpleType(
+  "null",
+  (value) => value === null
+);
+var undefinedType = createSimpleType(
+  "undefined",
+  (value) => value === void 0
+);
+var identifier = {
+  ...createSimpleType(
+    "identifier",
+    (value) => typeof value === "string"
+  ),
+  _kind: "identifier",
+  identifierAttribute: "id"
+};
+var identifierNumber = {
+  ...createSimpleType(
+    "identifierNumber",
+    (value) => typeof value === "number" && !isNaN(value)
+  ),
+  _kind: "identifierNumber",
+  identifierAttribute: "id"
+};
+function literal(value) {
+  return {
+    name: `literal(${JSON.stringify(value)})`,
+    _kind: "literal",
+    _value: value,
+    _C: void 0,
+    _S: void 0,
+    _T: void 0,
+    create(snapshot) {
+      if (snapshot === void 0) {
+        return value;
+      }
+      if (snapshot !== value) {
+        throw new Error(
+          `[jotai-state-tree] Value '${String(snapshot)}' is not the literal '${String(value)}'`
+        );
+      }
+      return snapshot;
+    },
+    is(v) {
+      return v === value;
+    },
+    validate(v, context) {
+      if (v === value) {
+        return { valid: true, errors: [] };
+      }
+      return {
+        valid: false,
+        errors: [
+          {
+            context,
+            value: v,
+            message: `Value '${String(v)}' is not the literal '${String(value)}'`
+          }
+        ]
+      };
+    }
+  };
+}
+function enumeration(nameOrOptions, maybeOptions) {
+  const name = typeof nameOrOptions === "string" ? nameOrOptions : "enumeration";
+  const options = typeof nameOrOptions === "string" ? maybeOptions : nameOrOptions;
+  const optionSet = new Set(options);
+  return {
+    name,
+    _kind: "enumeration",
+    _options: options,
+    _C: void 0,
+    _S: void 0,
+    _T: void 0,
+    create(snapshot) {
+      if (snapshot === void 0) {
+        throw new Error(`[jotai-state-tree] A value for enumeration '${name}' is required`);
+      }
+      if (!optionSet.has(snapshot)) {
+        throw new Error(
+          `[jotai-state-tree] Value '${snapshot}' is not a valid option for enumeration '${name}'. Expected one of: ${options.join(", ")}`
+        );
+      }
+      return snapshot;
+    },
+    is(value) {
+      return typeof value === "string" && optionSet.has(value);
+    },
+    validate(value, context) {
+      if (typeof value === "string" && optionSet.has(value)) {
+        return { valid: true, errors: [] };
+      }
+      return {
+        valid: false,
+        errors: [
+          {
+            context,
+            value,
+            message: `Value '${String(value)}' is not a valid option. Expected one of: ${options.join(", ")}`
+          }
+        ]
+      };
+    }
+  };
+}
+function frozen(defaultValue) {
+  return {
+    name: "frozen",
+    _kind: "frozen",
+    _C: void 0,
+    _S: void 0,
+    _T: void 0,
+    create(snapshot) {
+      if (snapshot === void 0) {
+        if (defaultValue !== void 0) {
+          return deepFreeze(structuredClone(defaultValue));
+        }
+        return void 0;
+      }
+      return deepFreeze(structuredClone(snapshot));
+    },
+    is(value) {
+      return true;
+    },
+    validate() {
+      return { valid: true, errors: [] };
+    }
+  };
+}
+function deepFreeze(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  Object.freeze(obj);
+  if (Array.isArray(obj)) {
+    obj.forEach(deepFreeze);
+  } else {
+    Object.values(obj).forEach(deepFreeze);
+  }
+  return obj;
+}
+function custom(options) {
+  return {
+    name: options.name,
+    _kind: "simple",
+    _C: void 0,
+    _S: void 0,
+    _T: void 0,
+    create(snapshot) {
+      if (snapshot === void 0) {
+        throw new Error(`[jotai-state-tree] A value for custom type '${options.name}' is required`);
+      }
+      return options.fromSnapshot(snapshot);
+    },
+    is(value) {
+      return options.isTargetType(value);
+    },
+    validate(value, context) {
+      if (options.isTargetType(value)) {
+        return { valid: true, errors: [] };
+      }
+      return {
+        valid: false,
+        errors: [
+          {
+            context,
+            value,
+            message: options.getValidationMessage(value)
+          }
+        ]
+      };
+    }
+  };
+}
+var finite = createSimpleType(
+  "finite",
+  (value) => typeof value === "number" && isFinite(value)
+);
+var float = number;
+
+// src/tree.ts
+import { atom, createStore } from "jotai";
+var lifecycleHookHandlers = {};
+function setLifecycleHookHandlers(handlers) {
+  lifecycleHookHandlers = handlers;
+}
+var isApplyingSnapshotOrPatch = false;
+function getIsApplyingSnapshotOrPatch() {
+  return isApplyingSnapshotOrPatch;
+}
+function setIsApplyingSnapshotOrPatch(value) {
+  isApplyingSnapshotOrPatch = value;
+}
+var globalStore = createStore();
+function getGlobalStore() {
+  return globalStore;
+}
+function setGlobalStore(store) {
+  globalStore = store;
+}
+function resetGlobalStore() {
+  globalStore = createStore();
+}
+var activeTrackingFn = null;
+function getActiveTrackingFn() {
+  return activeTrackingFn;
+}
+function setActiveTrackingFn(fn) {
+  activeTrackingFn = fn;
+}
+function trackNodeAccess(node) {
+  if (activeTrackingFn) {
+    activeTrackingFn(node);
+  }
+}
+var nodeRegistry = /* @__PURE__ */ new Map();
+var nodeFinalizationRegistry = new FinalizationRegistry((nodeId) => {
+  nodeRegistry.delete(nodeId);
+});
+var identifierRegistry = /* @__PURE__ */ new Map();
+var identifierFinalizationRegistry = new FinalizationRegistry(
+  (info) => {
+    const typeMap = identifierRegistry.get(info.typeName);
+    if (typeMap) {
+      const ref = typeMap.get(info.identifier);
+      if (!ref || ref.deref() === void 0) {
+        typeMap.delete(info.identifier);
+        if (typeMap.size === 0) {
+          identifierRegistry.delete(info.typeName);
+        }
+      }
+    }
+  }
+);
+var nodeIdCounter = 0;
+function generateNodeId() {
+  return `node_${++nodeIdCounter}_${Date.now().toString(36)}`;
+}
+var lifecycleListeners = /* @__PURE__ */ new WeakMap();
+function onLifecycleChange(node, listener) {
+  let listeners = lifecycleListeners.get(node);
+  if (!listeners) {
+    listeners = /* @__PURE__ */ new Set();
+    lifecycleListeners.set(node, listeners);
+  }
+  listeners.add(listener);
+  return () => {
+    listeners?.delete(listener);
+  };
+}
+function notifyLifecycleChange(node, isAlive2) {
+  const listeners = lifecycleListeners.get(node);
+  if (listeners) {
+    listeners.forEach((listener) => listener(isAlive2));
+  }
+}
+function cloneAndSerialize(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (hasStateTreeNode(value)) {
+    return getSnapshotFromNode(getStateTreeNode(value));
+  }
+  if (Array.isArray(value)) {
+    return value.map(cloneAndSerialize);
+  }
+  if (typeof value === "object") {
+    if (value instanceof Map) {
+      const res = {};
+      for (const [k, v] of value.entries()) {
+        res[k] = cloneAndSerialize(v);
+      }
+      return res;
+    }
+    const proto = Object.getPrototypeOf(value);
+    if (proto === null || proto === Object.prototype) {
+      const res = {};
+      for (const [k, v] of Object.entries(value)) {
+        res[k] = cloneAndSerialize(v);
+      }
+      return res;
+    }
+  }
+  return value;
+}
+var StateTreeNode = class {
+  constructor(type, initialValue, env, parent, pathSegment) {
+    this.$parent = null;
+    this.$path = "";
+    this.$isAlive = true;
+    this.$isApplyingHistory = false;
+    /** Child nodes - uses Map but children are explicitly destroyed */
+    this.children = /* @__PURE__ */ new Map();
+    /** Snapshot listeners */
+    this.snapshotListeners = /* @__PURE__ */ new Set();
+    /** Patch listeners */
+    this.patchListeners = /* @__PURE__ */ new Set();
+    /** Volatile state (non-serialized) */
+    this.volatileState = {};
+    /** Cached snapshot for structural sharing optimization */
+    this.cachedSnapshot = void 0;
+    this.isSnapshotDirty = true;
+    /** Strong reference to the instance proxy to prevent GC of active nodes */
+    this.instance = null;
+    this.$id = generateNodeId();
+    this.$type = type;
+    this.$env = env ?? parent?.$env;
+    this.$parent = parent ?? null;
+    this.$path = parent ? `${parent.$path}/${pathSegment}` : "";
+    this.valueAtom = atom(initialValue);
+    this.isAliveAtom = atom(true);
+    this.snapshotAtom = atom((get) => {
+      const value = get(this.valueAtom);
+      if (this.$type._kind === "model") {
+        const res = {};
+        for (const [key, childNode] of this.children.entries()) {
+          res[key] = get(childNode.snapshotAtom);
+        }
+        if (value && typeof value === "object") {
+          for (const key of Object.keys(value)) {
+            if (!this.children.has(key)) {
+              res[key] = value[key];
+            }
+          }
+        }
+        return this.postProcessor ? this.postProcessor(res) : res;
+      }
+      if (this.$type._kind === "array") {
+        const res = [];
+        const childrenKeys = Array.from(this.children.keys()).sort((a, b) => Number(a) - Number(b));
+        for (const key of childrenKeys) {
+          const childNode = this.children.get(key);
+          res.push(get(childNode.snapshotAtom));
+        }
+        return res;
+      }
+      if (this.$type._kind === "map") {
+        const res = {};
+        for (const [key, childNode] of this.children.entries()) {
+          res[key] = get(childNode.snapshotAtom);
+        }
+        return res;
+      }
+      return value;
+    });
+    nodeRegistry.set(this.$id, { node: new WeakRef(this), instance: null });
+    nodeFinalizationRegistry.register(this, this.$id, this);
+  }
+  invalidateSnapshot() {
+    if (!this.isSnapshotDirty) {
+      this.isSnapshotDirty = true;
+      this.cachedSnapshot = void 0;
+      if (this.$parent) {
+        this.$parent.invalidateSnapshot();
+      }
+    }
+  }
+  /** Set the instance reference */
+  setInstance(instance) {
+    this.instance = instance;
+    const entry = nodeRegistry.get(this.$id);
+    if (entry && instance && typeof instance === "object") {
+      entry.instance = new WeakRef(instance);
+    }
+  }
+  /** Get the instance */
+  getInstance() {
+    return this.instance;
+  }
+  /** Get current value from atom */
+  getValue() {
+    return globalStore.get(this.valueAtom);
+  }
+  /** Set value on atom */
+  setValue(value) {
+    if (!this.$isAlive) {
+      throw new Error(
+        `[jotai-state-tree] Cannot modify a node that is no longer part of the state tree. (Node type: '${this.$type.name}', Path: '${this.$path}')`
+      );
+    }
+    const oldValue = this.getValue();
+    if (oldValue === value) {
+      return;
+    }
+    globalStore.set(this.valueAtom, value);
+    this.notifySnapshotChange();
+    this.notifyPatch(
+      { op: "replace", path: this.$path, value },
+      { op: "replace", path: this.$path, value: oldValue, oldValue }
+    );
+  }
+  /** Add a child node */
+  addChild(key, child) {
+    child.$parent = this;
+    const newPath = `${this.$path}/${key}`;
+    if (child.$path !== newPath) {
+      this.updatePathRecursively(child, newPath);
+    }
+    child.$env = child.$env ?? this.$env;
+    this.children.set(key, child);
+    lifecycleHookHandlers.runAfterAttach?.(child);
+    this.invalidateSnapshot();
+  }
+  /** Recursively update the path of a node and all its children */
+  updatePathRecursively(node, newPath) {
+    node.$path = newPath;
+    for (const [childKey, childNode] of node.children) {
+      const childNewPath = `${newPath}/${childKey}`;
+      this.updatePathRecursively(childNode, childNewPath);
+    }
+  }
+  /** Remove a child node */
+  removeChild(key) {
+    const child = this.children.get(key);
+    if (child) {
+      child.destroy();
+      this.children.delete(key);
+      this.invalidateSnapshot();
+    }
+  }
+  /** Get a child node */
+  getChild(key) {
+    return this.children.get(key);
+  }
+  /** Get all children */
+  getChildren() {
+    return this.children;
+  }
+  /** Register identifier */
+  registerIdentifier(typeName, identifier2) {
+    this.identifierTypeName = typeName;
+    this.identifierValue = identifier2;
+    let typeMap = identifierRegistry.get(typeName);
+    if (!typeMap) {
+      typeMap = /* @__PURE__ */ new Map();
+      identifierRegistry.set(typeName, typeMap);
+    }
+    typeMap.set(identifier2, new WeakRef(this));
+    identifierFinalizationRegistry.register(
+      this,
+      { typeName, identifier: identifier2 },
+      this
+    );
+  }
+  /** Unregister identifier */
+  unregisterIdentifier() {
+    if (this.identifierTypeName !== void 0 && this.identifierValue !== void 0) {
+      const typeMap = identifierRegistry.get(this.identifierTypeName);
+      if (typeMap) {
+        typeMap.delete(this.identifierValue);
+        if (typeMap.size === 0) {
+          identifierRegistry.delete(this.identifierTypeName);
+        }
+      }
+      identifierFinalizationRegistry.unregister(this);
+    }
+  }
+  /** Subscribe to snapshot changes */
+  onSnapshot(listener) {
+    this.snapshotListeners.add(listener);
+    return () => {
+      this.snapshotListeners.delete(listener);
+    };
+  }
+  /** Subscribe to patches */
+  onPatch(listener) {
+    this.patchListeners.add(listener);
+    return () => {
+      this.patchListeners.delete(listener);
+    };
+  }
+  /** Notify patch listeners */
+  notifyPatch(patch, reversePatch) {
+    const serializedPatch = {
+      ...patch,
+      value: "value" in patch ? cloneAndSerialize(patch.value) : void 0
+    };
+    if (!("value" in patch)) {
+      delete serializedPatch.value;
+    }
+    const serializedReversePatch = {
+      ...reversePatch,
+      value: "value" in reversePatch ? cloneAndSerialize(reversePatch.value) : void 0,
+      oldValue: "oldValue" in reversePatch ? cloneAndSerialize(reversePatch.oldValue) : void 0
+    };
+    if (!("value" in reversePatch)) {
+      delete serializedReversePatch.value;
+    }
+    if (!("oldValue" in reversePatch)) {
+      delete serializedReversePatch.oldValue;
+    }
+    this.patchListeners.forEach((listener) => listener(serializedPatch, serializedReversePatch));
+    if (this.$parent) {
+      this.$parent.notifyPatch(serializedPatch, serializedReversePatch);
+    }
+  }
+  /** Notify snapshot listeners */
+  notifySnapshotChange() {
+    let current = this;
+    while (current) {
+      current.invalidateSnapshot();
+      const snapshot = getSnapshotFromNode(current);
+      current.snapshotListeners.forEach((listener) => listener(snapshot));
+      current = current.$parent;
+    }
+  }
+  /** Notify about a property change (for use by model proxy) */
+  notifyPropertyChange(propName, newValue, oldValue) {
+    const path = this.$path ? `${this.$path}/${propName}` : `/${propName}`;
+    this.notifySnapshotChange();
+    this.notifyPatch(
+      { op: "replace", path, value: newValue },
+      { op: "replace", path, value: oldValue, oldValue }
+    );
+  }
+  /** Notify about a volatile state change (triggers snapshot listeners without patches) */
+  notifyVolatileChange() {
+    this.notifySnapshotChange();
+  }
+  /** Get root node */
+  getRoot() {
+    let node = this;
+    while (node.$parent) {
+      node = node.$parent;
+    }
+    return node;
+  }
+  /** Destroy this node and all children */
+  destroy() {
+    if (!this.$isAlive) return;
+    this.instance = null;
+    lifecycleHookHandlers.runBeforeDestroy?.(this);
+    this.children.forEach((child) => child.destroy());
+    this.children.clear();
+    this.unregisterIdentifier();
+    this.$isAlive = false;
+    try {
+      globalStore.set(this.isAliveAtom, false);
+    } catch (e) {
+    }
+    notifyLifecycleChange(this, false);
+    nodeRegistry.delete(this.$id);
+    nodeFinalizationRegistry.unregister(this);
+    lifecycleListeners.delete(this);
+    this.snapshotListeners.forEach((listener) => {
+      try {
+        listener(void 0);
+      } catch (e) {
+      }
+    });
+    try {
+      globalStore.set(this.valueAtom, void 0);
+    } catch (e) {
+    }
+    this.snapshotListeners.clear();
+    this.patchListeners.clear();
+  }
+  /** Detach from parent */
+  detach() {
+    if (this.$parent) {
+      lifecycleHookHandlers.runBeforeDetach?.(this);
+      const parent = this.$parent;
+      for (const [key, child] of this.$parent.children) {
+        if (child === this) {
+          this.$parent.children.delete(key);
+          break;
+        }
+      }
+      this.$parent = null;
+      this.$path = "";
+      parent.invalidateSnapshot();
+    }
+  }
+};
+var $treenode = /* @__PURE__ */ Symbol.for("jotai-state-tree-node");
+function getStateTreeNode(instance) {
+  if (instance && typeof instance === "object" && $treenode in instance) {
+    return instance[$treenode];
+  }
+  throw new Error("[jotai-state-tree] Value is not a state tree node");
+}
+function hasStateTreeNode(instance) {
+  return instance !== null && typeof instance === "object" && $treenode in instance;
+}
+function getSnapshotFromNode(node) {
+  if (!node.isSnapshotDirty && node.cachedSnapshot !== void 0) {
+    return node.cachedSnapshot;
+  }
+  const type = node.$type;
+  const value = node.getValue();
+  let snapshot;
+  if (type._kind === "model") {
+    const modelSnapshot = {};
+    const children = node.getChildren();
+    for (const [key, childNode] of children) {
+      modelSnapshot[key] = getSnapshotFromNode(childNode);
+    }
+    if (node.postProcessor) {
+      snapshot = node.postProcessor(modelSnapshot);
+    } else {
+      snapshot = modelSnapshot;
+    }
+  } else if (type._kind === "array") {
+    const arr = value;
+    snapshot = arr.map((_, index) => {
+      const childNode = node.getChild(String(index));
+      return childNode ? getSnapshotFromNode(childNode) : arr[index];
+    });
+  } else if (type._kind === "map") {
+    const mapSnapshot = {};
+    const children = node.getChildren();
+    for (const [key, childNode] of children) {
+      mapSnapshot[key] = getSnapshotFromNode(childNode);
+    }
+    snapshot = mapSnapshot;
+  } else if (type._kind === "reference") {
+    snapshot = node.identifierValue ?? value;
+  } else {
+    snapshot = value;
+  }
+  node.cachedSnapshot = snapshot;
+  node.isSnapshotDirty = false;
+  return snapshot;
+}
+function applySnapshotToNode(node, snapshot) {
+  if (!node.$isAlive) {
+    throw new Error("[jotai-state-tree] Cannot apply snapshot to a dead node");
+  }
+  const type = node.$type;
+  if (node.preProcessor) {
+    snapshot = node.preProcessor(snapshot);
+  }
+  if (type._kind === "model" && typeof snapshot === "object" && snapshot !== null) {
+    const snapshotObj = snapshot;
+    const children = node.getChildren();
+    for (const [key, childNode] of children) {
+      if (key in snapshotObj) {
+        applySnapshotToNode(childNode, snapshotObj[key]);
+      }
+    }
+  } else if (type._kind === "array" && Array.isArray(snapshot)) {
+    const mstArray = node.getInstance();
+    if (mstArray) {
+      mstArray.replace(snapshot);
+    } else {
+      node.setValue(snapshot);
+    }
+  } else if (type._kind === "map" && typeof snapshot === "object" && snapshot !== null) {
+    const mstMap = node.getInstance();
+    if (mstMap) {
+      mstMap.replace(snapshot);
+    } else {
+      node.setValue(snapshot);
+    }
+  } else {
+    node.setValue(snapshot);
+  }
+}
+function resolveIdentifier(typeName, identifier2) {
+  const weakRef = identifierRegistry.get(typeName)?.get(identifier2);
+  return weakRef?.deref();
+}
+function getRegistryStats() {
+  let liveNodeCount = 0;
+  let staleNodeCount = 0;
+  for (const entry of nodeRegistry.values()) {
+    const node = entry.node.deref();
+    if (node && node.$isAlive) {
+      liveNodeCount++;
+    } else {
+      staleNodeCount++;
+    }
+  }
+  let identifierCount = 0;
+  for (const typeMap of identifierRegistry.values()) {
+    for (const weakRef of typeMap.values()) {
+      const node = weakRef.deref();
+      if (node && node.$isAlive) {
+        identifierCount++;
+      }
+    }
+  }
+  return {
+    nodeRegistrySize: nodeRegistry.size,
+    identifierRegistrySize: identifierCount,
+    identifierTypeCount: identifierRegistry.size,
+    liveNodeCount,
+    staleNodeCount
+  };
+}
+function cleanupStaleEntries() {
+  let cleaned = 0;
+  for (const [id, entry] of nodeRegistry.entries()) {
+    if (!entry.node.deref()) {
+      nodeRegistry.delete(id);
+      cleaned++;
+    }
+  }
+  for (const [typeName, typeMap] of identifierRegistry.entries()) {
+    for (const [identifier2, weakRef] of typeMap.entries()) {
+      if (!weakRef.deref()) {
+        typeMap.delete(identifier2);
+        cleaned++;
+      }
+    }
+    if (typeMap.size === 0) {
+      identifierRegistry.delete(typeName);
+    }
+  }
+  return cleaned;
+}
+function clearAllRegistries() {
+  for (const entry of nodeRegistry.values()) {
+    const node = entry.node.deref();
+    if (node) {
+      node.$isAlive = false;
+      try {
+        globalStore.set(node.isAliveAtom, false);
+      } catch (e) {
+      }
+    }
+  }
+  nodeRegistry.clear();
+  identifierRegistry.clear();
+  nodeIdCounter = 0;
+}
+function getRoot(target) {
+  const node = getStateTreeNode(target);
+  const rootNode = node.getRoot();
+  return rootNode.getInstance();
+}
+function getParent(target, depth = 1) {
+  let node = getStateTreeNode(target);
+  for (let i = 0; i < depth; i++) {
+    if (!node.$parent) {
+      throw new Error("[jotai-state-tree] Cannot get parent of root node");
+    }
+    node = node.$parent;
+  }
+  return node.getInstance();
+}
+function tryGetParent(target, depth = 1) {
+  try {
+    return getParent(target, depth);
+  } catch {
+    return void 0;
+  }
+}
+function hasParent(target, depth = 1) {
+  let node = getStateTreeNode(target);
+  for (let i = 0; i < depth; i++) {
+    if (!node.$parent) return false;
+    node = node.$parent;
+  }
+  return true;
+}
+function getParentOfType(target, type) {
+  let node = getStateTreeNode(target).$parent;
+  while (node) {
+    if (node.$type === type || node.$type.name === type.name) {
+      return node.getInstance();
+    }
+    node = node.$parent;
+  }
+  throw new Error(`[jotai-state-tree] No parent of type '${type.name}' found`);
+}
+function getPath(target) {
+  return getStateTreeNode(target).$path;
+}
+function getPathParts(target) {
+  const path = getPath(target);
+  return path ? path.split("/").filter(Boolean) : [];
+}
+function getEnv(target) {
+  return getStateTreeNode(target).$env;
+}
+function isAlive(target) {
+  try {
+    return getStateTreeNode(target).$isAlive;
+  } catch {
+    return false;
+  }
+}
+function isRoot(target) {
+  return getStateTreeNode(target).$parent === null;
+}
+function getType(target) {
+  return getStateTreeNode(target).$type;
+}
+function isStateTreeNode(value) {
+  return hasStateTreeNode(value);
+}
+function getIdentifier(target) {
+  const node = getStateTreeNode(target);
+  return node.identifierValue ?? null;
+}
+function destroy(target) {
+  const node = getStateTreeNode(target);
+  node.destroy();
+}
+function detach(target) {
+  const node = getStateTreeNode(target);
+  node.detach();
+  return target;
+}
+function clone(target, keepEnvironment = true) {
+  const node = getStateTreeNode(target);
+  const snapshot = getSnapshotFromNode(node);
+  const type = node.$type;
+  return type.create(snapshot, keepEnvironment ? node.$env : void 0);
+}
+function getSnapshot(target) {
+  const node = getStateTreeNode(target);
+  trackNodeAccess(node);
+  return getSnapshotFromNode(node);
+}
+function applySnapshot(target, snapshot) {
+  const node = getStateTreeNode(target);
+  const wasApplying = getIsApplyingSnapshotOrPatch();
+  setIsApplyingSnapshotOrPatch(true);
+  try {
+    applySnapshotToNode(node, snapshot);
+  } finally {
+    setIsApplyingSnapshotOrPatch(wasApplying);
+  }
+}
+function onSnapshot(target, listener) {
+  const node = getStateTreeNode(target);
+  return node.onSnapshot(listener);
+}
+function onPatch(target, listener) {
+  const node = getStateTreeNode(target);
+  return node.onPatch(listener);
+}
+function applyPatch(target, patch) {
+  const patches = Array.isArray(patch) ? patch : [patch];
+  const rootNode = getStateTreeNode(target).getRoot();
+  const wasApplying = getIsApplyingSnapshotOrPatch();
+  setIsApplyingSnapshotOrPatch(true);
+  try {
+    for (const p of patches) {
+      applyPatchToNode(rootNode, p);
+    }
+  } finally {
+    setIsApplyingSnapshotOrPatch(wasApplying);
+  }
+}
+function applyPatchToNode(rootNode, patch) {
+  const pathParts = patch.path.split("/").filter(Boolean);
+  let node = rootNode;
+  for (let i = 0; i < pathParts.length - 1; i++) {
+    const childNode = node.getChild(pathParts[i]);
+    if (!childNode) {
+      throw new Error(`[jotai-state-tree] Invalid patch path: ${patch.path}`);
+    }
+    node = childNode;
+  }
+  const key = pathParts[pathParts.length - 1];
+  switch (patch.op) {
+    case "replace": {
+      const instance = node.getInstance();
+      if (instance && Array.isArray(instance)) {
+        const index = parseInt(key, 10);
+        instance[index] = patch.value;
+      } else if (instance && instance instanceof Map) {
+        instance.set(key, patch.value);
+      } else {
+        const childNode = node.getChild(key);
+        if (childNode) {
+          applySnapshotToNode(childNode, patch.value);
+        } else {
+          const currentValue = node.getValue();
+          currentValue[key] = patch.value;
+          node.setValue(currentValue);
+        }
+      }
+      break;
+    }
+    case "add": {
+      const instance = node.getInstance();
+      if (instance && Array.isArray(instance)) {
+        const index = key === "-" ? instance.length : parseInt(key, 10);
+        instance.splice(index, 0, patch.value);
+      } else if (instance && instance instanceof Map) {
+        instance.set(key, patch.value);
+      } else {
+        const currentValue = node.getValue();
+        if (Array.isArray(currentValue)) {
+          const index = key === "-" ? currentValue.length : parseInt(key, 10);
+          currentValue.splice(index, 0, patch.value);
+          node.setValue([...currentValue]);
+        } else if (typeof currentValue === "object" && currentValue !== null) {
+          currentValue[key] = patch.value;
+          node.setValue({ ...currentValue });
+        }
+      }
+      break;
+    }
+    case "remove": {
+      const instance = node.getInstance();
+      if (instance && Array.isArray(instance)) {
+        const index = parseInt(key, 10);
+        instance.splice(index, 1);
+      } else if (instance && instance instanceof Map) {
+        instance.delete(key);
+      } else {
+        const currentValue = node.getValue();
+        if (Array.isArray(currentValue)) {
+          const index = parseInt(key, 10);
+          currentValue.splice(index, 1);
+          node.setValue([...currentValue]);
+        } else if (typeof currentValue === "object" && currentValue !== null) {
+          delete currentValue[key];
+          node.setValue({ ...currentValue });
+        }
+      }
+      break;
+    }
+  }
+}
+function recordPatches(target) {
+  const patches = [];
+  const inversePatches = [];
+  let recording = true;
+  const disposer = onPatch(target, (patch, reversePatch) => {
+    if (recording) {
+      patches.push(patch);
+      inversePatches.push(reversePatch);
+    }
+  });
+  return {
+    patches,
+    inversePatches,
+    stop: () => {
+      recording = false;
+      disposer();
+    },
+    resume: () => {
+      recording = true;
+    },
+    replay: (t) => {
+      applyPatch(t, patches);
+    },
+    undo: (t) => {
+      applyPatch(t, inversePatches.slice().reverse());
+    }
+  };
+}
+var currentAction = null;
+function getCurrentAction() {
+  return currentAction;
+}
+var actionListeners = /* @__PURE__ */ new Set();
+var actionRecorderHooks = [];
+function registerActionRecorderHook(hook) {
+  actionRecorderHooks.push(hook);
+  return () => {
+    const index = actionRecorderHooks.indexOf(hook);
+    if (index >= 0) {
+      actionRecorderHooks.splice(index, 1);
+    }
+  };
+}
+function isActionRunning() {
+  return currentAction !== null;
+}
+function trackAction(node, name, args, fn) {
+  const previousAction = currentAction;
+  currentAction = { name, args, tree: node, parent: previousAction };
+  try {
+    const result = fn();
+    const call = {
+      name,
+      path: node.$path,
+      args
+    };
+    actionListeners.forEach((listener) => listener(call));
+    actionRecorderHooks.forEach((hook) => hook(node, call));
+    return result;
+  } finally {
+    currentAction = previousAction;
+  }
+}
+function onAction(target, listener) {
+  actionListeners.add(listener);
+  return () => {
+    actionListeners.delete(listener);
+  };
+}
+function walk(target, visitor) {
+  const treeNode = getStateTreeNode(target);
+  function visitNode(node) {
+    const instance = node.getInstance();
+    if (instance) {
+      visitor(instance);
+    }
+    node.getChildren().forEach(visitNode);
+  }
+  visitNode(treeNode);
+}
+function getMembers(target) {
+  const result = [];
+  const node = getStateTreeNode(target);
+  const instance = target;
+  for (const [key] of node.getChildren()) {
+    result.push({
+      name: key,
+      type: "property",
+      value: instance[key]
+    });
+  }
+  for (const [key, value] of Object.entries(node.volatileState)) {
+    result.push({
+      name: key,
+      type: "volatile",
+      value
+    });
+  }
+  return result;
+}
+function resolvePath(target, path) {
+  const parts = path.split("/").filter(Boolean);
+  let node = getStateTreeNode(target);
+  for (const part of parts) {
+    const child = node.getChild(part);
+    if (!child) {
+      throw new Error(`[jotai-state-tree] Invalid path: ${path}`);
+    }
+    node = child;
+  }
+  return node.getInstance();
+}
+function tryResolve(target, path) {
+  try {
+    return resolvePath(target, path);
+  } catch {
+    return void 0;
+  }
+}
+function getRelativePath(from, to) {
+  const fromNode = getStateTreeNode(from);
+  const toNode = getStateTreeNode(to);
+  const fromParts = fromNode.$path.split("/").filter(Boolean);
+  const toParts = toNode.$path.split("/").filter(Boolean);
+  let commonLength = 0;
+  for (let i = 0; i < Math.min(fromParts.length, toParts.length); i++) {
+    if (fromParts[i] === toParts[i]) {
+      commonLength++;
+    } else {
+      break;
+    }
+  }
+  const upCount = fromParts.length - commonLength;
+  const downParts = toParts.slice(commonLength);
+  const parts = [];
+  for (let i = 0; i < upCount; i++) {
+    parts.push("..");
+  }
+  parts.push(...downParts);
+  return parts.join("/") || ".";
+}
+function isAncestor(ancestor, descendant) {
+  const ancestorNode = getStateTreeNode(ancestor);
+  let currentNode = getStateTreeNode(descendant);
+  while (currentNode) {
+    if (currentNode === ancestorNode) {
+      return true;
+    }
+    currentNode = currentNode.$parent;
+  }
+  return false;
+}
+function haveSameRoot(a, b) {
+  return getRoot(a) === getRoot(b);
+}
+function findAll(target, predicate) {
+  const results = [];
+  walk(target, (node) => {
+    if (predicate(node)) {
+      results.push(node);
+    }
+  });
+  return results;
+}
+function findFirst(target, predicate) {
+  let result;
+  walk(target, (node) => {
+    if (!result && predicate(node)) {
+      result = node;
+    }
+  });
+  return result;
+}
+function isValidReference(target, identifier2) {
+  if (!hasStateTreeNode(target)) return false;
+  try {
+    const node = getStateTreeNode(target);
+    const typeName = node.$type.name;
+    const resolved = resolveIdentifier(typeName, identifier2);
+    return resolved !== void 0;
+  } catch {
+    return false;
+  }
+}
+function getTreeStats(target) {
+  let nodeCount = 0;
+  let maxDepth = 0;
+  const types = {};
+  walk(target, (node) => {
+    if (!hasStateTreeNode(node)) return;
+    const stateNode = getStateTreeNode(node);
+    nodeCount++;
+    const depth = stateNode.$path.split("/").filter(Boolean).length;
+    maxDepth = Math.max(maxDepth, depth);
+    const typeName = stateNode.$type.name;
+    types[typeName] = (types[typeName] || 0) + 1;
+  });
+  return {
+    nodeCount,
+    depth: maxDepth,
+    types
+  };
+}
+function cloneDeep(target) {
+  const snapshot = getSnapshot(target);
+  const node = getStateTreeNode(target);
+  return node.$type.create(snapshot, node.$env);
+}
+function getOrCreatePath(target, path, creator) {
+  const parts = path.split("/").filter(Boolean);
+  let node = getStateTreeNode(target);
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    let child = node.getChild(part);
+    if (!child && i === parts.length - 1) {
+      const instance = creator();
+      if (hasStateTreeNode(instance)) {
+        child = getStateTreeNode(instance);
+        node.addChild(part, child);
+      } else {
+        throw new Error(
+          "[jotai-state-tree] Creator must return a state tree node"
+        );
+      }
+    }
+    if (!child) {
+      throw new Error(`[jotai-state-tree] Invalid path: ${path}`);
+    }
+    node = child;
+  }
+  return node.getInstance();
+}
+function freeze(target) {
+  const node = getStateTreeNode(target);
+  node.volatileState.$frozen = true;
+  for (const [, child] of node.getChildren()) {
+    const instance = child.getInstance();
+    if (instance && hasStateTreeNode(instance)) {
+      freeze(instance);
+    }
+  }
+}
+function isFrozen(target) {
+  const node = getStateTreeNode(target);
+  return node.volatileState.$frozen === true;
+}
+function unfreeze(target) {
+  const node = getStateTreeNode(target);
+  delete node.volatileState.$frozen;
+  for (const [, child] of node.getChildren()) {
+    const instance = child.getInstance();
+    if (instance && hasStateTreeNode(instance)) {
+      unfreeze(instance);
+    }
+  }
+}
+
+// src/lifecycle.ts
+var nodeHooks = /* @__PURE__ */ new WeakMap();
+function registerHooks(node, hooks) {
+  const existing = nodeHooks.get(node) || {};
+  const filteredHooks = {};
+  for (const [key, value] of Object.entries(hooks)) {
+    if (value !== void 0) {
+      const existingHook = existing[key];
+      if (existingHook) {
+        filteredHooks[key] = () => {
+          existingHook();
+          value();
+        };
+      } else {
+        filteredHooks[key] = value;
+      }
+    }
+  }
+  const merged = { ...existing, ...filteredHooks };
+  nodeHooks.set(node, merged);
+}
+function runAfterCreate(node) {
+  const hooks = nodeHooks.get(node);
+  if (hooks?.afterCreate) {
+    hooks.afterCreate();
+  }
+}
+function runAfterAttach(node) {
+  const hooks = nodeHooks.get(node);
+  if (hooks?.afterAttach) {
+    hooks.afterAttach();
+  }
+}
+function runBeforeDetach(node) {
+  const hooks = nodeHooks.get(node);
+  if (hooks?.beforeDetach) {
+    hooks.beforeDetach();
+  }
+}
+function runBeforeDestroy(node) {
+  const hooks = nodeHooks.get(node);
+  if (hooks?.beforeDestroy) {
+    hooks.beforeDestroy();
+  }
+}
+var activeMiddlewareEvent = null;
+var middlewareIdCounter = 0;
+var middlewareStack = [];
+var nodeMiddlewares = /* @__PURE__ */ new WeakMap();
+function addMiddleware(target, handler, includeHooks = true) {
+  if (target && isStateTreeNode(target)) {
+    const node = getStateTreeNode(target);
+    let middlewares = nodeMiddlewares.get(node);
+    if (!middlewares) {
+      middlewares = /* @__PURE__ */ new Set();
+      nodeMiddlewares.set(node, middlewares);
+    }
+    middlewares.add(handler);
+    return () => {
+      const current = nodeMiddlewares.get(node);
+      if (current) {
+        current.delete(handler);
+      }
+    };
+  }
+  middlewareStack.push(handler);
+  return () => {
+    const index = middlewareStack.indexOf(handler);
+    if (index >= 0) {
+      middlewareStack.splice(index, 1);
+    }
+  };
+}
+function getMiddlewaresForNode(node) {
+  const handlers = [];
+  let current = node;
+  while (current) {
+    const middlewares = nodeMiddlewares.get(current);
+    if (middlewares) {
+      handlers.unshift(...Array.from(middlewares));
+    }
+    current = current.$parent;
+  }
+  return [...Array.from(middlewareStack), ...handlers];
+}
+function runMiddlewares(node, event, fn) {
+  const handlers = getMiddlewaresForNode(node);
+  if (handlers.length === 0) {
+    const previousEvent = activeMiddlewareEvent;
+    activeMiddlewareEvent = event;
+    try {
+      return fn(event);
+    } finally {
+      activeMiddlewareEvent = previousEvent;
+    }
+  }
+  let index = 0;
+  let aborted = false;
+  let abortValue;
+  const abort = (value) => {
+    aborted = true;
+    abortValue = value;
+    return value;
+  };
+  const next = (call, callback) => {
+    if (aborted) return abortValue;
+    const previousEvent = activeMiddlewareEvent;
+    activeMiddlewareEvent = call;
+    try {
+      if (index >= handlers.length) {
+        const result = fn(call);
+        return callback ? callback(result) : result;
+      }
+      const middleware = handlers[index++];
+      return middleware(call, next, abort);
+    } finally {
+      activeMiddlewareEvent = previousEvent;
+    }
+  };
+  return next(event);
+}
+function createMiddlewareRunner(node, actionName, args) {
+  const id = ++middlewareIdCounter;
+  const parentEvent = activeMiddlewareEvent;
+  const event = {
+    type: "action",
+    name: actionName,
+    id,
+    parentId: parentEvent ? parentEvent.id : 0,
+    rootId: parentEvent ? parentEvent.rootId : id,
+    context: node.getInstance(),
+    tree: node.getRoot().getInstance(),
+    args,
+    parentEvent: parentEvent ?? void 0
+  };
+  return (fn) => {
+    return runMiddlewares(node, event, fn);
+  };
+}
+function flow(generator) {
+  return function flowAction(...args) {
+    const node = (this && typeof this === "object" && $treenode in this ? this[$treenode] : null) ?? getCurrentAction()?.tree;
+    if (!node) {
+      let step2 = function(nextFn) {
+        let result;
+        try {
+          result = nextFn();
+        } catch (e) {
+          return Promise.reject(e);
+        }
+        if (result.done) {
+          return Promise.resolve(result.value);
+        }
+        return Promise.resolve(result.value).then(
+          (value) => step2(() => gen2.next(value)),
+          (error) => step2(() => gen2.throw(error))
+        );
+      };
+      var step = step2;
+      const gen2 = generator.apply(this, args);
+      return step2(() => gen2.next(void 0));
+    }
+    const actionName = getCurrentAction()?.name ?? "anonymousFlow";
+    const gen = generator.apply(this, args);
+    const actionEvent = activeMiddlewareEvent;
+    const spawnEventId = ++middlewareIdCounter;
+    const spawnEvent = {
+      type: "flow_spawn",
+      name: actionName,
+      id: spawnEventId,
+      parentId: actionEvent ? actionEvent.id : 0,
+      rootId: actionEvent ? actionEvent.rootId : spawnEventId,
+      context: node.getInstance(),
+      tree: node.getRoot().getInstance(),
+      args,
+      parentEvent: actionEvent ?? void 0
+    };
+    return new Promise((resolve, reject) => {
+      runMiddlewares(node, spawnEvent, () => {
+        function step2(nextFn, isResume, resumeError) {
+          let result;
+          if (isResume) {
+            if (!node.$isAlive) {
+              gen.return(void 0);
+              handleThrow(new Error("FLOW_CANCELLED"));
+              return;
+            }
+            const resumeEventId = ++middlewareIdCounter;
+            const resumeEvent = {
+              type: resumeError !== void 0 ? "flow_resume_error" : "flow_resume",
+              name: actionName,
+              id: resumeEventId,
+              parentId: spawnEvent.id,
+              rootId: spawnEvent.rootId,
+              context: node.getInstance(),
+              tree: node.getRoot().getInstance(),
+              args: resumeError !== void 0 ? [resumeError] : [],
+              parentEvent: spawnEvent
+            };
+            runMiddlewares(node, resumeEvent, () => {
+              try {
+                result = trackAction(node, actionName, args, () => {
+                  return nextFn();
+                });
+              } catch (e) {
+                handleThrow(e);
+                return;
+              }
+              handleResult(result);
+            });
+          } else {
+            try {
+              result = nextFn();
+            } catch (e) {
+              handleThrow(e);
+              return;
+            }
+            handleResult(result);
+          }
+        }
+        function handleResult(result) {
+          if (result.done) {
+            const returnEventId = ++middlewareIdCounter;
+            const returnEvent = {
+              type: "flow_return",
+              name: actionName,
+              id: returnEventId,
+              parentId: spawnEvent.id,
+              rootId: spawnEvent.rootId,
+              context: node.getInstance(),
+              tree: node.getRoot().getInstance(),
+              args: [result.value],
+              parentEvent: spawnEvent
+            };
+            runMiddlewares(node, returnEvent, () => {
+              resolve(result.value);
+            });
+          } else {
+            Promise.resolve(result.value).then(
+              (value) => step2(() => gen.next(value), true),
+              (error) => step2(() => gen.throw(error), true, error)
+            );
+          }
+        }
+        function handleThrow(error) {
+          const throwEventId = ++middlewareIdCounter;
+          const throwEvent = {
+            type: "flow_throw",
+            name: actionName,
+            id: throwEventId,
+            parentId: spawnEvent.id,
+            rootId: spawnEvent.rootId,
+            context: node.getInstance(),
+            tree: node.getRoot().getInstance(),
+            args: [error],
+            parentEvent: spawnEvent
+          };
+          runMiddlewares(node, throwEvent, () => {
+            reject(error);
+          });
+        }
+        step2(() => gen.next(void 0), false);
+      });
+    });
+  };
+}
+var actionRecorders = /* @__PURE__ */ new WeakMap();
+function recordActions(target) {
+  const node = getStateTreeNode(target);
+  const actions = [];
+  const recorder = (action) => {
+    if (node.$isAlive) {
+      actions.push(action);
+    }
+  };
+  let recorders = actionRecorders.get(node);
+  if (!recorders) {
+    recorders = /* @__PURE__ */ new Set();
+    actionRecorders.set(node, recorders);
+  }
+  recorders.add(recorder);
+  return {
+    actions,
+    stop: () => {
+      const currentRecorders = actionRecorders.get(node);
+      if (currentRecorders) {
+        currentRecorders.delete(recorder);
+        if (currentRecorders.size === 0) {
+        }
+      }
+    },
+    replay: (replayTarget) => {
+      const replayNode = getStateTreeNode(replayTarget);
+      for (const action of actions) {
+        const instance = replayNode.getInstance();
+        if (typeof instance[action.name] === "function") {
+          instance[action.name](...action.args);
+        }
+      }
+    }
+  };
+}
+function notifyActionRecorders(node, action) {
+  let current = node;
+  while (current) {
+    const recorders = actionRecorders.get(current);
+    if (recorders) {
+      recorders.forEach((recorder) => recorder(action));
+    }
+    current = current.$parent;
+  }
+}
+registerActionRecorderHook((node, call) => {
+  const action = {
+    name: call.name,
+    path: call.path,
+    args: call.args
+  };
+  notifyActionRecorders(node, action);
+});
+var unprotectedNodes = /* @__PURE__ */ new WeakSet();
+function isNodeUnprotected(node) {
+  let curr = node;
+  while (curr) {
+    if (unprotectedNodes.has(curr)) {
+      return true;
+    }
+    curr = curr.$parent;
+  }
+  return false;
+}
+function protect(target) {
+  const node = getStateTreeNode(target);
+  unprotectedNodes.delete(node);
+}
+function unprotect(target) {
+  const node = getStateTreeNode(target);
+  unprotectedNodes.add(node);
+}
+function isProtected(target) {
+  const node = getStateTreeNode(target);
+  return !isNodeUnprotected(node);
+}
+function canWrite(node) {
+  if (!node.$isAlive) {
+    return false;
+  }
+  if (getIsApplyingSnapshotOrPatch()) {
+    return true;
+  }
+  if (typeof process !== "undefined" && process.env && process.env.NODE_ENV === "production") {
+    return true;
+  }
+  if (isNodeUnprotected(node)) {
+    return true;
+  }
+  return isActionRunning();
+}
+function applyAction(target, action) {
+  const node = getStateTreeNode(target);
+  let currentNode = node;
+  if (action.path) {
+    const parts = action.path.split("/").filter(Boolean);
+    for (const part of parts) {
+      const child = currentNode.getChild(part);
+      if (!child) {
+        throw new Error(
+          `[jotai-state-tree] Invalid action path: ${action.path}`
+        );
+      }
+      currentNode = child;
+    }
+  }
+  const instance = currentNode.getInstance();
+  if (typeof instance[action.name] !== "function") {
+    throw new Error(`[jotai-state-tree] Action '${action.name}' not found`);
+  }
+  return instance[action.name](...action.args);
+}
+function escapeJsonPath(path) {
+  return path.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function unescapeJsonPath(path) {
+  return path.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function splitJsonPath(path) {
+  return path.split("/").filter(Boolean).map(unescapeJsonPath);
+}
+function joinJsonPath(parts) {
+  return parts.map(escapeJsonPath).join("/");
+}
+setLifecycleHookHandlers({
+  runAfterAttach,
+  runBeforeDetach,
+  runBeforeDestroy
+});
+
+// src/model.ts
+import { atom as atom2 } from "jotai";
+var MAX_CACHE_SIZE = 100;
+var LRUCache = class {
+  constructor(maxSize = MAX_CACHE_SIZE) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== void 0) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+var ModelType = class _ModelType {
+  constructor(config) {
+    this._kind = "model";
+    this.config = config;
+    this.name = config.name;
+    this.properties = config.properties;
+    for (const [key, type] of Object.entries(config.properties)) {
+      if (type._kind === "identifier" || type._kind === "identifierNumber") {
+        this.identifierAttribute = key;
+        break;
+      }
+    }
+  }
+  create(snapshot, env) {
+    let processedSnapshot = snapshot ?? {};
+    if (this.config.preProcessor) {
+      processedSnapshot = this.config.preProcessor(
+        processedSnapshot
+      );
+    }
+    const node = new StateTreeNode(this, processedSnapshot, env);
+    node.preProcessor = this.config.preProcessor;
+    node.postProcessor = this.config.postProcessor;
+    const propertyAtoms = /* @__PURE__ */ new Map();
+    const store = getGlobalStore();
+    for (const [key, propType] of Object.entries(this.properties)) {
+      const type = propType;
+      const initialValue = processedSnapshot?.[key];
+      const isComplexType = type._kind === "model" || type._kind === "array" || type._kind === "map";
+      if (isComplexType) {
+        const childInstance = type.create(initialValue, env);
+        const childNode = getStateTreeNode(childInstance);
+        node.addChild(key, childNode);
+        propertyAtoms.set(key, childNode.valueAtom);
+      } else {
+        const value = type.create(initialValue, env);
+        if (value && typeof value === "object" && $treenode in value) {
+          const childNode = getStateTreeNode(value);
+          node.addChild(key, childNode);
+          propertyAtoms.set(key, childNode.valueAtom);
+        } else {
+          const propAtom = atom2(value);
+          propertyAtoms.set(key, propAtom);
+          const childNode = new StateTreeNode(type, value, env, node, key);
+          childNode.valueAtom = propAtom;
+          node.addChild(key, childNode);
+        }
+      }
+    }
+    const instance = this.createInstanceProxy(node, propertyAtoms, store);
+    if (this.identifierAttribute) {
+      const idValue = processedSnapshot?.[this.identifierAttribute];
+      if (idValue !== void 0) {
+        node.registerIdentifier(this.name, idValue);
+      }
+    }
+    node.setInstance(instance);
+    if (this.config.hooks) {
+      registerHooks(node, {
+        afterCreate: this.config.hooks.afterCreate ? () => this.config.hooks.afterCreate(instance) : void 0,
+        afterAttach: this.config.hooks.afterAttach ? () => this.config.hooks.afterAttach(instance) : void 0,
+        beforeDetach: this.config.hooks.beforeDetach ? () => this.config.hooks.beforeDetach(instance) : void 0,
+        beforeDestroy: this.config.hooks.beforeDestroy ? () => this.config.hooks.beforeDestroy(instance) : void 0
+      });
+    }
+    for (const initializer of this.config.initializers) {
+      initializer(instance);
+    }
+    runAfterCreate(node);
+    return instance;
+  }
+  createInstanceProxy(node, propertyAtoms, store) {
+    const self = this;
+    const viewCache = new LRUCache(MAX_CACHE_SIZE);
+    const actionCache = new LRUCache(MAX_CACHE_SIZE);
+    const allViews = {};
+    const allActions = {};
+    const volatileState = {};
+    const base = {
+      [$treenode]: node
+    };
+    const proxy = new Proxy(base, {
+      get(target, prop) {
+        if (prop === $treenode) {
+          return node;
+        }
+        if (prop === "$treenode") {
+          return node;
+        }
+        if (!node.$isAlive) {
+          throw new Error(`[jotai-state-tree] Cannot access '${String(prop)}' - the node is dead.`);
+        }
+        const propStr = String(prop);
+        if (propertyAtoms.has(propStr)) {
+          const childNode = node.getChild(propStr);
+          if (childNode) {
+            trackNodeAccess(childNode);
+            const instance = childNode.getInstance();
+            if (instance !== void 0) {
+              if (instance && typeof instance === "object" && $treenode in instance) {
+                return instance;
+              }
+            }
+            return store.get(propertyAtoms.get(propStr));
+          }
+        }
+        if (propStr in node.volatileState) {
+          trackNodeAccess(node);
+          return node.volatileState[propStr];
+        }
+        if (propStr in allViews) {
+          const descriptor = allViews[propStr];
+          if (descriptor.get) {
+            return descriptor.get.call(proxy);
+          }
+          if (typeof descriptor.value === "function") {
+            return descriptor.value.bind(proxy);
+          }
+          return descriptor.value;
+        }
+        if (propStr === "toggle") {
+          console.log("PROXY GET toggle:", propStr, "in allActions:", propStr in allActions, "keys:", Object.keys(allActions), "node alive:", node.$isAlive);
+        }
+        if (propStr in allActions) {
+          return allActions[propStr];
+        }
+        return void 0;
+      },
+      set(target, prop, value) {
+        const propStr = String(prop);
+        if (propertyAtoms.has(propStr)) {
+          if (!node.$isAlive) {
+            throw new Error(`[jotai-state-tree] Cannot modify '${propStr}' - the node is dead.`);
+          }
+          if (!canWrite(node)) {
+            throw new Error(`Cannot modify '${propStr}' - the object is protected and can only be modified inside an action.`);
+          }
+          const propType = self.properties[propStr];
+          const existingChildNode = node.getChild(propStr);
+          if (propType._kind === "model") {
+            if (existingChildNode) {
+              applySnapshotToNode(existingChildNode, value);
+            }
+            return true;
+          }
+          if (propType._kind === "array" || propType._kind === "map") {
+            if (existingChildNode) {
+              existingChildNode.setValue(value);
+            }
+            return true;
+          }
+          const oldValue = existingChildNode?.getValue();
+          const newValue = propType.create(value, node.$env);
+          const isOldComplex = oldValue && typeof oldValue === "object" && $treenode in oldValue;
+          const isNewComplex = newValue && typeof newValue === "object" && $treenode in newValue;
+          if (existingChildNode && !isOldComplex && !isNewComplex) {
+            existingChildNode.setValue(newValue);
+            return true;
+          }
+          if (existingChildNode) {
+            existingChildNode.destroy();
+            node.getChildren().delete(propStr);
+          }
+          if (isNewComplex) {
+            const newChildNode = getStateTreeNode(newValue);
+            node.addChild(propStr, newChildNode);
+            propertyAtoms.set(propStr, newChildNode.valueAtom);
+          } else {
+            const newChildNode = new StateTreeNode(
+              propType,
+              newValue,
+              node.$env,
+              node,
+              propStr
+            );
+            const propAtom = atom2(newValue);
+            newChildNode.valueAtom = propAtom;
+            node.addChild(propStr, newChildNode);
+            propertyAtoms.set(propStr, propAtom);
+            store.set(propAtom, newValue);
+          }
+          node.notifyPropertyChange(propStr, newValue, oldValue);
+          return true;
+        }
+        if (propStr in node.volatileState) {
+          if (!node.$isAlive) {
+            throw new Error(`[jotai-state-tree] Cannot modify volatile property '${propStr}' - the node is dead.`);
+          }
+          if (!canWrite(node)) {
+            throw new Error(`Cannot modify volatile property '${propStr}' - the object is protected and can only be modified inside an action.`);
+          }
+          const oldValue = node.volatileState[propStr];
+          if (oldValue !== value) {
+            node.volatileState[propStr] = value;
+            node.notifyVolatileChange();
+          }
+          return true;
+        }
+        return false;
+      },
+      has(target, prop) {
+        const propStr = String(prop);
+        return prop === $treenode || propertyAtoms.has(propStr) || propStr in allViews || propStr in allActions || propStr in node.volatileState;
+      },
+      ownKeys() {
+        return [
+          ...propertyAtoms.keys(),
+          ...Object.keys(allViews),
+          ...Object.keys(allActions),
+          ...Object.keys(node.volatileState)
+        ];
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        const propStr = String(prop);
+        if (propertyAtoms.has(propStr) || propStr in allViews || propStr in allActions || propStr in node.volatileState) {
+          return {
+            configurable: true,
+            enumerable: true,
+            writable: true
+          };
+        }
+        return void 0;
+      }
+    });
+    for (const viewFn of this.config.views) {
+      const views = viewFn(proxy);
+      for (const [key, value] of Object.entries(
+        Object.getOwnPropertyDescriptors(views)
+      )) {
+        allViews[key] = value;
+      }
+    }
+    for (const actionFn of this.config.actions) {
+      const actions = actionFn(proxy);
+      for (const [key, value] of Object.entries(actions)) {
+        if (typeof value === "function") {
+          allActions[key] = (...args) => {
+            const runner = createMiddlewareRunner(node, key, args);
+            return runner((currEvent) => {
+              return trackAction(node, currEvent.name, currEvent.args, () => {
+                return value.apply(proxy, currEvent.args);
+              });
+            });
+          };
+          if (key === "afterCreate" || key === "afterAttach" || key === "beforeDetach" || key === "beforeDestroy") {
+            registerHooks(node, {
+              [key]: () => {
+                return value.apply(proxy);
+              }
+            });
+          }
+        }
+      }
+    }
+    for (const volatileFn of this.config.volatiles) {
+      const volatile = volatileFn(proxy);
+      Object.assign(node.volatileState, volatile);
+    }
+    return proxy;
+  }
+  is(value) {
+    if (!value || typeof value !== "object") return false;
+    if (!($treenode in value)) return false;
+    const node = value[$treenode];
+    return node.$type === this || node.$type.name === this.name;
+  }
+  validate(value, context) {
+    const errors = [];
+    if (!value || typeof value !== "object") {
+      return {
+        valid: false,
+        errors: [
+          {
+            context,
+            value,
+            message: `Value is not an object`
+          }
+        ]
+      };
+    }
+    for (const [key, propType] of Object.entries(this.properties)) {
+      const propValue = value[key];
+      const propContext = {
+        path: context.length > 0 ? `${context[0].path}/${key}` : `/${key}`,
+        type: propType,
+        parent: value
+      };
+      const result = propType.validate(propValue, [
+        ...context,
+        propContext
+      ]);
+      if (!result.valid) {
+        errors.push(...result.errors);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  // ============================================================================
+  // Model Modifiers
+  // ============================================================================
+  named(name) {
+    return new _ModelType({
+      ...this.config,
+      name
+    });
+  }
+  props(properties) {
+    return new _ModelType({
+      ...this.config,
+      properties: { ...this.config.properties, ...properties }
+    });
+  }
+  views(fn) {
+    return new _ModelType({
+      ...this.config,
+      views: [
+        ...this.config.views,
+        fn
+      ]
+    });
+  }
+  actions(fn) {
+    return new _ModelType({
+      ...this.config,
+      actions: [
+        ...this.config.actions,
+        fn
+      ]
+    });
+  }
+  volatile(fn) {
+    return new _ModelType({
+      ...this.config,
+      volatiles: [
+        ...this.config.volatiles,
+        fn
+      ]
+    });
+  }
+  preProcessSnapshot(fn) {
+    return new _ModelType({
+      ...this.config,
+      preProcessor: fn
+    });
+  }
+  postProcessSnapshot(fn) {
+    return new _ModelType({
+      ...this.config,
+      postProcessor: fn
+    });
+  }
+  extend(fn) {
+    const viewsFn = (self) => {
+      const result = fn(self);
+      return result.views ?? {};
+    };
+    const actionsFn = (self) => {
+      const result = fn(self);
+      return result.actions ?? {};
+    };
+    const volatileFn = (self) => {
+      const result = fn(self);
+      return result.state ?? {};
+    };
+    return new _ModelType({
+      ...this.config,
+      views: [
+        ...this.config.views,
+        viewsFn
+      ],
+      actions: [
+        ...this.config.actions,
+        actionsFn
+      ],
+      volatiles: [
+        ...this.config.volatiles,
+        volatileFn
+      ]
+    });
+  }
+  /**
+   * Add afterCreate lifecycle hook
+   */
+  afterCreate(fn) {
+    return new _ModelType({
+      ...this.config,
+      hooks: {
+        ...this.config.hooks,
+        afterCreate: fn
+      }
+    });
+  }
+  /**
+   * Add afterAttach lifecycle hook
+   */
+  afterAttach(fn) {
+    return new _ModelType({
+      ...this.config,
+      hooks: {
+        ...this.config.hooks,
+        afterAttach: fn
+      }
+    });
+  }
+  /**
+   * Add beforeDetach lifecycle hook
+   */
+  beforeDetach(fn) {
+    return new _ModelType({
+      ...this.config,
+      hooks: {
+        ...this.config.hooks,
+        beforeDetach: fn
+      }
+    });
+  }
+  /**
+   * Add beforeDestroy lifecycle hook
+   */
+  beforeDestroy(fn) {
+    return new _ModelType({
+      ...this.config,
+      hooks: {
+        ...this.config.hooks,
+        beforeDestroy: fn
+      }
+    });
+  }
+  /**
+   * Apply a mixin to this model.
+   * The mixin's views, actions, and volatile state are added to the model.
+   */
+  apply(mixinDef) {
+    const newViews = [];
+    const newActions = [];
+    const newVolatiles = [];
+    if (mixinDef.views) {
+      const viewsFn = mixinDef.views;
+      newViews.push(
+        (self) => viewsFn(self)
+      );
+    }
+    if (mixinDef.actions) {
+      const actionsFn = mixinDef.actions;
+      newActions.push(
+        (self) => actionsFn(self)
+      );
+    }
+    if (mixinDef.volatile) {
+      const volatileFn = mixinDef.volatile;
+      newVolatiles.push(
+        (self) => volatileFn(
+          self
+        )
+      );
+    }
+    return new _ModelType({
+      ...this.config,
+      views: [...this.config.views, ...newViews],
+      actions: [...this.config.actions, ...newActions],
+      volatiles: [...this.config.volatiles, ...newVolatiles]
+    });
+  }
+  /**
+   * Get the internal config for use by compose
+   * @internal
+   */
+  getConfig() {
+    return this.config;
+  }
+};
+function model(nameOrProperties, maybeProperties) {
+  const name = typeof nameOrProperties === "string" ? nameOrProperties : "AnonymousModel";
+  const properties = typeof nameOrProperties === "string" ? maybeProperties : nameOrProperties;
+  return new ModelType({
+    name,
+    properties,
+    views: [],
+    actions: [],
+    volatiles: [],
+    initializers: [],
+    hooks: {}
+  });
+}
+function compose(...args) {
+  const name = typeof args[0] === "string" ? args[0] : "ComposedModel";
+  const types = typeof args[0] === "string" ? args.slice(1) : args;
+  const mergedProperties = {};
+  const mergedViews = [];
+  const mergedActions = [];
+  const mergedVolatiles = [];
+  const mergedInitializers = [];
+  let mergedHooks = {};
+  for (const type of types) {
+    Object.assign(mergedProperties, type.properties);
+    if (type instanceof ModelType) {
+      const config = type.getConfig();
+      mergedViews.push(...config.views);
+      mergedActions.push(...config.actions);
+      mergedVolatiles.push(...config.volatiles);
+      mergedInitializers.push(...config.initializers);
+      mergedHooks = { ...mergedHooks, ...config.hooks };
+    }
+  }
+  return new ModelType({
+    name,
+    properties: mergedProperties,
+    views: mergedViews,
+    actions: mergedActions,
+    volatiles: mergedVolatiles,
+    initializers: mergedInitializers,
+    hooks: mergedHooks
+  });
+}
+function mixin(config) {
+  return {
+    _kind: "mixin",
+    requires: config.requires ?? {},
+    views: config.views,
+    actions: config.actions,
+    volatile: config.volatile,
+    // Phantom types for inference
+    _V: void 0,
+    _A: void 0,
+    _Vol: void 0
+  };
+}
+
+// src/array.ts
+var MSTArray = class _MSTArray extends Array {
+  constructor(node, itemType, items = []) {
+    super(...items);
+    this._isMutating = false;
+    this.node = node;
+    this.itemType = itemType;
+    this._isMutating = false;
+    Object.setPrototypeOf(this, _MSTArray.prototype);
+  }
+  checkWrite() {
+    if (!this.node.$isAlive) {
+      throw new Error("[jotai-state-tree] Cannot modify array - the node is dead.");
+    }
+    if (!canWrite(this.node)) {
+      throw new Error(
+        `Cannot modify the array - the parent object is protected and can only be modified inside an action.`
+      );
+    }
+  }
+  replace(items) {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      this.length = 0;
+      this.push(...items);
+      this.syncToNode();
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  clear() {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      this.length = 0;
+      this.syncToNode();
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  remove(item) {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      const index = this.indexOf(item);
+      if (index >= 0) {
+        this.splice(index, 1);
+        this.syncToNode();
+        return true;
+      }
+      return false;
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  spliceWithArray(index, deleteCount, newItems) {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      const result = deleteCount !== void 0 ? newItems ? this.splice(index, deleteCount, ...newItems) : this.splice(index, deleteCount) : this.splice(index);
+      this.syncToNode();
+      return result;
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  // Override mutating methods to sync
+  push(...items) {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      const result = super.push(...items);
+      this.syncToNode();
+      return result;
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  pop() {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      const result = super.pop();
+      this.syncToNode();
+      return result;
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  shift() {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      const result = super.shift();
+      this.syncToNode();
+      return result;
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  unshift(...items) {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      const result = super.unshift(...items);
+      this.syncToNode();
+      return result;
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  splice(start, deleteCount, ...items) {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      const result = deleteCount !== void 0 ? super.splice(start, deleteCount, ...items) : super.splice(start);
+      this.syncToNode();
+      return result;
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  sort(compareFn) {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      super.sort(compareFn);
+      this.syncToNode();
+      return this;
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  reverse() {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      super.reverse();
+      this.syncToNode();
+      return this;
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  fill(value, start, end) {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      super.fill(value, start, end);
+      this.syncToNode();
+      return this;
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  copyWithin(target, start, end) {
+    this.checkWrite();
+    const wasMutating = this._isMutating;
+    this._isMutating = true;
+    try {
+      super.copyWithin(target, start, end);
+      this.syncToNode();
+      return this;
+    } finally {
+      this._isMutating = wasMutating;
+    }
+  }
+  toJSON() {
+    return [...this];
+  }
+  syncToNode() {
+    const oldArray = this.node.getValue() || [];
+    const newArray = [...this];
+    const oldSnapshots = /* @__PURE__ */ new Map();
+    for (let i = 0; i < oldArray.length; i++) {
+      const childNode = this.node.getChild(String(i));
+      oldSnapshots.set(i, childNode ? getSnapshotFromNode(childNode) : oldArray[i]);
+    }
+    const existingChildNodes = /* @__PURE__ */ new Set();
+    for (const [, child] of this.node.getChildren()) {
+      existingChildNodes.add(child);
+    }
+    const newChildren = /* @__PURE__ */ new Map();
+    const keptNodes = /* @__PURE__ */ new Set();
+    this.forEach((item, index) => {
+      const key = String(index);
+      if (item && typeof item === "object" && $treenode in item) {
+        const childNode = getStateTreeNode(item);
+        newChildren.set(key, childNode);
+        keptNodes.add(childNode);
+      } else {
+        let reusedNode = null;
+        const resolveActualType = (type) => {
+          let current = type;
+          while (current) {
+            if (current._kind === "optional" || current._kind === "maybe" || current._kind === "maybeNull" || current._kind === "refinement") {
+              current = current._subType;
+            } else if (current._kind === "late") {
+              current = current._definition();
+            } else {
+              break;
+            }
+          }
+          return current;
+        };
+        const actualType = resolveActualType(this.itemType);
+        const isComplex = actualType._kind === "model" || actualType._kind === "array" || actualType._kind === "map";
+        const identifierAttr = actualType.identifierAttribute;
+        if (identifierAttr && item && typeof item === "object") {
+          const idValue = item[identifierAttr];
+          if (idValue !== void 0 && idValue !== null) {
+            for (const existingNode of existingChildNodes) {
+              if (!keptNodes.has(existingNode) && existingNode.identifierValue === idValue) {
+                reusedNode = existingNode;
+                break;
+              }
+            }
+          }
+        }
+        if (!reusedNode && !identifierAttr) {
+          const existingNodeAtIndex = this.node.getChild(key);
+          if (existingNodeAtIndex && !keptNodes.has(existingNodeAtIndex) && existingNodeAtIndex.$type === this.itemType) {
+            reusedNode = existingNodeAtIndex;
+          }
+        }
+        if (reusedNode) {
+          applySnapshotToNode(reusedNode, item);
+          const instance = isComplex ? reusedNode.getInstance() : reusedNode.getValue();
+          newChildren.set(key, reusedNode);
+          keptNodes.add(reusedNode);
+          this[index] = instance;
+          newArray[index] = instance;
+        } else {
+          const instance = this.itemType.create(item);
+          if (instance && typeof instance === "object" && $treenode in instance) {
+            const childNode = getStateTreeNode(instance);
+            newChildren.set(key, childNode);
+            keptNodes.add(childNode);
+            this[index] = instance;
+            newArray[index] = instance;
+          } else {
+            let reusedPrimitiveNode = null;
+            for (const existingNode of existingChildNodes) {
+              if (!keptNodes.has(existingNode) && existingNode.getValue() === item) {
+                reusedPrimitiveNode = existingNode;
+                break;
+              }
+            }
+            if (reusedPrimitiveNode) {
+              newChildren.set(key, reusedPrimitiveNode);
+              keptNodes.add(reusedPrimitiveNode);
+              this[index] = instance;
+              newArray[index] = instance;
+            } else {
+              const childNode = new StateTreeNode(
+                this.itemType,
+                item,
+                this.node.$env
+              );
+              newChildren.set(key, childNode);
+              keptNodes.add(childNode);
+              this[index] = instance;
+              newArray[index] = instance;
+            }
+          }
+        }
+      }
+    });
+    for (const existingNode of existingChildNodes) {
+      if (!keptNodes.has(existingNode)) {
+        existingNode.destroy();
+      }
+    }
+    this.node.getChildren().clear();
+    for (const [key, childNode] of newChildren) {
+      this.node.addChild(key, childNode);
+    }
+    const patches = [];
+    const reversePatches = [];
+    if (newArray.length > oldArray.length && oldArray.every((val, idx) => val === newArray[idx])) {
+      for (let i = oldArray.length; i < newArray.length; i++) {
+        const childNode = this.node.getChild(String(i));
+        const valSnap = childNode ? getSnapshotFromNode(childNode) : newArray[i];
+        patches.push({
+          op: "add",
+          path: `${this.node.$path}/${i}`,
+          value: valSnap
+        });
+        reversePatches.push({
+          op: "remove",
+          path: `${this.node.$path}/${i}`
+        });
+      }
+    } else if (newArray.length < oldArray.length && newArray.every((val, idx) => val === oldArray[idx])) {
+      for (let i = oldArray.length - 1; i >= newArray.length; i--) {
+        const oldValSnap = oldSnapshots.get(i);
+        patches.push({
+          op: "remove",
+          path: `${this.node.$path}/${i}`
+        });
+        reversePatches.push({
+          op: "add",
+          path: `${this.node.$path}/${i}`,
+          value: oldValSnap
+        });
+      }
+    } else {
+      const oldSnap = oldArray.map((_, idx) => oldSnapshots.get(idx));
+      const newSnap = newArray.map((_, idx) => {
+        const childNode = this.node.getChild(String(idx));
+        return childNode ? getSnapshotFromNode(childNode) : newArray[idx];
+      });
+      patches.push({
+        op: "replace",
+        path: this.node.$path,
+        value: newSnap
+      });
+      reversePatches.push({
+        op: "replace",
+        path: this.node.$path,
+        value: oldSnap
+      });
+    }
+    const store = getGlobalStore();
+    store.set(this.node.valueAtom, newArray);
+    this.node.notifySnapshotChange();
+    patches.forEach((patch, idx) => {
+      this.node.notifyPatch(patch, reversePatches[idx]);
+    });
+    this.node.notifyVolatileChange();
+  }
+};
+var ArrayType = class {
+  constructor(itemType) {
+    this._kind = "array";
+    this._subType = itemType;
+    this.name = `array<${itemType.name}>`;
+  }
+  create(snapshot, env) {
+    const items = snapshot ?? [];
+    const node = new StateTreeNode(this, items, env);
+    const instances = items.map((item, index) => {
+      const instance = this._subType.create(item, env);
+      if (instance && typeof instance === "object" && $treenode in instance) {
+        const childNode = getStateTreeNode(instance);
+        node.addChild(String(index), childNode);
+      } else {
+        const childNode = new StateTreeNode(
+          this._subType,
+          instance,
+          env,
+          node,
+          String(index)
+        );
+        node.addChild(String(index), childNode);
+      }
+      return instance;
+    });
+    const mstArray = new MSTArray(node, this._subType, instances);
+    Object.defineProperty(mstArray, $treenode, {
+      value: node,
+      writable: false,
+      enumerable: false
+    });
+    const proxy = new Proxy(mstArray, {
+      get(target, prop, receiver) {
+        if (prop === $treenode) {
+          return node;
+        }
+        if (!node.$isAlive) {
+          throw new Error("[jotai-state-tree] Cannot access array - the node is dead.");
+        }
+        return Reflect.get(target, prop, receiver);
+      },
+      set(target, prop, value) {
+        const propStr = String(prop);
+        const isIndex = /^\d+$/.test(propStr);
+        if (isIndex || propStr === "length") {
+          if (!node.$isAlive) {
+            throw new Error("[jotai-state-tree] Cannot modify array - the node is dead.");
+          }
+          if (!canWrite(node)) {
+            throw new Error(
+              `Cannot modify the array - the parent object is protected and can only be modified inside an action.`
+            );
+          }
+          target[prop] = value;
+          if (!target._isMutating) {
+            target.syncToNode();
+          }
+          return true;
+        }
+        target[prop] = value;
+        return true;
+      }
+    });
+    node.setInstance(proxy);
+    node.setValue(instances);
+    return proxy;
+  }
+  is(value) {
+    if (!Array.isArray(value)) return false;
+    return $treenode in value;
+  }
+  validate(value, context) {
+    const errors = [];
+    if (!Array.isArray(value)) {
+      return {
+        valid: false,
+        errors: [
+          {
+            context,
+            value,
+            message: "Value is not an array"
+          }
+        ]
+      };
+    }
+    value.forEach((item, index) => {
+      const itemContext = {
+        path: context.length > 0 ? `${context[0].path}/${index}` : `/${index}`,
+        type: this._subType,
+        parent: value
+      };
+      const result = this._subType.validate(item, [...context, itemContext]);
+      if (!result.valid) {
+        errors.push(...result.errors);
+      }
+    });
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+};
+function array(itemType) {
+  return new ArrayType(itemType);
+}
+
+// src/utilities.ts
+var OptionalType = class {
+  constructor(subType, defaultValue) {
+    this._kind = "optional";
+    this._subType = subType;
+    this._defaultValue = defaultValue;
+    this.name = `optional<${subType.name}>`;
+  }
+  create(snapshot, env) {
+    if (snapshot === void 0) {
+      const defaultVal = typeof this._defaultValue === "function" ? this._defaultValue() : this._defaultValue;
+      return this._subType.create(defaultVal, env);
+    }
+    return this._subType.create(snapshot, env);
+  }
+  is(value) {
+    return value === void 0 || this._subType.is(value);
+  }
+  validate(value, context) {
+    if (value === void 0) {
+      return { valid: true, errors: [] };
+    }
+    return this._subType.validate(value, context);
+  }
+};
+function optional(type, defaultValue) {
+  return new OptionalType(type, defaultValue);
+}
+var MaybeType = class {
+  constructor(subType) {
+    this._kind = "maybe";
+    this._subType = subType;
+    this.name = `maybe<${subType.name}>`;
+  }
+  create(snapshot, env) {
+    if (snapshot === void 0) {
+      return void 0;
+    }
+    return this._subType.create(snapshot, env);
+  }
+  is(value) {
+    return value === void 0 || this._subType.is(value);
+  }
+  validate(value, context) {
+    if (value === void 0) {
+      return { valid: true, errors: [] };
+    }
+    return this._subType.validate(value, context);
+  }
+};
+function maybe(type) {
+  return new MaybeType(type);
+}
+var MaybeNullType = class {
+  constructor(subType) {
+    this._kind = "maybeNull";
+    this._subType = subType;
+    this.name = `maybeNull<${subType.name}>`;
+  }
+  create(snapshot, env) {
+    if (snapshot === null || snapshot === void 0) {
+      return null;
+    }
+    return this._subType.create(snapshot, env);
+  }
+  is(value) {
+    return value === null || this._subType.is(value);
+  }
+  validate(value, context) {
+    if (value === null) {
+      return { valid: true, errors: [] };
+    }
+    return this._subType.validate(value, context);
+  }
+};
+function maybeNull(type) {
+  return new MaybeNullType(type);
+}
+var UnionType = class {
+  constructor(types, options) {
+    this._kind = "union";
+    this._types = types;
+    this.dispatcher = options?.dispatcher;
+    this.eager = options?.eager ?? true;
+    this.name = `union(${types.map((t) => t.name).join(" | ")})`;
+  }
+  create(snapshot, env) {
+    if (this.dispatcher && snapshot !== void 0) {
+      const type = this.dispatcher(snapshot);
+      return type.create(snapshot, env);
+    }
+    for (const type of this._types) {
+      try {
+        const result = type.validate(snapshot, []);
+        if (result.valid) {
+          return type.create(snapshot, env);
+        }
+      } catch {
+      }
+    }
+    throw new Error(
+      `[jotai-state-tree] No type in union matched the value: ${JSON.stringify(snapshot)}`
+    );
+  }
+  is(value) {
+    return this._types.some((type) => type.is(value));
+  }
+  validate(value, context) {
+    for (const type of this._types) {
+      const result = type.validate(value, context);
+      if (result.valid) {
+        return result;
+      }
+    }
+    return {
+      valid: false,
+      errors: [
+        {
+          context,
+          value,
+          message: `Value does not match any type in union`
+        }
+      ]
+    };
+  }
+};
+function union(optionsOrType, ...rest) {
+  if (optionsOrType && typeof optionsOrType === "object" && "dispatcher" in optionsOrType) {
+    return new UnionType(rest, optionsOrType);
+  }
+  return new UnionType([optionsOrType, ...rest]);
+}
+var LateType = class {
+  constructor(definition, name) {
+    this._kind = "late";
+    this._definition = definition;
+    this.name = name ?? "late(...)";
+  }
+  getType() {
+    if (!this.resolvedType) {
+      this.resolvedType = this._definition();
+    }
+    return this.resolvedType;
+  }
+  create(snapshot, env) {
+    return this.getType().create(snapshot, env);
+  }
+  is(value) {
+    return this.getType().is(value);
+  }
+  validate(value, context) {
+    return this.getType().validate(value, context);
+  }
+};
+function late(nameOrDefinition, maybeDefinition) {
+  if (typeof nameOrDefinition === "string") {
+    return new LateType(maybeDefinition, nameOrDefinition);
+  }
+  return new LateType(nameOrDefinition);
+}
+var RefinementType = class {
+  constructor(subType, predicate, message) {
+    this._kind = "refinement";
+    this._subType = subType;
+    this._predicate = predicate;
+    this.message = message ?? "Value failed refinement predicate";
+    this.name = `refinement<${subType.name}>`;
+  }
+  create(snapshot, env) {
+    const instance = this._subType.create(snapshot, env);
+    if (!this._predicate(instance)) {
+      const msg = typeof this.message === "function" ? this.message(instance) : this.message;
+      throw new Error(`[jotai-state-tree] ${msg}`);
+    }
+    return instance;
+  }
+  is(value) {
+    return this._subType.is(value) && this._predicate(value);
+  }
+  validate(value, context) {
+    const baseResult = this._subType.validate(value, context);
+    if (!baseResult.valid) {
+      return baseResult;
+    }
+    if (!this._predicate(value)) {
+      const msg = typeof this.message === "function" ? this.message(value) : this.message;
+      return {
+        valid: false,
+        errors: [
+          {
+            context,
+            value,
+            message: msg
+          }
+        ]
+      };
+    }
+    return { valid: true, errors: [] };
+  }
+};
+function refinement(type, predicate, message) {
+  return new RefinementType(type, predicate, message);
+}
+var ReferenceType = class {
+  constructor(targetType, options) {
+    this._kind = "reference";
+    this._targetType = targetType;
+    this.options = options;
+    this.name = `reference<${targetType.name}>`;
+  }
+  create(snapshot, env) {
+    if (snapshot === void 0) {
+      throw new Error("[jotai-state-tree] Reference requires an identifier");
+    }
+    const self = this;
+    let resolved = null;
+    if (this.options?.get) {
+      const result = this.options.get(snapshot, null);
+      if (result) return result;
+    }
+    const node = new StateTreeNode(this, snapshot, env);
+    node.identifierValue = snapshot;
+    const proxy = new Proxy({}, {
+      get(target, prop) {
+        if (!resolved) {
+          const targetNode = resolveIdentifier(self._targetType.name, snapshot);
+          if (!targetNode) {
+            throw new Error(
+              `[jotai-state-tree] Failed to resolve reference '${snapshot}' to type '${self._targetType.name}'`
+            );
+          }
+          resolved = targetNode.getInstance();
+        }
+        if (prop === $treenode) {
+          return node;
+        }
+        return resolved[prop];
+      },
+      set(target, prop, value) {
+        if (!resolved) {
+          const targetNode = resolveIdentifier(self._targetType.name, snapshot);
+          if (!targetNode) {
+            throw new Error(
+              `[jotai-state-tree] Failed to resolve reference '${snapshot}' to type '${self._targetType.name}'`
+            );
+          }
+          resolved = targetNode.getInstance();
+        }
+        resolved[prop] = value;
+        return true;
+      },
+      has(target, prop) {
+        if (!resolved) {
+          const targetNode = resolveIdentifier(self._targetType.name, snapshot);
+          if (targetNode) {
+            resolved = targetNode.getInstance();
+          }
+        }
+        return resolved ? prop in resolved : false;
+      }
+    });
+    node.setInstance(proxy);
+    return proxy;
+  }
+  is(value) {
+    return this._targetType.is(value);
+  }
+  validate(value, context) {
+    if (typeof value === "string" || typeof value === "number") {
+      return { valid: true, errors: [] };
+    }
+    return {
+      valid: false,
+      errors: [
+        {
+          context,
+          value,
+          message: "Reference must be a string or number identifier"
+        }
+      ]
+    };
+  }
+};
+function reference(targetType, options) {
+  return new ReferenceType(targetType, options);
+}
+var SafeReferenceType = class {
+  constructor(targetType, options) {
+    this._kind = "safeReference";
+    this._targetType = targetType;
+    this.options = options;
+    this.name = `safeReference<${targetType.name}>`;
+  }
+  create(snapshot, env) {
+    if (snapshot === void 0) {
+      return void 0;
+    }
+    const targetNode = resolveIdentifier(this._targetType.name, snapshot);
+    if (!targetNode) {
+      if (this.options?.onInvalidated) {
+        return void 0;
+      }
+      return void 0;
+    }
+    return targetNode.getInstance();
+  }
+  is(value) {
+    return value === void 0 || this._targetType.is(value);
+  }
+  validate(value, context) {
+    if (value === void 0) {
+      return { valid: true, errors: [] };
+    }
+    if (typeof value === "string" || typeof value === "number") {
+      return { valid: true, errors: [] };
+    }
+    return {
+      valid: false,
+      errors: [
+        {
+          context,
+          value,
+          message: "Safe reference must be a string, number, or undefined"
+        }
+      ]
+    };
+  }
+};
+function safeReference(targetType, options) {
+  return new SafeReferenceType(targetType, options);
+}
+function snapshotProcessor(type, processors) {
+  return {
+    name: `snapshotProcessor<${type.name}>`,
+    _kind: "simple",
+    _C: void 0,
+    _S: void 0,
+    _T: void 0,
+    create(snapshot, env) {
+      const processed = processors.preProcessor ? processors.preProcessor(snapshot) : snapshot;
+      return type.create(processed, env);
+    },
+    is(value) {
+      return type.is(value);
+    },
+    validate(value, context) {
+      const processed = processors.preProcessor ? processors.preProcessor(value) : value;
+      return type.validate(processed, context);
+    }
+  };
+}
+
+// src/undo.ts
+import { atom as atom3 } from "jotai";
+var historyTrackersRegistry = /* @__PURE__ */ new WeakMap();
+var HistoryTracker = class {
+  constructor(target, options = {}) {
+    // Transient state
+    this.autoRecord = false;
+    this.isApplyingHistory = false;
+    this.skipRecording = false;
+    this.grouping = false;
+    this.actionGrouping = false;
+    this.currentGroup = [];
+    this.currentGroupInverse = [];
+    this.lastChangeTime = 0;
+    this.disposer = null;
+    this.actionDisposer = null;
+    this.target = target;
+    this.maxHistoryLength = options.maxHistoryLength ?? options.maxSnapshots ?? 100;
+    this.groupByTime = options.groupByTime ?? false;
+    this.groupingWindow = options.groupingWindow ?? 200;
+    this.autoRecord = options.autoRecord ?? false;
+    const initialSnapshot = getSnapshot(target);
+    this.historyAtom = atom3({
+      entries: [],
+      currentIndex: -1,
+      initialSnapshot
+    });
+    this.disposer = onPatch(target, (patch, reversePatch) => {
+      this.recordPatch(patch, reversePatch);
+    });
+    this.actionDisposer = onAction(target, () => {
+      const current = getCurrentAction();
+      if (current && !current.parent) {
+        if (this.actionGrouping) {
+          this.endGroup();
+        }
+      }
+    });
+  }
+  recordPatch(patch, reversePatch) {
+    if (!this.autoRecord) {
+      return;
+    }
+    if (this.isApplyingHistory || this.skipRecording) {
+      return;
+    }
+    const node = getStateTreeNode(this.target);
+    if (node.getRoot().$isApplyingHistory) {
+      return;
+    }
+    const store = getGlobalStore();
+    const now = Date.now();
+    if (isActionRunning() && !this.grouping) {
+      this.grouping = true;
+      this.actionGrouping = true;
+      this.currentGroup = [];
+      this.currentGroupInverse = [];
+      Promise.resolve().then(() => {
+        if (this.actionGrouping) {
+          this.endGroup();
+        }
+      });
+    }
+    if (this.grouping) {
+      this.currentGroup.push(reversePatch);
+      this.currentGroupInverse.push({ ...patch });
+      return;
+    }
+    store.set(this.historyAtom, (prev) => {
+      let entries = prev.currentIndex < prev.entries.length - 1 ? prev.entries.slice(0, prev.currentIndex + 1) : [...prev.entries];
+      if (this.groupByTime && entries.length > 0 && now - this.lastChangeTime < this.groupingWindow && prev.currentIndex === prev.entries.length - 1) {
+        const lastEntry = { ...entries[entries.length - 1] };
+        lastEntry.patches = [...lastEntry.patches, reversePatch];
+        lastEntry.inversePatches = [...lastEntry.inversePatches, { ...patch }];
+        lastEntry.timestamp = now;
+        lastEntry.snapshot = getSnapshot(this.target);
+        entries[entries.length - 1] = lastEntry;
+        this.lastChangeTime = now;
+        return {
+          ...prev,
+          entries
+        };
+      } else {
+        const newEntry = {
+          patches: [reversePatch],
+          inversePatches: [{ ...patch }],
+          timestamp: now,
+          snapshot: getSnapshot(this.target)
+        };
+        entries.push(newEntry);
+        let newIndex = entries.length - 1;
+        if (entries.length > this.maxHistoryLength) {
+          const excess = entries.length - this.maxHistoryLength;
+          entries = entries.slice(excess);
+          newIndex -= excess;
+        }
+        this.lastChangeTime = now;
+        return {
+          ...prev,
+          entries,
+          currentIndex: newIndex
+        };
+      }
+    });
+  }
+  undo() {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    if (state.currentIndex < 0) {
+      return;
+    }
+    const node = getStateTreeNode(this.target);
+    const rootNode = node.getRoot();
+    const wasApplying = rootNode.$isApplyingHistory;
+    rootNode.$isApplyingHistory = true;
+    this.isApplyingHistory = true;
+    try {
+      const entry = state.entries[state.currentIndex];
+      for (let i = entry.patches.length - 1; i >= 0; i--) {
+        applyPatch(this.target, entry.patches[i]);
+      }
+      store.set(this.historyAtom, (prev) => ({
+        ...prev,
+        currentIndex: prev.currentIndex - 1
+      }));
+    } finally {
+      this.isApplyingHistory = false;
+      rootNode.$isApplyingHistory = wasApplying;
+    }
+  }
+  redo() {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    if (state.currentIndex >= state.entries.length - 1) {
+      return;
+    }
+    const node = getStateTreeNode(this.target);
+    const rootNode = node.getRoot();
+    const wasApplying = rootNode.$isApplyingHistory;
+    rootNode.$isApplyingHistory = true;
+    this.isApplyingHistory = true;
+    try {
+      const nextIndex = state.currentIndex + 1;
+      const entry = state.entries[nextIndex];
+      for (const patch of entry.inversePatches) {
+        applyPatch(this.target, patch);
+      }
+      store.set(this.historyAtom, (prev) => ({
+        ...prev,
+        currentIndex: nextIndex
+      }));
+    } finally {
+      this.isApplyingHistory = false;
+      rootNode.$isApplyingHistory = wasApplying;
+    }
+  }
+  goTo(index) {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    const maxIdx = state.entries.length;
+    if (index < 0 || index > maxIdx) {
+      return;
+    }
+    const node = getStateTreeNode(this.target);
+    const rootNode = node.getRoot();
+    const wasApplying = rootNode.$isApplyingHistory;
+    rootNode.$isApplyingHistory = true;
+    this.isApplyingHistory = true;
+    try {
+      const targetSnapshot = index === 0 ? state.initialSnapshot : state.entries[index - 1].snapshot;
+      applySnapshot(this.target, targetSnapshot);
+      store.set(this.historyAtom, (prev) => ({
+        ...prev,
+        currentIndex: index - 1
+      }));
+    } finally {
+      this.isApplyingHistory = false;
+      rootNode.$isApplyingHistory = wasApplying;
+    }
+  }
+  goBack() {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    const currentSnapshotIndex = state.currentIndex + 1;
+    if (currentSnapshotIndex > 0) {
+      this.goTo(currentSnapshotIndex - 1);
+    }
+  }
+  goForward() {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    const currentSnapshotIndex = state.currentIndex + 1;
+    if (currentSnapshotIndex < state.entries.length) {
+      this.goTo(currentSnapshotIndex + 1);
+    }
+  }
+  record() {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    let entries = state.currentIndex < state.entries.length - 1 ? state.entries.slice(0, state.currentIndex + 1) : [...state.entries];
+    const newEntry = {
+      patches: [],
+      inversePatches: [],
+      timestamp: Date.now(),
+      snapshot: getSnapshot(this.target)
+    };
+    entries.push(newEntry);
+    let newIndex = entries.length - 1;
+    if (entries.length > this.maxHistoryLength) {
+      const excess = entries.length - this.maxHistoryLength;
+      entries = entries.slice(excess);
+      newIndex -= excess;
+    }
+    store.set(this.historyAtom, {
+      ...state,
+      entries,
+      currentIndex: newIndex
+    });
+  }
+  getSnapshot(index) {
+    const store = getGlobalStore();
+    const state = store.get(this.historyAtom);
+    if (index < 0 || index > state.entries.length) {
+      throw new Error(`[jotai-state-tree] Invalid snapshot index: ${index}`);
+    }
+    return index === 0 ? state.initialSnapshot : state.entries[index - 1].snapshot;
+  }
+  clear() {
+    const store = getGlobalStore();
+    store.set(this.historyAtom, {
+      entries: [],
+      currentIndex: -1,
+      initialSnapshot: getSnapshot(this.target)
+    });
+    this.currentGroup = [];
+    this.currentGroupInverse = [];
+    this.grouping = false;
+    this.actionGrouping = false;
+  }
+  startGroup() {
+    this.grouping = true;
+    this.actionGrouping = false;
+    this.currentGroup = [];
+    this.currentGroupInverse = [];
+  }
+  endGroup() {
+    if (!this.grouping) {
+      return;
+    }
+    this.grouping = false;
+    this.actionGrouping = false;
+    if (this.currentGroup.length > 0) {
+      const store = getGlobalStore();
+      store.set(this.historyAtom, (prev) => {
+        let entries = prev.currentIndex < prev.entries.length - 1 ? prev.entries.slice(0, prev.currentIndex + 1) : [...prev.entries];
+        const newEntry = {
+          patches: [...this.currentGroup],
+          inversePatches: [...this.currentGroupInverse],
+          timestamp: Date.now(),
+          snapshot: getSnapshot(this.target)
+        };
+        entries.push(newEntry);
+        let newIndex = entries.length - 1;
+        if (entries.length > this.maxHistoryLength) {
+          const excess = entries.length - this.maxHistoryLength;
+          entries = entries.slice(excess);
+          newIndex -= excess;
+        }
+        return {
+          ...prev,
+          entries,
+          currentIndex: newIndex
+        };
+      });
+    }
+    this.currentGroup = [];
+    this.currentGroupInverse = [];
+  }
+  withoutUndo(fn) {
+    this.skipRecording = true;
+    try {
+      return fn();
+    } finally {
+      this.skipRecording = false;
+    }
+  }
+  dispose() {
+    historyTrackersRegistry.delete(this.target);
+    if (this.disposer) {
+      this.disposer();
+      this.disposer = null;
+    }
+    if (this.actionDisposer) {
+      this.actionDisposer();
+      this.actionDisposer = null;
+    }
+  }
+};
+function getOrCreateHistoryTracker(target, options = {}) {
+  let tracker = historyTrackersRegistry.get(target);
+  if (!tracker) {
+    tracker = new HistoryTracker(target, options);
+    historyTrackersRegistry.set(target, tracker);
+  }
+  return tracker;
+}
+function createUndoManager(target, options) {
+  const tracker = getOrCreateHistoryTracker(target, options);
+  tracker.autoRecord = true;
+  const store = getGlobalStore();
+  return {
+    get canUndo() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex >= 0;
+    },
+    get canRedo() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex < state.entries.length - 1;
+    },
+    get undoLevels() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex + 1;
+    },
+    get redoLevels() {
+      const state = store.get(tracker.historyAtom);
+      return state.entries.length - state.currentIndex - 1;
+    },
+    get history() {
+      const state = store.get(tracker.historyAtom);
+      return state.entries;
+    },
+    get historyIndex() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex;
+    },
+    undo() {
+      tracker.undo();
+    },
+    redo() {
+      tracker.redo();
+    },
+    clear() {
+      tracker.clear();
+    },
+    startGroup() {
+      tracker.startGroup();
+    },
+    endGroup() {
+      tracker.endGroup();
+    },
+    withoutUndo(fn) {
+      return tracker.withoutUndo(fn);
+    },
+    dispose() {
+      tracker.dispose();
+    }
+  };
+}
+function createTimeTravelManager(target, options) {
+  const tracker = getOrCreateHistoryTracker(target, options);
+  if (options?.autoRecord) {
+    tracker.autoRecord = true;
+  }
+  const store = getGlobalStore();
+  return {
+    get currentIndex() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex + 1;
+    },
+    get snapshotCount() {
+      const state = store.get(tracker.historyAtom);
+      return state.entries.length + 1;
+    },
+    get canGoBack() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex + 1 > 0;
+    },
+    get canGoForward() {
+      const state = store.get(tracker.historyAtom);
+      return state.currentIndex + 1 < state.entries.length + 1 - 1;
+    },
+    record() {
+      tracker.record();
+    },
+    goBack() {
+      tracker.goBack();
+    },
+    goForward() {
+      tracker.goForward();
+    },
+    goTo(index) {
+      tracker.goTo(index);
+    },
+    getSnapshot(index) {
+      return tracker.getSnapshot(index);
+    },
+    clear() {
+      tracker.clear();
+    },
+    dispose() {
+      tracker.dispose();
+    }
+  };
+}
+var ActionRecorder = class {
+  constructor(target) {
+    this.recording = false;
+    this.recordedActions = [];
+    this.disposer = null;
+    this.target = target;
+  }
+  get isRecording() {
+    return this.recording;
+  }
+  get actions() {
+    return [...this.recordedActions];
+  }
+  start() {
+    if (this.recording) return;
+    this.recording = true;
+    this.disposer = onAction(this.target, (action) => {
+      this.recordedActions.push({
+        ...action,
+        timestamp: Date.now()
+      });
+    });
+  }
+  stop() {
+    this.recording = false;
+    if (this.disposer) {
+      this.disposer();
+      this.disposer = null;
+    }
+  }
+  clear() {
+    this.recordedActions = [];
+  }
+  replay(target) {
+    const node = getStateTreeNode(target);
+    for (const action of this.recordedActions) {
+      let currentNode = node;
+      if (action.path) {
+        const parts = action.path.split("/").filter(Boolean);
+        for (const part of parts) {
+          const child = currentNode.getChild(part);
+          if (!child) {
+            console.warn(`[jotai-state-tree] Could not find path: ${action.path}`);
+            continue;
+          }
+          currentNode = child;
+        }
+      }
+      const instance = currentNode.getInstance();
+      if (typeof instance[action.name] === "function") {
+        instance[action.name](...action.args);
+      }
+    }
+  }
+  export() {
+    return JSON.stringify(this.recordedActions, null, 2);
+  }
+  import(json) {
+    try {
+      const actions = JSON.parse(json);
+      if (Array.isArray(actions)) {
+        this.recordedActions = actions;
+      }
+    } catch (e) {
+      throw new Error(`[jotai-state-tree] Failed to import actions: ${e}`);
+    }
+  }
+  dispose() {
+    this.stop();
+    this.clear();
+  }
+};
+function createActionRecorder(target) {
+  return new ActionRecorder(target);
+}
+
+// src/router.ts
+import { createContext, useContext } from "react";
+import { useAtomValue } from "jotai";
+var RouteDefinition = model("RouteDefinition", {
+  path: string,
+  name: string,
+  meta: optional(frozen(), {})
+});
+function normalizePathname(path) {
+  if (path === "/") return path;
+  let normalized = path;
+  if (normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  return normalized;
+}
+function parseUrl(url) {
+  let pathname = url;
+  let search = "";
+  let hash = "";
+  if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("//")) {
+    try {
+      const fullUrl = url.startsWith("//") ? "http:" + url : url;
+      const u = new URL(fullUrl);
+      pathname = u.pathname;
+      search = u.search;
+      hash = u.hash;
+    } catch {
+    }
+  } else {
+    const hashIndex = pathname.indexOf("#");
+    if (hashIndex !== -1) {
+      hash = pathname.slice(hashIndex);
+      pathname = pathname.slice(0, hashIndex);
+    }
+    const queryIndex = pathname.indexOf("?");
+    if (queryIndex !== -1) {
+      search = pathname.slice(queryIndex);
+      pathname = pathname.slice(0, queryIndex);
+    }
+  }
+  const query = {};
+  if (search && search.length > 1) {
+    const pairs = search.slice(1).split("&");
+    for (const pair of pairs) {
+      const [key, value] = pair.split("=");
+      if (key) {
+        query[decodeURIComponent(key)] = value ? decodeURIComponent(value) : "";
+      }
+    }
+  }
+  return {
+    pathname: normalizePathname(pathname),
+    search,
+    hash,
+    query
+  };
+}
+function matchPath(pattern, pathname) {
+  const normalizedPattern = normalizePathname(pattern);
+  const normalizedPathname = normalizePathname(pathname);
+  if (normalizedPattern === "/*" || normalizedPattern === "*") {
+    return { "*": normalizedPathname };
+  }
+  const patternSegments = normalizedPattern.split("/").filter(Boolean);
+  const pathnameSegments = normalizedPathname.split("/").filter(Boolean);
+  const hasWildcard = patternSegments[patternSegments.length - 1] === "*";
+  if (!hasWildcard && patternSegments.length !== pathnameSegments.length) {
+    return null;
+  }
+  const params = {};
+  const limit = hasWildcard ? patternSegments.length - 1 : patternSegments.length;
+  for (let i = 0; i < limit; i++) {
+    const pSeg = patternSegments[i];
+    const pathSeg = pathnameSegments[i];
+    if (!pathSeg) return null;
+    if (pSeg.startsWith(":")) {
+      params[pSeg.slice(1)] = decodeURIComponent(pathSeg);
+    } else if (pSeg !== pathSeg) {
+      return null;
+    }
+  }
+  if (hasWildcard) {
+    const wildcardSegments = pathnameSegments.slice(limit);
+    params["*"] = "/" + wildcardSegments.map(decodeURIComponent).join("/");
+  }
+  return params;
+}
+function matchRoutes(routes, pathname) {
+  const normalizedPathname = normalizePathname(pathname);
+  for (const route of routes) {
+    const params = matchPath(route.path, normalizedPathname);
+    if (params) {
+      return {
+        route,
+        params
+      };
+    }
+  }
+  return null;
+}
+var RouterModel = model("RouterModel", {
+  pathname: string,
+  search: string,
+  hash: string,
+  action: enumeration("NavigationAction", ["PUSH", "REPLACE", "POP", "INITIAL"]),
+  params: optional(frozen(), {}),
+  query: optional(frozen(), {}),
+  currentRouteName: optional(maybeNull(string), null),
+  routes: array(RouteDefinition)
+}).views((self) => ({
+  get currentRoute() {
+    if (!self.currentRouteName) return null;
+    return self.routes.find((r) => r.name === self.currentRouteName) || null;
+  },
+  isActive(routeName, params) {
+    if (self.currentRouteName !== routeName) return false;
+    if (params) {
+      for (const [key, val] of Object.entries(params)) {
+        if (self.params[key] !== val) return false;
+      }
+    }
+    return true;
+  }
+})).volatile(() => ({
+  beforeNavigate: null,
+  afterNavigate: null,
+  _popStateListener: null
+})).actions((self) => {
+  return {
+    setGuards(before, after) {
+      self.beforeNavigate = before;
+      self.afterNavigate = after;
+    },
+    setPopStateListener(listener) {
+      self._popStateListener = listener;
+    },
+    syncLocation(pathname, search, hash, action, state) {
+      self.pathname = pathname;
+      self.search = search;
+      self.hash = hash;
+      self.action = action;
+      const parsed = parseUrl(pathname + search + hash);
+      const matched = matchRoutes(self.routes, parsed.pathname);
+      self.params = matched ? matched.params : {};
+      self.query = parsed.query;
+      self.currentRouteName = matched ? matched.route.name : null;
+      if (typeof window !== "undefined" && window.history) {
+        const fullPath = pathname + search + hash;
+        if (action === "PUSH") {
+          window.history.pushState(state, "", fullPath);
+        } else if (action === "REPLACE") {
+          window.history.replaceState(state, "", fullPath);
+        }
+      }
+    },
+    push: flow(function* (path, state) {
+      const parsed = parseUrl(path);
+      const matched = matchRoutes(self.routes, parsed.pathname);
+      const from = {
+        pathname: self.pathname,
+        search: self.search,
+        hash: self.hash,
+        params: self.params,
+        query: self.query,
+        currentRouteName: self.currentRouteName
+      };
+      const to = {
+        pathname: parsed.pathname,
+        search: parsed.search,
+        hash: parsed.hash,
+        params: matched ? matched.params : {},
+        query: parsed.query,
+        currentRouteName: matched ? matched.route.name : null,
+        state
+      };
+      if (self.beforeNavigate) {
+        const result = yield Promise.resolve(self.beforeNavigate(from, to));
+        if (result === false) {
+          return;
+        }
+        if (typeof result === "string") {
+          yield self.push(result, state);
+          return;
+        }
+      }
+      self.syncLocation(to.pathname, to.search, to.hash, "PUSH", state);
+      if (self.afterNavigate) {
+        self.afterNavigate(to);
+      }
+    }),
+    replace: flow(function* (path, state) {
+      const parsed = parseUrl(path);
+      const matched = matchRoutes(self.routes, parsed.pathname);
+      const from = {
+        pathname: self.pathname,
+        search: self.search,
+        hash: self.hash,
+        params: self.params,
+        query: self.query,
+        currentRouteName: self.currentRouteName
+      };
+      const to = {
+        pathname: parsed.pathname,
+        search: parsed.search,
+        hash: parsed.hash,
+        params: matched ? matched.params : {},
+        query: parsed.query,
+        currentRouteName: matched ? matched.route.name : null,
+        state
+      };
+      if (self.beforeNavigate) {
+        const result = yield Promise.resolve(self.beforeNavigate(from, to));
+        if (result === false) {
+          return;
+        }
+        if (typeof result === "string") {
+          yield self.replace(result, state);
+          return;
+        }
+      }
+      self.syncLocation(to.pathname, to.search, to.hash, "REPLACE", state);
+      if (self.afterNavigate) {
+        self.afterNavigate(to);
+      }
+    }),
+    go(delta) {
+      if (typeof window !== "undefined" && window.history) {
+        window.history.go(delta);
+      }
+    },
+    goBack() {
+      if (typeof window !== "undefined" && window.history) {
+        window.history.back();
+      }
+    },
+    goForward() {
+      if (typeof window !== "undefined" && window.history) {
+        window.history.forward();
+      }
+    }
+  };
+}).afterCreate((self) => {
+  if (typeof window !== "undefined") {
+    const handlePopState = (event) => {
+      const parsed = parseUrl(window.location.pathname + window.location.search + window.location.hash);
+      const matched = matchRoutes(self.routes, parsed.pathname);
+      const from = {
+        pathname: self.pathname,
+        search: self.search,
+        hash: self.hash,
+        params: self.params,
+        query: self.query,
+        currentRouteName: self.currentRouteName
+      };
+      const to = {
+        pathname: parsed.pathname,
+        search: parsed.search,
+        hash: parsed.hash,
+        params: matched ? matched.params : {},
+        query: parsed.query,
+        currentRouteName: matched ? matched.route.name : null,
+        state: event.state
+      };
+      const proceed = () => {
+        self.syncLocation(to.pathname, to.search, to.hash, "POP", event.state);
+        if (self.afterNavigate) {
+          self.afterNavigate(to);
+        }
+      };
+      const revert = () => {
+        const fullPath = from.pathname + from.search + from.hash;
+        window.history.replaceState(null, "", fullPath);
+      };
+      if (self.beforeNavigate) {
+        const result = self.beforeNavigate(from, to);
+        if (result instanceof Promise) {
+          result.then((res) => {
+            if (res === false) {
+              revert();
+            } else if (typeof res === "string") {
+              self.push(res);
+            } else {
+              proceed();
+            }
+          }).catch(() => {
+            revert();
+          });
+        } else {
+          if (result === false) {
+            revert();
+          } else if (typeof result === "string") {
+            self.push(result);
+          } else {
+            proceed();
+          }
+        }
+      } else {
+        proceed();
+      }
+    };
+    window.addEventListener("popstate", handlePopState);
+    self.setPopStateListener(handlePopState);
+  }
+}).beforeDestroy((self) => {
+  if (typeof window !== "undefined" && self._popStateListener) {
+    window.removeEventListener("popstate", self._popStateListener);
+    self.setPopStateListener(null);
+  }
+});
+function createRouter(config) {
+  let initialPathname = "/";
+  let initialSearch = "";
+  let initialHash = "";
+  if (config.initialUrl) {
+    const parsed = parseUrl(config.initialUrl);
+    initialPathname = parsed.pathname;
+    initialSearch = parsed.search;
+    initialHash = parsed.hash;
+  } else if (typeof window !== "undefined") {
+    initialPathname = window.location.pathname;
+    initialSearch = window.location.search;
+    initialHash = window.location.hash;
+  }
+  const router = RouterModel.create({
+    pathname: initialPathname,
+    search: initialSearch,
+    hash: initialHash,
+    action: "INITIAL",
+    currentRouteName: null,
+    routes: config.routes.map((r) => ({
+      path: r.path,
+      name: r.name,
+      meta: r.meta || {}
+    }))
+  });
+  router.setGuards(config.beforeNavigate, config.afterNavigate);
+  router.syncLocation(initialPathname, initialSearch, initialHash, "INITIAL");
+  return router;
+}
+var RouterContext = createContext(null);
+function useRouter() {
+  const router = useContext(RouterContext);
+  if (!router) {
+    throw new Error("[jotai-state-tree] useRouter must be used within a RouterContext.Provider");
+  }
+  if (hasStateTreeNode(router)) {
+    const node = getStateTreeNode(router);
+    useAtomValue(node.snapshotAtom, { store: getGlobalStore() });
+  }
+  return router;
+}
+
+export {
+  string,
+  number,
+  integer,
+  boolean,
+  DatePrimitive,
+  nullType,
+  undefinedType,
+  identifier,
+  identifierNumber,
+  literal,
+  enumeration,
+  frozen,
+  custom,
+  finite,
+  float,
+  getIsApplyingSnapshotOrPatch,
+  setIsApplyingSnapshotOrPatch,
+  getGlobalStore,
+  setGlobalStore,
+  resetGlobalStore,
+  getActiveTrackingFn,
+  setActiveTrackingFn,
+  onLifecycleChange,
+  StateTreeNode,
+  $treenode,
+  getStateTreeNode,
+  hasStateTreeNode,
+  applySnapshotToNode,
+  resolveIdentifier,
+  getRegistryStats,
+  cleanupStaleEntries,
+  clearAllRegistries,
+  getRoot,
+  getParent,
+  tryGetParent,
+  hasParent,
+  getParentOfType,
+  getPath,
+  getPathParts,
+  getEnv,
+  isAlive,
+  isRoot,
+  getType,
+  isStateTreeNode,
+  getIdentifier,
+  destroy,
+  detach,
+  clone,
+  getSnapshot,
+  applySnapshot,
+  onSnapshot,
+  onPatch,
+  applyPatch,
+  recordPatches,
+  onAction,
+  walk,
+  getMembers,
+  resolvePath,
+  tryResolve,
+  getRelativePath,
+  isAncestor,
+  haveSameRoot,
+  findAll,
+  findFirst,
+  isValidReference,
+  getTreeStats,
+  cloneDeep,
+  getOrCreatePath,
+  freeze,
+  isFrozen,
+  unfreeze,
+  addMiddleware,
+  flow,
+  recordActions,
+  protect,
+  unprotect,
+  isProtected,
+  canWrite,
+  applyAction,
+  escapeJsonPath,
+  unescapeJsonPath,
+  splitJsonPath,
+  joinJsonPath,
+  model,
+  compose,
+  mixin,
+  array,
+  optional,
+  maybe,
+  maybeNull,
+  union,
+  late,
+  refinement,
+  reference,
+  safeReference,
+  snapshotProcessor,
+  getOrCreateHistoryTracker,
+  createUndoManager,
+  createTimeTravelManager,
+  createActionRecorder,
+  RouteDefinition,
+  RouterModel,
+  createRouter,
+  RouterContext,
+  useRouter
+};