jotai-state-tree 0.1.0

package/dist/index.js

@@ -0,0 +1,3579 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tree.ts
+var tree_exports = {};
+__export(tree_exports, {
+  $treenode: () => $treenode,
+  StateTreeNode: () => StateTreeNode,
+  applyPatch: () => applyPatch,
+  applySnapshot: () => applySnapshot,
+  applySnapshotToNode: () => applySnapshotToNode,
+  cleanupStaleEntries: () => cleanupStaleEntries,
+  clearAllRegistries: () => clearAllRegistries,
+  clone: () => clone,
+  cloneDeep: () => cloneDeep,
+  destroy: () => destroy,
+  detach: () => detach,
+  findAll: () => findAll,
+  findFirst: () => findFirst,
+  freeze: () => freeze,
+  getEnv: () => getEnv,
+  getGlobalStore: () => getGlobalStore,
+  getIdentifier: () => getIdentifier,
+  getMembers: () => getMembers,
+  getNodesOfType: () => getNodesOfType,
+  getOrCreatePath: () => getOrCreatePath,
+  getParent: () => getParent,
+  getParentOfType: () => getParentOfType,
+  getPath: () => getPath,
+  getPathParts: () => getPathParts,
+  getRegistryStats: () => getRegistryStats,
+  getRelativePath: () => getRelativePath,
+  getRoot: () => getRoot,
+  getSnapshot: () => getSnapshot,
+  getSnapshotFromNode: () => getSnapshotFromNode,
+  getStateTreeNode: () => getStateTreeNode,
+  getTreeStats: () => getTreeStats,
+  getType: () => getType,
+  hasParent: () => hasParent,
+  hasStateTreeNode: () => hasStateTreeNode,
+  haveSameRoot: () => haveSameRoot,
+  isAlive: () => isAlive,
+  isAncestor: () => isAncestor,
+  isFrozen: () => isFrozen,
+  isRoot: () => isRoot,
+  isStateTreeNode: () => isStateTreeNode,
+  isValidReference: () => isValidReference,
+  onAction: () => onAction,
+  onLifecycleChange: () => onLifecycleChange,
+  onPatch: () => onPatch,
+  onSnapshot: () => onSnapshot,
+  recordPatches: () => recordPatches,
+  registerActionRecorderHook: () => registerActionRecorderHook,
+  resetGlobalStore: () => resetGlobalStore,
+  resolveIdentifier: () => resolveIdentifier,
+  resolvePath: () => resolvePath,
+  setGlobalStore: () => setGlobalStore,
+  trackAction: () => trackAction,
+  tryGetParent: () => tryGetParent,
+  tryResolve: () => tryResolve,
+  unfreeze: () => unfreeze,
+  walk: () => walk
+});
+function getGlobalStore() {
+  return globalStore;
+}
+function setGlobalStore(store) {
+  globalStore = store;
+}
+function resetGlobalStore() {
+  globalStore = (0, import_jotai.createStore)();
+}
+function generateNodeId() {
+  return `node_${++nodeIdCounter}_${Date.now().toString(36)}`;
+}
+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 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) {
+  const type = node.$type;
+  const value = node.getValue();
+  if (type._kind === "model") {
+    const snapshot = {};
+    const children = node.getChildren();
+    for (const [key, childNode] of children) {
+      snapshot[key] = getSnapshotFromNode(childNode);
+    }
+    if (node.postProcessor) {
+      return node.postProcessor(snapshot);
+    }
+    return snapshot;
+  }
+  if (type._kind === "array") {
+    const arr = value;
+    return arr.map((_, index) => {
+      const childNode = node.getChild(String(index));
+      return childNode ? getSnapshotFromNode(childNode) : arr[index];
+    });
+  }
+  if (type._kind === "map") {
+    const snapshot = {};
+    const children = node.getChildren();
+    for (const [key, childNode] of children) {
+      snapshot[key] = getSnapshotFromNode(childNode);
+    }
+    return snapshot;
+  }
+  if (type._kind === "reference") {
+    return node.identifierValue ?? value;
+  }
+  return value;
+}
+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)) {
+    node.setValue(snapshot);
+  } else if (type._kind === "map" && typeof snapshot === "object" && snapshot !== null) {
+    node.setValue(snapshot);
+  } else {
+    node.setValue(snapshot);
+  }
+}
+function resolveIdentifier(typeName, identifier2) {
+  const weakRef = identifierRegistry.get(typeName)?.get(identifier2);
+  return weakRef?.deref();
+}
+function getNodesOfType(typeName) {
+  const typeMap = identifierRegistry.get(typeName);
+  if (!typeMap) return [];
+  const nodes = [];
+  for (const weakRef of typeMap.values()) {
+    const node = weakRef.deref();
+    if (node) {
+      nodes.push(node);
+    }
+  }
+  return nodes;
+}
+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;
+    }
+  }
+  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);
+  return getSnapshotFromNode(node);
+}
+function applySnapshot(target, snapshot) {
+  const node = getStateTreeNode(target);
+  applySnapshotToNode(node, snapshot);
+}
+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();
+  for (const p of patches) {
+    applyPatchToNode(rootNode, p);
+  }
+}
+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 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 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 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());
+    }
+  };
+}
+function registerActionRecorderHook(hook) {
+  actionRecorderHooks.push(hook);
+  return () => {
+    const index = actionRecorderHooks.indexOf(hook);
+    if (index >= 0) {
+      actionRecorderHooks.splice(index, 1);
+    }
+  };
+}
+function trackAction(node, name, args, fn) {
+  const previousAction = currentAction;
+  currentAction = { name, args, tree: node };
+  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;
+  const node = getStateTreeNode(target);
+  const typeName = node.$type.name;
+  try {
+    const resolved = resolveIdentifier(typeName, identifier2);
+    return resolved !== void 0;
+  } catch {
+    return false;
+  }
+}
+function getTreeStats(target) {
+  let nodeCount = 0;
+  let maxDepth = 0;
+  const types2 = {};
+  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;
+    types2[typeName] = (types2[typeName] || 0) + 1;
+  });
+  return {
+    nodeCount,
+    depth: maxDepth,
+    types: types2
+  };
+}
+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);
+    }
+  }
+}
+var import_jotai, globalStore, nodeRegistry, nodeFinalizationRegistry, identifierRegistry, identifierFinalizationRegistry, nodeIdCounter, lifecycleListeners, StateTreeNode, $treenode, currentAction, actionListeners, actionRecorderHooks;
+var init_tree = __esm({
+  "src/tree.ts"() {
+    "use strict";
+    import_jotai = require("jotai");
+    globalStore = (0, import_jotai.createStore)();
+    nodeRegistry = /* @__PURE__ */ new Map();
+    nodeFinalizationRegistry = new FinalizationRegistry((nodeId) => {
+      nodeRegistry.delete(nodeId);
+    });
+    identifierRegistry = /* @__PURE__ */ new Map();
+    identifierFinalizationRegistry = new FinalizationRegistry(
+      (info) => {
+        const typeMap = identifierRegistry.get(info.typeName);
+        if (typeMap) {
+          typeMap.delete(info.identifier);
+          if (typeMap.size === 0) {
+            identifierRegistry.delete(info.typeName);
+          }
+        }
+      }
+    );
+    nodeIdCounter = 0;
+    lifecycleListeners = /* @__PURE__ */ new WeakMap();
+    StateTreeNode = class {
+      constructor(type, initialValue, env, parent, pathSegment) {
+        this.$parent = null;
+        this.$path = "";
+        this.$isAlive = true;
+        /** 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 = {};
+        this.$id = generateNodeId();
+        this.$type = type;
+        this.$env = env ?? parent?.$env;
+        this.$parent = parent ?? null;
+        this.$path = parent ? `${parent.$path}/${pathSegment}` : "";
+        this.valueAtom = (0, import_jotai.atom)(initialValue);
+        nodeRegistry.set(this.$id, { node: new WeakRef(this), instance: null });
+        nodeFinalizationRegistry.register(this, this.$id, this);
+      }
+      /** Set the instance reference */
+      setInstance(instance) {
+        const entry = nodeRegistry.get(this.$id);
+        if (entry && instance && typeof instance === "object") {
+          entry.instance = new WeakRef(instance);
+        }
+      }
+      /** Get the instance */
+      getInstance() {
+        const entry = nodeRegistry.get(this.$id);
+        return entry?.instance?.deref() ?? null;
+      }
+      /** 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();
+        globalStore.set(this.valueAtom, value);
+        this.notifyPatch(
+          { op: "replace", path: this.$path, value },
+          { op: "replace", path: this.$path, value: oldValue, oldValue }
+        );
+        this.notifySnapshotChange();
+      }
+      /** Add a child node */
+      addChild(key, child) {
+        child.$parent = this;
+        const newPath = `${this.$path}/${key}`;
+        this.updatePathRecursively(child, newPath);
+        child.$env = child.$env ?? this.$env;
+        this.children.set(key, child);
+      }
+      /** 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);
+        }
+      }
+      /** 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) {
+        this.patchListeners.forEach((listener) => listener(patch, reversePatch));
+        if (this.$parent) {
+          this.$parent.notifyPatch(patch, reversePatch);
+        }
+      }
+      /** Notify snapshot listeners */
+      notifySnapshotChange() {
+        const root = this.getRoot();
+        const snapshot = getSnapshotFromNode(root);
+        root.snapshotListeners.forEach((listener) => listener(snapshot));
+      }
+      /** Notify about a property change (for use by model proxy) */
+      notifyPropertyChange(propName, newValue, oldValue) {
+        const path = this.$path ? `${this.$path}/${propName}` : `/${propName}`;
+        this.notifyPatch(
+          { op: "replace", path, value: newValue },
+          { op: "replace", path, value: oldValue, oldValue }
+        );
+        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.children.forEach((child) => child.destroy());
+        this.children.clear();
+        this.unregisterIdentifier();
+        this.$isAlive = false;
+        notifyLifecycleChange(this, false);
+        nodeRegistry.delete(this.$id);
+        nodeFinalizationRegistry.unregister(this);
+        this.snapshotListeners.clear();
+        this.patchListeners.clear();
+      }
+      /** Detach from parent */
+      detach() {
+        if (this.$parent) {
+          for (const [key, child] of this.$parent.children) {
+            if (child === this) {
+              this.$parent.children.delete(key);
+              break;
+            }
+          }
+          this.$parent = null;
+          this.$path = "";
+        }
+      }
+    };
+    $treenode = /* @__PURE__ */ Symbol.for("jotai-state-tree-node");
+    currentAction = null;
+    actionListeners = /* @__PURE__ */ new Set();
+    actionRecorderHooks = [];
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Date: () => DatePrimitive,
+  addMiddleware: () => addMiddleware,
+  applyAction: () => applyAction,
+  applyPatch: () => applyPatch,
+  applySnapshot: () => applySnapshot,
+  array: () => array,
+  boolean: () => boolean,
+  cast: () => cast,
+  castToReferenceSnapshot: () => castToReferenceSnapshot,
+  castToSnapshot: () => castToSnapshot,
+  cleanupStaleEntries: () => cleanupStaleEntries,
+  clearAllRegistries: () => clearAllRegistries,
+  clearModelRegistry: () => clearModelRegistry,
+  clone: () => clone,
+  cloneDeep: () => cloneDeep,
+  cloneFrozen: () => cloneFrozen,
+  compose: () => compose,
+  createActionRecorder: () => createActionRecorder,
+  createTimeTravelManager: () => createTimeTravelManager,
+  createUndoManager: () => createUndoManager,
+  createWithDefaults: () => createWithDefaults,
+  custom: () => custom,
+  default: () => index_default,
+  destroy: () => destroy,
+  detach: () => detach,
+  dynamicReference: () => dynamicReference,
+  enumeration: () => enumeration,
+  escapeJsonPath: () => escapeJsonPath,
+  findAll: () => findAll,
+  findFirst: () => findFirst,
+  finite: () => finite,
+  float: () => float,
+  flow: () => flow,
+  freeze: () => freeze,
+  frozen: () => frozen,
+  getDebugInfo: () => getDebugInfo,
+  getEnv: () => getEnv,
+  getGlobalStore: () => getGlobalStore,
+  getIdentifier: () => getIdentifier,
+  getIdentifierAttribute: () => getIdentifierAttribute,
+  getMembers: () => getMembers,
+  getModelMetadata: () => getModelMetadata,
+  getOrCreate: () => getOrCreate,
+  getOrCreatePath: () => getOrCreatePath,
+  getParent: () => getParent,
+  getParentOfType: () => getParentOfType,
+  getPath: () => getPath,
+  getPathParts: () => getPathParts,
+  getRegisteredModelNames: () => getRegisteredModelNames,
+  getRegistryStats: () => getRegistryStats,
+  getRelativePath: () => getRelativePath,
+  getRoot: () => getRoot,
+  getSnapshot: () => getSnapshot,
+  getTreeStats: () => getTreeStats,
+  getType: () => getType,
+  getTypeName: () => getTypeName,
+  getValidationError: () => getValidationError,
+  hasIdentifier: () => hasIdentifier,
+  hasParent: () => hasParent,
+  haveSameRoot: () => haveSameRoot,
+  identifier: () => identifier,
+  identifierNumber: () => identifierNumber,
+  integer: () => integer,
+  isAlive: () => isAlive,
+  isAncestor: () => isAncestor,
+  isArrayType: () => isArrayType,
+  isFrozen: () => isFrozen,
+  isFrozenType: () => isFrozenType,
+  isIdentifierType: () => isIdentifierType,
+  isInstanceOf: () => isInstanceOf,
+  isLateType: () => isLateType,
+  isLiteralType: () => isLiteralType,
+  isMapType: () => isMapType,
+  isModelRegistered: () => isModelRegistered,
+  isModelType: () => isModelType,
+  isOptionalType: () => isOptionalType,
+  isPrimitiveType: () => isPrimitiveType,
+  isProtected: () => isProtected,
+  isReferenceType: () => isReferenceType,
+  isRoot: () => isRoot,
+  isStateTreeNode: () => isStateTreeNode,
+  isType: () => isType,
+  isUnionType: () => isUnionType,
+  isValidReference: () => isValidReference,
+  isValidSnapshot: () => isValidSnapshot,
+  joinJsonPath: () => joinJsonPath,
+  late: () => late,
+  lateModel: () => lateModel,
+  literal: () => literal,
+  map: () => map,
+  maybe: () => maybe,
+  maybeNull: () => maybeNull,
+  model: () => model,
+  nullType: () => nullType,
+  nullable: () => nullable,
+  number: () => number,
+  onAction: () => onAction,
+  onLifecycleChange: () => onLifecycleChange,
+  onModelRegistered: () => onModelRegistered,
+  onPatch: () => onPatch,
+  onSnapshot: () => onSnapshot,
+  optional: () => optional,
+  printTree: () => printTree,
+  protect: () => protect,
+  recordActions: () => recordActions,
+  recordPatches: () => recordPatches,
+  reference: () => reference,
+  refinement: () => refinement,
+  registerModel: () => registerModel,
+  resetGlobalStore: () => resetGlobalStore,
+  resolveIdentifier: () => resolveIdentifier,
+  resolveModel: () => resolveModel,
+  resolveModelAsync: () => resolveModelAsync,
+  resolvePath: () => resolvePath,
+  safeCreate: () => safeCreate,
+  safeDynamicReference: () => safeDynamicReference,
+  safeReference: () => safeReference,
+  setGlobalStore: () => setGlobalStore,
+  snapshotProcessor: () => snapshotProcessor,
+  splitJsonPath: () => splitJsonPath,
+  string: () => string,
+  tryGetParent: () => tryGetParent,
+  tryResolve: () => tryResolve,
+  tryResolveModel: () => tryResolveModel,
+  typecheck: () => typecheck,
+  types: () => types,
+  undefinedType: () => undefinedType,
+  unescapeJsonPath: () => unescapeJsonPath,
+  unfreeze: () => unfreeze,
+  union: () => union,
+  unprotect: () => unprotect,
+  unregisterModel: () => unregisterModel,
+  walk: () => walk
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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/model.ts
+var import_jotai2 = require("jotai");
+init_tree();
+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 = (0, import_jotai2.atom)(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);
+    for (const initializer of this.config.initializers) {
+      initializer(instance);
+    }
+    if (this.config.hooks.afterCreate) {
+      this.config.hooks.afterCreate(instance);
+    }
+    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;
+        }
+        const propStr = String(prop);
+        if (propertyAtoms.has(propStr)) {
+          const childNode = node.getChild(propStr);
+          if (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) {
+          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 in allActions) {
+          return allActions[propStr];
+        }
+        return void 0;
+      },
+      set(target, prop, value) {
+        const propStr = String(prop);
+        if (propertyAtoms.has(propStr)) {
+          const propType = self.properties[propStr];
+          const existingChildNode = node.getChild(propStr);
+          if (propType._kind === "model") {
+            if (existingChildNode) {
+              const { applySnapshotToNode: applySnapshotToNode2 } = (init_tree(), __toCommonJS(tree_exports));
+              applySnapshotToNode2(existingChildNode, value);
+            }
+            return true;
+          }
+          if (propType._kind === "array" || propType._kind === "map") {
+            if (existingChildNode) {
+              existingChildNode.setValue(value);
+            }
+            return true;
+          }
+          const oldValue = existingChildNode?.getValue();
+          if (existingChildNode) {
+            existingChildNode.destroy();
+            node.getChildren().delete(propStr);
+          }
+          const newValue = propType.create(value, node.$env);
+          if (newValue && typeof newValue === "object" && $treenode in newValue) {
+            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 = (0, import_jotai2.atom)(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) {
+          node.volatileState[propStr] = value;
+          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) => {
+            return trackAction(node, key, args, () => {
+              return value.apply(proxy, args);
+            });
+          };
+        }
+      }
+    }
+    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
+      }
+    });
+  }
+};
+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 types2 = typeof args[0] === "string" ? args.slice(1) : args;
+  const mergedProperties = {};
+  for (const type of types2) {
+    Object.assign(mergedProperties, type.properties);
+  }
+  return model(name, mergedProperties);
+}
+
+// src/array.ts
+init_tree();
+var MSTArray = class _MSTArray extends Array {
+  constructor(node, itemType, items = []) {
+    super(...items);
+    this.node = node;
+    this.itemType = itemType;
+    Object.setPrototypeOf(this, _MSTArray.prototype);
+  }
+  replace(items) {
+    this.length = 0;
+    this.push(...items);
+    this.syncToNode();
+  }
+  clear() {
+    this.length = 0;
+    this.syncToNode();
+  }
+  remove(item) {
+    const index = this.indexOf(item);
+    if (index >= 0) {
+      this.splice(index, 1);
+      this.syncToNode();
+      return true;
+    }
+    return false;
+  }
+  spliceWithArray(index, deleteCount, newItems) {
+    const result = deleteCount !== void 0 ? newItems ? this.splice(index, deleteCount, ...newItems) : this.splice(index, deleteCount) : this.splice(index);
+    this.syncToNode();
+    return result;
+  }
+  // Override mutating methods to sync
+  push(...items) {
+    const result = super.push(...items);
+    this.syncToNode();
+    return result;
+  }
+  pop() {
+    const result = super.pop();
+    this.syncToNode();
+    return result;
+  }
+  shift() {
+    const result = super.shift();
+    this.syncToNode();
+    return result;
+  }
+  unshift(...items) {
+    const result = super.unshift(...items);
+    this.syncToNode();
+    return result;
+  }
+  splice(start, deleteCount, ...items) {
+    const result = deleteCount !== void 0 ? super.splice(start, deleteCount, ...items) : super.splice(start);
+    this.syncToNode();
+    return result;
+  }
+  sort(compareFn) {
+    super.sort(compareFn);
+    this.syncToNode();
+    return this;
+  }
+  reverse() {
+    super.reverse();
+    this.syncToNode();
+    return this;
+  }
+  fill(value, start, end) {
+    super.fill(value, start, end);
+    this.syncToNode();
+    return this;
+  }
+  copyWithin(target, start, end) {
+    super.copyWithin(target, start, end);
+    this.syncToNode();
+    return this;
+  }
+  toJSON() {
+    return [...this];
+  }
+  syncToNode() {
+    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 {
+        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;
+        } else {
+          let reusedNode = null;
+          for (const existingNode of existingChildNodes) {
+            if (!keptNodes.has(existingNode) && existingNode.getValue() === item) {
+              reusedNode = existingNode;
+              break;
+            }
+          }
+          if (reusedNode) {
+            newChildren.set(key, reusedNode);
+            keptNodes.add(reusedNode);
+          } else {
+            const childNode = new StateTreeNode(
+              this.itemType,
+              item,
+              this.node.$env
+            );
+            newChildren.set(key, childNode);
+            keptNodes.add(childNode);
+          }
+        }
+      }
+    });
+    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);
+    }
+    this.node.setValue([...this]);
+  }
+};
+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
+    });
+    node.setInstance(mstArray);
+    node.setValue(instances);
+    return mstArray;
+  }
+  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/map.ts
+init_tree();
+var MSTMap = class extends Map {
+  constructor(node, valueType, entries) {
+    super();
+    this.initialized = false;
+    this.node = node;
+    this.valueType = valueType;
+    this.initialized = true;
+    if (entries) {
+      for (const [key, value] of entries) {
+        super.set(key, value);
+      }
+      this.syncToNode();
+    }
+  }
+  put(value) {
+    let key;
+    if (value && typeof value === "object" && $treenode in value) {
+      const valueNode = getStateTreeNode(value);
+      if (valueNode.identifierValue !== void 0) {
+        key = String(valueNode.identifierValue);
+      } else {
+        throw new Error("[jotai-state-tree] Cannot put a value without an identifier into a map");
+      }
+    } else {
+      throw new Error("[jotai-state-tree] Cannot put a non-model value using put()");
+    }
+    this.set(key, value);
+    return value;
+  }
+  merge(values) {
+    const entries = values instanceof Map ? values.entries() : Object.entries(values);
+    for (const [key, value] of entries) {
+      this.set(key, value);
+    }
+    return this;
+  }
+  replace(values) {
+    this.clear();
+    return this.merge(values);
+  }
+  // Override mutating methods to sync
+  set(key, value) {
+    super.set(key, value);
+    if (this.initialized) {
+      this.syncToNode();
+    }
+    return this;
+  }
+  // Override get to return the instance from child node for complex types
+  get(key) {
+    if (this.valueType._kind === "model" || this.valueType._kind === "array" || this.valueType._kind === "map") {
+      const childNode = this.node.getChild(key);
+      if (childNode) {
+        return childNode.getInstance();
+      }
+      return void 0;
+    }
+    return super.get(key);
+  }
+  delete(key) {
+    const result = super.delete(key);
+    if (result && this.initialized) {
+      this.syncToNode();
+    }
+    return result;
+  }
+  clear() {
+    super.clear();
+    if (this.initialized) {
+      this.syncToNode();
+    }
+  }
+  toJSON() {
+    const result = {};
+    this.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  syncToNode() {
+    const existingChildren = new Map(this.node.getChildren());
+    const newChildren = /* @__PURE__ */ new Map();
+    this.forEach((value, key) => {
+      if (this.valueType._kind === "model" || this.valueType._kind === "array" || this.valueType._kind === "map") {
+        if (value && typeof value === "object" && $treenode in value) {
+          const childNode = getStateTreeNode(value);
+          newChildren.set(key, childNode);
+        } else {
+          const childInstance = this.valueType.create(value);
+          const childNode = getStateTreeNode(childInstance);
+          newChildren.set(key, childNode);
+          super.set(key, childInstance);
+        }
+      } else {
+        const existingChild = existingChildren.get(key);
+        if (existingChild && existingChild.getValue() === value) {
+          newChildren.set(key, existingChild);
+        } else {
+          const childNode = new StateTreeNode(this.valueType, value, this.node.$env);
+          newChildren.set(key, childNode);
+        }
+      }
+    });
+    for (const [key, child] of existingChildren) {
+      if (!newChildren.has(key)) {
+        child.destroy();
+      }
+    }
+    this.node.getChildren().clear();
+    for (const [key, childNode] of newChildren) {
+      this.node.addChild(key, childNode);
+    }
+    this.node.setValue(this.toJSON());
+  }
+};
+var MapType = class {
+  constructor(valueType) {
+    this._kind = "map";
+    this._subType = valueType;
+    this.name = `map<${valueType.name}>`;
+  }
+  create(snapshot, env) {
+    const entries = snapshot ?? {};
+    const node = new StateTreeNode(this, entries, env);
+    const instanceEntries = Object.entries(entries).map(([key, value]) => {
+      const instance = this._subType.create(value, env);
+      if (this._subType._kind === "model" || this._subType._kind === "array" || this._subType._kind === "map") {
+        const childNode = getStateTreeNode(instance);
+        node.addChild(key, childNode);
+      } else {
+        const childNode = new StateTreeNode(this._subType, instance, env, node, key);
+        node.addChild(key, childNode);
+      }
+      return [key, instance];
+    });
+    const mstMap = new MSTMap(
+      node,
+      this._subType,
+      instanceEntries
+    );
+    Object.defineProperty(mstMap, $treenode, {
+      value: node,
+      writable: false,
+      enumerable: false
+    });
+    node.setInstance(mstMap);
+    return mstMap;
+  }
+  is(value) {
+    if (!(value instanceof Map)) return false;
+    return $treenode in value;
+  }
+  validate(value, context) {
+    const errors = [];
+    if (typeof value !== "object" || value === null) {
+      return {
+        valid: false,
+        errors: [
+          {
+            context,
+            value,
+            message: "Value is not an object or Map"
+          }
+        ]
+      };
+    }
+    const entries = value instanceof Map ? Array.from(value.entries()) : Object.entries(value);
+    for (const [key, itemValue] of entries) {
+      const itemContext = {
+        path: context.length > 0 ? `${context[0].path}/${key}` : `/${key}`,
+        type: this._subType,
+        parent: value
+      };
+      const result = this._subType.validate(itemValue, [...context, itemContext]);
+      if (!result.valid) {
+        errors.push(...result.errors);
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+};
+function map(valueType) {
+  return new MapType(valueType);
+}
+
+// src/utilities.ts
+init_tree();
+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(types2, options) {
+    this._kind = "union";
+    this._types = types2;
+    this.dispatcher = options?.dispatcher;
+    this.eager = options?.eager ?? true;
+    this.name = `union(${types2.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) {
+      return type.validate(value, context);
+    }
+  };
+}
+
+// src/registry.ts
+init_tree();
+var modelRegistry = /* @__PURE__ */ new Map();
+var pendingResolutions = /* @__PURE__ */ new Map();
+var registrationListeners = /* @__PURE__ */ new Set();
+function registerModel(name, type, metadata) {
+  if (modelRegistry.has(name)) {
+    throw new Error(
+      `[jotai-state-tree] Model "${name}" is already registered. Use unregisterModel() first if you want to replace it.`
+    );
+  }
+  modelRegistry.set(name, { type, metadata });
+  const pending = pendingResolutions.get(name);
+  if (pending) {
+    pending.forEach(({ resolve }) => resolve(type));
+    pendingResolutions.delete(name);
+  }
+  registrationListeners.forEach((listener) => listener(name, type));
+}
+function unregisterModel(name) {
+  return modelRegistry.delete(name);
+}
+function isModelRegistered(name) {
+  return modelRegistry.has(name);
+}
+function resolveModel(name) {
+  const entry = modelRegistry.get(name);
+  if (!entry) {
+    throw new Error(
+      `[jotai-state-tree] Model "${name}" is not registered. Make sure to call registerModel("${name}", YourModelType) before resolving.`
+    );
+  }
+  return entry.type;
+}
+function tryResolveModel(name) {
+  return modelRegistry.get(name)?.type;
+}
+function resolveModelAsync(name, timeout = 3e4) {
+  const entry = modelRegistry.get(name);
+  if (entry) {
+    return Promise.resolve(entry.type);
+  }
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      const pending = pendingResolutions.get(name);
+      if (pending) {
+        const index = pending.findIndex((p) => p.resolve === resolve);
+        if (index >= 0) {
+          pending.splice(index, 1);
+          if (pending.length === 0) {
+            pendingResolutions.delete(name);
+          }
+        }
+      }
+      reject(
+        new Error(
+          `[jotai-state-tree] Timeout waiting for model "${name}" to be registered`
+        )
+      );
+    }, timeout);
+    const wrappedResolve = (type) => {
+      clearTimeout(timeoutId);
+      resolve(type);
+    };
+    const wrappedReject = (error) => {
+      clearTimeout(timeoutId);
+      reject(error);
+    };
+    if (!pendingResolutions.has(name)) {
+      pendingResolutions.set(name, []);
+    }
+    pendingResolutions.get(name).push({
+      resolve: wrappedResolve,
+      reject: wrappedReject
+    });
+  });
+}
+function getModelMetadata(name) {
+  return modelRegistry.get(name)?.metadata;
+}
+function getRegisteredModelNames() {
+  return Array.from(modelRegistry.keys());
+}
+function onModelRegistered(listener) {
+  registrationListeners.add(listener);
+  return () => {
+    registrationListeners.delete(listener);
+  };
+}
+function clearModelRegistry() {
+  modelRegistry.clear();
+  pendingResolutions.forEach((pending, name) => {
+    pending.forEach(({ reject }) => {
+      reject(
+        new Error(
+          `[jotai-state-tree] Model registry was cleared while waiting for "${name}"`
+        )
+      );
+    });
+  });
+  pendingResolutions.clear();
+}
+var LateModelType = class {
+  constructor(modelName) {
+    this._kind = "lateModel";
+    this._modelName = modelName;
+    this.name = `lateModel("${modelName}")`;
+  }
+  getType() {
+    if (!this._resolvedType) {
+      this._resolvedType = resolveModel(this._modelName);
+    }
+    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 lateModel(modelName) {
+  return new LateModelType(modelName);
+}
+var DynamicReferenceType = class {
+  constructor(modelName, options = {}) {
+    this._kind = "dynamicReference";
+    this._modelName = modelName;
+    this._options = options;
+    this.name = `dynamicReference("${modelName}")`;
+  }
+  create(snapshot, env) {
+    if (snapshot === void 0 || snapshot === null) {
+      throw new Error(
+        `[jotai-state-tree] Cannot create dynamicReference with undefined/null identifier`
+      );
+    }
+    const self = this;
+    const referenceProxy = new Proxy({}, {
+      get(_target, prop) {
+        const resolved = self.resolveReference(snapshot, null);
+        if (!resolved) {
+          if (self._options.onInvalidated) {
+            const fallback = self._options.onInvalidated(snapshot, null);
+            if (fallback) {
+              return fallback[prop];
+            }
+          }
+          throw new Error(
+            `[jotai-state-tree] Failed to resolve dynamicReference("${self._modelName}") with identifier "${snapshot}"`
+          );
+        }
+        return resolved[prop];
+      },
+      has(_target, prop) {
+        const resolved = self.resolveReference(snapshot, null);
+        if (!resolved) return false;
+        return prop in resolved;
+      },
+      ownKeys(_target) {
+        const resolved = self.resolveReference(snapshot, null);
+        if (!resolved) return [];
+        return Reflect.ownKeys(resolved);
+      },
+      getOwnPropertyDescriptor(_target, prop) {
+        const resolved = self.resolveReference(snapshot, null);
+        if (!resolved) return void 0;
+        return Object.getOwnPropertyDescriptor(resolved, prop);
+      }
+    });
+    return referenceProxy;
+  }
+  resolveReference(identifier2, parent) {
+    if (this._options.get) {
+      return this._options.get(identifier2, parent);
+    }
+    try {
+      const targetType = tryResolveModel(this._modelName);
+      if (!targetType) {
+        return void 0;
+      }
+      return resolveIdentifier(this._modelName, identifier2);
+    } catch {
+      return void 0;
+    }
+  }
+  is(value) {
+    if (typeof value === "string" || typeof value === "number") {
+      return true;
+    }
+    const targetType = tryResolveModel(this._modelName);
+    if (targetType) {
+      return targetType.is(value);
+    }
+    return false;
+  }
+  validate(value, context) {
+    if (value === void 0 || value === null) {
+      return {
+        valid: false,
+        errors: [
+          {
+            context,
+            value,
+            message: "Reference identifier cannot be undefined or null"
+          }
+        ]
+      };
+    }
+    if (typeof value !== "string" && typeof value !== "number") {
+      return {
+        valid: false,
+        errors: [
+          {
+            context,
+            value,
+            message: "Reference identifier must be a string or number"
+          }
+        ]
+      };
+    }
+    return { valid: true, errors: [] };
+  }
+};
+function dynamicReference(modelName, options = {}) {
+  return new DynamicReferenceType(modelName, options);
+}
+var SafeDynamicReferenceType = class {
+  constructor(modelName, options = {}) {
+    this._kind = "safeDynamicReference";
+    this._modelName = modelName;
+    this._options = options;
+    this.name = `safeDynamicReference("${modelName}")`;
+  }
+  create(snapshot, env) {
+    if (snapshot === void 0 || snapshot === null) {
+      return void 0;
+    }
+    try {
+      if (this._options.get) {
+        return this._options.get(snapshot, null);
+      }
+      const targetType = tryResolveModel(this._modelName);
+      if (!targetType) {
+        return void 0;
+      }
+      return resolveIdentifier(this._modelName, snapshot);
+    } catch {
+      if (this._options.onInvalidated) {
+        return this._options.onInvalidated(snapshot, null);
+      }
+      return void 0;
+    }
+  }
+  is(value) {
+    if (value === void 0) return true;
+    if (typeof value === "string" || typeof value === "number") return true;
+    const targetType = tryResolveModel(this._modelName);
+    if (targetType) {
+      return targetType.is(value);
+    }
+    return false;
+  }
+  validate(value, context) {
+    if (value === void 0 || value === null) {
+      return { valid: true, errors: [] };
+    }
+    if (typeof value !== "string" && typeof value !== "number") {
+      return {
+        valid: false,
+        errors: [
+          {
+            context,
+            value,
+            message: "Reference identifier must be a string, number, or undefined"
+          }
+        ]
+      };
+    }
+    return { valid: true, errors: [] };
+  }
+};
+function safeDynamicReference(modelName, options = {}) {
+  return new SafeDynamicReferenceType(modelName, options);
+}
+
+// src/index.ts
+init_tree();
+
+// src/lifecycle.ts
+init_tree();
+var middlewareStack = [];
+function addMiddleware(target, handler, includeHooks = true) {
+  middlewareStack.push(handler);
+  return () => {
+    const index = middlewareStack.indexOf(handler);
+    if (index >= 0) {
+      middlewareStack.splice(index, 1);
+    }
+  };
+}
+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 protectedNodes = /* @__PURE__ */ new WeakSet();
+function protect(target) {
+  const node = getStateTreeNode(target);
+  protectedNodes.add(node);
+}
+function unprotect(target) {
+  const node = getStateTreeNode(target);
+  protectedNodes.delete(node);
+}
+function isProtected(target) {
+  const node = getStateTreeNode(target);
+  return protectedNodes.has(node);
+}
+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("/");
+}
+
+// src/compat.ts
+init_tree();
+function isType(value) {
+  return value !== null && typeof value === "object" && "_kind" in value && "create" in value && "is" in value;
+}
+function isPrimitiveType(type) {
+  return isType(type) && (type._kind === "simple" || type._kind === "literal" || type._kind === "enumeration" || type._kind === "identifier" || type._kind === "identifierNumber");
+}
+function getTypeName(type) {
+  return type.name;
+}
+function isValidSnapshot(type, value) {
+  try {
+    const result = type.validate(value, []);
+    return result.valid;
+  } catch {
+    return false;
+  }
+}
+function getValidationError(type, value) {
+  const result = type.validate(value, [{ path: "", type, parent: null }]);
+  if (result.valid) return null;
+  return result.errors.map((e) => e.message).join("; ");
+}
+function isInstanceOf(value, type) {
+  if (!hasStateTreeNode(value)) return false;
+  const node = getStateTreeNode(value);
+  return node.$type === type || node.$type.name === type.name;
+}
+function getOrCreate(type, snapshotOrInstance, env) {
+  if (hasStateTreeNode(snapshotOrInstance)) {
+    return snapshotOrInstance;
+  }
+  return type.create(snapshotOrInstance, env);
+}
+function getDebugInfo(target) {
+  const node = getStateTreeNode(target);
+  return {
+    typeName: node.$type.name,
+    path: node.$path,
+    identifier: node.identifierValue ?? null,
+    isAlive: node.$isAlive,
+    snapshot: getSnapshot(target)
+  };
+}
+function printTree(target, indent = 0) {
+  const node = getStateTreeNode(target);
+  const prefix = "  ".repeat(indent);
+  let output = `${prefix}${node.$type.name}`;
+  if (node.identifierValue !== void 0) {
+    output += ` (${node.identifierValue})`;
+  }
+  output += "\n";
+  for (const [key, child] of node.getChildren()) {
+    const childInstance = child.getInstance();
+    if (childInstance && hasStateTreeNode(childInstance)) {
+      output += `${prefix}  ${key}: ${printTree(childInstance, indent + 2)}`;
+    } else {
+      output += `${prefix}  ${key}: ${JSON.stringify(child.getValue())}
+`;
+    }
+  }
+  return output;
+}
+function hasIdentifier(type) {
+  return type.identifierAttribute !== void 0;
+}
+function getIdentifierAttribute(type) {
+  return type.identifierAttribute;
+}
+function nullable(type) {
+  return {
+    name: `nullable<${type.name}>`,
+    _kind: "maybe",
+    _C: void 0,
+    _S: void 0,
+    _T: void 0,
+    create(snapshot, env) {
+      if (snapshot === null || snapshot === void 0) {
+        return snapshot;
+      }
+      return type.create(snapshot, env);
+    },
+    is(value) {
+      return value === null || value === void 0 || type.is(value);
+    },
+    validate(value, context) {
+      if (value === null || value === void 0) {
+        return { valid: true, errors: [] };
+      }
+      return type.validate(value, context);
+    }
+  };
+}
+function cloneFrozen(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map(cloneFrozen);
+  }
+  const result = {};
+  for (const [key, val] of Object.entries(value)) {
+    result[key] = cloneFrozen(val);
+  }
+  return result;
+}
+function safeCreate(type, snapshot, env) {
+  try {
+    return type.create(snapshot, env);
+  } catch {
+    return void 0;
+  }
+}
+function createWithDefaults(type, snapshot = {}, env) {
+  return type.create(snapshot, env);
+}
+
+// src/undo.ts
+init_tree();
+var UndoManager = class {
+  constructor(target, options = {}) {
+    this.historyEntries = [];
+    this.currentIndex = -1;
+    this.isUndoing = false;
+    this.isRedoing = false;
+    this.skipRecording = false;
+    this.grouping = false;
+    this.currentGroup = [];
+    this.currentGroupInverse = [];
+    this.disposer = null;
+    this.lastChangeTime = 0;
+    this.target = target;
+    this.options = {
+      maxHistoryLength: options.maxHistoryLength ?? 100,
+      groupByTime: options.groupByTime ?? false,
+      groupingWindow: options.groupingWindow ?? 200
+    };
+    this.disposer = onPatch(target, (patch, reversePatch) => {
+      this.recordPatch(patch, reversePatch);
+    });
+  }
+  get canUndo() {
+    return this.currentIndex >= 0;
+  }
+  get canRedo() {
+    return this.currentIndex < this.historyEntries.length - 1;
+  }
+  get undoLevels() {
+    return this.currentIndex + 1;
+  }
+  get redoLevels() {
+    return this.historyEntries.length - this.currentIndex - 1;
+  }
+  get history() {
+    return [...this.historyEntries];
+  }
+  get historyIndex() {
+    return this.currentIndex;
+  }
+  recordPatch(patch, reversePatch) {
+    if (this.isUndoing || this.isRedoing || this.skipRecording) {
+      return;
+    }
+    const now = Date.now();
+    if (this.grouping) {
+      this.currentGroup.push(reversePatch);
+      this.currentGroupInverse.unshift({ ...patch });
+      return;
+    }
+    if (this.options.groupByTime && this.historyEntries.length > 0 && now - this.lastChangeTime < this.options.groupingWindow && this.currentIndex === this.historyEntries.length - 1) {
+      const lastEntry = this.historyEntries[this.currentIndex];
+      lastEntry.patches.push(reversePatch);
+      lastEntry.inversePatches.unshift({ ...patch });
+      lastEntry.timestamp = now;
+    } else {
+      if (this.currentIndex < this.historyEntries.length - 1) {
+        this.historyEntries.splice(this.currentIndex + 1);
+      }
+      this.historyEntries.push({
+        patches: [reversePatch],
+        inversePatches: [{ ...patch }],
+        timestamp: now
+      });
+      this.currentIndex++;
+      if (this.historyEntries.length > this.options.maxHistoryLength) {
+        const excess = this.historyEntries.length - this.options.maxHistoryLength;
+        this.historyEntries.splice(0, excess);
+        this.currentIndex -= excess;
+      }
+    }
+    this.lastChangeTime = now;
+  }
+  undo() {
+    if (!this.canUndo) {
+      return;
+    }
+    this.isUndoing = true;
+    try {
+      const entry = this.historyEntries[this.currentIndex];
+      for (let i = entry.patches.length - 1; i >= 0; i--) {
+        applyPatch(this.target, entry.patches[i]);
+      }
+      this.currentIndex--;
+    } finally {
+      this.isUndoing = false;
+    }
+  }
+  redo() {
+    if (!this.canRedo) {
+      return;
+    }
+    this.isRedoing = true;
+    try {
+      this.currentIndex++;
+      const entry = this.historyEntries[this.currentIndex];
+      for (const patch of entry.inversePatches) {
+        applyPatch(this.target, patch);
+      }
+    } finally {
+      this.isRedoing = false;
+    }
+  }
+  clear() {
+    this.historyEntries = [];
+    this.currentIndex = -1;
+    this.currentGroup = [];
+    this.currentGroupInverse = [];
+    this.grouping = false;
+  }
+  startGroup() {
+    this.grouping = true;
+    this.currentGroup = [];
+    this.currentGroupInverse = [];
+  }
+  endGroup() {
+    if (!this.grouping) {
+      return;
+    }
+    this.grouping = false;
+    if (this.currentGroup.length > 0) {
+      if (this.currentIndex < this.historyEntries.length - 1) {
+        this.historyEntries.splice(this.currentIndex + 1);
+      }
+      this.historyEntries.push({
+        patches: this.currentGroup,
+        inversePatches: this.currentGroupInverse,
+        timestamp: Date.now()
+      });
+      this.currentIndex++;
+      if (this.historyEntries.length > this.options.maxHistoryLength) {
+        const excess = this.historyEntries.length - this.options.maxHistoryLength;
+        this.historyEntries.splice(0, excess);
+        this.currentIndex -= excess;
+      }
+    }
+    this.currentGroup = [];
+    this.currentGroupInverse = [];
+  }
+  withoutUndo(fn) {
+    this.skipRecording = true;
+    try {
+      return fn();
+    } finally {
+      this.skipRecording = false;
+    }
+  }
+  dispose() {
+    if (this.disposer) {
+      this.disposer();
+      this.disposer = null;
+    }
+    this.clear();
+  }
+};
+function createUndoManager(target, options) {
+  return new UndoManager(target, options);
+}
+var TimeTravelManager = class {
+  constructor(target, options = {}) {
+    this.snapshots = [];
+    this.index = -1;
+    this.isApplying = false;
+    this.disposer = null;
+    this.target = target;
+    this.maxSnapshots = options.maxSnapshots ?? 50;
+    this.autoRecord = options.autoRecord ?? false;
+    this.record();
+    if (this.autoRecord) {
+      this.disposer = onPatch(target, () => {
+        if (!this.isApplying) {
+          this.record();
+        }
+      });
+    }
+  }
+  get currentIndex() {
+    return this.index;
+  }
+  get snapshotCount() {
+    return this.snapshots.length;
+  }
+  get canGoBack() {
+    return this.index > 0;
+  }
+  get canGoForward() {
+    return this.index < this.snapshots.length - 1;
+  }
+  record() {
+    if (this.index < this.snapshots.length - 1) {
+      this.snapshots.splice(this.index + 1);
+    }
+    this.snapshots.push(getSnapshot(this.target));
+    this.index++;
+    if (this.snapshots.length > this.maxSnapshots) {
+      const excess = this.snapshots.length - this.maxSnapshots;
+      this.snapshots.splice(0, excess);
+      this.index -= excess;
+    }
+  }
+  goBack() {
+    if (!this.canGoBack) return;
+    this.goTo(this.index - 1);
+  }
+  goForward() {
+    if (!this.canGoForward) return;
+    this.goTo(this.index + 1);
+  }
+  goTo(index) {
+    if (index < 0 || index >= this.snapshots.length) return;
+    this.isApplying = true;
+    try {
+      this.index = index;
+      applySnapshot(this.target, this.snapshots[index]);
+    } finally {
+      this.isApplying = false;
+    }
+  }
+  getSnapshot(index) {
+    if (index < 0 || index >= this.snapshots.length) {
+      throw new Error(`[jotai-state-tree] Invalid snapshot index: ${index}`);
+    }
+    return this.snapshots[index];
+  }
+  clear() {
+    this.snapshots = [];
+    this.index = -1;
+    this.record();
+  }
+  dispose() {
+    if (this.disposer) {
+      this.disposer();
+      this.disposer = null;
+    }
+  }
+};
+function createTimeTravelManager(target, options) {
+  return new TimeTravelManager(target, options);
+}
+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;
+    const { onAction: onAction2 } = (init_tree(), __toCommonJS(tree_exports));
+    this.disposer = onAction2(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/index.ts
+var types = {
+  // Primitives
+  string,
+  number,
+  integer,
+  boolean,
+  Date: DatePrimitive,
+  null: nullType,
+  undefined: undefinedType,
+  finite,
+  float,
+  // Identifiers
+  identifier,
+  identifierNumber,
+  // Literals & Enums
+  literal,
+  enumeration,
+  // Frozen
+  frozen,
+  // Custom
+  custom,
+  // Model
+  model,
+  compose,
+  // Collections
+  array,
+  map,
+  // Optionality
+  optional,
+  maybe,
+  maybeNull,
+  // Union & Late
+  union,
+  late,
+  // References
+  reference,
+  safeReference,
+  // Refinement
+  refinement,
+  // Snapshot processing
+  snapshotProcessor,
+  // Registry-based types (for dynamic model registration)
+  lateModel,
+  dynamicReference,
+  safeDynamicReference
+};
+function flow(generator) {
+  return function flowAction(...args) {
+    const gen = generator(...args);
+    function step(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) => step(() => gen.next(value)),
+        (error) => step(() => gen.throw(error))
+      );
+    }
+    return step(() => gen.next(void 0));
+  };
+}
+function cast(value) {
+  return value;
+}
+function castToSnapshot(value) {
+  return value;
+}
+function castToReferenceSnapshot(value) {
+  const { getIdentifier: getIdentifier2 } = (init_tree(), __toCommonJS(tree_exports));
+  return getIdentifier2(value) ?? value;
+}
+function isIdentifierType(type) {
+  return type !== null && typeof type === "object" && "_kind" in type && (type._kind === "identifier" || type._kind === "identifierNumber");
+}
+function isModelType(type) {
+  return type !== null && typeof type === "object" && "_kind" in type && type._kind === "model";
+}
+function isArrayType(type) {
+  return type !== null && typeof type === "object" && "_kind" in type && type._kind === "array";
+}
+function isMapType(type) {
+  return type !== null && typeof type === "object" && "_kind" in type && type._kind === "map";
+}
+function isReferenceType(type) {
+  return type !== null && typeof type === "object" && "_kind" in type && (type._kind === "reference" || type._kind === "safeReference");
+}
+function isUnionType(type) {
+  return type !== null && typeof type === "object" && "_kind" in type && type._kind === "union";
+}
+function isOptionalType(type) {
+  return type !== null && typeof type === "object" && "_kind" in type && (type._kind === "optional" || type._kind === "maybe" || type._kind === "maybeNull");
+}
+function isLateType(type) {
+  return type !== null && typeof type === "object" && "_kind" in type && type._kind === "late";
+}
+function isFrozenType(type) {
+  return type !== null && typeof type === "object" && "_kind" in type && type._kind === "frozen";
+}
+function isLiteralType(type) {
+  return type !== null && typeof type === "object" && "_kind" in type && type._kind === "literal";
+}
+function typecheck(type, value) {
+  if (!type.is(value)) {
+    throw new Error(`[jotai-state-tree] Value does not match type`);
+  }
+}
+var index_default = types;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Date,
+  addMiddleware,
+  applyAction,
+  applyPatch,
+  applySnapshot,
+  array,
+  boolean,
+  cast,
+  castToReferenceSnapshot,
+  castToSnapshot,
+  cleanupStaleEntries,
+  clearAllRegistries,
+  clearModelRegistry,
+  clone,
+  cloneDeep,
+  cloneFrozen,
+  compose,
+  createActionRecorder,
+  createTimeTravelManager,
+  createUndoManager,
+  createWithDefaults,
+  custom,
+  destroy,
+  detach,
+  dynamicReference,
+  enumeration,
+  escapeJsonPath,
+  findAll,
+  findFirst,
+  finite,
+  float,
+  flow,
+  freeze,
+  frozen,
+  getDebugInfo,
+  getEnv,
+  getGlobalStore,
+  getIdentifier,
+  getIdentifierAttribute,
+  getMembers,
+  getModelMetadata,
+  getOrCreate,
+  getOrCreatePath,
+  getParent,
+  getParentOfType,
+  getPath,
+  getPathParts,
+  getRegisteredModelNames,
+  getRegistryStats,
+  getRelativePath,
+  getRoot,
+  getSnapshot,
+  getTreeStats,
+  getType,
+  getTypeName,
+  getValidationError,
+  hasIdentifier,
+  hasParent,
+  haveSameRoot,
+  identifier,
+  identifierNumber,
+  integer,
+  isAlive,
+  isAncestor,
+  isArrayType,
+  isFrozen,
+  isFrozenType,
+  isIdentifierType,
+  isInstanceOf,
+  isLateType,
+  isLiteralType,
+  isMapType,
+  isModelRegistered,
+  isModelType,
+  isOptionalType,
+  isPrimitiveType,
+  isProtected,
+  isReferenceType,
+  isRoot,
+  isStateTreeNode,
+  isType,
+  isUnionType,
+  isValidReference,
+  isValidSnapshot,
+  joinJsonPath,
+  late,
+  lateModel,
+  literal,
+  map,
+  maybe,
+  maybeNull,
+  model,
+  nullType,
+  nullable,
+  number,
+  onAction,
+  onLifecycleChange,
+  onModelRegistered,
+  onPatch,
+  onSnapshot,
+  optional,
+  printTree,
+  protect,
+  recordActions,
+  recordPatches,
+  reference,
+  refinement,
+  registerModel,
+  resetGlobalStore,
+  resolveIdentifier,
+  resolveModel,
+  resolveModelAsync,
+  resolvePath,
+  safeCreate,
+  safeDynamicReference,
+  safeReference,
+  setGlobalStore,
+  snapshotProcessor,
+  splitJsonPath,
+  string,
+  tryGetParent,
+  tryResolve,
+  tryResolveModel,
+  typecheck,
+  types,
+  undefinedType,
+  unescapeJsonPath,
+  unfreeze,
+  union,
+  unprotect,
+  unregisterModel,
+  walk
+});