@axi-engine/fields 0.3.3 → 0.3.5

package/dist/index.mjs

@@ -1,1202 +1,1170 @@
-import { ConstructorRegistry, Emitter, ensurePathArray, ensurePathString, isBoolean, isNullOrUndefined, isNumber, isString, throwIf, throwIfEmpty } from "@axi-engine/utils";
-import { dequal } from "dequal";
-
-//#region src/policies/clamp-policy.ts
-var ClampPolicy = class ClampPolicy {
-	static id = "clamp";
-	id = ClampPolicy.id;
-	constructor(min, max) {
-		this.min = min;
-		this.max = max;
-	}
-	apply(val) {
-		return Math.max(this.min, Math.min(this.max, val));
-	}
-	updateBounds(min, max) {
-		this.min = min;
-		this.max = max;
-	}
+// src/policies/clamp-policy.ts
+var ClampPolicy = class _ClampPolicy {
+  constructor(min, max) {
+    this.min = min;
+    this.max = max;
+  }
+  static id = "clamp";
+  id = _ClampPolicy.id;
+  apply(val) {
+    return Math.max(this.min, Math.min(this.max, val));
+  }
+  updateBounds(min, max) {
+    this.min = min;
+    this.max = max;
+  }
 };
 function clampPolicy(min, max) {
-	return new ClampPolicy(min, max);
+  return new ClampPolicy(min, max);
 }
 
-//#endregion
-//#region src/policies/clamp-max-policy.ts
-var ClampMaxPolicy = class ClampMaxPolicy {
-	static id = "clampMax";
-	id = ClampMaxPolicy.id;
-	constructor(max) {
-		this.max = max;
-	}
-	apply(val) {
-		return Math.min(this.max, val);
-	}
-	updateBounds(max) {
-		this.max = max;
-	}
+// src/policies/clamp-max-policy.ts
+var ClampMaxPolicy = class _ClampMaxPolicy {
+  constructor(max) {
+    this.max = max;
+  }
+  static id = "clampMax";
+  id = _ClampMaxPolicy.id;
+  apply(val) {
+    return Math.min(this.max, val);
+  }
+  updateBounds(max) {
+    this.max = max;
+  }
 };
 function clampMaxPolicy(max) {
-	return new ClampMaxPolicy(max);
+  return new ClampMaxPolicy(max);
 }
 
-//#endregion
-//#region src/policies/clamp-min-policy.ts
-var ClampMinPolicy = class ClampMinPolicy {
-	static id = "clampMin";
-	id = ClampMinPolicy.id;
-	constructor(min) {
-		this.min = min;
-	}
-	apply(val) {
-		return Math.max(this.min, val);
-	}
-	updateBounds(min) {
-		this.min = min;
-	}
+// src/policies/clamp-min-policy.ts
+var ClampMinPolicy = class _ClampMinPolicy {
+  constructor(min) {
+    this.min = min;
+  }
+  static id = "clampMin";
+  id = _ClampMinPolicy.id;
+  apply(val) {
+    return Math.max(this.min, val);
+  }
+  updateBounds(min) {
+    this.min = min;
+  }
 };
 function clampMinPolicy(min) {
-	return new ClampMinPolicy(min);
+  return new ClampMinPolicy(min);
 }
 
-//#endregion
-//#region src/policies/policies.ts
+// src/policies/policies.ts
 var Policies = class {
-	policies = /* @__PURE__ */ new Map();
-	get items() {
-		return this.policies;
-	}
-	/**
-	* Retrieves a specific policy instance by its ID.
-	* Useful for accessing a policy's internal state or methods.
-	* @template P The expected type of the policy.
-	* @param id The unique ID of the policy to retrieve.
-	* @returns The policy instance, or `undefined` if not found.
-	*/
-	get(id) {
-		return this.policies.get(id);
-	}
-	/**
-	* Adds a new policy to the field or replaces an existing one with the same ID.
-	* The new policy will be applied on the next `set()` operation.
-	* If a policy with the same ID already exists, its `destroy` method will be called before it is replaced.
-	* @param policy The policy instance to add.
-	*/
-	add(policy) {
-		this.policies.get(policy.id)?.destroy?.();
-		this.policies.set(policy.id, policy);
-		return this;
-	}
-	/**
-	* Removes a policy from the field by its ID and call `destroy` method.
-	* @param policyId The unique ID of the policy to remove.
-	* @returns `true` if the policy was found and removed, otherwise `false`.
-	*/
-	remove(policyId) {
-		const policyToRemove = this.policies.get(policyId);
-		if (!policyToRemove) return false;
-		policyToRemove.destroy?.();
-		return this.policies.delete(policyId);
-	}
-	isEmpty() {
-		return this.policies.size === 0;
-	}
-	/**
-	* Removes all policies from the field.
-	* After this, `set()` will no longer apply any transformations to the value until new policies are added.
-	*/
-	clear() {
-		this.policies.forEach((policy) => policy.destroy?.());
-		this.policies.clear();
-	}
-	/**
-	* Forces the current value to be re-processed by all policies.
-	* Useful if a policy's logic has changed and you need to re-evaluate the current state.
-	*/
-	apply(val) {
-		let finalVal = val;
-		this.policies.forEach((policy) => finalVal = policy.apply(finalVal));
-		return finalVal;
-	}
+  policies = /* @__PURE__ */ new Map();
+  get items() {
+    return this.policies;
+  }
+  /**
+   * Retrieves a specific policy instance by its ID.
+   * Useful for accessing a policy's internal state or methods.
+   * @template P The expected type of the policy.
+   * @param id The unique ID of the policy to retrieve.
+   * @returns The policy instance, or `undefined` if not found.
+   */
+  get(id) {
+    return this.policies.get(id);
+  }
+  /**
+   * Adds a new policy to the field or replaces an existing one with the same ID.
+   * The new policy will be applied on the next `set()` operation.
+   * If a policy with the same ID already exists, its `destroy` method will be called before it is replaced.
+   * @param policy The policy instance to add.
+   */
+  add(policy) {
+    const existed = this.policies.get(policy.id);
+    existed?.destroy?.();
+    this.policies.set(policy.id, policy);
+    return this;
+  }
+  /**
+   * Removes a policy from the field by its ID and call `destroy` method.
+   * @param policyId The unique ID of the policy to remove.
+   * @returns `true` if the policy was found and removed, otherwise `false`.
+   */
+  remove(policyId) {
+    const policyToRemove = this.policies.get(policyId);
+    if (!policyToRemove) {
+      return false;
+    }
+    policyToRemove.destroy?.();
+    return this.policies.delete(policyId);
+  }
+  isEmpty() {
+    return this.policies.size === 0;
+  }
+  /**
+   * Removes all policies from the field.
+   * After this, `set()` will no longer apply any transformations to the value until new policies are added.
+   */
+  clear() {
+    this.policies.forEach((policy) => policy.destroy?.());
+    this.policies.clear();
+  }
+  /**
+   * Forces the current value to be re-processed by all policies.
+   * Useful if a policy's logic has changed and you need to re-evaluate the current state.
+   */
+  apply(val) {
+    let finalVal = val;
+    this.policies.forEach((policy) => finalVal = policy.apply(finalVal));
+    return finalVal;
+  }
 };
 
-//#endregion
-//#region src/mixins/mixin-factory.ts
-/**
-* A higher-order function that generates a mixin for a specific Field type.
-* This factory removes the need to write boilerplate mixin code for every new field type.
-*
-* @param typeName The `typeName` of the Field to create (e.g., 'boolean', 'my-signal-field').
-* @param baseMethodName The base name for the generated methods (e.g., 'Boolean', 'MySignal').
-* @returns A fully functional, typed mixin.
-*/
+// src/mixins/mixin-factory.ts
 function createTypedMethodsMixin(typeName, baseMethodName) {
-	const methodNames = {
-		create: `create${baseMethodName}`,
-		upset: `upset${baseMethodName}`,
-		get: `get${baseMethodName}`
-	};
-	return function(Base) {
-		return class FieldsWith extends Base {
-			[methodNames.create](name, initialValue, options) {
-				return this.create(typeName, name, initialValue, options);
-			}
-			[methodNames.upset](name, value, options) {
-				return this.upset(typeName, name, value, options);
-			}
-			[methodNames.get](name) {
-				return this.get(name);
-			}
-		};
-	};
+  const methodNames = {
+    create: `create${baseMethodName}`,
+    upset: `upset${baseMethodName}`,
+    get: `get${baseMethodName}`
+  };
+  return function(Base) {
+    return class FieldsWith extends Base {
+      // createBoolean, createMySignal, etc.
+      [methodNames.create](name, initialValue, options) {
+        return this.create(typeName, name, initialValue, options);
+      }
+      // upsetBoolean, upsetMySignal, etc.
+      [methodNames.upset](name, value, options) {
+        return this.upset(typeName, name, value, options);
+      }
+      // getBoolean, getMySignal, etc.
+      [methodNames.get](name) {
+        return this.get(name);
+      }
+    };
+  };
 }
 
-//#endregion
-//#region src/field-definitions/core-field.ts
-/**
-* A state container that wraps a value.
-* It allows applying a pipeline of transformation or validation "policies" before any new value is set.
-*
-* @template T The type of the value this field holds.
-*
-*/
-var CoreField = class CoreField {
-	/** A type keyword of the field */
-	static typeName = "default";
-	typeName = CoreField.typeName;
-	/** A unique identifier for the field. */
-	_name;
-	_value;
-	_onChange = new Emitter();
-	onChange;
-	policies = new Policies();
-	get name() {
-		return this._name;
-	}
-	/**
-	* Gets the current raw value of the field.
-	* For reactive updates, it's recommended to use the `.signal` property instead.
-	*/
-	get value() {
-		return this._value;
-	}
-	/**
-	* Sets a new value for the field.
-	* The provided value will be processed by all registered policies before the underlying signal is updated.
-	* @param val The new value to set.
-	*/
-	set value(val) {
-		const oldVal = this._value;
-		const finalVal = this.policies.apply(val);
-		if (!dequal(this._value, finalVal)) {
-			this._value = finalVal;
-			this._onChange.emit(this._value, oldVal);
-		}
-	}
-	/**
-	* Creates an instance of a Field.
-	* @param name A unique identifier for the field.
-	* @param initialVal The initial value of the field.
-	* @param options Optional configuration for the field.
-	* @param options.policies An array of policies to apply to the field's value on every `set` operation.
-	* @param options.isEqual An function for compare old and new value, by default uses the strictEquals from `utils`
-	*
-	*/
-	constructor(name, initialVal, options) {
-		this.onChange = this._onChange;
-		this._name = name;
-		options?.policies?.forEach((policy) => this.policies.add(policy));
-		this.value = initialVal;
-	}
-	setValueSilently(val) {
-		this._value = this.policies.apply(val);
-	}
-	batchUpdate(updateFn) {
-		this.value = updateFn(this.value);
-	}
-	/**
-	* Cleans up resources used by the field and its policies.
-	* This should be called when the field is no longer needed to prevent memory leaks from reactive policies.
-	*/
-	destroy() {
-		this.policies.clear();
-		this._onChange.clear();
-	}
+// src/field-definitions/core-field.ts
+import { Emitter } from "@axi-engine/utils";
+import { dequal } from "dequal";
+var CoreField = class _CoreField {
+  /** A type keyword of the field */
+  static typeName = "default";
+  typeName = _CoreField.typeName;
+  /** A unique identifier for the field. */
+  _name;
+  _value;
+  _onChange = new Emitter();
+  onChange;
+  policies = new Policies();
+  get name() {
+    return this._name;
+  }
+  /**
+   * Gets the current raw value of the field.
+   * For reactive updates, it's recommended to use the `.signal` property instead.
+   */
+  get value() {
+    return this._value;
+  }
+  /**
+   * Sets a new value for the field.
+   * The provided value will be processed by all registered policies before the underlying signal is updated.
+   * @param val The new value to set.
+   */
+  set value(val) {
+    const oldVal = this._value;
+    const finalVal = this.policies.apply(val);
+    if (!dequal(this._value, finalVal)) {
+      this._value = finalVal;
+      this._onChange.emit(this._value, oldVal);
+    }
+  }
+  /**
+   * Creates an instance of a Field.
+   * @param name A unique identifier for the field.
+   * @param initialVal The initial value of the field.
+   * @param options Optional configuration for the field.
+   * @param options.policies An array of policies to apply to the field's value on every `set` operation.
+   * @param options.isEqual An function for compare old and new value, by default uses the strictEquals from `utils`
+   *
+   */
+  constructor(name, initialVal, options) {
+    this.onChange = this._onChange;
+    this._name = name;
+    options?.policies?.forEach((policy) => this.policies.add(policy));
+    this.value = initialVal;
+  }
+  setValueSilently(val) {
+    this._value = this.policies.apply(val);
+  }
+  batchUpdate(updateFn) {
+    this.value = updateFn(this.value);
+  }
+  /**
+   * Cleans up resources used by the field and its policies.
+   * This should be called when the field is no longer needed to prevent memory leaks from reactive policies.
+   */
+  destroy() {
+    this.policies.clear();
+    this._onChange.clear();
+  }
 };
 
-//#endregion
-//#region src/field-definitions/core-boolean-field.ts
-var CoreBooleanField = class CoreBooleanField extends CoreField {
-	static typeName = "boolean";
-	typeName = CoreBooleanField.typeName;
-	constructor(name, initialVal, options) {
-		super(name, initialVal, options);
-	}
-	toggle() {
-		this.value = !this.value;
-		return this.value;
-	}
+// src/field-definitions/core-boolean-field.ts
+var CoreBooleanField = class _CoreBooleanField extends CoreField {
+  static typeName = "boolean";
+  typeName = _CoreBooleanField.typeName;
+  constructor(name, initialVal, options) {
+    super(name, initialVal, options);
+  }
+  toggle() {
+    this.value = !this.value;
+    return this.value;
+  }
 };
 
-//#endregion
-//#region src/field-definitions/core-string-field.ts
-var CoreStringField = class CoreStringField extends CoreField {
-	static typeName = "string";
-	typeName = CoreStringField.typeName;
-	constructor(name, initialVal, options) {
-		super(name, initialVal, options);
-	}
-	append(str) {
-		this.value = this.value + str;
-		return this;
-	}
-	prepend(str) {
-		this.value = str + this.value;
-		return this;
-	}
-	trim() {
-		this.value = this.value.trim();
-		return this;
-	}
-	isEmpty() {
-		return this.value.length === 0;
-	}
-	clear() {
-		this.value = "";
-	}
+// src/field-definitions/core-string-field.ts
+var CoreStringField = class _CoreStringField extends CoreField {
+  static typeName = "string";
+  typeName = _CoreStringField.typeName;
+  constructor(name, initialVal, options) {
+    super(name, initialVal, options);
+  }
+  append(str) {
+    this.value = this.value + str;
+    return this;
+  }
+  prepend(str) {
+    this.value = str + this.value;
+    return this;
+  }
+  trim() {
+    this.value = this.value.trim();
+    return this;
+  }
+  isEmpty() {
+    return this.value.length === 0;
+  }
+  clear() {
+    this.value = "";
+  }
 };
 
-//#endregion
-//#region src/field-definitions/core-numeric-field.ts
-var CoreNumericField = class CoreNumericField extends CoreField {
-	static typeName = "numeric";
-	typeName = CoreNumericField.typeName;
-	get min() {
-		return (this.policies.get(ClampPolicy.id) ?? this.policies.get(ClampMinPolicy.id))?.min;
-	}
-	get max() {
-		return (this.policies.get(ClampPolicy.id) ?? this.policies.get(ClampMaxPolicy.id))?.max;
-	}
-	constructor(name, initialVal, options) {
-		const policies = options?.policies ?? [];
-		if (!isNullOrUndefined(options?.min) && !isNullOrUndefined(options?.max)) policies.unshift(clampPolicy(options.min, options.max));
-		else if (!isNullOrUndefined(options?.min)) policies.unshift(clampMinPolicy(options.min));
-		else if (!isNullOrUndefined(options?.max)) policies.unshift(clampMaxPolicy(options.max));
-		super(name, initialVal, { policies });
-	}
-	isMin() {
-		const min = this.min;
-		return isNullOrUndefined(min) ? false : this.value <= min;
-	}
-	isMax() {
-		const max = this.max;
-		return isNullOrUndefined(max) ? false : this.value >= max;
-	}
-	inc(amount = 1) {
-		this.value = this.value + amount;
-	}
-	dec(amount = 1) {
-		this.value = this.value - amount;
-	}
+// src/field-definitions/core-numeric-field.ts
+import { isNullOrUndefined } from "@axi-engine/utils";
+var CoreNumericField = class _CoreNumericField extends CoreField {
+  static typeName = "numeric";
+  typeName = _CoreNumericField.typeName;
+  get min() {
+    const policy = this.policies.get(ClampPolicy.id) ?? this.policies.get(ClampMinPolicy.id);
+    return policy?.min;
+  }
+  get max() {
+    const policy = this.policies.get(ClampPolicy.id) ?? this.policies.get(ClampMaxPolicy.id);
+    return policy?.max;
+  }
+  constructor(name, initialVal, options) {
+    const policies = options?.policies ?? [];
+    if (!isNullOrUndefined(options?.min) && !isNullOrUndefined(options?.max)) {
+      policies.unshift(clampPolicy(options.min, options.max));
+    } else if (!isNullOrUndefined(options?.min)) {
+      policies.unshift(clampMinPolicy(options.min));
+    } else if (!isNullOrUndefined(options?.max)) {
+      policies.unshift(clampMaxPolicy(options.max));
+    }
+    super(name, initialVal, { policies });
+  }
+  isMin() {
+    const min = this.min;
+    return isNullOrUndefined(min) ? false : this.value <= min;
+  }
+  isMax() {
+    const max = this.max;
+    return isNullOrUndefined(max) ? false : this.value >= max;
+  }
+  inc(amount = 1) {
+    this.value = this.value + amount;
+  }
+  dec(amount = 1) {
+    this.value = this.value - amount;
+  }
 };
 
-//#endregion
-//#region src/field-registry.ts
-var FieldRegistry = class extends ConstructorRegistry {};
+// src/field-registry.ts
+import { ConstructorRegistry } from "@axi-engine/utils";
+var FieldRegistry = class extends ConstructorRegistry {
+};
 
-//#endregion
-//#region src/fields.ts
-/**
-* A container for a collection of named `Field` instances.
-*
-* This class acts as a "leaf" node in the `FieldTree` hierarchy, managing a flat
-* key-value store of reactive data points. It uses a `FieldRegistry` to dynamically
-* create `Field` instances of different types.
-*/
-var Fields = class Fields {
-	static typeName = "fields";
-	typeName = Fields.typeName;
-	_fields = /* @__PURE__ */ new Map();
-	_fieldRegistry;
-	/**
-	* An event emitter that fires when a new field is added to the collection.
-	* @event
-	* @param {object} event - The event payload.
-	* @param {string} event.name - The name of the added field.
-	* @param {Field<any>} event.field - The `Field` instance that was added.
-	*/
-	onAdd = new Emitter();
-	/**
-	* An event emitter that fires after one or more fields have been removed.
-	* @event
-	* @param {object} event - The event payload.
-	* @param {string[]} event.names - An array of names of the fields that were successfully removed.
-	*/
-	onRemove = new Emitter();
-	/**
-	* Gets the read-only map of all `Field` instances in this container.
-	* @returns {Map<string, Field<any>>} The collection of fields.
-	*/
-	get fields() {
-		return this._fields;
-	}
-	/**
-	* Creates an instance of Fields.
-	* @param {FieldRegistry} fieldRegistry - The registry used to create new `Field` instances.
-	*/
-	constructor(fieldRegistry) {
-		this._fieldRegistry = fieldRegistry;
-	}
-	/**
-	* Checks if a field with the given name exists in the collection.
-	* @param {string} name The name of the field to check.
-	* @returns {boolean} `true` if the field exists, otherwise `false`.
-	*/
-	has(name) {
-		return this._fields.has(name);
-	}
-	/**
-	* Adds a pre-existing `Field` instance to the collection and fires the `onAdd` event.
-	* @template T - The specific `Field` type being added.
-	* @param {Field<any>} field - The `Field` instance to add.
-	* @returns {T} The added `Field` instance, cast to type `T`.
-	* @throws If a field with the same name already exists.
-	*/
-	add(field) {
-		throwIf(this.has(field.name), `Field with name '${field.name}' already exists`);
-		this._fields.set(field.name, field);
-		this.onAdd.emit({
-			name: field.name,
-			field
-		});
-		return field;
-	}
-	/**
-	* Creates a new `Field` instance of a specified type, adds it to the collection, and returns it.
-	* This is the primary factory method for creating fields within this container.
-	* @template T - The expected `Field` type to be returned.
-	* @param {string} typeName - The registered type name of the field to create (e.g., 'numeric', 'boolean').
-	* @param {string} name - The unique name for the new field.
-	* @param {*} initialValue - The initial value for the new field.
-	* @param {*} [options] - Optional configuration passed to the field's constructor.
-	* @returns {T} The newly created `Field` instance.
-	*/
-	create(typeName, name, initialValue, options) {
-		const field = new (this._fieldRegistry.get(typeName))(name, initialValue, options);
-		this.add(field);
-		return field;
-	}
-	/**
-	* Updates an existing field's value or creates a new one if it doesn't exist.
-	* @template T - The expected `Field` type.
-	* @param {string} typeName - The type name to use if a new field needs to be created.
-	* @param {string} name - The name of the field to update or create.
-	* @param {*} value - The new value to set.
-	* @param {*} [options] - Optional configuration, used only if a new field is created.
-	* @returns {T} The existing or newly created `Field` instance.
-	*/
-	upset(typeName, name, value, options) {
-		if (this.has(name)) {
-			const field = this.get(name);
-			field.value = value;
-			return field;
-		}
-		return this.create(typeName, name, value, options);
-	}
-	/**
-	* Retrieves a field by its name.
-	* @template TField - The expected `Field` type to be returned.
-	* @param {string} name - The name of the field to retrieve.
-	* @returns {TField} The `Field` instance.
-	* @throws If the field does not exist.
-	*/
-	get(name) {
-		throwIf(!this._fields.has(name), `Field with name '${name}' not exists`);
-		return this._fields.get(name);
-	}
-	/**
-	* Removes one or more fields from the collection.
-	* This method ensures that the `destroy` method of each removed field is called to clean up its resources.
-	* @param {string| string[]} names A single name or an array of names to remove.
-	*/
-	remove(names) {
-		const reallyRemoved = (Array.isArray(names) ? names : [names]).filter((name) => {
-			const field = this._fields.get(name);
-			if (!field) return false;
-			field.destroy();
-			return this._fields.delete(name);
-		});
-		if (!reallyRemoved.length) return;
-		this.onRemove.emit({ names: reallyRemoved });
-	}
-	/**
-	* Removes all fields from the collection, ensuring each is properly destroyed.
-	*/
-	clear() {
-		this.remove(Array.from(this._fields.keys()));
-	}
-	destroy() {
-		this.clear();
-		this.onAdd.clear();
-		this.onRemove.clear();
-	}
+// src/fields.ts
+import { Emitter as Emitter2, throwIf } from "@axi-engine/utils";
+var Fields = class _Fields {
+  static typeName = "fields";
+  typeName = _Fields.typeName;
+  _fields = /* @__PURE__ */ new Map();
+  _fieldRegistry;
+  /**
+   * An event emitter that fires when a new field is added to the collection.
+   * @event
+   * @param {object} event - The event payload.
+   * @param {string} event.name - The name of the added field.
+   * @param {Field<any>} event.field - The `Field` instance that was added.
+   */
+  onAdd = new Emitter2();
+  /**
+   * An event emitter that fires after one or more fields have been removed.
+   * @event
+   * @param {object} event - The event payload.
+   * @param {string[]} event.names - An array of names of the fields that were successfully removed.
+   */
+  onRemove = new Emitter2();
+  /**
+   * Gets the read-only map of all `Field` instances in this container.
+   * @returns {Map<string, Field<any>>} The collection of fields.
+   */
+  get fields() {
+    return this._fields;
+  }
+  /**
+   * Creates an instance of Fields.
+   * @param {FieldRegistry} fieldRegistry - The registry used to create new `Field` instances.
+   */
+  constructor(fieldRegistry) {
+    this._fieldRegistry = fieldRegistry;
+  }
+  /**
+   * Checks if a field with the given name exists in the collection.
+   * @param {string} name The name of the field to check.
+   * @returns {boolean} `true` if the field exists, otherwise `false`.
+   */
+  has(name) {
+    return this._fields.has(name);
+  }
+  /**
+   * Adds a pre-existing `Field` instance to the collection and fires the `onAdd` event.
+   * @template T - The specific `Field` type being added.
+   * @param {Field<any>} field - The `Field` instance to add.
+   * @returns {T} The added `Field` instance, cast to type `T`.
+   * @throws If a field with the same name already exists.
+   */
+  add(field) {
+    throwIf(this.has(field.name), `Field with name '${field.name}' already exists`);
+    this._fields.set(field.name, field);
+    this.onAdd.emit({
+      name: field.name,
+      field
+    });
+    return field;
+  }
+  /**
+   * Creates a new `Field` instance of a specified type, adds it to the collection, and returns it.
+   * This is the primary factory method for creating fields within this container.
+   * @template T - The expected `Field` type to be returned.
+   * @param {string} typeName - The registered type name of the field to create (e.g., 'numeric', 'boolean').
+   * @param {string} name - The unique name for the new field.
+   * @param {*} initialValue - The initial value for the new field.
+   * @param {*} [options] - Optional configuration passed to the field's constructor.
+   * @returns {T} The newly created `Field` instance.
+   */
+  create(typeName, name, initialValue, options) {
+    const Ctor = this._fieldRegistry.get(typeName);
+    const field = new Ctor(name, initialValue, options);
+    this.add(field);
+    return field;
+  }
+  /**
+   * Updates an existing field's value or creates a new one if it doesn't exist.
+   * @template T - The expected `Field` type.
+   * @param {string} typeName - The type name to use if a new field needs to be created.
+   * @param {string} name - The name of the field to update or create.
+   * @param {*} value - The new value to set.
+   * @param {*} [options] - Optional configuration, used only if a new field is created.
+   * @returns {T} The existing or newly created `Field` instance.
+   */
+  upset(typeName, name, value, options) {
+    if (this.has(name)) {
+      const field = this.get(name);
+      field.value = value;
+      return field;
+    }
+    return this.create(typeName, name, value, options);
+  }
+  /**
+   * Retrieves a field by its name.
+   * @template TField - The expected `Field` type to be returned.
+   * @param {string} name - The name of the field to retrieve.
+   * @returns {TField} The `Field` instance.
+   * @throws If the field does not exist.
+   */
+  get(name) {
+    throwIf(!this._fields.has(name), `Field with name '${name}' not exists`);
+    return this._fields.get(name);
+  }
+  /**
+   * Removes one or more fields from the collection.
+   * This method ensures that the `destroy` method of each removed field is called to clean up its resources.
+   * @param {string| string[]} names A single name or an array of names to remove.
+   */
+  remove(names) {
+    const namesToRemove = Array.isArray(names) ? names : [names];
+    const reallyRemoved = namesToRemove.filter((name) => {
+      const field = this._fields.get(name);
+      if (!field) {
+        return false;
+      }
+      field.destroy();
+      return this._fields.delete(name);
+    });
+    if (!reallyRemoved.length) {
+      return;
+    }
+    this.onRemove.emit({ names: reallyRemoved });
+  }
+  /**
+   * Removes all fields from the collection, ensuring each is properly destroyed.
+   */
+  clear() {
+    this.remove(Array.from(this._fields.keys()));
+  }
+  destroy() {
+    this.clear();
+    this.onAdd.clear();
+    this.onRemove.clear();
+  }
 };
 
-//#endregion
-//#region src/field-tree.ts
-/**
-* Represents a hierarchical data structure for managing the global state of the system.
-*
-* This class acts as the single source of truth for long-term data that exists
-* across different scenes and scripts, such as player stats, inventory,
-* and overall game progress. It uses a path-based system for accessing and
-* manipulating nested data, similar to a file system.
-*
-*/
-var FieldTree = class FieldTree {
-	static typeName = "fieldTree";
-	typeName = FieldTree.typeName;
-	/** @private The internal map storing child nodes (branches or leaves). */
-	_nodes = /* @__PURE__ */ new Map();
-	/** @private The factory used to create new child nodes. */
-	_factory;
-	/**
-	* An event emitter that fires immediately after a new node is added to this tree branch.
-	* @event
-	* @param {object} event - The event payload.
-	* @param {string} event.name - The name (key) of the added node.
-	* @param event.node - The node instance that was added.
-	* @example
-	* myTree.onAdd.subscribe(({ name, node }) => {
-	*   console.log(`Node '${name}' was added.`, node);
-	* });
-	*/
-	onAdd = new Emitter();
-	/**
-	* An event emitter that fires once after one or more nodes have been successfully removed.
-	* @event
-	* @param {object} event - The event payload.
-	* @param {string[]} event.names - An array of names of the nodes that were removed.
-	* @example
-	* myTree.onRemove.subscribe(({ names }) => {
-	*   console.log(`Nodes removed: ${names.join(', ')}`);
-	* });
-	*/
-	onRemove = new Emitter();
-	/**
-	* Gets the collection of direct child nodes of this tree branch.
-	*/
-	get nodes() {
-		return this._nodes;
-	}
-	/**
-	* Creates an instance of FieldTree.
-	* @param {FieldTreeFactory} factory - A factory responsible for creating new nodes within the tree.
-	*/
-	constructor(factory) {
-		this._factory = factory;
-	}
-	/**
-	* Checks if a direct child node with the given name exists.
-	* @param {string} name - The name of the direct child node.
-	* @returns {boolean} `true` if the node exists, otherwise `false`.
-	*/
-	has(name) {
-		return this._nodes.has(name);
-	}
-	/**
-	* Checks if a node exists at a given path, traversing the tree.
-	* @param {PathType} path - The path to check (e.g., 'player/stats' or ['player', 'stats']).
-	* @returns {boolean} `true` if the entire path resolves to a node, otherwise `false`.
-	*/
-	hasPath(path) {
-		const traversedPath = this.traversePath(path);
-		return traversedPath.branch.has(traversedPath.leafName);
-	}
-	/**
-	* Adds a pre-existing node as a direct child of this tree branch.
-	* @param {string} name - The name to assign to the new child node.
-	* @param {TreeNode} node - The node instance to add.
-	* @returns {TreeNode} The added node.
-	* @throws If a node with the same name already exists.
-	*/
-	addNode(name, node) {
-		throwIf(this.has(name), `Can't add node with name: '${name}', node already exists`);
-		this._nodes.set(name, node);
-		this.onAdd.emit({
-			name,
-			node
-		});
-		return node;
-	}
-	/**
-	* Retrieves a direct child node by its name.
-	* @param {string} name - The name of the child node.
-	* @returns {TreeNode} The retrieved node.
-	* @throws If a node with the given name cannot be found.
-	*/
-	getNode(name) {
-		const node = this._nodes.get(name);
-		throwIfEmpty(node, `Can't find node with name '${name}'`);
-		return node;
-	}
-	/**
-	* Removes one or more nodes from this tree branch.
-	*
-	* This method first validates that all specified nodes exist. If validation passes,
-	* it recursively calls `destroy()` on each node to ensure proper cleanup of the entire subtree.
-	* Finally, it emits a single `onRemove` event with the names of all successfully removed nodes.
-	*
-	* @param {string | string[]} names - A single name or an array of names of the nodes to remove.
-	* @throws If any of the specified names do not correspond to an existing node.
-	*/
-	removeNode(names) {
-		const toRemoveNames = Array.isArray(names) ? names : [names];
-		toRemoveNames.forEach((name) => {
-			throwIf(!this.has(name), `Can't remove node with name: '${name}', node doesn't exists`);
-		});
-		toRemoveNames.forEach((name) => {
-			this._nodes.get(name).destroy();
-			this._nodes.delete(name);
-		});
-		if (toRemoveNames.length) this.onRemove.emit({ names: toRemoveNames });
-	}
-	/**
-	* Creates a new `FieldTree` (branch) node at the specified path.
-	* @param {PathType} path - The path where the new `FieldTree` should be created.
-	* @param {boolean} [createPath=false] - If `true`, any missing parent branches in the path will be created automatically.
-	* @returns {FieldTree} The newly created `FieldTree` instance.
-	* @throws If the path is invalid or a node already exists at the target location.
-	*/
-	createFieldTree(path, createPath) {
-		const traversedPath = this.traversePath(path, createPath);
-		return traversedPath.branch.addNode(traversedPath.leafName, this._factory.tree());
-	}
-	/**
-	* Creates a new `Fields` (leaf) container at the specified path.
-	* @param {PathType} path - The path where the new `Fields` container should be created.
-	* @param {boolean} [createPath=false] - If `true`, any missing parent branches in the path will be created automatically.
-	* @returns {Fields} The newly created `Fields` instance.
-	* @throws If the path is invalid or a node already exists at the target location.
-	*/
-	createFields(path, createPath) {
-		const traversedPath = this.traversePath(path, createPath);
-		return traversedPath.branch.addNode(traversedPath.leafName, this._factory.fields());
-	}
-	/**
-	* Retrieves a `FieldTree` (branch) node from a specified path.
-	* @param {PathType} path - The path to the `FieldTree` node.
-	* @returns {FieldTree} The `FieldTree` instance at the specified path.
-	* @throws If the path is invalid or the node at the path is not a `FieldTree`.
-	*/
-	getFieldTree(path) {
-		const traversedPath = this.traversePath(path);
-		const node = traversedPath.branch.getNode(traversedPath.leafName);
-		throwIf(!(node instanceof FieldTree), `Node with name: ${traversedPath.leafName} by path: '${ensurePathString(path)}' should be instance of FieldTree`);
-		return node;
-	}
-	/**
-	* Retrieves a `Fields` (leaf) container from a specified path.
-	* @param {PathType} path - The path to the `Fields` container.
-	* @returns {Fields} The `Fields` instance at the specified path.
-	* @throws If the path is invalid or the node at the path is not a `Fields` container.
-	*/
-	getFields(path) {
-		const traversedPath = this.traversePath(path);
-		const node = traversedPath.branch.getNode(traversedPath.leafName);
-		throwIf(!(node instanceof Fields), `Node with name: ${traversedPath.leafName} by path: '${ensurePathString(path)}' should be instance of Fields`);
-		return node;
-	}
-	/**
-	* Retrieves a `FieldTree` at the specified path. If it or any part of the path doesn't exist, it will be created.
-	* @param {PathType} path - The path to the `FieldTree` node.
-	* @returns {FieldTree} The existing or newly created `FieldTree` instance.
-	*/
-	getOrCreateFieldTree(path) {
-		const traversedPath = this.traversePath(path, true);
-		return traversedPath.branch.has(traversedPath.leafName) ? traversedPath.branch.getFieldTree(traversedPath.leafName) : traversedPath.branch.createFieldTree(traversedPath.leafName);
-	}
-	/**
-	* Retrieves a `Fields` container at the specified path. If it or any part of the path doesn't exist, it will be created.
-	* @param {PathType} path - The path to the `Fields` container.
-	* @returns {Fields} The existing or newly created `Fields` instance.
-	*/
-	getOrCreateFields(path) {
-		const traversedPath = this.traversePath(path, true);
-		return traversedPath.branch.has(traversedPath.leafName) ? traversedPath.branch.getFields(traversedPath.leafName) : traversedPath.branch.createFields(traversedPath.leafName);
-	}
-	/**
-	* Finds the parent node for a given path.
-	* @param path The path to the target node.
-	* @returns The parent node (either a FieldTree or Fields).
-	* @throws An error if the path is invalid or any intermediate node is not a FieldTree.
-	*/
-	findParentNode(path) {
-		return this.traversePath(path).branch;
-	}
-	/**
-	* Removes all child nodes from this tree branch.
-	* This method ensures that `destroy()` is called on each child node, allowing for
-	* a full, recursive cleanup of the entire subtree.
-	*/
-	clear() {
-		this.removeNode(Array.from(this._nodes.keys()));
-	}
-	/**
-	* Performs a complete cleanup of this node and its entire subtree.
-	*
-	* It recursively destroys all child nodes by calling `clear()` and then
-	* unsubscribes all listeners from its own event emitters.
-	* This method should be called when a node is no longer needed.
-	*/
-	destroy() {
-		this.clear();
-		this.onAdd.clear();
-		this.onRemove.clear();
-	}
-	/**
-	* @private
-	* Navigates the tree to the parent of a target node.
-	* This is the core traversal logic for all path-based operations.
-	* @param {PathType} path - The full path to the target node.
-	* @param {boolean} [createPath=false] - If `true`, creates missing `FieldTree` branches along the path.
-	* @returns {{branch: FieldTree, leafName: string}} An object containing the final branch (parent node) and the name of the leaf (target node).
-	* @throws If the path is empty, invalid, or contains a `Fields` container as an intermediate segment.
-	*/
-	traversePath(path, createPath) {
-		const pathArr = ensurePathArray(path);
-		throwIfEmpty(pathArr, "The path is empty");
-		const leafName = pathArr.pop();
-		let currentNode = this;
-		for (const pathPart of pathArr) {
-			let node;
-			if (currentNode.has(pathPart)) node = currentNode.getNode(pathPart);
-			else if (createPath) node = currentNode.createFieldTree(pathPart);
-			throwIfEmpty(node, `Can't find node with name ${pathPart} by path parsing: ${ensurePathString(path)}`);
-			throwIf(node instanceof Fields, `Node with name ${pathPart} should be instance of FieldTree`);
-			currentNode = node;
-		}
-		return {
-			branch: currentNode,
-			leafName
-		};
-	}
+// src/field-tree.ts
+import { Emitter as Emitter3, ensurePathArray, ensurePathString, throwIf as throwIf2, throwIfEmpty } from "@axi-engine/utils";
+var FieldTree = class _FieldTree {
+  static typeName = "fieldTree";
+  typeName = _FieldTree.typeName;
+  /** @private The internal map storing child nodes (branches or leaves). */
+  _nodes = /* @__PURE__ */ new Map();
+  /** @private The factory used to create new child nodes. */
+  _factory;
+  /**
+   * An event emitter that fires immediately after a new node is added to this tree branch.
+   * @event
+   * @param {object} event - The event payload.
+   * @param {string} event.name - The name (key) of the added node.
+   * @param event.node - The node instance that was added.
+   * @example
+   * myTree.onAdd.subscribe(({ name, node }) => {
+   *   console.log(`Node '${name}' was added.`, node);
+   * });
+   */
+  onAdd = new Emitter3();
+  /**
+   * An event emitter that fires once after one or more nodes have been successfully removed.
+   * @event
+   * @param {object} event - The event payload.
+   * @param {string[]} event.names - An array of names of the nodes that were removed.
+   * @example
+   * myTree.onRemove.subscribe(({ names }) => {
+   *   console.log(`Nodes removed: ${names.join(', ')}`);
+   * });
+   */
+  onRemove = new Emitter3();
+  /**
+   * Gets the collection of direct child nodes of this tree branch.
+   */
+  get nodes() {
+    return this._nodes;
+  }
+  /**
+   * Creates an instance of FieldTree.
+   * @param {FieldTreeFactory} factory - A factory responsible for creating new nodes within the tree.
+   */
+  constructor(factory) {
+    this._factory = factory;
+  }
+  /**
+   * Checks if a direct child node with the given name exists.
+   * @param {string} name - The name of the direct child node.
+   * @returns {boolean} `true` if the node exists, otherwise `false`.
+   */
+  has(name) {
+    return this._nodes.has(name);
+  }
+  /**
+   * Checks if a node exists at a given path, traversing the tree.
+   * @param {PathType} path - The path to check (e.g., 'player/stats' or ['player', 'stats']).
+   * @returns {boolean} `true` if the entire path resolves to a node, otherwise `false`.
+   */
+  hasPath(path) {
+    const traversedPath = this.traversePath(path);
+    return traversedPath.branch.has(traversedPath.leafName);
+  }
+  /**
+   * Adds a pre-existing node as a direct child of this tree branch.
+   * @param {string} name - The name to assign to the new child node.
+   * @param {TreeNode} node - The node instance to add.
+   * @returns {TreeNode} The added node.
+   * @throws If a node with the same name already exists.
+   */
+  addNode(name, node) {
+    throwIf2(this.has(name), `Can't add node with name: '${name}', node already exists`);
+    this._nodes.set(name, node);
+    this.onAdd.emit({ name, node });
+    return node;
+  }
+  /**
+   * Retrieves a direct child node by its name.
+   * @param {string} name - The name of the child node.
+   * @returns {TreeNode} The retrieved node.
+   * @throws If a node with the given name cannot be found.
+   */
+  getNode(name) {
+    const node = this._nodes.get(name);
+    throwIfEmpty(node, `Can't find node with name '${name}'`);
+    return node;
+  }
+  /**
+   * Removes one or more nodes from this tree branch.
+   *
+   * This method first validates that all specified nodes exist. If validation passes,
+   * it recursively calls `destroy()` on each node to ensure proper cleanup of the entire subtree.
+   * Finally, it emits a single `onRemove` event with the names of all successfully removed nodes.
+   *
+   * @param {string | string[]} names - A single name or an array of names of the nodes to remove.
+   * @throws If any of the specified names do not correspond to an existing node.
+   */
+  removeNode(names) {
+    const toRemoveNames = Array.isArray(names) ? names : [names];
+    toRemoveNames.forEach((name) => {
+      throwIf2(!this.has(name), `Can't remove node with name: '${name}', node doesn't exists`);
+    });
+    toRemoveNames.forEach((name) => {
+      this._nodes.get(name).destroy();
+      this._nodes.delete(name);
+    });
+    if (toRemoveNames.length) {
+      this.onRemove.emit({ names: toRemoveNames });
+    }
+  }
+  /**
+   * Creates a new `FieldTree` (branch) node at the specified path.
+   * @param {PathType} path - The path where the new `FieldTree` should be created.
+   * @param {boolean} [createPath=false] - If `true`, any missing parent branches in the path will be created automatically.
+   * @returns {FieldTree} The newly created `FieldTree` instance.
+   * @throws If the path is invalid or a node already exists at the target location.
+   */
+  createFieldTree(path, createPath) {
+    const traversedPath = this.traversePath(path, createPath);
+    return traversedPath.branch.addNode(traversedPath.leafName, this._factory.tree());
+  }
+  /**
+   * Creates a new `Fields` (leaf) container at the specified path.
+   * @param {PathType} path - The path where the new `Fields` container should be created.
+   * @param {boolean} [createPath=false] - If `true`, any missing parent branches in the path will be created automatically.
+   * @returns {Fields} The newly created `Fields` instance.
+   * @throws If the path is invalid or a node already exists at the target location.
+   */
+  createFields(path, createPath) {
+    const traversedPath = this.traversePath(path, createPath);
+    return traversedPath.branch.addNode(traversedPath.leafName, this._factory.fields());
+  }
+  /**
+   * Retrieves a `FieldTree` (branch) node from a specified path.
+   * @param {PathType} path - The path to the `FieldTree` node.
+   * @returns {FieldTree} The `FieldTree` instance at the specified path.
+   * @throws If the path is invalid or the node at the path is not a `FieldTree`.
+   */
+  getFieldTree(path) {
+    const traversedPath = this.traversePath(path);
+    const node = traversedPath.branch.getNode(traversedPath.leafName);
+    throwIf2(
+      !(node instanceof _FieldTree),
+      `Node with name: ${traversedPath.leafName} by path: '${ensurePathString(path)}' should be instance of FieldTree`
+    );
+    return node;
+  }
+  /**
+   * Retrieves a `Fields` (leaf) container from a specified path.
+   * @param {PathType} path - The path to the `Fields` container.
+   * @returns {Fields} The `Fields` instance at the specified path.
+   * @throws If the path is invalid or the node at the path is not a `Fields` container.
+   */
+  getFields(path) {
+    const traversedPath = this.traversePath(path);
+    const node = traversedPath.branch.getNode(traversedPath.leafName);
+    throwIf2(
+      !(node instanceof Fields),
+      `Node with name: ${traversedPath.leafName} by path: '${ensurePathString(path)}' should be instance of Fields`
+    );
+    return node;
+  }
+  /**
+   * Retrieves a `FieldTree` at the specified path. If it or any part of the path doesn't exist, it will be created.
+   * @param {PathType} path - The path to the `FieldTree` node.
+   * @returns {FieldTree} The existing or newly created `FieldTree` instance.
+   */
+  getOrCreateFieldTree(path) {
+    const traversedPath = this.traversePath(path, true);
+    return traversedPath.branch.has(traversedPath.leafName) ? traversedPath.branch.getFieldTree(traversedPath.leafName) : traversedPath.branch.createFieldTree(traversedPath.leafName);
+  }
+  /**
+   * Retrieves a `Fields` container at the specified path. If it or any part of the path doesn't exist, it will be created.
+   * @param {PathType} path - The path to the `Fields` container.
+   * @returns {Fields} The existing or newly created `Fields` instance.
+   */
+  getOrCreateFields(path) {
+    const traversedPath = this.traversePath(path, true);
+    return traversedPath.branch.has(traversedPath.leafName) ? traversedPath.branch.getFields(traversedPath.leafName) : traversedPath.branch.createFields(traversedPath.leafName);
+  }
+  /**
+   * Finds the parent node for a given path.
+   * @param path The path to the target node.
+   * @returns The parent node (either a FieldTree or Fields).
+   * @throws An error if the path is invalid or any intermediate node is not a FieldTree.
+   */
+  findParentNode(path) {
+    const info = this.traversePath(path);
+    return info.branch;
+  }
+  /**
+   * Removes all child nodes from this tree branch.
+   * This method ensures that `destroy()` is called on each child node, allowing for
+   * a full, recursive cleanup of the entire subtree.
+   */
+  clear() {
+    this.removeNode(Array.from(this._nodes.keys()));
+  }
+  /**
+   * Performs a complete cleanup of this node and its entire subtree.
+   *
+   * It recursively destroys all child nodes by calling `clear()` and then
+   * unsubscribes all listeners from its own event emitters.
+   * This method should be called when a node is no longer needed.
+   */
+  destroy() {
+    this.clear();
+    this.onAdd.clear();
+    this.onRemove.clear();
+  }
+  /**
+   * @private
+   * Navigates the tree to the parent of a target node.
+   * This is the core traversal logic for all path-based operations.
+   * @param {PathType} path - The full path to the target node.
+   * @param {boolean} [createPath=false] - If `true`, creates missing `FieldTree` branches along the path.
+   * @returns {{branch: FieldTree, leafName: string}} An object containing the final branch (parent node) and the name of the leaf (target node).
+   * @throws If the path is empty, invalid, or contains a `Fields` container as an intermediate segment.
+   */
+  traversePath(path, createPath) {
+    const pathArr = ensurePathArray(path);
+    throwIfEmpty(pathArr, "The path is empty");
+    const leafName = pathArr.pop();
+    let currentNode = this;
+    for (const pathPart of pathArr) {
+      let node;
+      if (currentNode.has(pathPart)) {
+        node = currentNode.getNode(pathPart);
+      } else {
+        if (createPath) {
+          node = currentNode.createFieldTree(pathPart);
+        }
+      }
+      throwIfEmpty(node, `Can't find node with name ${pathPart} by path parsing: ${ensurePathString(path)}`);
+      throwIf2(node instanceof Fields, `Node with name ${pathPart} should be instance of FieldTree`);
+      currentNode = node;
+    }
+    return { branch: currentNode, leafName };
+  }
 };
 
-//#endregion
-//#region src/mixins/with-boolean-fields.mixin.ts
-const WithBooleanFields = createTypedMethodsMixin(CoreBooleanField.typeName, "Boolean");
+// src/mixins/with-boolean-fields.mixin.ts
+var WithBooleanFields = createTypedMethodsMixin(CoreBooleanField.typeName, "Boolean");
 
-//#endregion
-//#region src/mixins/with-string-fields.mixin.ts
-const WithStringFields = createTypedMethodsMixin(CoreBooleanField.typeName, "String");
+// src/mixins/with-string-fields.mixin.ts
+var WithStringFields = createTypedMethodsMixin(CoreStringField.typeName, "String");
 
-//#endregion
-//#region src/mixins/with-numeric-fields.mixin.ts
-const WithNumericFields = createTypedMethodsMixin(CoreBooleanField.typeName, "Numeric");
+// src/mixins/with-numeric-fields.mixin.ts
+var WithNumericFields = createTypedMethodsMixin(CoreNumericField.typeName, "Numeric");
 
-//#endregion
-//#region src/mixins/with-default-generic-fields.mixin.ts
+// src/mixins/with-default-generic-fields.mixin.ts
 function WithDefaultGenericFields(Base) {
-	return class FieldsWithDefaultGeneric extends Base {
-		createGeneric(name, initialValue, options) {
-			return this.create(CoreField.typeName, name, initialValue, options);
-		}
-		upsetGeneric(name, value, options) {
-			return this.upset(CoreField.typeName, name, value, options);
-		}
-		getGeneric(name) {
-			return this.get(name);
-		}
-	};
+  return class FieldsWithDefaultGeneric extends Base {
+    createGeneric(name, initialValue, options) {
+      return this.create(CoreField.typeName, name, initialValue, options);
+    }
+    upsetGeneric(name, value, options) {
+      return this.upset(CoreField.typeName, name, value, options);
+    }
+    getGeneric(name) {
+      return this.get(name);
+    }
+  };
 }
 
-//#endregion
-//#region src/core-fields.ts
-var CoreFields = class extends WithBooleanFields(WithStringFields(WithNumericFields(WithDefaultGenericFields(Fields)))) {};
+// src/core-fields.ts
+var CoreFields = class extends WithBooleanFields(WithStringFields(WithNumericFields(WithDefaultGenericFields(Fields)))) {
+};
 
-//#endregion
-//#region src/core-fields-factory.ts
+// src/core-fields-factory.ts
 var CoreFieldsFactory = class {
-	_fieldRegistry;
-	get fieldRegistry() {
-		return this._fieldRegistry;
-	}
-	constructor(fieldRegistry) {
-		this._fieldRegistry = fieldRegistry;
-	}
-	fields() {
-		return new CoreFields(this._fieldRegistry);
-	}
+  _fieldRegistry;
+  get fieldRegistry() {
+    return this._fieldRegistry;
+  }
+  constructor(fieldRegistry) {
+    this._fieldRegistry = fieldRegistry;
+  }
+  fields() {
+    return new CoreFields(this._fieldRegistry);
+  }
 };
 
-//#endregion
-//#region src/core-field-tree.ts
-var CoreFieldTree = class extends FieldTree {};
+// src/core-field-tree.ts
+var CoreFieldTree = class extends FieldTree {
+};
 
-//#endregion
-//#region src/core-field-tree-factory.ts
-/**
-* The default factory implementation that creates standard DefaultFields and FieldTree instances.
-*/
+// src/core-field-tree-factory.ts
 var CoreTreeNodeFactory = class extends CoreFieldsFactory {
-	constructor(fieldRegistry) {
-		super(fieldRegistry);
-	}
-	tree() {
-		return new CoreFieldTree(this);
-	}
+  constructor(fieldRegistry) {
+    super(fieldRegistry);
+  }
+  tree() {
+    return new CoreFieldTree(this);
+  }
 };
 
-//#endregion
-//#region src/serializer/policies/clamp-policy-serializer-handler.ts
+// src/serializer/policies/clamp-policy-serializer-handler.ts
 var ClampPolicySerializerHandler = class {
-	snapshot(policy) {
-		return {
-			min: policy.min,
-			max: policy.max
-		};
-	}
-	hydrate(data) {
-		return new ClampPolicy(data.min, data.max);
-	}
+  snapshot(policy) {
+    return { min: policy.min, max: policy.max };
+  }
+  hydrate(data) {
+    return new ClampPolicy(data.min, data.max);
+  }
 };
 
-//#endregion
-//#region src/serializer/policies/clamp-max-policy-serializer-handler.ts
+// src/serializer/policies/clamp-max-policy-serializer-handler.ts
 var ClampMaxPolicySerializerHandler = class {
-	snapshot(policy) {
-		return { max: policy.max };
-	}
-	hydrate(data) {
-		return new ClampMaxPolicy(data.max);
-	}
+  snapshot(policy) {
+    return { max: policy.max };
+  }
+  hydrate(data) {
+    return new ClampMaxPolicy(data.max);
+  }
 };
 
-//#endregion
-//#region src/serializer/policies/clamp-min-policy-serializer-handler.ts
+// src/serializer/policies/clamp-min-policy-serializer-handler.ts
 var ClampMinPolicySerializerHandler = class {
-	snapshot(policy) {
-		return { min: policy.min };
-	}
-	hydrate(data) {
-		return new ClampMinPolicy(data.min);
-	}
+  snapshot(policy) {
+    return { min: policy.min };
+  }
+  hydrate(data) {
+    return new ClampMinPolicy(data.min);
+  }
 };
 
-//#endregion
-//#region src/serializer/policy-serializer.ts
+// src/serializer/policy-serializer.ts
+import { throwIf as throwIf3, throwIfEmpty as throwIfEmpty2 } from "@axi-engine/utils";
 var PolicySerializer = class {
-	handlers = /* @__PURE__ */ new Map();
-	register(policyId, handler) {
-		throwIf(this.handlers.has(policyId), `A handler for policy ID '${policyId}' is already registered.`);
-		this.handlers.set(policyId, handler);
-		return this;
-	}
-	clearHandlers() {
-		this.handlers.clear();
-	}
-	/**
-	* Creates a serializable snapshot of a policy instance.
-	* The snapshot includes the policy's state and a `__type` identifier.
-	* @param policy The policy instance to snapshot.
-	* @returns A plain object ready for JSON serialization.
-	* @throws If no handler is registered for the policy's ID.
-	*/
-	snapshot(policy) {
-		const handler = this.handlers.get(policy.id);
-		throwIfEmpty(handler, `No serializer handler registered for policy ID: '${policy.id}'`);
-		const data = handler.snapshot(policy);
-		return {
-			__type: policy.id,
-			...data
-		};
-	}
-	/**
-	* Restores a policy instance from its snapshot representation.
-	* @param snapshot The plain object snapshot, which must contain a `__type` property.
-	* @returns A new, fully functional policy instance.
-	* @throws If the snapshot is invalid or no handler is registered for its `__type`.
-	*/
-	hydrate(snapshot) {
-		const typeId = snapshot?.__type;
-		throwIfEmpty(typeId, "Invalid policy snapshot: missing \"__type\" identifier.");
-		const handler = this.handlers.get(typeId);
-		throwIfEmpty(handler, `No serializer handler registered for policy ID: '${typeId}'`);
-		const { __type, ...data } = snapshot;
-		return handler.hydrate(data);
-	}
+  handlers = /* @__PURE__ */ new Map();
+  register(policyId, handler) {
+    throwIf3(this.handlers.has(policyId), `A handler for policy ID '${policyId}' is already registered.`);
+    this.handlers.set(policyId, handler);
+    return this;
+  }
+  clearHandlers() {
+    this.handlers.clear();
+  }
+  /**
+   * Creates a serializable snapshot of a policy instance.
+   * The snapshot includes the policy's state and a `__type` identifier.
+   * @param policy The policy instance to snapshot.
+   * @returns A plain object ready for JSON serialization.
+   * @throws If no handler is registered for the policy's ID.
+   */
+  snapshot(policy) {
+    const handler = this.handlers.get(policy.id);
+    throwIfEmpty2(handler, `No serializer handler registered for policy ID: '${policy.id}'`);
+    const data = handler.snapshot(policy);
+    return {
+      __type: policy.id,
+      ...data
+    };
+  }
+  /**
+   * Restores a policy instance from its snapshot representation.
+   * @param snapshot The plain object snapshot, which must contain a `__type` property.
+   * @returns A new, fully functional policy instance.
+   * @throws If the snapshot is invalid or no handler is registered for its `__type`.
+   */
+  hydrate(snapshot) {
+    const typeId = snapshot?.__type;
+    throwIfEmpty2(typeId, 'Invalid policy snapshot: missing "__type" identifier.');
+    const handler = this.handlers.get(typeId);
+    throwIfEmpty2(handler, `No serializer handler registered for policy ID: '${typeId}'`);
+    const { __type, ...data } = snapshot;
+    return handler.hydrate(data);
+  }
 };
 
-//#endregion
-//#region src/serializer/field-serializer.ts
-/**
-* Orchestrates the serialization and deserialization of Field instances.
-*
-* This class acts as a central point for converting complex Field objects into
-* plain, storable data (snapshots) and vice-versa. It uses a `FieldRegistry`
-* to resolve class constructors and a `PolicySerializer` to handle the state
-* of any attached policies.
-*
-* @todo Implement a `patch(field, snapshot)` method.
-*       Unlike `hydrate`, which creates a new
-*       instance, `patch` should update the state of an *existing* field instance
-*       without breaking external references to it.
-*/
+// src/serializer/field-serializer.ts
+import { isNullOrUndefined as isNullOrUndefined2, throwIfEmpty as throwIfEmpty3 } from "@axi-engine/utils";
 var FieldSerializer = class {
-	/**
-	* Creates an instance of FieldSerializer.
-	* @param {FieldRegistry} fieldRegistry - A registry that maps string type names to Field constructors.
-	* @param {PolicySerializer} policySerializer - A serializer dedicated to handling Policy instances.
-	*/
-	constructor(fieldRegistry, policySerializer) {
-		this.fieldRegistry = fieldRegistry;
-		this.policySerializer = policySerializer;
-	}
-	/**
-	* Creates a serializable snapshot of a Field instance.
-	* The snapshot includes the field's type, name, current value, and the state of all its policies.
-	* @param {Field<any>} field - The Field instance to serialize.
-	* @returns {FieldSnapshot} A plain object ready for JSON serialization.
-	*/
-	snapshot(field) {
-		let snapshot = {
-			__type: field.typeName,
-			name: field.name,
-			value: field.value
-		};
-		if (!field.policies.isEmpty()) {
-			const serializedPolicies = [];
-			field.policies.items.forEach((policy) => serializedPolicies.push(this.policySerializer.snapshot(policy)));
-			snapshot.policies = serializedPolicies;
-		}
-		return snapshot;
-	}
-	/**
-	* Restores a Field instance from its snapshot representation.
-	* It uses the `__type` property to find the correct constructor and hydrates
-	* the field with its value and all its policies.
-	* @param {FieldSnapshot} snapshot - The plain object snapshot to deserialize.
-	* @returns {Field<any>} A new, fully functional Field instance.
-	* @throws If the snapshot is invalid, missing a `__type`, or if the type is not registered.
-	*/
-	hydrate(snapshot) {
-		const fieldType = snapshot.__type;
-		throwIfEmpty(fieldType, "Invalid field snapshot: missing \"__type\" identifier.");
-		const Ctor = this.fieldRegistry.get(fieldType);
-		let policies;
-		if (!isNullOrUndefined(snapshot.policies)) {
-			policies = [];
-			snapshot.policies.forEach((p) => policies.push(this.policySerializer.hydrate(p)));
-		}
-		return new Ctor(snapshot.name, snapshot.value, { policies });
-	}
+  /**
+   * Creates an instance of FieldSerializer.
+   * @param {FieldRegistry} fieldRegistry - A registry that maps string type names to Field constructors.
+   * @param {PolicySerializer} policySerializer - A serializer dedicated to handling Policy instances.
+   */
+  constructor(fieldRegistry, policySerializer) {
+    this.fieldRegistry = fieldRegistry;
+    this.policySerializer = policySerializer;
+  }
+  /**
+   * Creates a serializable snapshot of a Field instance.
+   * The snapshot includes the field's type, name, current value, and the state of all its policies.
+   * @param {Field<any>} field - The Field instance to serialize.
+   * @returns {FieldSnapshot} A plain object ready for JSON serialization.
+   */
+  snapshot(field) {
+    let snapshot = {
+      __type: field.typeName,
+      name: field.name,
+      value: field.value
+    };
+    if (!field.policies.isEmpty()) {
+      const serializedPolicies = [];
+      field.policies.items.forEach((policy) => serializedPolicies.push(this.policySerializer.snapshot(policy)));
+      snapshot.policies = serializedPolicies;
+    }
+    return snapshot;
+  }
+  /**
+   * Restores a Field instance from its snapshot representation.
+   * It uses the `__type` property to find the correct constructor and hydrates
+   * the field with its value and all its policies.
+   * @param {FieldSnapshot} snapshot - The plain object snapshot to deserialize.
+   * @returns {Field<any>} A new, fully functional Field instance.
+   * @throws If the snapshot is invalid, missing a `__type`, or if the type is not registered.
+   */
+  hydrate(snapshot) {
+    const fieldType = snapshot.__type;
+    throwIfEmpty3(fieldType, 'Invalid field snapshot: missing "__type" identifier.');
+    const Ctor = this.fieldRegistry.get(fieldType);
+    let policies;
+    if (!isNullOrUndefined2(snapshot.policies)) {
+      policies = [];
+      snapshot.policies.forEach((p) => policies.push(this.policySerializer.hydrate(p)));
+    }
+    return new Ctor(snapshot.name, snapshot.value, { policies });
+  }
 };
 
-//#endregion
-//#region src/serializer/fields-serializer.ts
-/**
-* Orchestrates the serialization and deserialization of `Fields` container instances.
-*
-* This class acts as a high-level composer, responsible for converting an entire `Fields` object
-* into a storable snapshot and back.
-* It delegates the actual serialization of each `Field` and `Policy` to their respective serializers.
-*
-* @todo Implement a `patch(fields, snapshot)` method. It should perform a non-destructive
-*       update, creating new fields, removing missing ones, and patching existing ones
-*       in place, preserving the container instance itself.
-*/
+// src/serializer/fields-serializer.ts
 var FieldsSerializer = class {
-	/**
-	* Creates an instance of FieldsSerializer.
-	* @param {FieldsFactory} fieldsFactory - A registry that maps string type names to Field constructors.
-	* @param {FieldSerializer} fieldSerializer - A serializer of field instances.
-	*/
-	constructor(fieldsFactory, fieldSerializer) {
-		this.fieldsFactory = fieldsFactory;
-		this.fieldSerializer = fieldSerializer;
-	}
-	/**
-	* Creates a serializable snapshot of a `Fields` container.
-	*
-	* The snapshot includes a `__type` identifier (currently hardcoded) and an array of snapshots
-	* for each `Field` within the container.
-	* @param {Fields} fields - The `Fields` instance to serialize.
-	* @returns {FieldsSnapshot} A plain object ready for JSON serialization.
-	*/
-	snapshot(fields) {
-		const res = { __type: fields.typeName };
-		fields.fields.forEach((field) => res[field.name] = this.fieldSerializer.snapshot(field));
-		return res;
-	}
-	/**
-	* Restores a `Fields` container instance from its snapshot representation.
-	*
-	* It iterates through the field snapshots and hydrates them individually, adding them to the new container.
-	* @param {FieldsSnapshot} snapshot - The plain object snapshot to deserialize.
-	* @returns {Fields} A new `DefaultFields` instance populated with the restored fields.
-	*/
-	hydrate(snapshot) {
-		const { __type, ...fieldsData } = snapshot;
-		const fields = this.fieldsFactory.fields();
-		for (const fieldName in fieldsData) {
-			const fieldSnapshot = fieldsData[fieldName];
-			const restoredField = this.fieldSerializer.hydrate(fieldSnapshot);
-			fields.add(restoredField);
-		}
-		return fields;
-	}
+  /**
+   * Creates an instance of FieldsSerializer.
+   * @param {FieldsFactory} fieldsFactory - A registry that maps string type names to Field constructors.
+   * @param {FieldSerializer} fieldSerializer - A serializer of field instances.
+   */
+  constructor(fieldsFactory, fieldSerializer) {
+    this.fieldsFactory = fieldsFactory;
+    this.fieldSerializer = fieldSerializer;
+  }
+  /**
+   * Creates a serializable snapshot of a `Fields` container.
+   *
+   * The snapshot includes a `__type` identifier (currently hardcoded) and an array of snapshots
+   * for each `Field` within the container.
+   * @param {Fields} fields - The `Fields` instance to serialize.
+   * @returns {FieldsSnapshot} A plain object ready for JSON serialization.
+   */
+  snapshot(fields) {
+    const res = {
+      __type: fields.typeName
+    };
+    fields.fields.forEach((field) => res[field.name] = this.fieldSerializer.snapshot(field));
+    return res;
+  }
+  /**
+   * Restores a `Fields` container instance from its snapshot representation.
+   *
+   * It iterates through the field snapshots and hydrates them individually, adding them to the new container.
+   * @param {FieldsSnapshot} snapshot - The plain object snapshot to deserialize.
+   * @returns {Fields} A new `DefaultFields` instance populated with the restored fields.
+   */
+  hydrate(snapshot) {
+    const { __type, ...fieldsData } = snapshot;
+    const fields = this.fieldsFactory.fields();
+    for (const fieldName in fieldsData) {
+      const fieldSnapshot = fieldsData[fieldName];
+      const restoredField = this.fieldSerializer.hydrate(fieldSnapshot);
+      fields.add(restoredField);
+    }
+    return fields;
+  }
 };
 
-//#endregion
-//#region src/serializer/field-tree-serializer.ts
-/**
-* Orchestrates the recursive serialization and deserialization of `FieldTree` instances.
-*
-* This class handles the conversion of an entire `FieldTree` object graph into a
-* plain, storable snapshot and vice-versa. It delegates the processing of `Fields`
-* leaf nodes to a dedicated `FieldsSerializer`.
-* @todo Refactoring: The current implementation uses `if/else` logic in `snapshot` and `hydrate`
-*       to process different node types. A more extensible approach would be to use a
-*       registry of dedicated handlers for each node type.
-*       This would allow new node types to be supported without
-*       modifying this class, adhering to the Open/Closed Principle.
-*
-* @todo Implement a `patch(tree, snapshot)` method for recursive, non-destructive
-*       updates. This method should traverse the existing tree and the snapshot,
-*       patching nodes in place to maintain object references.
-*/
+// src/serializer/field-tree-serializer.ts
+import { isString } from "@axi-engine/utils";
 var FieldTreeSerializer = class {
-	constructor(fieldTreeNodeFactory, fieldsSerializer) {
-		this.fieldTreeNodeFactory = fieldTreeNodeFactory;
-		this.fieldsSerializer = fieldsSerializer;
-	}
-	/**
-	* Creates a serializable snapshot of the entire tree and its contained fields.
-	* @returns A plain JavaScript object representing the complete state managed by this tree.
-	*/
-	snapshot(tree) {
-		const res = { __type: tree.typeName };
-		tree.nodes.forEach((node, key) => {
-			if (node.typeName === tree.typeName) res[key] = this.snapshot(node);
-			else if (node.typeName === Fields.typeName) res[key] = this.fieldsSerializer.snapshot(node);
-		});
-		return res;
-	}
-	/**
-	* Restores the state of the tree from a snapshot.
-	* It intelligently creates missing nodes based on `__type` metadata and delegates hydration to child nodes.
-	* @param snapshot The snapshot object to load.
-	*/
-	hydrate(snapshot) {
-		const { __type, ...nodes } = snapshot;
-		const tree = this.fieldTreeNodeFactory.tree();
-		for (const key in nodes) {
-			const nodeData = nodes[key];
-			if (isString(nodeData)) continue;
-			if (nodeData.__type === FieldTree.typeName) tree.addNode(key, this.hydrate(nodeData));
-			else if (nodeData.__type === Fields.typeName) tree.addNode(key, this.fieldsSerializer.hydrate(nodeData));
-		}
-		return tree;
-	}
+  constructor(fieldTreeNodeFactory, fieldsSerializer) {
+    this.fieldTreeNodeFactory = fieldTreeNodeFactory;
+    this.fieldsSerializer = fieldsSerializer;
+  }
+  /**
+   * Creates a serializable snapshot of the entire tree and its contained fields.
+   * @returns A plain JavaScript object representing the complete state managed by this tree.
+   */
+  snapshot(tree) {
+    const res = {
+      __type: tree.typeName
+    };
+    tree.nodes.forEach((node, key) => {
+      if (node.typeName === tree.typeName) {
+        res[key] = this.snapshot(node);
+      } else if (node.typeName === Fields.typeName) {
+        res[key] = this.fieldsSerializer.snapshot(node);
+      }
+    });
+    return res;
+  }
+  /**
+   * Restores the state of the tree from a snapshot.
+   * It intelligently creates missing nodes based on `__type` metadata and delegates hydration to child nodes.
+   * @param snapshot The snapshot object to load.
+   */
+  hydrate(snapshot) {
+    const { __type, ...nodes } = snapshot;
+    const tree = this.fieldTreeNodeFactory.tree();
+    for (const key in nodes) {
+      const nodeData = nodes[key];
+      if (isString(nodeData)) {
+        continue;
+      }
+      if (nodeData.__type === FieldTree.typeName) {
+        tree.addNode(key, this.hydrate(nodeData));
+      } else if (nodeData.__type === Fields.typeName) {
+        tree.addNode(key, this.fieldsSerializer.hydrate(nodeData));
+      }
+    }
+    return tree;
+  }
 };
 
-//#endregion
-//#region src/data-store-field-resolver.ts
+// src/data-store-field-resolver.ts
+import { isBoolean, isNumber, isString as isString2 } from "@axi-engine/utils";
 var NumericFieldResolver = class {
-	typeName = CoreNumericField.typeName;
-	supports(value) {
-		return isNumber(value);
-	}
+  typeName = CoreNumericField.typeName;
+  supports(value) {
+    return isNumber(value);
+  }
 };
 var BooleanFieldResolver = class {
-	typeName = CoreBooleanField.typeName;
-	supports(value) {
-		return isBoolean(value);
-	}
+  typeName = CoreBooleanField.typeName;
+  supports(value) {
+    return isBoolean(value);
+  }
 };
 var StringFieldResolver = class {
-	typeName = CoreStringField.typeName;
-	supports(value) {
-		return isString(value);
-	}
+  typeName = CoreStringField.typeName;
+  supports(value) {
+    return isString2(value);
+  }
 };
 
-//#endregion
-//#region src/data-store.ts
+// src/data-store.ts
+import { ensurePathArray as ensurePathArray2, ensurePathString as ensurePathString2, throwIfEmpty as throwIfEmpty4 } from "@axi-engine/utils";
 var DataStore = class {
-	resolvers = [];
-	rootFieldsName = "__root_fields";
-	_rootFields;
-	get rootFields() {
-		if (!this._rootFields) this._rootFields = this.tree.getOrCreateFields(this.rootFieldsName);
-		return this._rootFields;
-	}
-	constructor(tree) {
-		this.tree = tree;
-		this.registerResolver(new NumericFieldResolver());
-		this.registerResolver(new BooleanFieldResolver());
-		this.registerResolver(new StringFieldResolver());
-	}
-	registerResolver(resolver) {
-		this.resolvers.unshift(resolver);
-	}
-	clearResolvers() {
-		this.resolvers.length = 0;
-	}
-	getValue(path) {
-		return this.getField(path).value;
-	}
-	setValue(path, val) {
-		/** for case when field has policies */
-		const field = this.getField(path);
-		field.value = val;
-		return field.value;
-	}
-	createValue(path, val, options) {
-		const dest = this.getDestinationFields(path);
-		if (options?.fieldType) return dest.fields.create(options.fieldType, dest.leafName, val, options).value;
-		for (let resolver of this.resolvers) if (resolver.supports(val)) return dest.fields.create(resolver.typeName, dest.leafName, val, options).value;
-		return dest.fields.createGeneric(dest.leafName, val, options).value;
-	}
-	upsetValue(path, val, options) {
-		const dest = this.getDestinationFields(path);
-		if (options?.fieldType) return dest.fields.upset(options.fieldType, dest.leafName, val, options).value;
-		for (let resolver of this.resolvers) if (resolver.supports(val)) return dest.fields.upset(resolver.typeName, dest.leafName, val, options).value;
-		return dest.fields.upsetGeneric(dest.leafName, val, options).value;
-	}
-	createBoolean(path, initialValue, options) {
-		const dest = this.getDestinationFields(path);
-		return dest.fields.createBoolean(dest.leafName, initialValue, options);
-	}
-	createNumeric(path, initialValue, options) {
-		const dest = this.getDestinationFields(path);
-		return dest.fields.createNumeric(dest.leafName, initialValue, options);
-	}
-	createString(path, initialValue, options) {
-		const dest = this.getDestinationFields(path);
-		return dest.fields.createString(dest.leafName, initialValue, options);
-	}
-	createGeneric(path, initialValue, options) {
-		const dest = this.getDestinationFields(path);
-		return dest.fields.createGeneric(dest.leafName, initialValue, options);
-	}
-	getBoolean(path) {
-		return this.getField(path);
-	}
-	getNumeric(path) {
-		return this.getField(path);
-	}
-	getString(path) {
-		return this.getField(path);
-	}
-	getGeneric(path) {
-		return this.getField(path);
-	}
-	getField(path) {
-		const pathArr = ensurePathArray(path);
-		throwIfEmpty(pathArr, `Wrong path or path is empty: ${ensurePathString(path)}, should contain at least one path segment`);
-		if (this.isPathToRootFields(pathArr)) return this.rootFields.get(pathArr[0]);
-		const fieldName = pathArr.pop();
-		return this.tree.getFields(pathArr).get(fieldName);
-	}
-	createFields(path) {
-		return this.tree.createFields(path, true);
-	}
-	createTree(path) {
-		return this.tree.createFieldTree(path, true);
-	}
-	getFields(path) {
-		return this.tree.getFields(path);
-	}
-	getTree(path) {
-		return this.tree.getFieldTree(path);
-	}
-	remove(path) {
-		const pathArr = ensurePathArray(path);
-		throwIfEmpty(pathArr, `Wrong path or path is empty: ${ensurePathString(path)}, should contain at least one path segment`);
-		/** remove field from root fields */
-		if (this.isPathToRootFields(pathArr)) {
-			this.rootFields.remove(pathArr);
-			return;
-		}
-		const node = this.tree.findParentNode(pathArr);
-		const leafName = pathArr[pathArr.length - 1];
-		if (node instanceof CoreFields) node.remove(leafName);
-		else if (node instanceof CoreFieldTree) node.removeNode(leafName);
-	}
-	isPathToRootFields(path) {
-		return ensurePathArray(path).length === 1;
-	}
-	getDestinationFields(path) {
-		const pathArr = ensurePathArray(path);
-		if (this.isPathToRootFields(pathArr)) return {
-			fields: this.rootFields,
-			leafName: pathArr[0]
-		};
-		const leafName = pathArr.pop();
-		return {
-			fields: this.tree.getOrCreateFields(path),
-			leafName
-		};
-	}
+  constructor(tree) {
+    this.tree = tree;
+    this.registerResolver(new NumericFieldResolver());
+    this.registerResolver(new BooleanFieldResolver());
+    this.registerResolver(new StringFieldResolver());
+  }
+  resolvers = [];
+  rootFieldsName = "__root_fields";
+  _rootFields;
+  get rootFields() {
+    if (!this._rootFields) {
+      this._rootFields = this.tree.getOrCreateFields(this.rootFieldsName);
+    }
+    return this._rootFields;
+  }
+  registerResolver(resolver) {
+    this.resolvers.unshift(resolver);
+  }
+  clearResolvers() {
+    this.resolvers.length = 0;
+  }
+  getValue(path) {
+    return this.getField(path).value;
+  }
+  setValue(path, val) {
+    const field = this.getField(path);
+    field.value = val;
+    return field.value;
+  }
+  createValue(path, val, options) {
+    const dest = this.getDestinationFields(path);
+    if (options?.fieldType) {
+      return dest.fields.create(options.fieldType, dest.leafName, val, options).value;
+    }
+    for (let resolver of this.resolvers) {
+      if (resolver.supports(val)) {
+        return dest.fields.create(resolver.typeName, dest.leafName, val, options).value;
+      }
+    }
+    return dest.fields.createGeneric(dest.leafName, val, options).value;
+  }
+  upsetValue(path, val, options) {
+    const dest = this.getDestinationFields(path);
+    if (options?.fieldType) {
+      return dest.fields.upset(options.fieldType, dest.leafName, val, options).value;
+    }
+    for (let resolver of this.resolvers) {
+      if (resolver.supports(val)) {
+        return dest.fields.upset(resolver.typeName, dest.leafName, val, options).value;
+      }
+    }
+    return dest.fields.upsetGeneric(dest.leafName, val, options).value;
+  }
+  createBoolean(path, initialValue, options) {
+    const dest = this.getDestinationFields(path);
+    return dest.fields.createBoolean(dest.leafName, initialValue, options);
+  }
+  createNumeric(path, initialValue, options) {
+    const dest = this.getDestinationFields(path);
+    return dest.fields.createNumeric(dest.leafName, initialValue, options);
+  }
+  createString(path, initialValue, options) {
+    const dest = this.getDestinationFields(path);
+    return dest.fields.createString(dest.leafName, initialValue, options);
+  }
+  createGeneric(path, initialValue, options) {
+    const dest = this.getDestinationFields(path);
+    return dest.fields.createGeneric(dest.leafName, initialValue, options);
+  }
+  getBoolean(path) {
+    return this.getField(path);
+  }
+  getNumeric(path) {
+    return this.getField(path);
+  }
+  getString(path) {
+    return this.getField(path);
+  }
+  getGeneric(path) {
+    return this.getField(path);
+  }
+  getField(path) {
+    const pathArr = ensurePathArray2(path);
+    throwIfEmpty4(pathArr, `Wrong path or path is empty: ${ensurePathString2(path)}, should contain at least one path segment`);
+    if (this.isPathToRootFields(pathArr)) {
+      return this.rootFields.get(pathArr[0]);
+    }
+    const fieldName = pathArr.pop();
+    const fields = this.tree.getFields(pathArr);
+    return fields.get(fieldName);
+  }
+  createFields(path) {
+    return this.tree.createFields(path, true);
+  }
+  createTree(path) {
+    return this.tree.createFieldTree(path, true);
+  }
+  getFields(path) {
+    return this.tree.getFields(path);
+  }
+  getTree(path) {
+    return this.tree.getFieldTree(path);
+  }
+  remove(path) {
+    const pathArr = ensurePathArray2(path);
+    throwIfEmpty4(pathArr, `Wrong path or path is empty: ${ensurePathString2(path)}, should contain at least one path segment`);
+    if (this.isPathToRootFields(pathArr)) {
+      this.rootFields.remove(pathArr);
+      return;
+    }
+    const node = this.tree.findParentNode(pathArr);
+    const leafName = pathArr[pathArr.length - 1];
+    if (node instanceof CoreFields) {
+      node.remove(leafName);
+    } else if (node instanceof CoreFieldTree) {
+      node.removeNode(leafName);
+    }
+  }
+  isPathToRootFields(path) {
+    return ensurePathArray2(path).length === 1;
+  }
+  getDestinationFields(path) {
+    const pathArr = ensurePathArray2(path);
+    if (this.isPathToRootFields(pathArr)) {
+      return { fields: this.rootFields, leafName: pathArr[0] };
+    }
+    const leafName = pathArr.pop();
+    return { fields: this.tree.getOrCreateFields(path), leafName };
+  }
 };
 
-//#endregion
-//#region src/setup.ts
-/**
-* Creates and configures a FieldRegistry with all the core field types.
-* @returns {FieldRegistry} A pre-configured FieldRegistry instance.
-*/
+// src/setup.ts
 function createCoreFieldRegistry() {
-	const fieldRegistry = new FieldRegistry();
-	fieldRegistry.register(CoreField.typeName, CoreField);
-	fieldRegistry.register(CoreNumericField.typeName, CoreNumericField);
-	fieldRegistry.register(CoreStringField.typeName, CoreStringField);
-	fieldRegistry.register(CoreBooleanField.typeName, CoreBooleanField);
-	return fieldRegistry;
+  const fieldRegistry = new FieldRegistry();
+  fieldRegistry.register(CoreField.typeName, CoreField);
+  fieldRegistry.register(CoreNumericField.typeName, CoreNumericField);
+  fieldRegistry.register(CoreStringField.typeName, CoreStringField);
+  fieldRegistry.register(CoreBooleanField.typeName, CoreBooleanField);
+  return fieldRegistry;
 }
-/**
-* Creates and configures a PolicySerializer with handlers for core policies.
-* @returns {PolicySerializer} A pre-configured PolicySerializer instance.
-*/
 function createCorePolicySerializer() {
-	const policySerializer = new PolicySerializer();
-	policySerializer.register(ClampPolicy.id, new ClampPolicySerializerHandler());
-	policySerializer.register(ClampMinPolicy.id, new ClampMinPolicySerializerHandler());
-	policySerializer.register(ClampMaxPolicy.id, new ClampMaxPolicySerializerHandler());
-	return policySerializer;
+  const policySerializer = new PolicySerializer();
+  policySerializer.register(ClampPolicy.id, new ClampPolicySerializerHandler());
+  policySerializer.register(ClampMinPolicy.id, new ClampMinPolicySerializerHandler());
+  policySerializer.register(ClampMaxPolicy.id, new ClampMaxPolicySerializerHandler());
+  return policySerializer;
 }
-/**
-* Creates a factory for CoreFieldTree and CoreFields nodes.
-* @param {FieldRegistry} fieldRegistry - The registry to be used by the factory.
-* @returns {CoreTreeNodeFactory} A new CoreTreeNodeFactory instance.
-*/
 function createCoreTreeNodeFactory(fieldRegistry) {
-	return new CoreTreeNodeFactory(fieldRegistry);
+  return new CoreTreeNodeFactory(fieldRegistry);
 }
-/**
-* Creates a fully configured serializer for a FieldTree.
-* This function composes all necessary serializers (FieldTree, Fields, Field) for a complete setup.
-* @param {CoreTreeNodeFactory} fieldTreeNodeFactory - The factory used to create new tree nodes during deserialization.
-* @param policySerializer
-* @returns {FieldTreeSerializer<CoreFields>} A top-level serializer for the entire field tree.
-*/
 function createCoreTreeSerializer(fieldTreeNodeFactory, policySerializer) {
-	return new FieldTreeSerializer(fieldTreeNodeFactory, new FieldsSerializer(fieldTreeNodeFactory, new FieldSerializer(fieldTreeNodeFactory.fieldRegistry, policySerializer ?? createCorePolicySerializer())));
+  return new FieldTreeSerializer(
+    fieldTreeNodeFactory,
+    new FieldsSerializer(
+      fieldTreeNodeFactory,
+      new FieldSerializer(fieldTreeNodeFactory.fieldRegistry, policySerializer ?? createCorePolicySerializer())
+    )
+  );
 }
-/**
-* Creates a complete core setup for the field system.
-* @returns {{factory: CoreTreeNodeFactory, serializer: FieldTreeSerializer<CoreFields>}}
-*/
 function createCoreFieldSystem(config) {
-	const factory = createCoreTreeNodeFactory(config?.registry ?? createCoreFieldRegistry());
-	return {
-		factory,
-		serializer: createCoreTreeSerializer(factory, config?.policySerializer)
-	};
+  const registry = config?.registry ?? createCoreFieldRegistry();
+  const factory = createCoreTreeNodeFactory(registry);
+  const serializer = createCoreTreeSerializer(factory, config?.policySerializer);
+  return { factory, serializer };
 }
-
-//#endregion
-export { ClampMaxPolicy, ClampMaxPolicySerializerHandler, ClampMinPolicy, ClampMinPolicySerializerHandler, ClampPolicy, ClampPolicySerializerHandler, CoreBooleanField, CoreField, CoreFieldTree, CoreFields, CoreFieldsFactory, CoreNumericField, CoreStringField, CoreTreeNodeFactory, DataStore, FieldRegistry, FieldSerializer, FieldTree, FieldTreeSerializer, Fields, FieldsSerializer, Policies, PolicySerializer, clampMaxPolicy, clampMinPolicy, clampPolicy, createCoreFieldRegistry, createCoreFieldSystem, createCorePolicySerializer, createCoreTreeNodeFactory, createCoreTreeSerializer, createTypedMethodsMixin };
-//# sourceMappingURL=index.mjs.map
+export {
+  ClampMaxPolicy,
+  ClampMaxPolicySerializerHandler,
+  ClampMinPolicy,
+  ClampMinPolicySerializerHandler,
+  ClampPolicy,
+  ClampPolicySerializerHandler,
+  CoreBooleanField,
+  CoreField,
+  CoreFieldTree,
+  CoreFields,
+  CoreFieldsFactory,
+  CoreNumericField,
+  CoreStringField,
+  CoreTreeNodeFactory,
+  DataStore,
+  FieldRegistry,
+  FieldSerializer,
+  FieldTree,
+  FieldTreeSerializer,
+  Fields,
+  FieldsSerializer,
+  Policies,
+  PolicySerializer,
+  clampMaxPolicy,
+  clampMinPolicy,
+  clampPolicy,
+  createCoreFieldRegistry,
+  createCoreFieldSystem,
+  createCorePolicySerializer,
+  createCoreTreeNodeFactory,
+  createCoreTreeSerializer,
+  createTypedMethodsMixin
+};