@v-ibe/core 0.1.0

package/dist/reactivity/signals/composite.d.ts

@@ -0,0 +1,89 @@
+import { Subscriber } from '../types.js';
+export type { Subscriber };
+/**
+ * CompositeSignal - Con caché compartido y composición automática
+ *
+ * Soporta reactividad profunda con composición automática:
+ * - Objetos anidados se envuelven automáticamente en CompositeSignal
+ * - Arrays anidados se envuelven automáticamente en ReactiveArray
+ * - Usa caché compartido global para garantizar consistencia
+ * - El tracking funciona en cualquier nivel de profundidad
+ *
+ * IMPORTANTE: Usa el mismo tipo Subscriber que Signal, que es una función.
+ * Esto permite integración completa con el sistema de reactividad existente.
+ */
+export declare class CompositeSignal<T extends object> {
+    private value;
+    private propertySubscribers;
+    private nestedReactives;
+    private onChangeCallback?;
+    constructor(initialValue: T);
+    /**
+     * Registra un callback que se llamará cada vez que cualquier propiedad cambie
+     * El callback se llama síncronamente antes de cualquier notificación a subscribers
+     *
+     * @param callback - Función que recibe (property, oldValue, newValue)
+     */
+    onChange(callback: (property: string | symbol, oldValue: any, newValue: any) => void): void;
+    /**
+     * Obtiene el objeto JavaScript plano subyacente, sin envolver en CompositeSignal
+     *
+     * @returns El objeto plano original
+     */
+    getPlainValue(): T;
+    /**
+     * Obtiene el valor de una propiedad del objeto almacenado
+     * Si hay un efecto activo en reactiveContext, lo registra automáticamente
+     * como subscriber de esta propiedad
+     *
+     * COMPOSICIÓN AUTOMÁTICA:
+     * - Si el valor es un objeto → devuelve CompositeSignal
+     * - Si el valor es un array → devuelve ReactiveArray
+     * - Si el valor es primitivo → devuelve el valor directo
+     *
+     * Usa caché compartido para garantizar consistencia
+     *
+     * @param property - La clave de la propiedad a leer
+     * @returns El valor de la propiedad (envuelto si es objeto/array)
+     */
+    get(property: string | symbol): any;
+    /**
+     * Actualiza el valor de una propiedad en el objeto almacenado y notifica a los subscribers
+     * Solo notifica si el valor realmente cambió (usa Object.is para comparación)
+     *
+     * IMPORTANTE: Si se reemplaza un objeto, invalida el caché del CompositeSignal anidado
+     *
+     * @param property - La clave de la propiedad a actualizar
+     * @param newValue - El nuevo valor para la propiedad
+     */
+    set(property: string | symbol, newValue: any): void;
+    /**
+     * Notifica a todos los subscribers de una propiedad específica
+     * Distingue entre Computed (síncrono) y Effect (agendado en scheduler)
+     * @param property - La propiedad cuyos subscribers deben ser notificados
+     */
+    private _notifyProperty;
+    /**
+     * Registra un subscriber para una propiedad específica
+     * @param property - La propiedad a observar
+     * @param subscriber - El subscriber que se ejecutará cuando la propiedad cambie
+     */
+    subscribeToProperty(property: string | symbol, subscriber: Subscriber): void;
+    /**
+     * Método helper para inspeccionar los subscribers registrados (útil para testing)
+     * @param property - La propiedad a inspeccionar
+     * @returns El Set de subscribers para esa propiedad, o undefined si no hay
+     */
+    getSubscribers(property: string | symbol): Set<Subscriber> | undefined;
+    /**
+     * Método helper para obtener todas las propiedades que tienen subscribers
+     * @returns Array de propiedades que tienen al menos un subscriber
+     */
+    getSubscribedProperties(): (string | symbol)[];
+    /**
+     * ✅ NUEVO: Trackea shallow (cualquier cambio en el objeto)
+     * Se llama cuando se itera sobre el objeto (Object.keys, for...in, etc.)
+     * El effect se ejecutará cuando CUALQUIER propiedad cambie
+     */
+    trackShallow(): void;
+}

package/dist/reactivity/signals/composite.js

