@axi-engine/fields 0.3.1 → 0.3.3

package/dist/index.mjs

@@ -1,1214 +1,1202 @@
-// 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;
-  }
+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;
+	}
 };
 function clampPolicy(min, max) {
-  return new ClampPolicy(min, max);
+	return new ClampPolicy(min, 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;
-  }
+//#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;
+	}
 };
 function clampMaxPolicy(max) {
-  return new ClampMaxPolicy(max);
+	return new ClampMaxPolicy(max);
 }
 
-// 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;
-  }
+//#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;
+	}
 };
 function clampMinPolicy(min) {
-  return new ClampMinPolicy(min);
+	return new ClampMinPolicy(min);
 }
 
-// src/policies/policies.ts
+//#endregion
+//#region 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) {
-    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;
-  }
+	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;
+	}
 };
 
-// src/mixins/mixin-factory.ts
+//#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.
+*/
 function createTypedMethodsMixin(typeName, baseMethodName) {
-  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);
-      }
-    };
-  };
+	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);
+			}
+		};
+	};
 }
 
-// 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();
-  }
-};
-
-// 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-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-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-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-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-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/utils/constructor-registry.ts
-import { throwIf, throwIfEmpty } from "@axi-engine/utils";
-var ConstructorRegistry = class {
-  items = /* @__PURE__ */ new Map();
-  /**
-   * Registers a constructor with a unique string identifier.
-   *
-   * @param typeId - The unique identifier for the constructor (e.g., a static `typeName` property from a class).
-   * @param ctor - The class constructor to register.
-   * @returns The registry instance for chainable calls.
-   * @throws If a constructor with the same `typeId` is already registered.
-   */
-  register(typeId, ctor) {
-    throwIf(this.items.has(typeId), `A constructor with typeId '${typeId}' is already registered.`);
-    this.items.set(typeId, ctor);
-    return this;
-  }
-  /**
-   * Retrieves a constructor by its identifier.
-   *
-   * @param typeId - The identifier of the constructor to retrieve.
-   * @returns The found class constructor.
-   * @throws If no constructor is found for the given `typeId`.
-   */
-  get(typeId) {
-    const Ctor = this.items.get(typeId);
-    throwIfEmpty(Ctor, `No constructor found for typeId '${typeId}'`);
-    return Ctor;
-  }
-  /**
-   * Checks if a constructor for a given identifier is registered.
-   * @param typeId - The identifier to check.
-   * @returns `true` if a constructor is registered, otherwise `false`.
-   */
-  has(typeId) {
-    return this.items.has(typeId);
-  }
-  /**
-   * Clears all registered constructors from the registry.
-   */
-  clear() {
-    this.items.clear();
-  }
+//#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-registry.ts
-var FieldRegistry = class extends ConstructorRegistry {
-};
+//#endregion
+//#region src/field-registry.ts
+var FieldRegistry = class extends ConstructorRegistry {};
 
-// src/fields.ts
-import { Emitter as Emitter2, throwIf as throwIf2 } 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) {
-    throwIf2(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) {
-    throwIf2(!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/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/field-tree.ts
-import { Emitter as Emitter3, ensurePathArray, ensurePathString, throwIf as throwIf3, throwIfEmpty as throwIfEmpty2 } 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) {
-    throwIf3(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);
-    throwIfEmpty2(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) => {
-      throwIf3(!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);
-    throwIf3(
-      !(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);
-    throwIf3(
-      !(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);
-    throwIfEmpty2(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);
-        }
-      }
-      throwIfEmpty2(node, `Can't find node with name ${pathPart} by path parsing: ${ensurePathString(path)}`);
-      throwIf3(node instanceof Fields, `Node with name ${pathPart} should be instance of FieldTree`);
-      currentNode = node;
-    }
-    return { branch: currentNode, leafName };
-  }
+//#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/mixins/with-boolean-fields.mixin.ts
-var WithBooleanFields = createTypedMethodsMixin(CoreBooleanField.typeName, "Boolean");
+//#endregion
+//#region src/mixins/with-boolean-fields.mixin.ts
+const WithBooleanFields = createTypedMethodsMixin(CoreBooleanField.typeName, "Boolean");
 
-// src/mixins/with-string-fields.mixin.ts
-var WithStringFields = createTypedMethodsMixin(CoreBooleanField.typeName, "String");
+//#endregion
+//#region src/mixins/with-string-fields.mixin.ts
+const WithStringFields = createTypedMethodsMixin(CoreBooleanField.typeName, "String");
 
-// src/mixins/with-numeric-fields.mixin.ts
-var WithNumericFields = createTypedMethodsMixin(CoreBooleanField.typeName, "Numeric");
+//#endregion
+//#region src/mixins/with-numeric-fields.mixin.ts
+const WithNumericFields = createTypedMethodsMixin(CoreBooleanField.typeName, "Numeric");
 
-// src/mixins/with-default-generic-fields.mixin.ts
+//#endregion
+//#region 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);
+		}
+	};
 }
 
