createReactiveProxy(obj, path = "") {
      Logger.debug(`Creating reactive object with path ${path} for`, obj);
      if (Array.isArray(obj)) {
        return this.createArrayProxy(obj, path);
      }
      return new Proxy(obj, {
        get: (target, prop) => {
          if (typeof prop === "symbol") {
            return target[prop];
          }
          const value = target[prop];
          const fullPath = path ? `${path}.${prop}` : prop;
          if (value && typeof value === "object") {
            return this.createReactiveProxy(value, fullPath);
          }
          return value;
        },
        set: async (target, prop, value) => {
          if (typeof prop === "symbol") {
            target[prop] = value;
            return true;
          }
          const fullPath = path ? `${path}.${prop}` : prop;
          const oldValue = target[prop];
          if (oldValue === value) {
            return true;
          }
          if (this.validators?.has(`${fullPath}`)) {
            const isValid = this.validators.get(`${fullPath}`)(value);
            if (!isValid) return false;
          }
          if (this.formatters?.has(`${fullPath}`)) {
            value = this.formatters.get(`${fullPath}`)(value);
          }
          if (value && typeof value === "object") {
            value = this.createReactiveProxy(value, fullPath);
          }
          const context = {
            prop,
            oldValue,
            newValue: value,
            preventDefault: false
          };
          await this.middleware.process(context);
          if (context.preventDefault) {
            return true;
          }
          target[prop] = value;
          this.emit("change", {
            path: fullPath,
            oldValue,
            newValue: value
          });
          if (this.watchers.has(fullPath)) {
            this.watchers.get(fullPath).forEach((callback) => {
              callback(value, oldValue);
            });
          }
          return true;
        },
        deleteProperty: (target, prop) => {
          if (typeof prop === "symbol") {
            return delete target[prop];
          }
          const fullPath = path ? `${path}.${prop}` : prop;
          const oldValue = target[prop];
          const result = delete target[prop];
          if (result) {
            this.emit("delete", {
              path: fullPath,
              oldValue
            });
            if (this.watchers.has(fullPath)) {
              this.watchers.get(fullPath).forEach((callback) => {
                callback(void 0, oldValue);
              });
            }
          }
          return result;
        }
      });
    }
Creates reactive proxy for state objects.
Features:
- Special handling for arrays via separate proxy
- Deep reactivity for nested objects
- Property path tracking
- Value validation support
- Value formatting support
- Middleware integration
- Change prevention capability

@param {Object|Array} obj - Target object
@param {string} [path=''] - Property path
@returns {Proxy} Reactive proxy