@@ -0,0 +1,145 @@
+import { reactiveContext } from "../reactive-context.js";
+import { phaseScheduler } from "../phase-scheduler.js";
+import { getOrCreateReactive } from "../reactive-cache.js";
+const SHALLOW_KEY = Symbol.for("__composite_shallow__");
+class CompositeSignal {
+  constructor(initialValue) {
+    this.propertySubscribers = /* @__PURE__ */ new Map();
+    this.nestedReactives = /* @__PURE__ */ new Map();
+    this.value = initialValue;
+  }
+  /**
+   * Registra un callback que se llamará cada vez que cualquier propiedad cambie
+   * El callback se llama síncronamente antes de cualquier notificación a subscribers
+   * 
+   * @param callback - Función que recibe (property, oldValue, newValue)
+   */
+  onChange(callback) {
+    this.onChangeCallback = callback;
+  }
+  /**
+   * Obtiene el objeto JavaScript plano subyacente, sin envolver en CompositeSignal
+   * 
+   * @returns El objeto plano original
+   */
+  getPlainValue() {
+    return this.value;
+  }
+  /**
+   * Obtiene el valor de una propiedad del objeto almacenado
+   * Si hay un efecto activo en reactiveContext, lo registra automáticamente
+   * como subscriber de esta propiedad
+   * 
+   * COMPOSICIÓN AUTOMÁTICA:
+   * - Si el valor es un objeto → devuelve CompositeSignal
+   * - Si el valor es un array → devuelve ReactiveArray
+   * - Si el valor es primitivo → devuelve el valor directo
+   * 
+   * Usa caché compartido para garantizar consistencia
+   * 
+   * @param property - La clave de la propiedad a leer
+   * @returns El valor de la propiedad (envuelto si es objeto/array)
+   */
+  get(property) {
+    if (reactiveContext.currentComputation && reactiveContext.isTracking) {
+      this.subscribeToProperty(property, reactiveContext.currentComputation);
+    }
+    const value = this.value[property];
+    if (value === null || typeof value !== "object") {
+      return value;
+    }
+    if (!this.nestedReactives.has(property)) {
+      const reactive = getOrCreateReactive(value);
+      this.nestedReactives.set(property, reactive);
+    }
+    return this.nestedReactives.get(property);
+  }
+  /**
+   * Actualiza el valor de una propiedad en el objeto almacenado y notifica a los subscribers
+   * Solo notifica si el valor realmente cambió (usa Object.is para comparación)
+   * 
+   * IMPORTANTE: Si se reemplaza un objeto, invalida el caché del CompositeSignal anidado
+   * 
+   * @param property - La clave de la propiedad a actualizar
+   * @param newValue - El nuevo valor para la propiedad
+   */
+  set(property, newValue) {
+    const oldValue = this.value[property];
+    if (!Object.is(oldValue, newValue)) {
+      this.value[property] = newValue;
+      if (this.onChangeCallback) {
+        this.onChangeCallback(property, oldValue, newValue);
+      }
+      if (this.nestedReactives.has(property)) {
+        this.nestedReactives.delete(property);
+      }
+      this._notifyProperty(property);
+    }
+  }
+  /**
+   * Notifica a todos los subscribers de una propiedad específica
+   * Distingue entre Computed (síncrono) y Effect (agendado en scheduler)
+   * @param property - La propiedad cuyos subscribers deben ser notificados
+   */
+  _notifyProperty(property) {
+    const subscribers = this.propertySubscribers.get(property);
+    if (subscribers) {
+      subscribers.forEach((subscriber) => {
+        if (subscriber._isComputation) {
+          subscriber();
+        } else {
+          phaseScheduler.schedule(subscriber);
+        }
+      });
+    }
+    const shallowSubscribers = this.propertySubscribers.get(SHALLOW_KEY);
+    if (shallowSubscribers) {
+      shallowSubscribers.forEach((subscriber) => {
+        if (subscriber._isComputation) {
+          subscriber();
+        } else {
+          phaseScheduler.schedule(subscriber);
+        }
+      });
+    }
+  }
+  /**
+   * Registra un subscriber para una propiedad específica
+   * @param property - La propiedad a observar
+   * @param subscriber - El subscriber que se ejecutará cuando la propiedad cambie
+   */
+  subscribeToProperty(property, subscriber) {
+    if (!this.propertySubscribers.has(property)) {
+      this.propertySubscribers.set(property, /* @__PURE__ */ new Set());
+    }
+    this.propertySubscribers.get(property).add(subscriber);
+  }
+  /**
+   * Método helper para inspeccionar los subscribers registrados (útil para testing)
+   * @param property - La propiedad a inspeccionar
+   * @returns El Set de subscribers para esa propiedad, o undefined si no hay
+   */
+  getSubscribers(property) {
+    return this.propertySubscribers.get(property);
+  }
+  /**
+   * Método helper para obtener todas las propiedades que tienen subscribers
+   * @returns Array de propiedades que tienen al menos un subscriber
+   */
+  getSubscribedProperties() {
+    return Array.from(this.propertySubscribers.keys());
+  }
+  /**
+   * ✅ NUEVO: Trackea shallow (cualquier cambio en el objeto)
+   * Se llama cuando se itera sobre el objeto (Object.keys, for...in, etc.)
+   * El effect se ejecutará cuando CUALQUIER propiedad cambie
+   */
+  trackShallow() {
+    if (reactiveContext.currentComputation && reactiveContext.isTracking) {
+      this.subscribeToProperty(SHALLOW_KEY, reactiveContext.currentComputation);
+    }
+  }
+}
+export {
+  CompositeSignal
+};

