@framesquared/data 0.1.0

package/dist/index.js

@@ -0,0 +1,2931 @@
+import {
+  Operation
+} from "./chunk-CJJTXTV2.js";
+
+// src/Model.ts
+import { Base, Observable } from "@framesquared/core";
+
+// src/field/Field.ts
+var FieldType = /* @__PURE__ */ ((FieldType2) => {
+  FieldType2["STRING"] = "string";
+  FieldType2["INT"] = "int";
+  FieldType2["FLOAT"] = "float";
+  FieldType2["BOOLEAN"] = "boolean";
+  FieldType2["DATE"] = "date";
+  FieldType2["AUTO"] = "auto";
+  return FieldType2;
+})(FieldType || {});
+var Field = class {
+  name;
+  type;
+  mapping;
+  persist;
+  critical;
+  allowNull;
+  sortType;
+  validators;
+  customConvert;
+  customSerialize;
+  customDefault;
+  constructor(def) {
+    this.name = def.name;
+    this.type = def.type ?? "auto" /* AUTO */;
+    this.mapping = def.mapping;
+    this.persist = def.persist ?? true;
+    this.critical = def.critical ?? false;
+    this.allowNull = def.allowNull ?? false;
+    this.sortType = def.sortType;
+    this.validators = def.validators ?? [];
+    this.customConvert = def.convert;
+    this.customSerialize = def.serialize;
+    this.customDefault = def.defaultValue;
+  }
+  /** Type-specific default (overridden by subclasses). */
+  get defaultValue() {
+    return this.customDefault !== void 0 ? this.customDefault : this.getTypeDefault();
+  }
+  /**
+   * Converts a raw value to the field's type.
+   * If a custom `convert` was specified in the definition, it is used.
+   * Otherwise delegates to the subclass's `coerce()`.
+   */
+  convert(value, record) {
+    if (this.customConvert) {
+      return this.customConvert(value, record);
+    }
+    if (value === null && this.allowNull) return null;
+    if (value === void 0) return this.defaultValue;
+    return this.coerce(value);
+  }
+  /**
+   * Serializes a value for transport.
+   */
+  serialize(value, record) {
+    if (this.customSerialize) {
+      return this.customSerialize(value, record);
+    }
+    return value;
+  }
+};
+var StringField = class extends Field {
+  constructor(def) {
+    super({ ...def, type: "string" /* STRING */ });
+  }
+  getTypeDefault() {
+    return "";
+  }
+  coerce(value) {
+    if (value === null) return "";
+    return String(value);
+  }
+};
+var IntField = class extends Field {
+  constructor(def) {
+    super({ ...def, type: "int" /* INT */ });
+  }
+  getTypeDefault() {
+    return 0;
+  }
+  coerce(value) {
+    if (value === null) return 0;
+    if (typeof value === "boolean") return value ? 1 : 0;
+    const n = parseInt(String(value), 10);
+    return Number.isNaN(n) ? 0 : n;
+  }
+};
+var FloatField = class extends Field {
+  constructor(def) {
+    super({ ...def, type: "float" /* FLOAT */ });
+  }
+  getTypeDefault() {
+    return 0;
+  }
+  coerce(value) {
+    if (value === null) return 0;
+    if (typeof value === "boolean") return value ? 1 : 0;
+    const n = parseFloat(String(value));
+    return Number.isNaN(n) ? 0 : n;
+  }
+};
+var FALSE_STRINGS = /* @__PURE__ */ new Set(["false", "0", "no", "off", ""]);
+var BooleanField = class extends Field {
+  constructor(def) {
+    super({ ...def, type: "boolean" /* BOOLEAN */ });
+  }
+  getTypeDefault() {
+    return false;
+  }
+  coerce(value) {
+    if (value === null || value === void 0) return false;
+    if (typeof value === "string") {
+      return !FALSE_STRINGS.has(value.toLowerCase());
+    }
+    return Boolean(value);
+  }
+};
+var DateField = class extends Field {
+  constructor(def) {
+    super({ ...def, type: "date" /* DATE */ });
+  }
+  getTypeDefault() {
+    return null;
+  }
+  coerce(value) {
+    if (value instanceof Date) return value;
+    if (typeof value === "number") return new Date(value);
+    if (typeof value === "string") {
+      const d = new Date(value);
+      return Number.isNaN(d.getTime()) ? null : d;
+    }
+    return null;
+  }
+  serialize(value) {
+    if (value instanceof Date) return value.toISOString();
+    return value;
+  }
+};
+var AutoField = class extends Field {
+  constructor(def) {
+    super({ ...def, type: "auto" /* AUTO */ });
+  }
+  getTypeDefault() {
+    return void 0;
+  }
+  coerce(value) {
+    return value;
+  }
+};
+var FIELD_CONSTRUCTORS = {
+  ["string" /* STRING */]: StringField,
+  ["int" /* INT */]: IntField,
+  ["float" /* FLOAT */]: FloatField,
+  ["boolean" /* BOOLEAN */]: BooleanField,
+  ["date" /* DATE */]: DateField,
+  ["auto" /* AUTO */]: AutoField
+};
+function createField(def) {
+  if (typeof def === "string") {
+    return new AutoField({ name: def });
+  }
+  const type = def.type ?? "auto" /* AUTO */;
+  const Ctor = FIELD_CONSTRUCTORS[type] ?? AutoField;
+  return new Ctor(def);
+}
+
+// src/association/Association.ts
+var Association = class {
+  type;
+  config;
+  ownerModelName;
+  /** Resolved associated model class (may be null until forward ref resolves). */
+  associatedModel = null;
+  constructor(type, ownerModelName, config) {
+    this.type = type;
+    this.ownerModelName = ownerModelName;
+    this.config = config;
+  }
+  /**
+   * The property name used for nested JSON loading and as the
+   * default getter/collection accessor name.
+   */
+  get associationName() {
+    if (!this.associatedModel) return "";
+    const raw = this.associatedModel.$className.split(".").pop();
+    const lower = raw[0].toLowerCase() + raw.slice(1);
+    if (this.type === "hasMany" || this.type === "manyToMany") {
+      return lower.endsWith("s") ? lower : lower + "s";
+    }
+    return lower;
+  }
+  get getterName() {
+    if (this.config.getterName) return this.config.getterName;
+    const name = this.associationName;
+    return `get${name[0].toUpperCase()}${name.slice(1)}`;
+  }
+  get setterName() {
+    if (this.config.setterName) return this.config.setterName;
+    const name = this.associationName;
+    return `set${name[0].toUpperCase()}${name.slice(1)}`;
+  }
+  get foreignKey() {
+    return this.config.foreignKey;
+  }
+  get primaryKey() {
+    return this.config.primaryKey ?? "id";
+  }
+  get cascade() {
+    return this.config.cascade ?? false;
+  }
+};
+
+// src/association/HasOne.ts
+var HasOne = class extends Association {
+  constructor(ownerModelName, config) {
+    super("hasOne", ownerModelName, config);
+  }
+};
+
+// src/association/HasMany.ts
+var HasMany = class extends Association {
+  constructor(ownerModelName, config) {
+    super("hasMany", ownerModelName, config);
+  }
+};
+
+// src/association/BelongsTo.ts
+var BelongsTo = class extends Association {
+  constructor(ownerModelName, config) {
+    super("belongsTo", ownerModelName, config);
+  }
+};
+
+// src/association/ManyToMany.ts
+var ManyToMany = class extends Association {
+  constructor(ownerModelName, config) {
+    super("manyToMany", ownerModelName, config);
+  }
+  get through() {
+    return this.config.through ?? "";
+  }
+  get otherKey() {
+    return this.config.otherKey ?? "";
+  }
+};
+
+// src/Schema.ts
+var models = /* @__PURE__ */ new Map();
+var associations = /* @__PURE__ */ new Map();
+var pendingReferences = /* @__PURE__ */ new Map();
+var SchemaImpl = class {
+  /**
+   * Registers a Model class and processes its association declarations.
+   * If the model has `static hasOne`, `static hasMany`, `static belongsTo`,
+   * or `static manyToMany` arrays, creates Association instances for each.
+   */
+  register(ModelClass) {
+    const name = ModelClass.$className;
+    models.set(name, ModelClass);
+    this.processAssociations(ModelClass, "hasOne", HasOne);
+    this.processAssociations(ModelClass, "hasMany", HasMany);
+    this.processAssociations(ModelClass, "belongsTo", BelongsTo);
+    this.processAssociations(ModelClass, "manyToMany", ManyToMany);
+    const pending = pendingReferences.get(name);
+    if (pending) {
+      for (const assoc of pending) {
+        assoc.associatedModel = ModelClass;
+      }
+      pendingReferences.delete(name);
+    }
+  }
+  /**
+   * Retrieves a registered Model class by name.
+   */
+  get(name) {
+    return models.get(name);
+  }
+  /**
+   * Returns all Association instances owned by the given model name.
+   */
+  getAssociations(modelName) {
+    return associations.get(modelName) ?? [];
+  }
+  /**
+   * Clears all registrations (for testing).
+   */
+  clear() {
+    models.clear();
+    associations.clear();
+    pendingReferences.clear();
+  }
+  // -----------------------------------------------------------------------
+  // Internal: process static association arrays
+  // -----------------------------------------------------------------------
+  processAssociations(ModelClass, staticProp, AssocClass) {
+    const configs = ModelClass[staticProp];
+    if (!configs || !Array.isArray(configs)) return;
+    const ownerName = ModelClass.$className;
+    if (!associations.has(ownerName)) {
+      associations.set(ownerName, []);
+    }
+    const list = associations.get(ownerName);
+    for (const config of configs) {
+      const assoc = new AssocClass(ownerName, config);
+      const modelRef = config.model;
+      if (typeof modelRef === "string") {
+        const resolved = models.get(modelRef);
+        if (resolved) {
+          assoc.associatedModel = resolved;
+        } else {
+          if (!pendingReferences.has(modelRef)) {
+            pendingReferences.set(modelRef, []);
+          }
+          pendingReferences.get(modelRef).push(assoc);
+        }
+      } else {
+        assoc.associatedModel = modelRef;
+      }
+      list.push(assoc);
+    }
+  }
+};
+var Schema = new SchemaImpl();
+
+// src/ModelCollection.ts
+var ModelCollection = class {
+  items = [];
+  getCount() {
+    return this.items.length;
+  }
+  getAll() {
+    return [...this.items];
+  }
+  add(record) {
+    if (!this.items.includes(record)) {
+      this.items.push(record);
+    }
+  }
+  remove(record) {
+    const idx = this.items.indexOf(record);
+    if (idx !== -1) this.items.splice(idx, 1);
+  }
+  getById(id) {
+    return this.items.find((r) => r.getId() === id);
+  }
+  filter(fn) {
+    return this.items.filter(fn);
+  }
+  destroyAll() {
+    for (const item of this.items) {
+      if (!item.isDestroyed) item.destroy();
+    }
+    this.items.length = 0;
+  }
+};
+var ManyToManyCollection = class extends ModelCollection {
+  junctions = /* @__PURE__ */ new Map();
+  link(record, _junctionData) {
+    this.add(record);
+    this.junctions.set(record, _junctionData ?? {});
+  }
+  unlink(record) {
+    this.remove(record);
+    this.junctions.delete(record);
+  }
+};
+
+// src/Model.ts
+function getNestedValue(data, path) {
+  const segments = path.split(".");
+  let current = data;
+  for (const seg of segments) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[seg];
+  }
+  return current;
+}
+var MODEL_PROPS = /* @__PURE__ */ new Set([
+  // Commonly accessed non-field properties/methods that should NOT
+  // be intercepted by the proxy's field get/set logic.
+  "constructor",
+  "prototype",
+  "__proto__",
+  "get",
+  "set",
+  "getData",
+  "getId",
+  "setId",
+  "isModified",
+  "getChanges",
+  "commit",
+  "reject",
+  "validate",
+  "isValid",
+  "on",
+  "un",
+  "fireEvent",
+  "fireEventArgs",
+  "addListener",
+  "removeListener",
+  "hasListener",
+  "clearListeners",
+  "suspendEvents",
+  "resumeEvents",
+  "isSuspended",
+  "mon",
+  "mun",
+  "relayEvents",
+  "fireEventedAction",
+  "destroy",
+  "isDestroyed",
+  "$destroyHooks",
+  "$className",
+  "self",
+  "$callStack",
+  "$configInitialized",
+  "$pendingConfig",
+  "hasMixin",
+  "initConfig",
+  "callParent",
+  "modified",
+  "phantom",
+  "$associations",
+  "$fieldMap",
+  "$data",
+  Symbol.dispose,
+  Symbol.toPrimitive,
+  Symbol.toStringTag
+]);
+function createModelProxy(model) {
+  return new Proxy(model, {
+    get(target, prop, receiver) {
+      if (MODEL_PROPS.has(prop) || typeof prop === "symbol") {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (prop in target) {
+        const desc = Object.getOwnPropertyDescriptor(target, prop) ?? Object.getOwnPropertyDescriptor(Object.getPrototypeOf(target), prop);
+        if (desc?.get || typeof desc?.value === "function") {
+          return Reflect.get(target, prop, receiver);
+        }
+      }
+      if (typeof prop === "string" && target.$fieldMap?.has(prop)) {
+        return target.get(prop);
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+    set(target, prop, value, receiver) {
+      if (typeof prop === "string" && target.$fieldMap?.has(prop)) {
+        target.set(prop, value);
+        return true;
+      }
+      return Reflect.set(target, prop, value, receiver);
+    }
+  });
+}
+var ObservableMixin = Observable;
+var Model = class extends Base {
+  static $className = "Ext.data.Model";
+  /** Field definitions — override in subclasses. */
+  static fields = [];
+  /** Name of the ID field. */
+  static idProperty = "id";
+  // -- Instance state (non-enumerable to keep proxy clean) --
+  /** Resolved Field instances keyed by name. */
+  $fieldMap;
+  /** Current field values. */
+  $data;
+  /** Previous values for dirty fields (fieldName → old value). */
+  modified = {};
+  /** Per-instance association storage: assocName → Model | ModelCollection */
+  $associations = /* @__PURE__ */ new Map();
+  // -----------------------------------------------------------------------
+  // Construction
+  // -----------------------------------------------------------------------
+  constructor(_data) {
+    super();
+  }
+  /**
+   * Factory method that sets up fields, applies data, wraps in proxy.
+   */
+  static create(data) {
+    const instance = new this();
+    instance.$fieldMap = /* @__PURE__ */ new Map();
+    instance.$data = {};
+    instance.modified = {};
+    instance.$associations = /* @__PURE__ */ new Map();
+    const fieldDefs = this.fields;
+    for (const def of fieldDefs) {
+      const field = createField(def);
+      instance.$fieldMap.set(field.name, field);
+    }
+    ensureObservable(instance);
+    instance.$loadData(data ?? {});
+    installAssociations(instance, data ?? {});
+    return createModelProxy(instance);
+  }
+  // -----------------------------------------------------------------------
+  // Data loading (initial — not dirty)
+  // -----------------------------------------------------------------------
+  /** @internal Loads initial data without marking as dirty. */
+  $loadData(rawData) {
+    for (const [key, value] of Object.entries(rawData)) {
+      if (!this.$fieldMap.has(key)) {
+        this.$data[key] = value;
+      }
+    }
+    for (const [name, field] of this.$fieldMap) {
+      let value;
+      if (field.mapping) {
+        value = getNestedValue(rawData, field.mapping);
+      } else {
+        value = rawData[name];
+      }
+      if (value !== void 0) {
+        value = field.convert(value, this);
+      } else {
+        value = field.defaultValue;
+        if (value !== void 0) {
+          value = field.convert(value, this);
+        }
+      }
+      this.$data[name] = value;
+    }
+  }
+  // -----------------------------------------------------------------------
+  // get / set
+  // -----------------------------------------------------------------------
+  get(fieldName) {
+    return this.$data[fieldName];
+  }
+  set(fieldNameOrData, value) {
+    const changes = typeof fieldNameOrData === "string" ? { [fieldNameOrData]: value } : fieldNameOrData;
+    const modifiedFields = [];
+    for (const [name, newValue] of Object.entries(changes)) {
+      const field = this.$fieldMap.get(name);
+      if (!field) {
+        const oldValue2 = this.$data[name];
+        if (newValue !== oldValue2) {
+          if (!(name in this.modified)) this.modified[name] = oldValue2;
+          this.$data[name] = newValue;
+          modifiedFields.push(name);
+        }
+        continue;
+      }
+      const converted = field.convert(newValue, this);
+      const oldValue = this.$data[name];
+      if (converted === oldValue) continue;
+      if (!(name in this.modified)) {
+        this.modified[name] = oldValue;
+      }
+      this.$data[name] = converted;
+      modifiedFields.push(name);
+      const Ctor = this.constructor;
+      if (name === Ctor.idProperty && typeof this.fireEvent === "function") {
+        this.fireEvent("idchanged", this, converted, oldValue);
+      }
+    }
+    if (modifiedFields.length > 0 && typeof this.fireEvent === "function") {
+      this.fireEvent("change", this, modifiedFields);
+    }
+    return modifiedFields;
+  }
+  getData(options) {
+    const result = {};
+    for (const [name, field] of this.$fieldMap) {
+      const value = this.$data[name];
+      result[name] = options?.serialize ? field.serialize(value, this) : value;
+    }
+    return result;
+  }
+  // -----------------------------------------------------------------------
+  // Dirty tracking
+  // -----------------------------------------------------------------------
+  isModified(fieldName) {
+    if (fieldName) {
+      return fieldName in this.modified;
+    }
+    return Object.keys(this.modified).length > 0;
+  }
+  getChanges() {
+    const result = {};
+    for (const name of Object.keys(this.modified)) {
+      result[name] = this.$data[name];
+    }
+    return result;
+  }
+  commit(silent) {
+    this.modified = {};
+    if (!silent && typeof this.fireEvent === "function") {
+      this.fireEvent("commit", this);
+    }
+  }
+  reject(silent) {
+    for (const [name, oldValue] of Object.entries(this.modified)) {
+      this.$data[name] = oldValue;
+    }
+    this.modified = {};
+    if (!silent && typeof this.fireEvent === "function") {
+      this.fireEvent("reject", this);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Identification
+  // -----------------------------------------------------------------------
+  getId() {
+    const Ctor = this.constructor;
+    return this.$data[Ctor.idProperty];
+  }
+  setId(id) {
+    const Ctor = this.constructor;
+    this.set(Ctor.idProperty, id);
+  }
+  get phantom() {
+    const id = this.getId();
+    return id === void 0 || id === null || id === 0 || id === "";
+  }
+  // -----------------------------------------------------------------------
+  // Validation
+  // -----------------------------------------------------------------------
+  validate() {
+    const errors = [];
+    for (const [name, field] of this.$fieldMap) {
+      const value = this.$data[name];
+      for (const validator of field.validators) {
+        const msg = validator(value, this);
+        if (msg) {
+          errors.push({ field: name, message: msg });
+        }
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  isValid() {
+    return this.validate().valid;
+  }
+};
+function ensureObservable(instance) {
+  const proto = ObservableMixin.prototype;
+  for (const name of Object.getOwnPropertyNames(proto)) {
+    if (name === "constructor") continue;
+    if (name in instance) continue;
+    const desc = Object.getOwnPropertyDescriptor(proto, name);
+    if (desc && typeof desc.value === "function") {
+      instance[name] = desc.value.bind(instance);
+    }
+  }
+}
+function installAssociations(instance, rawData) {
+  const modelName = instance.constructor.$className;
+  const assocs = Schema.getAssociations(modelName);
+  if (assocs.length === 0) return;
+  for (const assoc of assocs) {
+    if (!assoc.associatedModel) continue;
+    switch (assoc.type) {
+      case "hasOne":
+        installHasOne(instance, assoc, rawData);
+        break;
+      case "hasMany":
+        installHasMany(instance, assoc, rawData);
+        break;
+      case "belongsTo":
+        installBelongsTo(instance, assoc, rawData);
+        break;
+      case "manyToMany":
+        installManyToMany(instance, assoc, rawData);
+        break;
+    }
+  }
+}
+function installHasOne(instance, assoc, rawData) {
+  const AssocModel = assoc.associatedModel;
+  const name = assoc.associationName;
+  const getterName = assoc.getterName;
+  const setterName = assoc.setterName;
+  instance.$associations.set(name, null);
+  instance[getterName] = function() {
+    return instance.$associations.get(name) ?? null;
+  };
+  instance[setterName] = function(child) {
+    instance.$associations.set(name, child);
+    const parentId = instance.get(assoc.primaryKey);
+    if (parentId !== void 0 && child.$fieldMap?.has(assoc.foreignKey)) {
+      child.set(assoc.foreignKey, parentId);
+    }
+  };
+  const nestedData = rawData[name];
+  if (nestedData && typeof nestedData === "object" && !Array.isArray(nestedData)) {
+    const childData = { ...nestedData };
+    const parentId = instance.get(assoc.primaryKey);
+    if (parentId !== void 0) {
+      childData[assoc.foreignKey] = parentId;
+    }
+    const child = AssocModel.create(childData);
+    instance.$associations.set(name, child);
+  }
+  if (assoc.cascade) {
+    instance.$destroyHooks.push(() => {
+      const child = instance.$associations.get(name);
+      if (child && !child.isDestroyed) child.destroy();
+    });
+  }
+}
+function installHasMany(instance, assoc, rawData) {
+  const AssocModel = assoc.associatedModel;
+  const name = assoc.associationName;
+  const collection = new ModelCollection();
+  instance.$associations.set(name, collection);
+  const wrappedCollection = {
+    getCount: () => collection.getCount(),
+    getAll: () => collection.getAll(),
+    getById: (id) => collection.getById(id),
+    filter: (fn) => collection.filter(fn),
+    add(child) {
+      const parentId = instance.get(assoc.primaryKey);
+      if (parentId !== void 0 && child.$fieldMap?.has(assoc.foreignKey)) {
+        child.set(assoc.foreignKey, parentId);
+      }
+      collection.add(child);
+    },
+    remove(child) {
+      collection.remove(child);
+    }
+  };
+  instance[name] = function() {
+    return wrappedCollection;
+  };
+  const nestedData = rawData[name];
+  if (Array.isArray(nestedData)) {
+    const parentId = instance.get(assoc.primaryKey);
+    for (const itemData of nestedData) {
+      if (typeof itemData === "object" && itemData !== null) {
+        const childData = { ...itemData };
+        if (parentId !== void 0) {
+          childData[assoc.foreignKey] = parentId;
+        }
+        const child = AssocModel.create(childData);
+        collection.add(child);
+      }
+    }
+  }
+  if (assoc.cascade) {
+    instance.$destroyHooks.push(() => {
+      collection.destroyAll();
+    });
+  }
+}
+function installBelongsTo(instance, assoc, rawData) {
+  const AssocModel = assoc.associatedModel;
+  const name = assoc.associationName;
+  const getterName = assoc.getterName;
+  const setterName = assoc.setterName;
+  instance.$associations.set(name, null);
+  instance[getterName] = function() {
+    return instance.$associations.get(name) ?? null;
+  };
+  instance[setterName] = function(parent) {
+    instance.$associations.set(name, parent);
+    const parentId = parent.get(assoc.primaryKey);
+    if (parentId !== void 0 && instance.$fieldMap?.has(assoc.foreignKey)) {
+      instance.set(assoc.foreignKey, parentId);
+    }
+  };
+  const nestedData = rawData[name];
+  if (nestedData && typeof nestedData === "object" && !Array.isArray(nestedData)) {
+    const parent = AssocModel.create(nestedData);
+    instance.$associations.set(name, parent);
+  }
+}
+function installManyToMany(instance, assoc, rawData) {
+  const AssocModel = assoc.associatedModel;
+  const name = assoc.associationName;
+  const collection = new ManyToManyCollection();
+  instance.$associations.set(name, collection);
+  instance[name] = function() {
+    return collection;
+  };
+  const nestedData = rawData[name];
+  if (Array.isArray(nestedData)) {
+    for (const itemData of nestedData) {
+      if (typeof itemData === "object" && itemData !== null) {
+        const child = AssocModel.create(itemData);
+        collection.link(child);
+      }
+    }
+  }
+}
+
+// src/validators.ts
+function presence(message = "is required") {
+  return (value) => {
+    if (value === null || value === void 0 || value === "") {
+      return message;
+    }
+    return null;
+  };
+}
+function length(opts) {
+  return (value) => {
+    const str = String(value ?? "");
+    if (opts.min !== void 0 && str.length < opts.min) {
+      return opts.message ?? `must be at least ${opts.min} characters`;
+    }
+    if (opts.max !== void 0 && str.length > opts.max) {
+      return opts.message ?? `must be at most ${opts.max} characters`;
+    }
+    return null;
+  };
+}
+function formatValidator(pattern, message) {
+  return (value) => {
+    if (!pattern.test(String(value ?? ""))) {
+      return message ?? `does not match the required format`;
+    }
+    return null;
+  };
+}
+function inclusion(list, message) {
+  return (value) => {
+    if (!list.includes(value)) {
+      return message ?? `must be one of: ${list.join(", ")}`;
+    }
+    return null;
+  };
+}
+function exclusion(list, message) {
+  return (value) => {
+    if (list.includes(value)) {
+      return message ?? `is not allowed`;
+    }
+    return null;
+  };
+}
+function rangeValidator(opts) {
+  return (value) => {
+    const n = Number(value);
+    if (opts.min !== void 0 && n < opts.min) {
+      return opts.message ?? `must be at least ${opts.min}`;
+    }
+    if (opts.max !== void 0 && n > opts.max) {
+      return opts.message ?? `must be at most ${opts.max}`;
+    }
+    return null;
+  };
+}
+var EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function email(message = "is not a valid email address") {
+  return (value) => {
+    if (!EMAIL_RE.test(String(value ?? ""))) {
+      return message;
+    }
+    return null;
+  };
+}
+
+// src/store/Store.ts
+import { Base as Base2, Observable as Observable2 } from "@framesquared/core";
+
+// src/store/Collection.ts
+var Collection = class {
+  items = [];
+  keyMap = null;
+  keyFn;
+  constructor(keyFn) {
+    this.keyFn = keyFn;
+    if (keyFn) {
+      this.keyMap = /* @__PURE__ */ new Map();
+    }
+  }
+  getCount() {
+    return this.items.length;
+  }
+  getAt(index) {
+    return this.items[index];
+  }
+  getByKey(key) {
+    return this.keyMap?.get(key);
+  }
+  indexOf(item) {
+    return this.items.indexOf(item);
+  }
+  contains(item) {
+    return this.items.includes(item);
+  }
+  add(item) {
+    this.items.push(item);
+    if (this.keyFn && this.keyMap) {
+      this.keyMap.set(this.keyFn(item), item);
+    }
+  }
+  insert(index, item) {
+    this.items.splice(index, 0, item);
+    if (this.keyFn && this.keyMap) {
+      this.keyMap.set(this.keyFn(item), item);
+    }
+  }
+  remove(item) {
+    const idx = this.items.indexOf(item);
+    if (idx === -1) return void 0;
+    this.items.splice(idx, 1);
+    if (this.keyFn && this.keyMap) {
+      this.keyMap.delete(this.keyFn(item));
+    }
+    return item;
+  }
+  removeAt(index, count = 1) {
+    const removed = this.items.splice(index, count);
+    if (this.keyFn && this.keyMap) {
+      for (const item of removed) {
+        this.keyMap.delete(this.keyFn(item));
+      }
+    }
+    return removed;
+  }
+  clear() {
+    this.items.length = 0;
+    this.keyMap?.clear();
+  }
+  toArray() {
+    return [...this.items];
+  }
+  each(fn) {
+    for (let i = 0; i < this.items.length; i++) {
+      if (fn(this.items[i], i) === false) break;
+    }
+  }
+  find(fn) {
+    return this.items.find(fn);
+  }
+  filter(fn) {
+    return this.items.filter(fn);
+  }
+  sort(compareFn) {
+    this.items.sort(compareFn);
+  }
+  first() {
+    return this.items[0];
+  }
+  last() {
+    return this.items[this.items.length - 1];
+  }
+  getRange(start = 0, end) {
+    return this.items.slice(start, end);
+  }
+  /** Rebuilds the key map (call after sort or external mutation). */
+  rekey() {
+    if (this.keyFn && this.keyMap) {
+      this.keyMap.clear();
+      for (const item of this.items) {
+        this.keyMap.set(this.keyFn(item), item);
+      }
+    }
+  }
+};
+
+// src/store/Store.ts
+var ObservableMixin2 = Observable2;
+function ensureObservable2(instance) {
+  const proto = ObservableMixin2.prototype;
+  for (const name of Object.getOwnPropertyNames(proto)) {
+    if (name === "constructor") continue;
+    if (name in instance) continue;
+    const desc = Object.getOwnPropertyDescriptor(proto, name);
+    if (desc && typeof desc.value === "function") {
+      instance[name] = desc.value.bind(instance);
+    }
+  }
+}
+function matchFilter(record, f) {
+  if (f.filterFn) return f.filterFn(record);
+  const fieldValue = record.get(f.property);
+  const filterValue = f.value;
+  const op = f.operator ?? "=";
+  const ci = !(f.caseSensitive ?? false);
+  switch (op) {
+    case "=":
+      return fieldValue === filterValue;
+    case "!=":
+      return fieldValue !== filterValue;
+    case "<":
+      return fieldValue < filterValue;
+    case "<=":
+      return fieldValue <= filterValue;
+    case ">":
+      return fieldValue > filterValue;
+    case ">=":
+      return fieldValue >= filterValue;
+    case "like": {
+      const sv = ci ? String(fieldValue).toLowerCase() : String(fieldValue);
+      const fv = ci ? String(filterValue).toLowerCase() : String(filterValue);
+      return sv.includes(fv);
+    }
+    case "in":
+      return Array.isArray(filterValue) && filterValue.includes(fieldValue);
+    case "notin":
+      return Array.isArray(filterValue) && !filterValue.includes(fieldValue);
+    default:
+      return false;
+  }
+}
+function buildComparator(sorters) {
+  return (a, b) => {
+    for (const sorter of sorters) {
+      if (sorter.sorterFn) {
+        const result = sorter.sorterFn(a, b);
+        if (result !== 0) return result;
+        continue;
+      }
+      const va = a.get(sorter.property);
+      const vb = b.get(sorter.property);
+      const dir = sorter.direction === "DESC" ? -1 : 1;
+      if (va < vb) return -1 * dir;
+      if (va > vb) return 1 * dir;
+    }
+    return 0;
+  };
+}
+var Store = class extends Base2 {
+  static $className = "Ext.data.Store";
+  ModelClass;
+  data;
+  allData;
+  // unfiltered snapshot
+  currentSorters = [];
+  currentFilters = [];
+  groupField = null;
+  groupDirection = "ASC";
+  cachedGroups = null;
+  removedRecords = [];
+  // Observable state (populated by ensureObservable)
+  $destroyHooks = [];
+  constructor(config) {
+    super();
+    ensureObservable2(this);
+    this.ModelClass = config.model;
+    this.data = new Collection((r) => r.getId());
+    this.allData = new Collection((r) => r.getId());
+    if (config.data) {
+      this.loadData(config.data);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Data loading
+  // -----------------------------------------------------------------------
+  loadData(rawRecords) {
+    for (const raw of rawRecords) {
+      const record = this.ModelClass.create(raw);
+      this.data.add(record);
+      this.allData.add(record);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // CRUD
+  // -----------------------------------------------------------------------
+  add(...records) {
+    for (const record of records) {
+      this.data.add(record);
+      this.allData.add(record);
+    }
+    this.invalidateGroups();
+    this.fire("add", this, records);
+    this.fire("datachanged", this);
+    return records;
+  }
+  insert(index, ...records) {
+    for (let i = 0; i < records.length; i++) {
+      this.data.insert(index + i, records[i]);
+      this.allData.add(records[i]);
+    }
+    this.invalidateGroups();
+    this.fire("add", this, records, index);
+    this.fire("datachanged", this);
+    return records;
+  }
+  remove(...records) {
+    const removed = [];
+    for (const record of records) {
+      if (this.data.remove(record)) {
+        this.allData.remove(record);
+        removed.push(record);
+        if (!record.phantom) {
+          this.removedRecords.push(record);
+        }
+      }
+    }
+    if (removed.length > 0) {
+      this.invalidateGroups();
+      this.fire("remove", this, removed);
+      this.fire("datachanged", this);
+    }
+    return removed;
+  }
+  removeAt(index, count = 1) {
+    const removed = this.data.removeAt(index, count);
+    for (const record of removed) {
+      this.allData.remove(record);
+      if (!record.phantom) {
+        this.removedRecords.push(record);
+      }
+    }
+    if (removed.length > 0) {
+      this.invalidateGroups();
+      this.fire("remove", this, removed);
+      this.fire("datachanged", this);
+    }
+    return removed;
+  }
+  removeAll(silent) {
+    this.data.clear();
+    this.allData.clear();
+    this.invalidateGroups();
+    if (!silent) {
+      this.fire("clear", this);
+      this.fire("datachanged", this);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Lookup
+  // -----------------------------------------------------------------------
+  getAt(index) {
+    return this.data.getAt(index);
+  }
+  getById(id) {
+    return this.data.getByKey(id);
+  }
+  getRange(start, end) {
+    return this.data.getRange(start, end);
+  }
+  getCount() {
+    return this.data.getCount();
+  }
+  getTotalCount() {
+    return this.allData.getCount();
+  }
+  indexOf(record) {
+    return this.data.indexOf(record);
+  }
+  contains(record) {
+    return this.data.contains(record);
+  }
+  first() {
+    return this.data.first();
+  }
+  last() {
+    return this.data.last();
+  }
+  each(fn) {
+    this.data.each(fn);
+  }
+  collect(fieldName) {
+    const seen = /* @__PURE__ */ new Set();
+    this.data.each((r) => {
+      seen.add(r.get(fieldName));
+    });
+    return [...seen];
+  }
+  getData() {
+    return this.data;
+  }
+  // -----------------------------------------------------------------------
+  // Sorting
+  // -----------------------------------------------------------------------
+  sort(fieldOrSorters, direction = "ASC") {
+    if (typeof fieldOrSorters === "string") {
+      this.currentSorters = [{ property: fieldOrSorters, direction }];
+    } else if (Array.isArray(fieldOrSorters)) {
+      this.currentSorters = fieldOrSorters;
+    }
+    if (this.currentSorters.length > 0) {
+      this.data.sort(buildComparator(this.currentSorters));
+    }
+    this.invalidateGroups();
+    this.fire("sort", this, this.currentSorters);
+  }
+  getSorters() {
+    return [...this.currentSorters];
+  }
+  // -----------------------------------------------------------------------
+  // Filtering
+  // -----------------------------------------------------------------------
+  filter(fieldOrFilters, value) {
+    if (typeof fieldOrFilters === "string") {
+      this.currentFilters = [{ property: fieldOrFilters, value }];
+    } else {
+      this.currentFilters = fieldOrFilters;
+    }
+    this.applyFilters();
+    this.fire("filter", this, this.currentFilters);
+  }
+  clearFilter(suppressEvent) {
+    this.currentFilters = [];
+    this.applyFilters();
+    if (!suppressEvent) {
+      this.fire("filter", this, []);
+    }
+  }
+  getFilters() {
+    return [...this.currentFilters];
+  }
+  applyFilters() {
+    if (this.currentFilters.length === 0) {
+      this.data = new Collection((r) => r.getId());
+      this.allData.each((r) => this.data.add(r));
+    } else {
+      this.data = new Collection((r) => r.getId());
+      this.allData.each((r) => {
+        const passes = this.currentFilters.every((f) => matchFilter(r, f));
+        if (passes) this.data.add(r);
+      });
+    }
+    if (this.currentSorters.length > 0) {
+      this.data.sort(buildComparator(this.currentSorters));
+    }
+    this.invalidateGroups();
+  }
+  // -----------------------------------------------------------------------
+  // Grouping
+  // -----------------------------------------------------------------------
+  group(field, direction = "ASC") {
+    this.groupField = field;
+    this.groupDirection = direction;
+    this.invalidateGroups();
+    this.fire("groupchange", this, field, direction);
+  }
+  clearGrouping() {
+    this.groupField = null;
+    this.cachedGroups = null;
+    this.fire("groupchange", this, null, null);
+  }
+  isGrouped() {
+    return this.groupField !== null;
+  }
+  getGroups() {
+    if (!this.groupField) return [];
+    if (this.cachedGroups) return this.cachedGroups;
+    const map = /* @__PURE__ */ new Map();
+    this.data.each((r) => {
+      const key = String(r.get(this.groupField) ?? "");
+      if (!map.has(key)) map.set(key, []);
+      map.get(key).push(r);
+    });
+    const groups = [...map.entries()].map(([name, children]) => ({ name, children }));
+    const dir = this.groupDirection === "DESC" ? -1 : 1;
+    groups.sort((a, b) => {
+      if (a.name < b.name) return -1 * dir;
+      if (a.name > b.name) return 1 * dir;
+      return 0;
+    });
+    this.cachedGroups = groups;
+    return groups;
+  }
+  invalidateGroups() {
+    this.cachedGroups = null;
+  }
+  // -----------------------------------------------------------------------
+  // Sync / change tracking
+  // -----------------------------------------------------------------------
+  getModifiedRecords() {
+    const result = [];
+    this.data.each((r) => {
+      if (r.isModified()) result.push(r);
+    });
+    return result;
+  }
+  getNewRecords() {
+    const result = [];
+    this.data.each((r) => {
+      if (r.phantom) result.push(r);
+    });
+    return result;
+  }
+  getRemovedRecords() {
+    return [...this.removedRecords];
+  }
+  commitChanges() {
+    this.data.each((r) => {
+      if (r.isModified()) r.commit(true);
+    });
+    this.removedRecords.length = 0;
+  }
+  rejectChanges() {
+    this.data.each((r) => {
+      if (r.isModified()) r.reject(true);
+    });
+    for (const record of this.removedRecords) {
+      this.data.add(record);
+      this.allData.add(record);
+    }
+    this.removedRecords.length = 0;
+    this.invalidateGroups();
+  }
+  // -----------------------------------------------------------------------
+  // Event helper
+  // -----------------------------------------------------------------------
+  fire(eventName, ...args) {
+    if (typeof this.fireEvent === "function") {
+      this.fireEvent(eventName, ...args);
+    }
+  }
+};
+
+// src/ResultSet.ts
+var ResultSet = class {
+  records;
+  total;
+  success;
+  message;
+  constructor(config) {
+    this.records = config.records;
+    this.total = config.total ?? config.records.length;
+    this.success = config.success;
+    this.message = config.message;
+  }
+};
+
+// src/reader/Reader.ts
+function getNestedValue2(obj, path) {
+  const segments = path.split(".");
+  let current = obj;
+  for (const seg of segments) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[seg];
+  }
+  return current;
+}
+var JsonReader = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  read(data) {
+    const { model, rootProperty, totalProperty, successProperty, messageProperty } = this.config;
+    let rawRecords;
+    let total;
+    let success = true;
+    let message;
+    if (rootProperty) {
+      const root = getNestedValue2(data, rootProperty);
+      rawRecords = Array.isArray(root) ? root : [];
+    } else {
+      rawRecords = Array.isArray(data) ? data : [];
+    }
+    if (totalProperty && typeof data === "object" && data !== null) {
+      const t = getNestedValue2(data, totalProperty);
+      if (typeof t === "number") total = t;
+    }
+    if (successProperty && typeof data === "object" && data !== null) {
+      const s = getNestedValue2(data, successProperty);
+      if (typeof s === "boolean") success = s;
+    }
+    if (messageProperty && typeof data === "object" && data !== null) {
+      const m = getNestedValue2(data, messageProperty);
+      if (typeof m === "string") message = m;
+    }
+    const records = rawRecords.map((raw) => model.create(raw));
+    return new ResultSet({
+      records,
+      total: total ?? records.length,
+      success,
+      message
+    });
+  }
+};
+var ArrayReader = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  read(data) {
+    const { model } = this.config;
+    const fieldNames = model.fields.map(
+      (f) => typeof f === "string" ? f : f.name
+    );
+    const records = data.map((row) => {
+      const obj = {};
+      for (let i = 0; i < fieldNames.length; i++) {
+        if (i < row.length) {
+          obj[fieldNames[i]] = row[i];
+        }
+      }
+      return model.create(obj);
+    });
+    return new ResultSet({ records, success: true });
+  }
+};
+var XmlReader = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  read(xmlString) {
+    const { model, record: tagName } = this.config;
+    const parser = new DOMParser();
+    const doc = parser.parseFromString(xmlString, "text/xml");
+    const nodes = doc.getElementsByTagName(tagName);
+    const fieldNames = model.fields.map(
+      (f) => typeof f === "string" ? f : f.name
+    );
+    const records = [];
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      const obj = {};
+      for (const fieldName of fieldNames) {
+        let el = node.getElementsByTagName(fieldName)[0];
+        if (!el) {
+          el = node.getElementsByTagName(fieldName[0])[0];
+        }
+        if (el) {
+          obj[fieldName] = el.textContent ?? "";
+        }
+      }
+      records.push(model.create(obj));
+    }
+    return new ResultSet({ records, success: true });
+  }
+};
+
+// src/writer/Writer.ts
+var JsonWriter = class {
+  config;
+  constructor(config) {
+    this.config = {
+      writeAllFields: true,
+      allowSingle: false,
+      encode: false,
+      ...config
+    };
+  }
+  write(records) {
+    const serialized = records.map((r) => this.serializeRecord(r));
+    let result;
+    if (this.config.allowSingle && serialized.length === 1) {
+      result = serialized[0];
+    } else {
+      result = serialized;
+    }
+    if (this.config.rootProperty) {
+      result = { [this.config.rootProperty]: result };
+    }
+    if (this.config.encode) {
+      return JSON.stringify(result);
+    }
+    return result;
+  }
+  serializeRecord(record) {
+    if (this.config.writeAllFields) {
+      return record.getData({ serialize: true });
+    }
+    const Ctor = record.constructor;
+    const changes = record.getChanges();
+    const result = {};
+    const idProp = Ctor.idProperty;
+    result[idProp] = record.get(idProp);
+    for (const [key, value] of Object.entries(changes)) {
+      result[key] = value;
+    }
+    return result;
+  }
+};
+var XmlWriter = class {
+  config;
+  constructor(config) {
+    this.config = {
+      documentRoot: "xmlData",
+      record: "record",
+      ...config
+    };
+  }
+  write(records) {
+    const root = this.config.documentRoot;
+    const tag = this.config.record;
+    const parts = [`<${root}>`];
+    for (const record of records) {
+      parts.push(`<${tag}>`);
+      const data = record.getData({ serialize: true });
+      for (const [key, value] of Object.entries(data)) {
+        parts.push(`<${key}>${escapeXml(String(value ?? ""))}</${key}>`);
+      }
+      parts.push(`</${tag}>`);
+    }
+    parts.push(`</${root}>`);
+    return parts.join("");
+  }
+};
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+
+// src/proxy/Proxy.ts
+var Proxy2 = class {
+  model;
+  constructor(config) {
+    this.model = config.model;
+  }
+  async batch(options) {
+    const { Operation: OpClass } = await import("./Operation-4K76GXM7.js");
+    const operations = [];
+    let allSuccess = true;
+    if (options.create && options.create.length > 0) {
+      const op = new OpClass({ action: "create", records: options.create });
+      const rs = await this.create(op);
+      op.setResult(rs);
+      operations.push(op);
+      if (!rs.success) allSuccess = false;
+    }
+    if (options.update && options.update.length > 0) {
+      const op = new OpClass({ action: "update", records: options.update });
+      const rs = await this.update(op);
+      op.setResult(rs);
+      operations.push(op);
+      if (!rs.success) allSuccess = false;
+    }
+    if (options.destroy && options.destroy.length > 0) {
+      const op = new OpClass({ action: "destroy", records: options.destroy });
+      const rs = await this.destroy(op);
+      op.setResult(rs);
+      operations.push(op);
+      if (!rs.success) allSuccess = false;
+    }
+    return { success: allSuccess, operations };
+  }
+};
+
+// src/proxy/ClientProxy.ts
+var MemoryProxy = class extends Proxy2 {
+  store;
+  constructor(config) {
+    super(config);
+    this.store = config.data ? [...config.data] : [];
+  }
+  async read(operation) {
+    let data = [...this.store];
+    if (operation.filters && operation.filters.length > 0) {
+      data = data.filter((raw) => {
+        return operation.filters.every((f) => {
+          const fieldVal = raw[f.property];
+          const op = f.operator ?? "=";
+          switch (op) {
+            case "=":
+              return fieldVal === f.value;
+            case "!=":
+              return fieldVal !== f.value;
+            case "<":
+              return fieldVal < f.value;
+            case "<=":
+              return fieldVal <= f.value;
+            case ">":
+              return fieldVal > f.value;
+            case ">=":
+              return fieldVal >= f.value;
+            default:
+              return true;
+          }
+        });
+      });
+    }
+    if (operation.sorters && operation.sorters.length > 0) {
+      data.sort((a, b) => {
+        for (const sorter of operation.sorters) {
+          const va = a[sorter.property];
+          const vb = b[sorter.property];
+          const dir = sorter.direction === "DESC" ? -1 : 1;
+          if (va < vb) return -1 * dir;
+          if (va > vb) return 1 * dir;
+        }
+        return 0;
+      });
+    }
+    const total = data.length;
+    if (operation.start !== void 0 || operation.limit !== void 0) {
+      const start = operation.start ?? 0;
+      const limit = operation.limit ?? data.length;
+      data = data.slice(start, start + limit);
+    }
+    const records = data.map((raw) => this.model.create(raw));
+    return new ResultSet({ records, total, success: true });
+  }
+  async create(operation) {
+    for (const record of operation.records) {
+      this.store.push(record.getData());
+    }
+    return new ResultSet({ records: operation.records, success: true });
+  }
+  async update(operation) {
+    for (const record of operation.records) {
+      const id = record.getId();
+      const idProp = this.model.idProperty ?? "id";
+      const idx = this.store.findIndex((r) => r[idProp] === id);
+      if (idx !== -1) {
+        this.store[idx] = record.getData();
+      }
+    }
+    return new ResultSet({ records: operation.records, success: true });
+  }
+  async destroy(operation) {
+    for (const record of operation.records) {
+      const id = record.getId();
+      const idProp = this.model.idProperty ?? "id";
+      const idx = this.store.findIndex((r) => r[idProp] === id);
+      if (idx !== -1) {
+        this.store.splice(idx, 1);
+      }
+    }
+    return new ResultSet({ records: operation.records, success: true });
+  }
+};
+var WebStorageProxy = class extends Proxy2 {
+  storageId;
+  constructor(config) {
+    super(config);
+    this.storageId = config.id;
+  }
+  loadAll() {
+    const raw = this.getStorage().getItem(this.storageId);
+    if (!raw) return [];
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  saveAll(data) {
+    this.getStorage().setItem(this.storageId, JSON.stringify(data));
+  }
+  async read(_operation) {
+    const data = this.loadAll();
+    const records = data.map((raw) => this.model.create(raw));
+    return new ResultSet({ records, success: true });
+  }
+  async create(operation) {
+    const data = this.loadAll();
+    for (const record of operation.records) {
+      data.push(record.getData({ serialize: true }));
+    }
+    this.saveAll(data);
+    return new ResultSet({ records: operation.records, success: true });
+  }
+  async update(operation) {
+    const data = this.loadAll();
+    const idProp = this.model.idProperty ?? "id";
+    for (const record of operation.records) {
+      const id = record.getId();
+      const idx = data.findIndex((r) => r[idProp] === id);
+      if (idx !== -1) {
+        data[idx] = record.getData({ serialize: true });
+      }
+    }
+    this.saveAll(data);
+    return new ResultSet({ records: operation.records, success: true });
+  }
+  async destroy(operation) {
+    let data = this.loadAll();
+    const idProp = this.model.idProperty ?? "id";
+    for (const record of operation.records) {
+      const id = record.getId();
+      data = data.filter((r) => r[idProp] !== id);
+    }
+    this.saveAll(data);
+    return new ResultSet({ records: operation.records, success: true });
+  }
+};
+var LocalStorageProxy = class extends WebStorageProxy {
+  getStorage() {
+    return localStorage;
+  }
+};
+var SessionStorageProxy = class extends WebStorageProxy {
+  getStorage() {
+    return sessionStorage;
+  }
+};
+
+// src/proxy/ServerProxy.ts
+var ACTION_METHODS = {
+  read: "GET",
+  create: "POST",
+  update: "PUT",
+  destroy: "DELETE"
+};
+var AjaxProxy = class extends Proxy2 {
+  url;
+  api;
+  headers;
+  timeout;
+  withCredentials;
+  reader;
+  writer;
+  constructor(config) {
+    super(config);
+    this.url = config.url;
+    this.api = config.api ?? {};
+    this.headers = config.headers ?? {};
+    this.timeout = config.timeout ?? 3e4;
+    this.withCredentials = config.withCredentials ?? false;
+    this.reader = new JsonReader({ model: config.model });
+    this.writer = new JsonWriter({});
+  }
+  async read(operation, signal) {
+    return this.doRequest(operation, "read", signal);
+  }
+  async create(operation) {
+    return this.doRequest(operation, "create");
+  }
+  async update(operation) {
+    return this.doRequest(operation, "update");
+  }
+  async destroy(operation) {
+    return this.doRequest(operation, "destroy");
+  }
+  buildUrl(operation, action) {
+    const base = this.api[action] ?? this.url;
+    const params = { ...operation.params };
+    if (operation.start !== void 0) params.start = operation.start;
+    if (operation.limit !== void 0) params.limit = operation.limit;
+    if (operation.page !== void 0) params.page = operation.page;
+    const qs = Object.entries(params).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+    return qs ? `${base}?${qs}` : base;
+  }
+  async doRequest(operation, action, signal) {
+    const method = ACTION_METHODS[action] ?? "GET";
+    const url = this.buildUrl(operation, action);
+    const init = {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...this.headers
+      },
+      credentials: this.withCredentials ? "include" : "same-origin",
+      signal
+    };
+    if (method !== "GET" && operation.records.length > 0) {
+      init.body = JSON.stringify(this.writer.write(operation.records));
+    }
+    try {
+      const response = await fetch(url, init);
+      if (!response.ok) {
+        let message = `HTTP ${response.status}`;
+        try {
+          const body = await response.json();
+          if (body?.message) message = body.message;
+        } catch {
+        }
+        return new ResultSet({ records: [], success: false, message });
+      }
+      const data = await response.json();
+      if (action === "read") {
+        return this.reader.read(data);
+      }
+      const records = Array.isArray(data) ? data.map((d) => this.model.create(d)) : data && typeof data === "object" && "id" in data ? [this.model.create(data)] : operation.records;
+      return new ResultSet({ records, success: true });
+    } catch (err) {
+      return new ResultSet({
+        records: [],
+        success: false,
+        message: err?.message ?? "Unknown error"
+      });
+    }
+  }
+};
+var RestProxy = class extends AjaxProxy {
+  appendId;
+  constructor(config) {
+    super(config);
+    this.appendId = config.appendId ?? true;
+  }
+  buildUrl(operation, action) {
+    let base = this.api[action] ?? this.url;
+    if (this.appendId && action !== "create" && operation.records.length === 1) {
+      const id = operation.records[0].getId();
+      if (id !== void 0 && id !== null && id !== 0 && id !== "") {
+        base = `${base}/${id}`;
+      }
+    }
+    const params = { ...operation.params };
+    if (operation.start !== void 0) params.start = operation.start;
+    if (operation.limit !== void 0) params.limit = operation.limit;
+    if (operation.page !== void 0) params.page = operation.page;
+    const qs = Object.entries(params).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+    return qs ? `${base}?${qs}` : base;
+  }
+};
+
+// src/store/TreeStore.ts
+import { Base as Base3, Observable as Observable3 } from "@framesquared/core";
+
+// src/mixin/NodeInterface.ts
+function applyNodeInterface(model, depth = 0) {
+  const node = model;
+  node.parentNode = node.parentNode ?? null;
+  node.childNodes = node.childNodes ?? [];
+  node.firstChild = node.firstChild ?? null;
+  node.lastChild = node.lastChild ?? null;
+  node.previousSibling = node.previousSibling ?? null;
+  node.nextSibling = node.nextSibling ?? null;
+  node.depth = depth;
+  node.expanded = node.expanded ?? false;
+  node.loaded = node.loaded ?? false;
+  node.isLeaf = function() {
+    if (this.get("leaf") === true) return true;
+    return this.childNodes.length === 0;
+  };
+  node.isRoot = function() {
+    return this.parentNode === null;
+  };
+  node.isExpanded = function() {
+    return this.expanded;
+  };
+  node.isLoaded = function() {
+    return this.loaded;
+  };
+  node.appendChild = function(child) {
+    const c = child;
+    if (c.parentNode) {
+      c.parentNode.removeChild(c);
+    }
+    c.parentNode = this;
+    c.depth = this.depth + 1;
+    const children = this.childNodes;
+    const prevLast = children.length > 0 ? children[children.length - 1] : null;
+    children.push(c);
+    if (prevLast) {
+      prevLast.nextSibling = c;
+      c.previousSibling = prevLast;
+    } else {
+      c.previousSibling = null;
+    }
+    c.nextSibling = null;
+    this.firstChild = children[0];
+    this.lastChild = children[children.length - 1];
+    updateDepthRecursive(c, this.depth + 1);
+  };
+  node.removeChild = function(child) {
+    const children = this.childNodes;
+    const idx = children.indexOf(child);
+    if (idx === -1) return;
+    children.splice(idx, 1);
+    if (child.previousSibling) {
+      child.previousSibling.nextSibling = child.nextSibling;
+    }
+    if (child.nextSibling) {
+      child.nextSibling.previousSibling = child.previousSibling;
+    }
+    child.parentNode = null;
+    child.previousSibling = null;
+    child.nextSibling = null;
+    this.firstChild = children.length > 0 ? children[0] : null;
+    this.lastChild = children.length > 0 ? children[children.length - 1] : null;
+  };
+  node.insertBefore = function(newChild, refChild) {
+    const children = this.childNodes;
+    const refIdx = children.indexOf(refChild);
+    if (refIdx === -1) {
+      this.appendChild(newChild);
+      return;
+    }
+    if (newChild.parentNode) {
+      newChild.parentNode.removeChild(newChild);
+    }
+    newChild.parentNode = this;
+    newChild.depth = this.depth + 1;
+    children.splice(refIdx, 0, newChild);
+    rebuildSiblings(children);
+    this.firstChild = children[0];
+    this.lastChild = children[children.length - 1];
+    updateDepthRecursive(newChild, this.depth + 1);
+  };
+  node.getPath = function(separator = "/") {
+    const parts = [];
+    let current = this;
+    while (current) {
+      parts.unshift(current.get("text") ?? String(current.getId()));
+      current = current.parentNode;
+    }
+    return separator + parts.join(separator);
+  };
+  node.cascadeBy = function(fn) {
+    cascadeByImpl(this, fn);
+  };
+  node.bubble = function(fn) {
+    let current = this;
+    while (current) {
+      if (fn(current) === false) return;
+      current = current.parentNode;
+    }
+  };
+  node.contains = function(descendant) {
+    let current = descendant.parentNode;
+    while (current) {
+      if (current === this) return true;
+      current = current.parentNode;
+    }
+    return false;
+  };
+  node.findChild = function(field, value, deep = false) {
+    for (const child of this.childNodes) {
+      if (child.get(field) === value) return child;
+      if (deep) {
+        const found = child.findChild(field, value, true);
+        if (found) return found;
+      }
+    }
+    return void 0;
+  };
+  node.sort = function(sorters) {
+    this.childNodes.sort((a, b) => {
+      for (const s of sorters) {
+        const va = a.get(s.property);
+        const vb = b.get(s.property);
+        const dir = s.direction === "DESC" ? -1 : 1;
+        if (va < vb) return -1 * dir;
+        if (va > vb) return 1 * dir;
+      }
+      return 0;
+    });
+    rebuildSiblings(this.childNodes);
+    this.firstChild = this.childNodes[0] ?? null;
+    this.lastChild = this.childNodes[this.childNodes.length - 1] ?? null;
+  };
+  node.serialize = function() {
+    const data = this.getData();
+    if (this.childNodes.length > 0) {
+      data.children = this.childNodes.map((c) => c.serialize());
+    }
+    return data;
+  };
+  node.eachChild = function(fn) {
+    for (let i = 0; i < this.childNodes.length; i++) {
+      if (fn(this.childNodes[i], i) === false) return;
+    }
+  };
+  node.indexOf = function(child) {
+    return this.childNodes.indexOf(child);
+  };
+  node.getChildAt = function(index) {
+    return this.childNodes[index];
+  };
+  node.childCount = function() {
+    return this.childNodes.length;
+  };
+  node.hasChildNodes = function() {
+    return this.childNodes.length > 0;
+  };
+  node.getChildren = function(deep = false) {
+    if (!deep) {
+      return [...this.childNodes];
+    }
+    const result = [];
+    const collect = (n) => {
+      for (const child of n.childNodes) {
+        result.push(child);
+        collect(child);
+      }
+    };
+    collect(this);
+    return result;
+  };
+  node.findChildBy = function(predicate, deep = false) {
+    for (const child of this.childNodes) {
+      const matched = predicate(child);
+      if (matched !== false && matched !== void 0 && matched !== null) return child;
+      if (deep) {
+        const found = child.findChildBy(predicate, true);
+        if (found) return found;
+      }
+    }
+    return void 0;
+  };
+  node.removeAll = function() {
+    const removed = [...this.childNodes];
+    for (const child of removed) {
+      child.parentNode = null;
+      child.previousSibling = null;
+      child.nextSibling = null;
+    }
+    this.childNodes = [];
+    this.firstChild = null;
+    this.lastChild = null;
+    return removed;
+  };
+  node.copy = function(deep = true) {
+    const copyCounter = { i: 0 };
+    return copyNodeImpl(this, deep, copyCounter);
+  };
+  node.getDepth = function() {
+    return this.depth;
+  };
+}
+function rebuildSiblings(children) {
+  for (let i = 0; i < children.length; i++) {
+    children[i].previousSibling = i > 0 ? children[i - 1] : null;
+    children[i].nextSibling = i < children.length - 1 ? children[i + 1] : null;
+  }
+}
+function updateDepthRecursive(node, depth) {
+  node.depth = depth;
+  for (const child of node.childNodes) {
+    updateDepthRecursive(child, depth + 1);
+  }
+}
+function copyNodeImpl(node, deep, counter) {
+  counter.i += 1;
+  const newId = "copy-" + Date.now() + "-" + counter.i;
+  const data = node.getData();
+  const Ctor = node.constructor;
+  const copyModel = Ctor.create({ ...data, id: newId });
+  applyNodeInterface(copyModel, 0);
+  const copyNode = copyModel;
+  if (deep) {
+    for (const child of node.childNodes) {
+      const childCopy = copyNodeImpl(child, true, counter);
+      copyNode.appendChild(childCopy);
+    }
+  }
+  return copyNode;
+}
+function cascadeByImpl(node, fn) {
+  if (fn(node) === false) return false;
+  for (const child of [...node.childNodes]) {
+    if (!cascadeByImpl(child, fn)) return false;
+  }
+  return true;
+}
+
+// src/model/TreeModel.ts
+var TreeModel = class extends Model {
+  static $className = "Ext.data.TreeModel";
+  static idProperty = "id";
+  static defaultRootId = "root";
+  static defaultRootText = "Root";
+  static fields = [
+    { name: "id", type: "auto" /* AUTO */ },
+    { name: "text", type: "string" /* STRING */, defaultValue: "" },
+    { name: "leaf", type: "boolean" /* BOOLEAN */, defaultValue: false },
+    { name: "cls", type: "string" /* STRING */, defaultValue: "" },
+    { name: "iconCls", type: "string" /* STRING */, defaultValue: "" },
+    { name: "icon", type: "string" /* STRING */, defaultValue: "" },
+    { name: "href", type: "string" /* STRING */, defaultValue: "" },
+    { name: "hrefTarget", type: "string" /* STRING */, defaultValue: "" },
+    { name: "qtip", type: "string" /* STRING */, defaultValue: "" },
+    { name: "qtitle", type: "string" /* STRING */, defaultValue: "" },
+    { name: "allowDrop", type: "boolean" /* BOOLEAN */, defaultValue: true },
+    { name: "allowDrag", type: "boolean" /* BOOLEAN */, defaultValue: true }
+  ];
+  /**
+   * Factory method that creates a TreeModel instance with NodeInterface
+   * already applied.
+   */
+  static create(data) {
+    const instance = super.create(data);
+    applyNodeInterface(instance, 0);
+    return instance;
+  }
+};
+
+// src/store/TreeStore.ts
+var ObservableMixin3 = Observable3;
+function ensureObservable3(instance) {
+  const proto = ObservableMixin3.prototype;
+  for (const name of Object.getOwnPropertyNames(proto)) {
+    if (name === "constructor") continue;
+    if (name in instance) continue;
+    const desc = Object.getOwnPropertyDescriptor(proto, name);
+    if (desc && typeof desc.value === "function") {
+      instance[name] = desc.value.bind(instance);
+    }
+  }
+}
+var TreeStore = class extends Base3 {
+  static $className = "Ext.data.TreeStore";
+  ModelClass;
+  rootNode;
+  nodeMap = /* @__PURE__ */ new Map();
+  $destroyHooks = [];
+  constructor(config) {
+    super();
+    ensureObservable3(this);
+    this.ModelClass = config.model ?? TreeModel;
+    if (config.root) {
+      this.replaceRoot(this.buildNode(config.root, 0));
+    } else {
+      const empty = this.ModelClass.create({ id: "__root__", text: "Root" });
+      applyNodeInterface(empty, 0);
+      this.replaceRoot(empty);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Root
+  // -----------------------------------------------------------------------
+  getRoot() {
+    return this.rootNode;
+  }
+  getRootNode() {
+    return this.rootNode;
+  }
+  /**
+   * Replaces the root with new data (or a pre-built node).
+   * Fires 'rootchange'.
+   */
+  setRoot(nodeOrData) {
+    let node;
+    if (this.isNodeInterface(nodeOrData)) {
+      node = nodeOrData;
+    } else {
+      node = this.buildNode(nodeOrData, 0);
+    }
+    this.replaceRoot(node);
+    return node;
+  }
+  isNodeInterface(value) {
+    return typeof value === "object" && value !== null && "childNodes" in value && "parentNode" in value && typeof value.isRoot === "function";
+  }
+  replaceRoot(node) {
+    this.rootNode = node;
+    this.nodeMap.clear();
+    this.registerRecursive(node);
+    this.fire("rootchange", this, node);
+  }
+  // -----------------------------------------------------------------------
+  // Lookup
+  // -----------------------------------------------------------------------
+  getNodeById(id) {
+    return this.nodeMap.get(id);
+  }
+  // -----------------------------------------------------------------------
+  // Tree operations
+  // -----------------------------------------------------------------------
+  appendChild(parent, child) {
+    parent.appendChild(child);
+    this.registerRecursive(child);
+    this.fire("nodeappend", this, child, parent);
+    this.fire("datachanged", this);
+  }
+  removeChild(parent, child) {
+    parent.removeChild(child);
+    this.unregisterRecursive(child);
+    this.fire("noderemove", this, child, parent);
+    this.fire("datachanged", this);
+  }
+  insertBefore(node, refNode) {
+    const parent = refNode.parentNode;
+    if (!parent) return;
+    parent.insertBefore(node, refNode);
+    this.registerRecursive(node);
+    this.fire("nodeinsert", this, node, refNode, parent);
+    this.fire("datachanged", this);
+  }
+  // -----------------------------------------------------------------------
+  // Expand / Collapse
+  // -----------------------------------------------------------------------
+  expandNode(node) {
+    node.expanded = true;
+    node.loaded = true;
+    this.fire("nodeexpand", this, node);
+  }
+  collapseNode(node) {
+    node.expanded = false;
+    this.fire("nodecollapse", this, node);
+  }
+  // -----------------------------------------------------------------------
+  // Deep search
+  // -----------------------------------------------------------------------
+  findNode(field, value) {
+    return this.findNodeImpl(this.rootNode, field, value);
+  }
+  findNodeImpl(node, field, value) {
+    const model = node;
+    const nodeValue = field === "id" ? model.getId() : model.get(field);
+    if (nodeValue === value) return node;
+    for (const child of node.childNodes) {
+      const found = this.findNodeImpl(child, field, value);
+      if (found) return found;
+    }
+    return void 0;
+  }
+  // -----------------------------------------------------------------------
+  // Collapse / Expand all
+  // -----------------------------------------------------------------------
+  collapseAll() {
+    this.rootNode.cascadeBy((node) => {
+      node.expanded = false;
+    });
+  }
+  expandAll() {
+    this.rootNode.cascadeBy((node) => {
+      node.expanded = true;
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Count helpers
+  // -----------------------------------------------------------------------
+  getCount() {
+    return this.flattenNodes().length;
+  }
+  getTotalCount() {
+    return this.nodeMap.size;
+  }
+  // -----------------------------------------------------------------------
+  // Flatten (for rendering in a flat list / grid)
+  // -----------------------------------------------------------------------
+  flattenNodes() {
+    const result = [];
+    this.flattenWalk(this.rootNode, result);
+    return result;
+  }
+  flattenWalk(node, out) {
+    out.push(node);
+    if (node.expanded || node.isRoot()) {
+      for (const child of node.childNodes) {
+        this.flattenWalk(child, out);
+      }
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Build tree from nested data
+  // -----------------------------------------------------------------------
+  buildNode(data, depth) {
+    const children = data.children;
+    const expanded = data.expanded;
+    const nodeData = { ...data };
+    delete nodeData.children;
+    delete nodeData.expanded;
+    const model = this.ModelClass.create(nodeData);
+    applyNodeInterface(model, depth);
+    const node = model;
+    if (expanded) {
+      node.expanded = true;
+      node.loaded = true;
+    }
+    if (children && Array.isArray(children)) {
+      for (const childData of children) {
+        const childNode = this.buildNode(childData, depth + 1);
+        node.appendChild(childNode);
+      }
+      node.loaded = true;
+    }
+    return node;
+  }
+  // -----------------------------------------------------------------------
+  // Node registration (for id-based lookup)
+  // -----------------------------------------------------------------------
+  registerRecursive(node) {
+    const id = node.getId();
+    if (id !== void 0 && id !== null) {
+      this.nodeMap.set(id, node);
+    }
+    for (const child of node.childNodes) {
+      this.registerRecursive(child);
+    }
+  }
+  unregisterRecursive(node) {
+    const id = node.getId();
+    if (id !== void 0 && id !== null) {
+      this.nodeMap.delete(id);
+    }
+    for (const child of node.childNodes) {
+      this.unregisterRecursive(child);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Event helper
+  // -----------------------------------------------------------------------
+  fire(eventName, ...args) {
+    if (typeof this.fireEvent === "function") {
+      this.fireEvent(eventName, ...args);
+    }
+  }
+};
+
+// src/reader/TreeReader.ts
+var TreeReader = class extends JsonReader {
+  childrenProperty;
+  constructor(config) {
+    super(config);
+    this.childrenProperty = config.childrenProperty ?? "children";
+  }
+  /**
+   * Reads data, recursively collecting ALL nodes (at all levels) into a flat
+   * ResultSet.  The original children references are preserved on the raw
+   * objects, so the tree structure is available to callers (e.g. TreeStore).
+   */
+  read(data) {
+    const flat = [];
+    const rootRecords = this.extractRootArray(data);
+    this.collectFlat(rootRecords, flat);
+    const model = this.config.model;
+    const records = flat.map((raw) => model.create(raw));
+    return new ResultSet({ records, total: records.length, success: true });
+  }
+  /**
+   * Returns `{ root, records }` where `root` is the first raw record and
+   * `records` is the full flat list of all nodes.
+   */
+  readTree(data) {
+    const flat = [];
+    this.collectFlat([data], flat);
+    return { root: data, records: flat };
+  }
+  // ---------------------------------------------------------------------------
+  // Internal helpers
+  // ---------------------------------------------------------------------------
+  extractRootArray(data) {
+    if (this.config.rootProperty) {
+      const root = getNestedValue3(data, this.config.rootProperty);
+      return Array.isArray(root) ? root : [];
+    }
+    return Array.isArray(data) ? data : [];
+  }
+  collectFlat(items, out) {
+    for (const item of items) {
+      out.push(item);
+      const children = item[this.childrenProperty];
+      if (Array.isArray(children) && children.length > 0) {
+        this.collectFlat(children, out);
+      }
+    }
+  }
+};
+function getNestedValue3(obj, path) {
+  const segments = path.split(".");
+  let current = obj;
+  for (const seg of segments) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[seg];
+  }
+  return current;
+}
+
+// src/writer/TreeWriter.ts
+var TreeWriter = class {
+  childrenProperty;
+  constructor(config) {
+    this.childrenProperty = config?.childrenProperty ?? "children";
+  }
+  /**
+   * Serializes an array of root-level NodeInterface records to plain objects.
+   * Children are nested under the configured `childrenProperty`.
+   */
+  writeRecords(records) {
+    return records.map((r) => this.writeRecord(r));
+  }
+  writeRecord(record) {
+    const data = record.getData();
+    if (record.childNodes && record.childNodes.length > 0) {
+      data[this.childrenProperty] = record.childNodes.map(
+        (c) => this.writeRecord(c)
+      );
+    }
+    return data;
+  }
+};
+
+// src/store/BufferedStore.ts
+import { Base as Base4, Observable as Observable4 } from "@framesquared/core";
+var ObservableMixin4 = Observable4;
+function ensureObservable4(instance) {
+  const proto = ObservableMixin4.prototype;
+  for (const name of Object.getOwnPropertyNames(proto)) {
+    if (name === "constructor") continue;
+    if (name in instance) continue;
+    const desc = Object.getOwnPropertyDescriptor(proto, name);
+    if (desc && typeof desc.value === "function") {
+      instance[name] = desc.value.bind(instance);
+    }
+  }
+}
+var BufferedStore = class extends Base4 {
+  static $className = "Ext.data.BufferedStore";
+  pageSize;
+  leadingBufferZone;
+  trailingBufferZone;
+  proxyRef;
+  /** Page number → array of Model records for that page. */
+  pageMap = /* @__PURE__ */ new Map();
+  /** Total count from the server. */
+  totalCount = 0;
+  /** All loaded records in a flat sparse index. */
+  recordMap = /* @__PURE__ */ new Map();
+  /** Pages currently being fetched (to avoid duplicate requests). */
+  pendingPages = /* @__PURE__ */ new Set();
+  $destroyHooks = [];
+  constructor(config) {
+    super();
+    ensureObservable4(this);
+    this.pageSize = config.pageSize ?? 25;
+    this.leadingBufferZone = config.leadingBufferZone ?? 0;
+    this.trailingBufferZone = config.trailingBufferZone ?? 0;
+    this.proxyRef = config.proxy ?? null;
+  }
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  getPageSize() {
+    return this.pageSize;
+  }
+  getCount() {
+    return this.recordMap.size;
+  }
+  getTotalCount() {
+    return this.totalCount;
+  }
+  getAt(index) {
+    return this.recordMap.get(index);
+  }
+  isPageLoaded(pageNumber) {
+    return this.pageMap.has(pageNumber);
+  }
+  /**
+   * Ensures the given range [start, end] of row indices is loaded.
+   * Loads missing pages from the proxy and fires 'guaranteedrange'
+   * when the requested range is fully available.
+   */
+  async guaranteeRange(start, end) {
+    const startPage = Math.floor(start / this.pageSize);
+    const endPage = Math.floor(end / this.pageSize);
+    const pagesToLoad = [];
+    for (let p = startPage; p <= endPage; p++) {
+      if (!this.pageMap.has(p) && !this.pendingPages.has(p)) {
+        pagesToLoad.push(p);
+      }
+    }
+    if (pagesToLoad.length > 0) {
+      await Promise.all(pagesToLoad.map((p) => this.loadPage(p)));
+    }
+    const records = [];
+    for (let i = start; i <= end; i++) {
+      const rec = this.recordMap.get(i);
+      if (rec) records.push(rec);
+    }
+    this.fire("guaranteedrange", this, records, start, end);
+    this.prefetchBufferZones(startPage, endPage);
+  }
+  // -----------------------------------------------------------------------
+  // Page loading
+  // -----------------------------------------------------------------------
+  async loadPage(pageNumber) {
+    if (!this.proxyRef) return;
+    if (this.pageMap.has(pageNumber)) return;
+    this.pendingPages.add(pageNumber);
+    try {
+      const start = pageNumber * this.pageSize;
+      const op = new Operation({
+        action: "read",
+        start,
+        limit: this.pageSize,
+        page: pageNumber + 1
+        // 1-based page for server
+      });
+      const rs = await this.proxyRef.read(op);
+      if (rs.success) {
+        this.pageMap.set(pageNumber, rs.records);
+        for (let i = 0; i < rs.records.length; i++) {
+          this.recordMap.set(start + i, rs.records[i]);
+        }
+        if (rs.total > 0) {
+          this.totalCount = rs.total;
+        }
+      }
+    } finally {
+      this.pendingPages.delete(pageNumber);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Prefetching
+  // -----------------------------------------------------------------------
+  prefetchBufferZones(startPage, endPage) {
+    if (this.leadingBufferZone <= 0 && this.trailingBufferZone <= 0) return;
+    const leadingPages = Math.ceil(this.leadingBufferZone / this.pageSize);
+    const trailingPages = Math.ceil(this.trailingBufferZone / this.pageSize);
+    for (let p = startPage - leadingPages; p < startPage; p++) {
+      if (p >= 0 && !this.pageMap.has(p) && !this.pendingPages.has(p)) {
+        this.loadPage(p);
+      }
+    }
+    const maxPage = this.totalCount > 0 ? Math.floor((this.totalCount - 1) / this.pageSize) : endPage + trailingPages;
+    for (let p = endPage + 1; p <= endPage + trailingPages && p <= maxPage; p++) {
+      if (!this.pageMap.has(p) && !this.pendingPages.has(p)) {
+        this.loadPage(p);
+      }
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Event helper
+  // -----------------------------------------------------------------------
+  fire(eventName, ...args) {
+    if (typeof this.fireEvent === "function") {
+      this.fireEvent(eventName, ...args);
+    }
+  }
+};
+
+// src/proxy/GraphQLProxy.ts
+var GraphQLProxy = class extends Proxy2 {
+  url;
+  query;
+  mutation;
+  rootProperty;
+  headers;
+  constructor(config) {
+    super(config);
+    this.url = config.url;
+    this.query = config.query ?? "";
+    this.mutation = config.mutation ?? "";
+    this.rootProperty = config.rootProperty ?? "data";
+    this.headers = config.headers ?? {};
+  }
+  async read(operation) {
+    return this.doRequest(this.query, operation.params);
+  }
+  async create(operation) {
+    const variables = { ...operation.params };
+    if (operation.records.length > 0) {
+      variables.input = operation.records[0].getData();
+    }
+    return this.doRequest(this.mutation, variables);
+  }
+  async update(operation) {
+    const variables = { ...operation.params };
+    if (operation.records.length > 0) {
+      variables.input = operation.records[0].getData();
+    }
+    return this.doRequest(this.mutation, variables);
+  }
+  async destroy(operation) {
+    const variables = { ...operation.params };
+    if (operation.records.length > 0) {
+      variables.id = operation.records[0].getId();
+    }
+    return this.doRequest(this.mutation, variables);
+  }
+  async doRequest(queryStr, variables) {
+    try {
+      const response = await fetch(this.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...this.headers },
+        body: JSON.stringify({ query: queryStr, variables })
+      });
+      const data = await response.json();
+      if (data.errors && data.errors.length > 0) {
+        return new ResultSet({
+          records: [],
+          success: false,
+          message: data.errors[0].message
+        });
+      }
+      const raw = this.extractByPath(data, this.rootProperty);
+      const items = Array.isArray(raw) ? raw : raw ? [raw] : [];
+      const records = items.map((item) => this.model.create(item));
+      return new ResultSet({ records, success: true });
+    } catch (err) {
+      return new ResultSet({
+        records: [],
+        success: false,
+        message: err?.message ?? "GraphQL request failed"
+      });
+    }
+  }
+  extractByPath(obj, path) {
+    const parts = path.split(".");
+    let current = obj;
+    for (const part of parts) {
+      if (current == null) return void 0;
+      current = current[part];
+    }
+    return current;
+  }
+};
+
+// src/proxy/WebSocketProxy.ts
+var WebSocketProxy = class extends Proxy2 {
+  url;
+  reconnect;
+  reconnectInterval;
+  ws = null;
+  listeners = {};
+  intentionalClose = false;
+  reconnectTimer = null;
+  constructor(config) {
+    super(config);
+    this.url = config.url;
+    this.reconnect = config.reconnect ?? false;
+    this.reconnectInterval = config.reconnectInterval ?? 3e3;
+  }
+  // -----------------------------------------------------------------------
+  // Connection management
+  // -----------------------------------------------------------------------
+  connect() {
+    this.intentionalClose = false;
+    this.ws = new WebSocket(this.url);
+    this.ws.onopen = () => this.fire("open");
+    this.ws.onerror = (e) => this.fire("error", e);
+    this.ws.onmessage = (e) => {
+      try {
+        const data = JSON.parse(e.data);
+        this.fire("message", data);
+      } catch {
+        this.fire("message", e.data);
+      }
+    };
+    this.ws.onclose = () => {
+      this.fire("close");
+      if (this.reconnect && !this.intentionalClose) {
+        this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectInterval);
+      }
+    };
+  }
+  disconnect() {
+    this.intentionalClose = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.ws?.close();
+    this.ws = null;
+  }
+  // -----------------------------------------------------------------------
+  // Send operations
+  // -----------------------------------------------------------------------
+  send(operation) {
+    if (!this.ws || this.ws.readyState !== 1) return;
+    const message = {
+      action: operation.action,
+      records: operation.records.map((r) => r.getData()),
+      params: operation.params
+    };
+    this.ws.send(JSON.stringify(message));
+  }
+  // -----------------------------------------------------------------------
+  // Proxy interface (returns empty ResultSets — real data comes via events)
+  // -----------------------------------------------------------------------
+  async read(operation) {
+    this.send(operation);
+    return new ResultSet({ records: [], success: true });
+  }
+  async create(operation) {
+    this.send(operation);
+    return new ResultSet({ records: operation.records, success: true });
+  }
+  async update(operation) {
+    this.send(operation);
+    return new ResultSet({ records: operation.records, success: true });
+  }
+  async destroy(operation) {
+    this.send(operation);
+    return new ResultSet({ records: [], success: true });
+  }
+  // -----------------------------------------------------------------------
+  // Events
+  // -----------------------------------------------------------------------
+  on(event, fn) {
+    (this.listeners[event] ??= []).push(fn);
+  }
+  off(event, fn) {
+    const list = this.listeners[event];
+    if (!list) return;
+    const idx = list.indexOf(fn);
+    if (idx >= 0) list.splice(idx, 1);
+  }
+  fire(event, ...args) {
+    (this.listeners[event] ?? []).forEach((fn) => fn(...args));
+  }
+};
+
+// src/proxy/BatchProxy.ts
+var BatchProxy = class extends Proxy2 {
+  url;
+  headers;
+  constructor(config) {
+    super(config);
+    this.url = config.url;
+    this.headers = config.headers ?? {};
+  }
+  /**
+   * Send multiple operations as a single batched request.
+   * Returns an array of ResultSets, one per operation.
+   */
+  async sendBatch(operations) {
+    const body = {
+      operations: operations.map((op) => ({
+        action: op.action,
+        records: op.records.map((r) => r.getData()),
+        params: op.params
+      }))
+    };
+    try {
+      const response = await fetch(this.url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...this.headers },
+        body: JSON.stringify(body)
+      });
+      const data = await response.json();
+      const results = [];
+      if (data.results && Array.isArray(data.results)) {
+        for (const r of data.results) {
+          const records = (r.records ?? []).map((item) => this.model.create(item));
+          results.push(new ResultSet({
+            records,
+            success: r.success ?? false,
+            message: r.message
+          }));
+        }
+      }
+      return results;
+    } catch (err) {
+      return operations.map(() => new ResultSet({
+        records: [],
+        success: false,
+        message: err?.message ?? "Batch request failed"
+      }));
+    }
+  }
+  // Proxy interface — delegate to sendBatch with single operation
+  async read(operation) {
+    const results = await this.sendBatch([operation]);
+    return results[0] ?? new ResultSet({ records: [], success: false });
+  }
+  async create(operation) {
+    const results = await this.sendBatch([operation]);
+    return results[0] ?? new ResultSet({ records: [], success: false });
+  }
+  async update(operation) {
+    const results = await this.sendBatch([operation]);
+    return results[0] ?? new ResultSet({ records: [], success: false });
+  }
+  async destroy(operation) {
+    const results = await this.sendBatch([operation]);
+    return results[0] ?? new ResultSet({ records: [], success: false });
+  }
+};
+
+// src/data/Connection.ts
+var requestInterceptors = [];
+var responseInterceptors = [];
+var defaultHeaders = {};
+var errorHandler = null;
+var Connection = {
+  /**
+   * Fetch with interceptors and default headers applied.
+   */
+  async fetch(url, init = {}) {
+    init.headers = { ...defaultHeaders, ...init.headers ?? {} };
+    let currentUrl = url;
+    let currentInit = init;
+    for (const interceptor of requestInterceptors) {
+      [currentUrl, currentInit] = interceptor(currentUrl, currentInit);
+    }
+    try {
+      let response = await fetch(currentUrl, currentInit);
+      for (const interceptor of responseInterceptors) {
+        response = interceptor(response);
+      }
+      return response;
+    } catch (err) {
+      if (errorHandler) errorHandler(err);
+      throw err;
+    }
+  },
+  addRequestInterceptor(fn) {
+    requestInterceptors.push(fn);
+  },
+  addResponseInterceptor(fn) {
+    responseInterceptors.push(fn);
+  },
+  setDefaultHeaders(headers) {
+    defaultHeaders = { ...headers };
+  },
+  setErrorHandler(handler) {
+    errorHandler = handler;
+  },
+  reset() {
+    requestInterceptors.length = 0;
+    responseInterceptors.length = 0;
+    defaultHeaders = {};
+    errorHandler = null;
+  }
+};
+
+// src/data/Session.ts
+var Session = class {
+  created = /* @__PURE__ */ new Map();
+  updated = /* @__PURE__ */ new Map();
+  destroyed = /* @__PURE__ */ new Map();
+  // -----------------------------------------------------------------------
+  // Track operations
+  // -----------------------------------------------------------------------
+  trackCreate(record) {
+    const key = this.recordKey(record);
+    this.created.set(key, record);
+  }
+  trackUpdate(record) {
+    const key = this.recordKey(record);
+    if (this.created.has(key)) return;
+    this.updated.set(key, record);
+  }
+  trackDestroy(record) {
+    const key = this.recordKey(record);
+    if (this.created.has(key)) {
+      this.created.delete(key);
+      return;
+    }
+    this.updated.delete(key);
+    this.destroyed.set(key, record);
+  }
+  // -----------------------------------------------------------------------
+  // Accessors
+  // -----------------------------------------------------------------------
+  getCreated() {
+    return [...this.created.values()];
+  }
+  getUpdated() {
+    return [...this.updated.values()];
+  }
+  getDestroyed() {
+    return [...this.destroyed.values()];
+  }
+  getChanges() {
+    return {
+      create: this.getCreated(),
+      update: this.getUpdated(),
+      destroy: this.getDestroyed()
+    };
+  }
+  isDirty() {
+    return this.created.size > 0 || this.updated.size > 0 || this.destroyed.size > 0;
+  }
+  // -----------------------------------------------------------------------
+  // Save via BatchProxy
+  // -----------------------------------------------------------------------
+  async save(proxy) {
+    const ops = [];
+    const creates = this.getCreated();
+    const updates = this.getUpdated();
+    const destroys = this.getDestroyed();
+    if (creates.length > 0) {
+      ops.push(new Operation({ action: "create", records: creates }));
+    }
+    if (updates.length > 0) {
+      ops.push(new Operation({ action: "update", records: updates }));
+    }
+    if (destroys.length > 0) {
+      ops.push(new Operation({ action: "destroy", records: destroys }));
+    }
+    if (ops.length === 0) {
+      return { success: true, results: [] };
+    }
+    const results = await proxy.sendBatch(ops);
+    const success = results.every((r) => r.success);
+    return { success, results };
+  }
+  // -----------------------------------------------------------------------
+  // Commit / Reject
+  // -----------------------------------------------------------------------
+  commit() {
+    this.created.clear();
+    this.updated.clear();
+    this.destroyed.clear();
+  }
+  reject() {
+    this.created.clear();
+    this.updated.clear();
+    this.destroyed.clear();
+  }
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+  recordKey(record) {
+    return record;
+  }
+};
+export {
+  AjaxProxy,
+  ArrayReader,
+  Association,
+  AutoField,
+  BatchProxy,
+  BelongsTo,
+  BooleanField,
+  BufferedStore,
+  Collection,
+  Connection,
+  DateField,
+  Field,
+  FieldType,
+  FloatField,
+  GraphQLProxy,
+  HasMany,
+  HasOne,
+  IntField,
+  JsonReader,
+  JsonWriter,
+  LocalStorageProxy,
+  ManyToMany,
+  ManyToManyCollection,
+  MemoryProxy,
+  Model,
+  ModelCollection,
+  Operation,
+  Proxy2 as Proxy,
+  RestProxy,
+  ResultSet,
+  Schema,
+  Session,
+  SessionStorageProxy,
+  Store,
+  StringField,
+  TreeModel,
+  TreeReader,
+  TreeStore,
+  TreeWriter,
+  WebSocketProxy,
+  XmlReader,
+  XmlWriter,
+  applyNodeInterface,
+  createField,
+  email,
+  exclusion,
+  formatValidator,
+  inclusion,
+  length,
+  presence,
+  rangeValidator
+};
+//# sourceMappingURL=index.js.map