jotai-state-tree 0.1.0

package/dist/react.js

@@ -0,0 +1,1259 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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, identifier) {
+  const weakRef = identifierRegistry.get(typeName)?.get(identifier);
+  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 [identifier, weakRef] of typeMap.entries()) {
+      if (!weakRef.deref()) {
+        typeMap.delete(identifier);
+        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, identifier) {
+  if (!hasStateTreeNode(target)) return false;
+  const node = getStateTreeNode(target);
+  const typeName = node.$type.name;
+  try {
+    const resolved = resolveIdentifier(typeName, identifier);
+    return resolved !== void 0;
+  } catch {
+    return false;
+  }
+}
+function getTreeStats(target) {
+  let nodeCount = 0;
+  let maxDepth = 0;
+  const types = {};
+  walk(target, (node) => {
+    if (!hasStateTreeNode(node)) return;
+    const stateNode = getStateTreeNode(node);
+    nodeCount++;
+    const depth = stateNode.$path.split("/").filter(Boolean).length;
+    maxDepth = Math.max(maxDepth, depth);
+    const typeName = stateNode.$type.name;
+    types[typeName] = (types[typeName] || 0) + 1;
+  });
+  return {
+    nodeCount,
+    depth: maxDepth,
+    types
+  };
+}
+function cloneDeep(target) {
+  const snapshot = getSnapshot(target);
+  const node = getStateTreeNode(target);
+  return node.$type.create(snapshot, node.$env);
+}
+function getOrCreatePath(target, path, creator) {
+  const parts = path.split("/").filter(Boolean);
+  let node = getStateTreeNode(target);
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    let child = node.getChild(part);
+    if (!child && i === parts.length - 1) {
+      const instance = creator();
+      if (hasStateTreeNode(instance)) {
+        child = getStateTreeNode(instance);
+        node.addChild(part, child);
+      } else {
+        throw new Error(
+          "[jotai-state-tree] Creator must return a state tree node"
+        );
+      }
+    }
+    if (!child) {
+      throw new Error(`[jotai-state-tree] Invalid path: ${path}`);
+    }
+    node = child;
+  }
+  return node.getInstance();
+}
+function freeze(target) {
+  const node = getStateTreeNode(target);
+  node.volatileState.$frozen = true;
+  for (const [, child] of node.getChildren()) {
+    const instance = child.getInstance();
+    if (instance && hasStateTreeNode(instance)) {
+      freeze(instance);
+    }
+  }
+}
+function isFrozen(target) {
+  const node = getStateTreeNode(target);
+  return node.volatileState.$frozen === true;
+}
+function unfreeze(target) {
+  const node = getStateTreeNode(target);
+  delete node.volatileState.$frozen;
+  for (const [, child] of node.getChildren()) {
+    const instance = child.getInstance();
+    if (instance && hasStateTreeNode(instance)) {
+      unfreeze(instance);
+    }
+  }
+}
+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, identifier) {
+        this.identifierTypeName = typeName;
+        this.identifierValue = identifier;
+        let typeMap = identifierRegistry.get(typeName);
+        if (!typeMap) {
+          typeMap = /* @__PURE__ */ new Map();
+          identifierRegistry.set(typeName, typeMap);
+        }
+        typeMap.set(identifier, new WeakRef(this));
+        identifierFinalizationRegistry.register(
+          this,
+          { typeName, identifier },
+          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/react.ts
+var react_exports = {};
+__export(react_exports, {
+  Observer: () => Observer,
+  Provider: () => Provider,
+  batch: () => batch,
+  createStoreContext: () => createStoreContext,
+  observer: () => observer,
+  scheduleUpdate: () => scheduleUpdate,
+  useAction: () => useAction,
+  useActions: () => useActions,
+  useCleanup: () => useCleanup,
+  useIsAlive: () => useIsAlive,
+  useLocalObservable: () => useLocalObservable,
+  useObserver: () => useObserver,
+  usePatches: () => usePatches,
+  useSnapshot: () => useSnapshot,
+  useStore: () => useStore,
+  useStoreSnapshot: () => useStoreSnapshot,
+  useSyncedStore: () => useSyncedStore,
+  useWatchPath: () => useWatchPath
+});
+module.exports = __toCommonJS(react_exports);
+var import_react = __toESM(require("react"));
+init_tree();
+function observer(Component, options) {
+  const displayName = Component.displayName || Component.name || "Component";
+  const ObserverComponent = (0, import_react.memo)((props) => {
+    const [, forceUpdate] = (0, import_react.useState)({});
+    const disposersRef = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+    const trackedNodesRef = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+    const trackNode = (node) => {
+      if (hasStateTreeNode(node) && !trackedNodesRef.current.has(node)) {
+        trackedNodesRef.current.add(node);
+        const disposer = onSnapshot(node, () => {
+          forceUpdate({});
+        });
+        disposersRef.current.add(disposer);
+      }
+    };
+    const createTrackingProxy = (target) => {
+      if (!target || typeof target !== "object") return target;
+      if (hasStateTreeNode(target)) {
+        trackNode(target);
+      }
+      return new Proxy(target, {
+        get(obj, prop) {
+          const value = obj[prop];
+          if (value && typeof value === "object" && hasStateTreeNode(value)) {
+            trackNode(value);
+            return createTrackingProxy(value);
+          }
+          return value;
+        }
+      });
+    };
+    (0, import_react.useEffect)(() => {
+      return () => {
+        disposersRef.current.forEach((d) => d());
+        disposersRef.current.clear();
+        trackedNodesRef.current.clear();
+      };
+    }, []);
+    const trackedProps = (0, import_react.useMemo)(() => {
+      const tracked = {};
+      for (const [key, value] of Object.entries(props)) {
+        if (value && typeof value === "object") {
+          tracked[key] = createTrackingProxy(value);
+        } else {
+          tracked[key] = value;
+        }
+      }
+      return tracked;
+    }, [props]);
+    return import_react.default.createElement(Component, trackedProps);
+  });
+  ObserverComponent.displayName = `Observer(${displayName})`;
+  if (options?.forwardRef) {
+    const ForwardedComponent = (0, import_react.forwardRef)((props, ref) => {
+      const propsWithRef = Object.assign({}, props, { ref });
+      return import_react.default.createElement(
+        ObserverComponent,
+        propsWithRef
+      );
+    });
+    ForwardedComponent.displayName = `ForwardRef(${displayName})`;
+    return ForwardedComponent;
+  }
+  return ObserverComponent;
+}
+var Observer = observer(({ children }) => {
+  return import_react.default.createElement(import_react.default.Fragment, null, children());
+});
+function useObserver(fn) {
+  const [, forceUpdate] = (0, import_react.useState)({});
+  const disposersRef = (0, import_react.useRef)([]);
+  const trackedNodes = (0, import_react.useRef)(/* @__PURE__ */ new Set());
+  (0, import_react.useEffect)(() => {
+    return () => {
+      disposersRef.current.forEach((d) => d());
+      disposersRef.current = [];
+    };
+  }, []);
+  const result = (0, import_react.useMemo)(() => {
+    trackedNodes.current.clear();
+    disposersRef.current.forEach((d) => d());
+    disposersRef.current = [];
+    const value = fn();
+    return value;
+  }, [fn]);
+  return result;
+}
+function useLocalObservable(initializer, dependencies = []) {
+  const [, forceUpdate] = (0, import_react.useState)({});
+  const storeRef = (0, import_react.useRef)(null);
+  const disposerRef = (0, import_react.useRef)(null);
+  if (storeRef.current === null) {
+    storeRef.current = initializer();
+    if (hasStateTreeNode(storeRef.current)) {
+      disposerRef.current = onSnapshot(storeRef.current, () => {
+        forceUpdate({});
+      });
+    }
+  }
+  (0, import_react.useEffect)(() => {
+    return () => {
+      disposerRef.current?.();
+    };
+  }, []);
+  (0, import_react.useEffect)(() => {
+    if (dependencies.length > 0) {
+      disposerRef.current?.();
+      storeRef.current = initializer();
+      if (hasStateTreeNode(storeRef.current)) {
+        disposerRef.current = onSnapshot(storeRef.current, () => {
+          forceUpdate({});
+        });
+      }
+    }
+  }, dependencies);
+  return storeRef.current;
+}
+function useSyncedStore(store) {
+  const snapshotRef = (0, import_react.useRef)(null);
+  const subscribe = (0, import_react.useCallback)(
+    (callback) => {
+      if (!hasStateTreeNode(store)) {
+        return () => {
+        };
+      }
+      return onSnapshot(store, () => {
+        snapshotRef.current = getSnapshot(store);
+        callback();
+      });
+    },
+    [store]
+  );
+  const getSnapshotValue = (0, import_react.useCallback)(() => {
+    if (!hasStateTreeNode(store)) {
+      return null;
+    }
+    if (snapshotRef.current === null) {
+      snapshotRef.current = getSnapshot(store);
+    }
+    return snapshotRef.current;
+  }, [store]);
+  (0, import_react.useSyncExternalStore)(subscribe, getSnapshotValue, getSnapshotValue);
+  return store;
+}
+var StoreContext = import_react.default.createContext(
+  null
+);
+function Provider({
+  store,
+  children
+}) {
+  const value = (0, import_react.useMemo)(() => ({ store }), [store]);
+  return import_react.default.createElement(StoreContext.Provider, { value }, children);
+}
+function useStore() {
+  const context = import_react.default.useContext(StoreContext);
+  if (!context) {
+    throw new Error(
+      "[jotai-state-tree] useStore must be used within a Provider"
+    );
+  }
+  return context.store;
+}
+function useStoreSnapshot(selector) {
+  const store = useStore();
+  const [, forceUpdate] = (0, import_react.useState)({});
+  (0, import_react.useEffect)(() => {
+    if (hasStateTreeNode(store)) {
+      return onSnapshot(store, () => {
+        forceUpdate({});
+      });
+    }
+    return () => {
+    };
+  }, [store]);
+  if (selector) {
+    return selector(store);
+  }
+  return store;
+}
+function createStoreContext() {
+  const Context = import_react.default.createContext(null);
+  function StoreProvider({
+    store,
+    children
+  }) {
+    return import_react.default.createElement(Context.Provider, { value: store }, children);
+  }
+  function useTypedStore() {
+    const store = import_react.default.useContext(Context);
+    if (store === null) {
+      throw new Error(
+        "[jotai-state-tree] useStore must be used within a Provider"
+      );
+    }
+    return store;
+  }
+  function useTypedStoreSnapshot(selector) {
+    const store = useTypedStore();
+    const [, forceUpdate] = (0, import_react.useState)({});
+    (0, import_react.useEffect)(() => {
+      if (hasStateTreeNode(store)) {
+        return onSnapshot(store, () => {
+          forceUpdate({});
+        });
+      }
+      return () => {
+      };
+    }, [store]);
+    if (selector) {
+      return selector(store);
+    }
+    return store;
+  }
+  function useTypedIsAlive() {
+    const store = useTypedStore();
+    return useIsAlive(store);
+  }
+  return {
+    Provider: StoreProvider,
+    useStore: useTypedStore,
+    useStoreSnapshot: useTypedStoreSnapshot,
+    useIsAlive: useTypedIsAlive,
+    Context
+  };
+}
+function useSnapshot(target) {
+  const [snapshot, setSnapshot] = (0, import_react.useState)(() => getSnapshot(target));
+  (0, import_react.useEffect)(() => {
+    const disposer = onSnapshot(target, (newSnapshot) => {
+      setSnapshot(newSnapshot);
+    });
+    return disposer;
+  }, [target]);
+  return snapshot;
+}
+function useWatchPath(target, path, defaultValue) {
+  const [value, setValue] = (0, import_react.useState)(() => {
+    const snapshot = getSnapshot(target);
+    const parts = path.split(".");
+    let current = snapshot;
+    for (const part of parts) {
+      if (current && typeof current === "object" && part in current) {
+        current = current[part];
+      } else {
+        return defaultValue;
+      }
+    }
+    return current;
+  });
+  (0, import_react.useEffect)(() => {
+    const disposer = onSnapshot(target, (newSnapshot) => {
+      const snapshot = newSnapshot;
+      const parts = path.split(".");
+      let current = snapshot;
+      for (const part of parts) {
+        if (current && typeof current === "object" && part in current) {
+          current = current[part];
+        } else {
+          setValue(defaultValue);
+          return;
+        }
+      }
+      setValue(current);
+    });
+    return disposer;
+  }, [target, path, defaultValue]);
+  return value;
+}
+function usePatches(target, callback) {
+  (0, import_react.useEffect)(() => {
+    const { onPatch: onPatch2 } = (init_tree(), __toCommonJS(tree_exports));
+    const disposer = onPatch2(target, callback);
+    return disposer;
+  }, [target, callback]);
+}
+function useAction(action) {
+  return (0, import_react.useMemo)(() => action, [action]);
+}
+function useActions(actions) {
+  return (0, import_react.useMemo)(() => actions, [actions]);
+}
+var batchDepth = 0;
+var pendingUpdates = /* @__PURE__ */ new Set();
+function batch(fn) {
+  batchDepth++;
+  try {
+    fn();
+  } finally {
+    batchDepth--;
+    if (batchDepth === 0 && pendingUpdates.size > 0) {
+      const updates = pendingUpdates;
+      pendingUpdates = /* @__PURE__ */ new Set();
+      updates.forEach((update) => update());
+    }
+  }
+}
+function scheduleUpdate(update) {
+  if (batchDepth > 0) {
+    pendingUpdates.add(update);
+  } else {
+    update();
+  }
+}
+function useIsAlive(target) {
+  const [isAlive2, setIsAlive] = (0, import_react.useState)(() => {
+    if (!hasStateTreeNode(target)) return false;
+    return getStateTreeNode(target).$isAlive;
+  });
+  (0, import_react.useEffect)(() => {
+    if (!hasStateTreeNode(target)) return;
+    const node = getStateTreeNode(target);
+    setIsAlive(node.$isAlive);
+    const disposer = onLifecycleChange(node, (alive) => {
+      setIsAlive(alive);
+    });
+    return disposer;
+  }, [target]);
+  return isAlive2;
+}
+function useCleanup(cleanupFn) {
+  const cleanupRef = (0, import_react.useRef)(cleanupFn);
+  cleanupRef.current = cleanupFn;
+  (0, import_react.useEffect)(() => {
+    return () => {
+      cleanupRef.current();
+    };
+  }, []);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Observer,
+  Provider,
+  batch,
+  createStoreContext,
+  observer,
+  scheduleUpdate,
+  useAction,
+  useActions,
+  useCleanup,
+  useIsAlive,
+  useLocalObservable,
+  useObserver,
+  usePatches,
+  useSnapshot,
+  useStore,
+  useStoreSnapshot,
+  useSyncedStore,
+  useWatchPath
+});