jotai-state-tree 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2625 @@
+import {
+  $treenode,
+  StateTreeNode,
+  __toCommonJS,
+  applyPatch,
+  applySnapshot,
+  cleanupStaleEntries,
+  clearAllRegistries,
+  clone,
+  cloneDeep,
+  destroy,
+  detach,
+  findAll,
+  findFirst,
+  freeze,
+  getEnv,
+  getGlobalStore,
+  getIdentifier,
+  getMembers,
+  getOrCreatePath,
+  getParent,
+  getParentOfType,
+  getPath,
+  getPathParts,
+  getRegistryStats,
+  getRelativePath,
+  getRoot,
+  getSnapshot,
+  getStateTreeNode,
+  getTreeStats,
+  getType,
+  hasParent,
+  hasStateTreeNode,
+  haveSameRoot,
+  init_tree,
+  isAlive,
+  isAncestor,
+  isFrozen,
+  isRoot,
+  isStateTreeNode,
+  isValidReference,
+  onAction,
+  onLifecycleChange,
+  onPatch,
+  onSnapshot,
+  recordPatches,
+  registerActionRecorderHook,
+  resetGlobalStore,
+  resolveIdentifier,
+  resolvePath,
+  setGlobalStore,
+  trackAction,
+  tree_exports,
+  tryGetParent,
+  tryResolve,
+  unfreeze,
+  walk
+} from "./chunk-XXZK62DD.mjs";
+
+// 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
+init_tree();
+import { atom } from "jotai";
+var MAX_CACHE_SIZE = 100;
+var LRUCache = class {
+  constructor(maxSize = MAX_CACHE_SIZE) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    const value = this.cache.get(key);
+    if (value !== void 0) {
+      this.cache.delete(key);
+      this.cache.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  get size() {
+    return this.cache.size;
+  }
+};
+var ModelType = class _ModelType {
+  constructor(config) {
+    this._kind = "model";
+    this.config = config;
+    this.name = config.name;
+    this.properties = config.properties;
+    for (const [key, type] of Object.entries(config.properties)) {
+      if (type._kind === "identifier" || type._kind === "identifierNumber") {
+        this.identifierAttribute = key;
+        break;
+      }
+    }
+  }
+  create(snapshot, env) {
+    let processedSnapshot = snapshot ?? {};
+    if (this.config.preProcessor) {
+      processedSnapshot = this.config.preProcessor(
+        processedSnapshot
+      );
+    }
+    const node = new StateTreeNode(this, processedSnapshot, env);
+    node.preProcessor = this.config.preProcessor;
+    node.postProcessor = this.config.postProcessor;
+    const propertyAtoms = /* @__PURE__ */ new Map();
+    const store = getGlobalStore();
+    for (const [key, propType] of Object.entries(this.properties)) {
+      const type = propType;
+      const initialValue = processedSnapshot?.[key];
+      const isComplexType = type._kind === "model" || type._kind === "array" || type._kind === "map";
+      if (isComplexType) {
+        const childInstance = type.create(initialValue, env);
+        const childNode = getStateTreeNode(childInstance);
+        node.addChild(key, childNode);
+        propertyAtoms.set(key, childNode.valueAtom);
+      } else {
+        const value = type.create(initialValue, env);
+        if (value && typeof value === "object" && $treenode in value) {
+          const childNode = getStateTreeNode(value);
+          node.addChild(key, childNode);
+          propertyAtoms.set(key, childNode.valueAtom);
+        } else {
+          const propAtom = 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 } = (init_tree(), __toCommonJS(tree_exports));
+              applySnapshotToNode(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 = 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;
+export {
+  DatePrimitive as Date,
+  addMiddleware,
+  applyAction,
+  applyPatch,
+  applySnapshot,
+  array,
+  boolean,
+  cast,
+  castToReferenceSnapshot,
+  castToSnapshot,
+  cleanupStaleEntries,
+  clearAllRegistries,
+  clearModelRegistry,
+  clone,
+  cloneDeep,
+  cloneFrozen,
+  compose,
+  createActionRecorder,
+  createTimeTravelManager,
+  createUndoManager,
+  createWithDefaults,
+  custom,
+  index_default as default,
+  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
+};