package/dist/reactivity/signals/computed.d.ts

@@ -0,0 +1,61 @@
+import { ISignal } from './signal';
+/**
+ * Computed Signal - Lazy evaluation with dirty flag (like Solid.js, Vue 3)
+ *
+ * Características:
+ * - Solo recalcula cuando se lee (lazy/pull-based)
+ * - Usa un flag "_isDirty" para saber si necesita recalcular
+ * - Recalcula SÍNCRONAMENTE cuando se lee y está dirty
+ * - NO usa scheduler asíncrono para recalcular (no hay glitches)
+ * - Trackea sus dependencias automáticamente
+ *
+ * STACK UNIFICADO:
+ * - Usa reactiveContext.enter() para crear su contexto de tracking
+ * - Garantiza limpieza correcta del contexto
+ */
+export declare class Computed<T> implements ISignal<T> {
+    readonly isSignal = true;
+    private _value;
+    private _subscribers;
+    private _getter;
+    private _isDirty;
+    private _computation;
+    private _sources;
+    constructor(getter: () => T);
+    get(): T;
+    /**
+     * Recalcula el valor del computed síncronamente.
+     * Se ejecuta cuando:
+     * 1. Se lee el computed (get) y está dirty
+     * 2. Es la primera vez que se lee
+     */
+    private _recompute;
+    /**
+     * Notifica a los subscribers que este computed cambió.
+     *
+     * FIX: Distingue entre Computed y Effect:
+     * - Computed: Ejecutar síncronamente
+     * - Effect: Agendar en el scheduler
+     */
+    private _notify;
+    /**
+     * Limpia las suscripciones a las signals anteriores.
+     * Este es el patrón Solid/Vue de bi-directional tracking:
+     * - Signal sabe quién depende de ella (_subscribers)
+     * - Computed sabe de qué signals depende (_sources)
+     *
+     * Cuando recalculamos, necesitamos:
+     * 1. Des-suscribirnos de las signals viejas
+     * 2. Re-trackear las nuevas signals que leemos
+     *
+     * Esto permite dependencias dinámicas/condicionales.
+     */
+    private _cleanup;
+    set(newValue: T): void;
+    update(updater: (currentValue: T) => T): void;
+    /**
+     * Limpia los recursos del computed.
+     */
+    dispose(): void;
+}
+export declare function computed<T>(getter: () => T): ISignal<T>;

package/dist/reactivity/signals/computed.js