-// src/core-fields.ts
-var CoreFields = class extends WithBooleanFields(WithStringFields(WithNumericFields(WithDefaultGenericFields(Fields)))) {
-};
+//#endregion
+//#region src/core-fields.ts
+var CoreFields = class extends WithBooleanFields(WithStringFields(WithNumericFields(WithDefaultGenericFields(Fields)))) {};
 
-// src/core-fields-factory.ts
+//#endregion
+//#region 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);
+	}
 };
 
-// src/core-field-tree.ts
-var CoreFieldTree = class extends FieldTree {
-};
+//#endregion
+//#region src/core-field-tree.ts
+var CoreFieldTree = class extends FieldTree {};
 
-// src/core-field-tree-factory.ts
+//#endregion
+//#region src/core-field-tree-factory.ts
+/**
+* The default factory implementation that creates standard DefaultFields and FieldTree instances.
+*/
 var CoreTreeNodeFactory = class extends CoreFieldsFactory {
-  constructor(fieldRegistry) {
-    super(fieldRegistry);
-  }
-  tree() {
-    return new CoreFieldTree(this);
-  }
+	constructor(fieldRegistry) {
+		super(fieldRegistry);
+	}
+	tree() {
+		return new CoreFieldTree(this);
+	}
 };
 
-// src/serializer/policies/clamp-policy-serializer-handler.ts
+//#endregion
+//#region 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);
+	}
 };
 
-// src/serializer/policies/clamp-max-policy-serializer-handler.ts
+//#endregion
+//#region 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);
+	}
 };
 
-// src/serializer/policies/clamp-min-policy-serializer-handler.ts
+//#endregion
+//#region 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);
+	}
 };
 
-// src/serializer/policy-serializer.ts
-import { throwIf as throwIf4, throwIfEmpty as throwIfEmpty3 } from "@axi-engine/utils";
+//#endregion
+//#region src/serializer/policy-serializer.ts
 var PolicySerializer = class {
-  handlers = /* @__PURE__ */ new Map();
-  register(policyId, handler) {
-    throwIf4(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);
-    throwIfEmpty3(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;
-    throwIfEmpty3(typeId, 'Invalid policy snapshot: missing "__type" identifier.');
-    const handler = this.handlers.get(typeId);
-    throwIfEmpty3(handler, `No serializer handler registered for policy ID: '${typeId}'`);
-    const { __type, ...data } = snapshot;
-    return handler.hydrate(data);
-  }
+	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);
+	}
 };
 
-// src/serializer/field-serializer.ts
-import { isNullOrUndefined as isNullOrUndefined2, throwIfEmpty as throwIfEmpty4 } from "@axi-engine/utils";
+//#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.
+*/
 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;
-    throwIfEmpty4(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 });
-  }
+	/**
+	* 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 });
+	}
 };
 
-// src/serializer/fields-serializer.ts
+//#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.
+*/
 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;
+	}
 };
 
-// src/serializer/field-tree-serializer.ts
-import { isString } from "@axi-engine/utils";
+//#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.
+*/
 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;
+	}
 };
 
-// src/data-store-field-resolver.ts
-import { isBoolean, isNumber, isString as isString2 } from "@axi-engine/utils";
+//#endregion
+//#region src/data-store-field-resolver.ts
 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 isString2(value);
-  }
+	typeName = CoreStringField.typeName;
+	supports(value) {
+		return isString(value);
+	}
 };
 
-// src/data-store.ts
-import { ensurePathArray as ensurePathArray2, ensurePathString as ensurePathString2, throwIfEmpty as throwIfEmpty5 } from "@axi-engine/utils";
+//#endregion
+//#region src/data-store.ts
 var DataStore = class {
-  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);
-    throwIfEmpty5(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);
-    throwIfEmpty5(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 };
-  }
+	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
+		};
+	}
 };
 
-// src/setup.ts
+//#endregion
+//#region src/setup.ts
+/**
+* Creates and configures a FieldRegistry with all the core field types.
+* @returns {FieldRegistry} A pre-configured FieldRegistry instance.
+*/
 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 registry = config?.registry ?? createCoreFieldRegistry();
-  const factory = createCoreTreeNodeFactory(registry);
-  const serializer = createCoreTreeSerializer(factory, config?.policySerializer);
-  return { factory, serializer };
+	const factory = createCoreTreeNodeFactory(config?.registry ?? createCoreFieldRegistry());
+	return {
+		factory,
+		serializer: createCoreTreeSerializer(factory, config?.policySerializer)
+	};
 }
-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
-};
+
+//#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