@@ -0,0 +1,107 @@
+import { reactiveContext } from "../reactive-context.js";
+import { phaseScheduler } from "../phase-scheduler.js";
+class Computed {
+  constructor(getter) {
+    this.isSignal = true;
+    this._subscribers = /* @__PURE__ */ new Set();
+    this._isDirty = true;
+    this._sources = /* @__PURE__ */ new Set();
+    this._getter = getter;
+    this._value = void 0;
+    const self = this;
+    this._computation = () => {
+      self._isDirty = true;
+      self._notify();
+    };
+    this._computation.priority = "Sync";
+    this._computation._isComputation = true;
+  }
+  get() {
+    if (this._isDirty) {
+      this._recompute();
+    }
+    if (reactiveContext.currentComputation && reactiveContext.isTracking) {
+      this._subscribers.add(reactiveContext.currentComputation);
+    }
+    return this._value;
+  }
+  /**
+   * Recalcula el valor del computed síncronamente.
+   * Se ejecuta cuando:
+   * 1. Se lee el computed (get) y está dirty
+   * 2. Es la primera vez que se lee
+   */
+  _recompute() {
+    this._isDirty = false;
+    this._cleanup();
+    const previousOnTrack = reactiveContext.onTrack;
+    reactiveContext.onTrack = (signal) => {
+      this._sources.add(signal);
+    };
+    const exitContext = reactiveContext.enter(this._computation, true, "computed");
+    try {
+      const newValue = this._getter();
+      this._value = newValue;
+    } finally {
+      exitContext();
+      reactiveContext.onTrack = previousOnTrack;
+    }
+  }
+  /**
+   * Notifica a los subscribers que este computed cambió.
+   *
+   * FIX: Distingue entre Computed y Effect:
+   * - Computed: Ejecutar síncronamente
+   * - Effect: Agendar en el scheduler
+   */
+  _notify() {
+    this._subscribers.forEach((subscriber) => {
+      if (subscriber._isComputation) {
+        subscriber();
+      } else {
+        phaseScheduler.schedule(subscriber);
+      }
+    });
+  }
+  /**
+   * Limpia las suscripciones a las signals anteriores.
+   * Este es el patrón Solid/Vue de bi-directional tracking:
+   * - Signal sabe quién depende de ella (_subscribers)
+   * - Computed sabe de qué signals depende (_sources)
+   *
+   * Cuando recalculamos, necesitamos:
+   * 1. Des-suscribirnos de las signals viejas
+   * 2. Re-trackear las nuevas signals que leemos
+   *
+   * Esto permite dependencias dinámicas/condicionales.
+   */
+  _cleanup() {
+    this._sources.forEach((source) => {
+      if (source._unsubscribe) {
+        source._unsubscribe(this._computation);
+      }
+    });
+    this._sources.clear();
+  }
+  // Las signals computadas son de solo lectura
+  set(newValue) {
+    throw new Error("Cannot set a computed signal.");
+  }
+  update(updater) {
+    throw new Error("Cannot update a computed signal.");
+  }
+  /**
+   * Limpia los recursos del computed.
+   */
+  dispose() {
+    this._cleanup();
+    this._subscribers.clear();
+  }
+}
+function computed(getter) {
+  return new Computed(getter);
+}
+export {
+  Computed,
+  computed
+};

package/dist/reactivity/signals/computed.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/reactivity/signals/derived.d.ts

@@ -0,0 +1,10 @@
+import { ISignal } from './signal';
+export declare class Derived<T> implements ISignal<T> {
+    readonly isSignal = true;
+    private _inner;
+    constructor(source: ISignal<T>, mapper?: (value: T) => T);
+    get(): T;
+    set(_: T): void;
+    update(_: (currentValue: T) => T): void;
+}
+export declare function derived<T>(source: ISignal<T>, mapper?: (value: T) => T): ISignal<T>;

package/dist/reactivity/signals/derived.js

@@ -0,0 +1,24 @@
+import { computed } from "./computed.js";
+class Derived {
+  constructor(source, mapper) {
+    this.isSignal = true;
+    const safeMapper = mapper ?? ((v) => v);
+    this._inner = computed(() => safeMapper(source.get()));
+  }
+  get() {
+    return this._inner.get();
+  }
+  set(_) {
+    throw new Error("Cannot set a ContextSignal.");
+  }
+  update(_) {
+    throw new Error("Cannot update a ContextSignal.");
+  }
+}
+function derived(source, mapper) {
+  return new Derived(source, mapper);
+}
+export {
+  Derived,
+  derived
+};

package/dist/reactivity/signals/effect.d.ts

@@ -0,0 +1,27 @@
+interface Computation extends Function {
+}
+/**
+ * Crea un effect reactivo que se re-ejecuta cuando sus dependencias cambian
+ *
+ * Sistema basado en fases:
+ * - Elimina glitches garantizando orden de ejecución consistente
+ * - Batching automático de actualizaciones
+ * - Ordenamiento topológico de dependencias
+ *
+ * IMPORTANTE (Stack Unificado):
+ * - Cada effect usa reactiveContext.enter() para crear su propio frame
+ * - Esto garantiza que el effect tenga su propio contexto incluso si
+ *   se crea dentro de un untrack() del padre
+ * - Resuelve el bug de suscripciones perdidas en effects anidados
+ *
+ * @param fn - Función a ejecutar. Recibe onCleanup para registrar limpieza
+ * @param options - Opciones (deprecado: priority ya no se usa)
+ * @returns Objeto con métodos run y dispose
+ */
+export declare function effect(fn: (onCleanup: (cb: () => void) => void) => void | Promise<void>, options?: {
+    priority?: string;
+}): {
+    run: Computation;
+    dispose: () => void;
+};
+export {};

package/dist/reactivity/signals/effect.js

@@ -0,0 +1,46 @@
+import { reactiveContext } from "../reactive-context.js";
+function effect(fn, options) {
+  let cleanupFn = null;
+  let isDisposed = false;
+  const onCleanup = (cb) => {
+    cleanupFn = cb;
+  };
+  const computation = () => {
+    if (isDisposed) {
+      return;
+    }
+    if (cleanupFn) {
+      cleanupFn();
+      cleanupFn = null;
+    }
+    const exitContext = reactiveContext.enter(computation, true, "effect");
+    try {
+      const result = fn(onCleanup);
+      if (result && typeof result.then === "function") {
+        result.finally(exitContext);
+      } else {
+        exitContext();
+      }
+    } catch (error) {
+      exitContext();
+      throw error;
+    }
+  };
+  computation();
+  return {
+    run: computation,
+    dispose: () => {
+      if (isDisposed) {
+        return;
+      }
+      isDisposed = true;
+      if (cleanupFn) {
+        cleanupFn();
+        cleanupFn = null;
+      }
+    }
+  };
+}
+export {
+  effect
+};

package/dist/reactivity/signals/event.d.ts

@@ -0,0 +1,9 @@
+import { Signal } from './signal';
+export declare function eventListener<T, K extends keyof HTMLElementEventMap>(eventTarget: EventTarget, eventType: K, valueGetter: (e: HTMLElementEventMap[K]) => T, initialValueGetter?: () => T): {
+    signal: Signal<T>;
+    cleanup: () => void;
+};
+export declare function eventListener<T>(eventTarget: EventTarget, eventType: string, valueGetter: (e: Event) => T, initialValueGetter?: () => T): {
+    signal: Signal<T>;
+    cleanup: () => void;
+};

package/dist/reactivity/signals/event.js

@@ -0,0 +1,15 @@
+import { Signal } from "./signal.js";
+function eventListener(eventTarget, eventType, valueGetter, initialValueGetter) {
+  const signal = new Signal(
+    valueGetter(null)
+  );
+  const updateSignal = (e) => signal.set(valueGetter(e));
+  eventTarget.addEventListener(eventType, updateSignal);
+  const cleanup = () => {
+    eventTarget.removeEventListener(eventType, updateSignal);
+  };
+  return { signal, cleanup };
+}
+export {
+  eventListener
+};

package/dist/reactivity/signals/reactive-array.d.ts

@@ -0,0 +1,133 @@
+import { Subscriber } from '../types.js';
+export type { Subscriber };
+export declare class ReactiveArray<T> {
+    private strategy;
+    private ownedStrategy?;
+    private subscribers;
+    private onChangeCallback?;
+    private mapCache;
+    constructor(itemsOrConfig?: T[] | {
+        source: ReactiveArray<any>;
+        transform: (value: any, index: number) => T;
+    } | {
+        source: ReactiveArray<T>;
+        predicate: (value: T, index: number, array: T[]) => boolean;
+    });
+    /**
+     * Registra un callback que se llama síncronamente antes de notificar subscribers
+     */
+    onChange(callback: (operation: string, ...args: any[]) => void): void;
+    /**
+     * Retorna el array plano subyacente (sin reactividad)
+     * Útil para serialización o interoperación con código no reactivo
+     */
+    getPlainValue(): T[];
+    /**
+     * Getter reactivo para la longitud del array
+     */
+    get length(): number;
+    /**
+     * Método at() reactivo que soporta índices negativos
+     * Similar a array.at() pero con tracking granular por índice
+     */
+    at(index: number): T | undefined;
+    /**
+     * Asegura que el array esté en modo owned (tiene datos propios)
+     * Lanza error si se intenta mutar un array derivado
+     */
+    private ensureOwned;
+    push(...items: T[]): number;
+    pop(): T | undefined;
+    shift(): T | undefined;
+    unshift(...items: T[]): number;
+    splice(start: number, deleteCount?: number, ...items: T[]): T[];
+    sort(compareFn?: (a: T, b: T) => number): this;
+    reverse(): this;
+    fill(value: T, start?: number, end?: number): this;
+    /**
+     * map() ahora retorna un ReactiveArray derivado, no un array plano
+     * Este es el corazón de tu insight: mantener la reactividad en la cadena
+     *
+     * MEMOIZACIÓN INTELIGENTE:
+     * - Cachea el array derivado por toString() del callback
+     * - Captura dependencias externas (signals que el callback lee)
+     * - Si las dependencias no cambiaron, retorna el MISMO array derivado
+     * - Esto permite granularidad: push/pop solo afectan nuevos elementos
+     */
+    map<U>(callback: (value: T, index: number, array: T[]) => U): ReactiveArray<U>;
+    /**
+     * filter() también retorna un ReactiveArray derivado
+     * Implementación especial que necesita manejar índices no lineales
+     */
+    filter(callback: (value: T, index: number, array: T[]) => boolean): ReactiveArray<T>;
+    slice(start?: number, end?: number): T[];
+    concat(...items: (T | T[])[]): T[];
+    find(callback: (value: T, index: number, array: T[]) => boolean): T | undefined;
+    findIndex(callback: (value: T, index: number, array: T[]) => boolean): number;
+    indexOf(searchElement: T, fromIndex?: number): number;
+    includes(searchElement: T, fromIndex?: number): boolean;
+    forEach(callback: (value: T, index: number, array: T[]) => void): void;
+    some(callback: (value: T, index: number, array: T[]) => boolean): boolean;
+    every(callback: (value: T, index: number, array: T[]) => boolean): boolean;
+    reduce<U>(callback: (accumulator: U, value: T, index: number, array: T[]) => U, initialValue: U): U;
+    reduceRight<U>(callback: (accumulator: U, value: T, index: number, array: T[]) => U, initialValue: U): U;
+    join(separator?: string): string;
+    toString(): string;
+    toLocaleString(): string;
+    [Symbol.iterator](): IterableIterator<T>;
+    entries(): IterableIterator<[number, T]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<T>;
+    /**
+     * Registra un subscriber para un tipo específico de cambio
+     */
+    private _subscribe;
+    /**
+     * Notifica a subscribers de un tipo específico de cambio
+     */
+    private _notify;
+    /**
+     * Notifica que el array mutó (cualquier cambio en contenido)
+     */
+    private _notifyMutation;
+    /**
+     * Notifica que la longitud cambió
+     */
+    private _notifyLength;
+    /**
+     * Notifica a todos los índices numéricos suscritos
+     * Se usa cuando operaciones como shift/unshift/splice afectan múltiples índices
+     */
+    private _notifyAllIndices;
+    /**
+     * Notifica todos los índices desde start hacia adelante
+     * Útil cuando splice/insert afecta índices posteriores
+     */
+    private _notifyIndicesFrom;
+    getSubscribers(key: string | number): Set<Subscriber> | undefined;
+    getSubscribedKeys(): (string | number)[];
+}
+export type ObservableArray<T> = ReactiveArray<T>;
+export type Collection<T> = ReactiveArray<T>;
+/**
+ * Factory function to create a new ReactiveArray
+ */
+export declare function collection<T>(items?: T[]): ReactiveArray<T>;
+/**
+ * Type guard to check if a value is a ReactiveArray
+ */
+export declare function isObservableArray(value: any): value is ReactiveArray<any>;
+/**
+ * Type guard to check if a value is a Collection (same as ObservableArray)
+ */
+export declare function isCollection(value: any): value is ReactiveArray<any>;
+/**
+ * Type guard to check if a value is a ReactiveArray OR a proxy wrapping a ReactiveArray
+ * This is useful in JSX rendering where arrays might be wrapped in proxies
+ */
+export declare function isReactiveArrayLike(value: any): boolean;
+/**
+ * Unwraps a ReactiveArray from a proxy if necessary
+ * Returns the underlying ReactiveArray or null if the value is not a ReactiveArray
+ */
+export declare function unwrapReactiveArray<T = any>(value: any): ReactiveArray<T> | null;