@blac/core 2.0.0-rc.10 → 2.0.0-rc.13

package/dist/core/StateContainerRegistry.d.ts

@@ -1,119 +0,0 @@
-import type { StateContainer } from './StateContainer';
-import type { Vertex } from './Vertex';
-export interface InstanceEntry<T = any> {
-    instance: T;
-    refCount: number;
-}
-export type LifecycleEvent = 'created' | 'stateChanged' | 'eventAdded' | 'disposed';
-export type LifecycleListener<E extends LifecycleEvent> = E extends 'created' ? (container: StateContainer<any>) => void : E extends 'stateChanged' ? (container: StateContainer<any>, previousState: any, currentState: any, callstack?: string) => void : E extends 'eventAdded' ? (container: Vertex<any, any>, event: any) => void : E extends 'disposed' ? (container: StateContainer<any>) => void : never;
-export declare class StateContainerRegistry {
-    private readonly instancesByConstructor;
-    private readonly types;
-    private readonly typeConfigs;
-    private readonly listeners;
-    registerType<T extends StateContainer<any>>(constructor: new (...args: any[]) => T): void;
-    register<T extends StateContainer<any>>(constructor: new (...args: any[]) => T, isolated?: boolean): void;
-    private ensureInstancesMap;
-    /**
-     * Get the instances Map for a specific class (public API for stats/debugging)
-     */
-    getInstancesMap<T extends StateContainer<any>>(Type: new (...args: any[]) => T): Map<string, InstanceEntry>;
-    /**
-     * Resolve an instance with ref counting (ownership semantics)
-     */
-    resolve<T extends StateContainer<any>>(Type: new (...args: any[]) => T, instanceKey?: string, constructorArgs?: any): T;
-    /**
-     * Get an existing instance without ref counting (borrowing semantics)
-     * @throws Error if instance doesn't exist
-     */
-    get<T extends StateContainer<any>>(Type: new (...args: any[]) => T, instanceKey?: string): T;
-    /**
-     * Safely get an existing instance (borrowing semantics with error handling)
-     * Returns discriminated union for type-safe conditional access
-     */
-    getSafe<T extends StateContainer<any>>(Type: new (...args: any[]) => T, instanceKey?: string): {
-        error: Error;
-        instance: null;
-    } | {
-        error: null;
-        instance: T;
-    };
-    /**
-     * Connect to an instance with borrowing semantics (for B2B communication)
-     * Gets existing instance OR creates it if it doesn't exist, without incrementing ref count.
-     * Tracks cross-bloc dependency for reactive updates.
-     *
-     * Use this in bloc-to-bloc communication when you need to ensure an instance exists
-     * but don't want to claim ownership (no ref count increment).
-     *
-     * @param Type - The bloc class constructor
-     * @param instanceKey - Optional instance key (defaults to 'default')
-     * @param constructorArgs - Constructor arguments (only used if creating new instance)
-     * @returns The bloc instance
-     */
-    connect<T extends StateContainer<any>>(Type: new (...args: any[]) => T, instanceKey?: string, constructorArgs?: any): T;
-    /**
-     * Release a reference to an instance
-     */
-    release<T extends StateContainer<any>>(Type: new (...args: any[]) => T, instanceKey?: string, forceDispose?: boolean): void;
-    /**
-     * Get all instances of a specific type
-     */
-    getAll<T extends StateContainer<any>>(Type: new (...args: any[]) => T): T[];
-    /**
-     * Safely iterate over all instances of a type
-     */
-    forEach<T extends StateContainer<any>>(Type: new (...args: any[]) => T, callback: (instance: T) => void): void;
-    /**
-     * Clear all instances of a specific type
-     */
-    clear<T extends StateContainer<any>>(Type: new (...args: any[]) => T): void;
-    /**
-     * Get reference count for an instance
-     */
-    getRefCount<T extends StateContainer<any>>(Type: new (...args: any[]) => T, instanceKey?: string): number;
-    /**
-     * Check if an instance exists
-     */
-    hasInstance<T extends StateContainer<any>>(Type: new (...args: any[]) => T, instanceKey?: string): boolean;
-    /**
-     * Clear all instances from all types (for testing)
-     *
-     * Iterates all registered types and clears their instances.
-     * Also clears type tracking to reset the registry state.
-     */
-    clearAll(): void;
-    /**
-     * Get registry statistics (for debugging)
-     */
-    getStats(): {
-        registeredTypes: number;
-        totalInstances: number;
-        typeBreakdown: Record<string, number>;
-    };
-    /**
-     * Get all registered types (for plugin system)
-     */
-    getTypes(): Array<new (...args: any[]) => StateContainer<any>>;
-    /**
-     * Subscribe to lifecycle events
-     * @param event - The lifecycle event to listen for
-     * @param listener - The listener function to call when the event occurs
-     * @returns Unsubscribe function
-     */
-    on<E extends LifecycleEvent>(event: E, listener: LifecycleListener<E>): () => void;
-    /**
-     * Emit lifecycle event to all listeners
-     * @internal - Called by StateContainer/Vertex lifecycle methods
-     */
-    emit(event: LifecycleEvent, ...args: any[]): void;
-}
-/**
- * Global default registry instance
- */
-export declare const globalRegistry: StateContainerRegistry;
-/**
- * Get the global plugin manager
- */
-export declare function getPluginManager(): any;
-//# sourceMappingURL=StateContainerRegistry.d.ts.map

package/dist/core/Vertex.d.ts

@@ -1,74 +0,0 @@
-import { StateContainer } from './StateContainer';
-import { BaseEvent } from '../types/events';
-export type EventHandler<E extends BaseEvent, S> = (event: E, emit: (state: S) => void) => void;
-export type EventConstructor<T extends BaseEvent = BaseEvent> = new (...args: never[]) => T;
-export declare abstract class Vertex<S, E extends BaseEvent = BaseEvent, P = undefined> extends StateContainer<S, P> {
-    private eventHandlers;
-    private isProcessing;
-    private eventQueue;
-    constructor(initialState: S);
-    protected on: <T extends E>(EventClass: EventConstructor<T>, handler: EventHandler<T, S>) => void;
-    add: (event: E) => void;
-    private processEvent;
-    private handleEvent;
-    protected onEventError(_event: E, _error: Error): void;
-}
-/**
- * Example: Counter Events
- */
-export declare class IncrementEvent implements BaseEvent {
-    readonly amount: number;
-    readonly type = "increment";
-    readonly timestamp: number;
-    constructor(amount?: number);
-}
-export declare class DecrementEvent implements BaseEvent {
-    readonly amount: number;
-    readonly type = "decrement";
-    readonly timestamp: number;
-    constructor(amount?: number);
-}
-export declare class ResetEvent implements BaseEvent {
-    readonly type = "reset";
-    readonly timestamp: number;
-}
-/**
- * Example: Counter Vertex
- * Demonstrates proper typing and event handling
- */
-export declare class CounterVertex extends Vertex<number> {
-    constructor();
-    increment: (amount?: number) => void;
-    decrement: (amount?: number) => void;
-    reset: () => void;
-}
-/**
- * Auth State and Events for testing async handlers
- */
-export interface AuthState {
-    isAuthenticated: boolean;
-    isLoading: boolean;
-    user: {
-        id: string;
-        name: string;
-        email: string;
-    } | null;
-    error: string | null;
-}
-export declare class LoginEvent implements BaseEvent {
-    readonly email: string;
-    readonly password: string;
-    readonly type = "login";
-    readonly timestamp: number;
-    constructor(email: string, password: string);
-}
-export declare class LogoutEvent implements BaseEvent {
-    readonly type = "logout";
-    readonly timestamp: number;
-}
-export declare class AuthVertex extends Vertex<AuthState> {
-    constructor();
-    login: (email: string, password: string) => void;
-    logout: () => void;
-}
-//# sourceMappingURL=Vertex.d.ts.map

package/dist/decorators/blac.d.ts

@@ -1,31 +0,0 @@
-export type BlacOptions = {
-    isolated: true;
-} | {
-    keepAlive: true;
-} | {
-    excludeFromDevTools: true;
-};
-/**
- * Decorator to configure StateContainer classes.
- *
- * @example Decorator syntax (requires experimentalDecorators or TC39 decorators)
- * ```typescript
- * @blac({ isolated: true })
- * class FormBloc extends Cubit<FormState> {}
- *
- * @blac({ keepAlive: true })
- * class AuthBloc extends Cubit<AuthState> {}
- *
- * @blac({ excludeFromDevTools: true })
- * class InternalBloc extends Cubit<InternalState> {}
- * ```
- *
- * @example Function syntax (no decorator support needed)
- * ```typescript
- * const FormBloc = blac({ isolated: true })(
- *   class extends Cubit<FormState> {}
- * );
- * ```
- */
-export declare function blac(options: BlacOptions): <T extends new (...args: any[]) => any>(target: T, _context?: ClassDecoratorContext) => T;
-//# sourceMappingURL=blac.d.ts.map

package/dist/decorators/index.d.ts

@@ -1,2 +0,0 @@
-export { blac, type BlacOptions } from './blac';
-//# sourceMappingURL=index.d.ts.map

package/dist/logging/Logger.d.ts

@@ -1,57 +0,0 @@
-export declare enum LogLevel {
-    ERROR = 0,
-    WARN = 1,
-    INFO = 2,
-    DEBUG = 3
-}
-export interface LogEntry {
-    level: string;
-    context: string;
-    message: string;
-    data?: any;
-    timestamp: number;
-}
-export interface LogConfig {
-    enabled: boolean;
-    level: LogLevel;
-    output: (entry: LogEntry) => void;
-}
-/**
- * Creates a logger instance with given configuration
- *
- * @param config - Logger configuration
- * @returns Logger instance with debug, info, warn, error, and configure methods
- *
- * @example
- * ```ts
- * const logger = createLogger({
- *   enabled: true,
- *   level: LogLevel.DEBUG,
- *   output: (entry) => console.log(JSON.stringify(entry))
- * });
- * logger.debug('MyComponent', 'Rendering', { props: { foo: 'bar' } });
- * ```
- */
-export declare function createLogger(config: LogConfig): {
-    debug: (context: string, message: string, data?: any) => void;
-    info: (context: string, message: string, data?: any) => void;
-    warn: (context: string, message: string, data?: any) => void;
-    error: (context: string, message: string, data?: any) => void;
-    configure: (opts: Partial<LogConfig>) => void;
-};
-export declare const debug: (context: string, message: string, data?: any) => void;
-export declare const info: (context: string, message: string, data?: any) => void;
-export declare const warn: (context: string, message: string, data?: any) => void;
-export declare const error: (context: string, message: string, data?: any) => void;
-/**
- * Configuration function that recreates the default logger
- *
- * @param opts - Partial logger configuration
- *
- * @example
- * ```ts
- * configureLogger({ enabled: true, level: LogLevel.DEBUG });
- * ```
- */
-export declare function configureLogger(opts: Partial<LogConfig>): void;
-//# sourceMappingURL=Logger.d.ts.map

package/dist/plugin/BlacPlugin.d.ts

@@ -1,46 +0,0 @@
-import type { StateContainer } from '../core/StateContainer';
-import type { Vertex } from '../core/Vertex';
-import type { BaseEvent } from '../types/events';
-export interface InstanceMetadata {
-    id: string;
-    className: string;
-    isDisposed: boolean;
-    name: string;
-    lastStateChangeTimestamp: number;
-    state: any;
-    createdAt: number;
-    isIsolated: boolean;
-    callstack?: string;
-    previousState?: any;
-    currentState?: any;
-}
-export interface PluginContext {
-    getInstanceMetadata(instance: StateContainer<any>): InstanceMetadata;
-    getState<S>(instance: StateContainer<S>): S;
-    queryInstances<T extends StateContainer<any>>(typeClass: new (...args: any[]) => T): T[];
-    getAllTypes(): Array<new (...args: any[]) => StateContainer<any>>;
-    getStats(): {
-        registeredTypes: number;
-        totalInstances: number;
-        typeBreakdown: Record<string, number>;
-    };
-}
-export interface BlacPlugin {
-    readonly name: string;
-    readonly version: string;
-    onInstall?(context: PluginContext): void;
-    onUninstall?(): void;
-    onInstanceCreated?(instance: StateContainer<any>, context: PluginContext): void;
-    onStateChanged?<S>(instance: StateContainer<S>, previousState: S, currentState: S, callstack: string | undefined, context: PluginContext): void;
-    onEventAdded?<E extends BaseEvent>(vertex: Vertex<any, E>, event: E, context: PluginContext): void;
-    onInstanceDisposed?(instance: StateContainer<any>, context: PluginContext): void;
-}
-export interface BlacPluginWithInit extends BlacPlugin {
-    onInstall(context: PluginContext): void;
-}
-export interface PluginConfig {
-    enabled?: boolean;
-    environment?: 'development' | 'production' | 'test' | 'all';
-}
-export declare function hasInitHook(plugin: BlacPlugin): plugin is BlacPluginWithInit;
-//# sourceMappingURL=BlacPlugin.d.ts.map

package/dist/plugin/PluginManager.d.ts

@@ -1,38 +0,0 @@
-import type { StateContainerRegistry } from '../core/StateContainerRegistry';
-import type { BlacPlugin, PluginConfig } from './BlacPlugin';
-export declare class PluginManager {
-    private plugins;
-    private registry;
-    constructor(registry: StateContainerRegistry);
-    install(plugin: BlacPlugin, config?: PluginConfig): void;
-    uninstall(pluginName: string): void;
-    getPlugin(pluginName: string): BlacPlugin | undefined;
-    getAllPlugins(): BlacPlugin[];
-    hasPlugin(pluginName: string): boolean;
-    clear(): void;
-    /**
-     * Setup lifecycle hooks to notify plugins
-     */
-    private setupLifecycleHooks;
-    /**
-     * Notify all plugins of a lifecycle event
-     */
-    private notifyPlugins;
-    /**
-     * Create plugin context with safe API access
-     */
-    private createPluginContext;
-    /**
-     * Check if plugin should be enabled based on environment
-     */
-    private shouldEnablePlugin;
-    /**
-     * Get current environment
-     */
-    private getCurrentEnvironment;
-}
-/**
- * Create a plugin manager instance
- */
-export declare function createPluginManager(registry: StateContainerRegistry): PluginManager;
-//# sourceMappingURL=PluginManager.d.ts.map

package/dist/registry/index.d.ts

@@ -1,20 +0,0 @@
-/**
- * Registry module (deprecated)
- *
- * Registry functionality has been consolidated into StateContainer.
- * Use StateContainer static methods instead:
- *
- * - StateContainer.register() - Register a type
- * - StateContainer.getOrCreate() - Get or create instance
- * - StateContainer.isRegistered() - Check if type is registered
- * - StateContainer.hasInstance() - Check if instance exists
- * - StateContainer.removeInstance() - Remove instance
- * - StateContainer.getAll() - Get all instances of a type
- * - StateContainer.clear() - Clear all instances of a type
- * - StateContainer.clearAllInstances() - Clear all instances
- * - StateContainer.unregister() - Unregister a type
- * - StateContainer.getStats() - Get statistics
- */
-export { type BlocConstructor } from '../types/utilities';
-export { type InstanceId, instanceId as createInstanceId, } from '../types/branded';
-//# sourceMappingURL=index.d.ts.map

package/dist/test-utils/index.d.ts

@@ -1,43 +0,0 @@
-/**
- * Test utilities and fixtures
- */
-/**
- * Create a test state object
- */
-export declare function createTestState<T extends Record<string, unknown>>(overrides?: Partial<T>): T;
-/**
- * Wait for a condition to be true
- */
-export declare function waitFor(condition: () => boolean, timeout?: number, interval?: number): Promise<void>;
-/**
- * Create a mock subscription notify function
- */
-export declare function createMockNotify<T = unknown>(): {
-    fn: import("vitest").Mock<(state: T) => void>;
-    calls: T[];
-    callCount: () => number;
-    lastCall: () => T;
-    reset: () => void;
-};
-/**
- * Memory usage tracker for tests
- */
-export declare class MemoryTracker {
-    private baseline;
-    start(): void;
-    getUsage(): number;
-    getMB(): number;
-}
-/**
- * Performance timer for benchmarking
- */
-export declare class PerfTimer {
-    private start;
-    private marks;
-    begin(): void;
-    mark(label: string): void;
-    end(): number;
-    getMark(label: string): number | undefined;
-    getAllMarks(): Record<string, number>;
-}
-//# sourceMappingURL=index.d.ts.map

package/dist/tracking/dependency-tracker.d.ts

@@ -1,21 +0,0 @@
-import { type ProxyTrackerState } from './proxy-tracker';
-export interface PathInfo {
-    segments: string[];
-    value: any;
-}
-export interface TrackerState<T> {
-    proxyTrackerState: ProxyTrackerState<T>;
-    previousRenderPaths: Set<string>;
-    currentRenderPaths: Set<string>;
-    pathCache: Map<string, PathInfo>;
-    lastCheckedState: T | null;
-    lastCheckedValues: Map<string, any>;
-}
-export declare function optimizeTrackedPaths(paths: Set<string>): Set<string>;
-export declare function createTrackerState<T>(): TrackerState<T>;
-export declare function startTracking<T>(tracker: TrackerState<T>): void;
-export declare function createProxy<T>(tracker: TrackerState<T>, state: T): T;
-export declare function captureTrackedPaths<T>(tracker: TrackerState<T>, state: T): void;
-export declare function hasChanges<T>(tracker: TrackerState<T>, state: T): boolean;
-export declare function hasTrackedData<T>(tracker: TrackerState<T>): boolean;
-//# sourceMappingURL=dependency-tracker.d.ts.map

package/dist/tracking/getter-tracker.d.ts

@@ -1,31 +0,0 @@
-import type { StateContainer } from '../core/StateContainer';
-export interface GetterTrackerState {
-    trackedValues: Map<string | symbol, unknown>;
-    currentlyAccessing: Set<string | symbol>;
-    trackedGetters: Set<string | symbol>;
-    isTracking: boolean;
-    renderCache: Map<string | symbol, unknown>;
-    cacheValid: boolean;
-    externalDependencies: Set<StateContainer<any>>;
-}
-interface GetterExecutionContext {
-    tracker: GetterTrackerState | null;
-    currentBloc: StateContainer<any> | null;
-    depth: number;
-    visitedBlocs: Set<StateContainer<any>>;
-}
-export declare function getGetterExecutionContext(): GetterExecutionContext;
-export declare function getDescriptor(obj: any, prop: string | symbol): PropertyDescriptor | undefined;
-export declare function isGetter(obj: any, prop: string | symbol): boolean;
-export declare function createGetterTracker(): GetterTrackerState;
-export declare function setActiveTracker<TBloc extends StateContainer<any>>(bloc: TBloc, tracker: GetterTrackerState): void;
-export declare function clearActiveTracker<TBloc extends StateContainer<any>>(bloc: TBloc): void;
-export declare function getActiveTracker<TBloc extends StateContainer<any>>(bloc: TBloc): GetterTrackerState | undefined;
-export declare function commitTrackedGetters(tracker: GetterTrackerState): void;
-export declare function createBlocProxy<TBloc extends StateContainer<any>>(bloc: TBloc): TBloc;
-export declare function hasGetterChanges<TBloc extends StateContainer<any>>(bloc: TBloc, tracker: GetterTrackerState | null): boolean;
-export declare function invalidateRenderCache(tracker: GetterTrackerState): void;
-export declare function clearExternalDependencies(tracker: GetterTrackerState): void;
-export declare function resetGetterTracker(tracker: GetterTrackerState): void;
-export {};
-//# sourceMappingURL=getter-tracker.d.ts.map

package/dist/tracking/index.d.ts

@@ -1,38 +0,0 @@
-/**
- * Dependency Tracking
- *
- * Framework-agnostic dependency tracking utilities for automatic reactivity.
- * These utilities can be used by any framework integration (React, Vue, Angular, etc.)
- * to track property accesses and detect changes.
- *
- * ## Usage
- *
- * ```typescript
- * import {
- *   createTrackerState,
- *   startTracking,
- *   createProxy,
- *   captureTrackedPaths,
- *   hasChanges
- * } from '@blac/core';
- *
- * // Create tracker state
- * const tracker = createTrackerState<MyState>();
- *
- * // During render:
- * startTracking(tracker);
- * const proxy = createProxy(tracker, state);
- * // ... render with proxy ...
- * captureTrackedPaths(tracker, state);
- *
- * // On state change:
- * if (hasChanges(tracker, newState)) {
- *   // Trigger re-render
- * }
- * ```
- */
-export { type TrackerState, type PathInfo, createTrackerState, startTracking, createProxy, captureTrackedPaths, hasChanges, hasTrackedData, } from './dependency-tracker';
-export { type ProxyTrackerState, createProxyTrackerState, startProxyTracking, stopProxyTracking, createProxyInternal, createArrayProxy, createProxyForTarget, isProxyable, } from './proxy-tracker';
-export { parsePath, getValueAtPath, shallowEqual } from './path-utils';
-export { type GetterTrackerState, createGetterTracker, createBlocProxy, hasGetterChanges, isGetter, getDescriptor, setActiveTracker, clearActiveTracker, getActiveTracker, commitTrackedGetters, invalidateRenderCache, resetGetterTracker, clearExternalDependencies, getGetterExecutionContext, } from './getter-tracker';
-//# sourceMappingURL=index.d.ts.map

package/dist/tracking/path-utils.d.ts

@@ -1,39 +0,0 @@
-/**
- * Path utilities for dependency tracking
- *
- * Provides utilities for parsing property paths and extracting values
- * from nested objects using path strings.
- */
-/**
- * Parse a property path string into an array of segments
- *
- * Handles both dot notation (a.b.c) and bracket notation (a[0].b)
- *
- * @example
- * parsePath('user.name') // ['user', 'name']
- * parsePath('items[0].name') // ['items', '0', 'name']
- * parsePath('data.users[2].address.city') // ['data', 'users', '2', 'address', 'city']
- */
-export declare function parsePath(path: string): string[];
-/**
- * Get a value from an object using a path of segments
- *
- * @example
- * const obj = { user: { name: 'Alice', age: 30 } }
- * getValueAtPath(obj, ['user', 'name']) // 'Alice'
- * getValueAtPath(obj, ['user', 'age']) // 30
- * getValueAtPath(obj, ['user', 'missing']) // undefined
- */
-export declare function getValueAtPath(obj: any, segments: string[]): any;
-/**
- * Shallow equality comparison for arrays
- *
- * Compares two arrays element-by-element using Object.is
- *
- * @example
- * shallowEqual([1, 2, 3], [1, 2, 3]) // true
- * shallowEqual([1, 2, 3], [1, 2, 4]) // false
- * shallowEqual([1, 2], [1, 2, 3]) // false
- */
-export declare function shallowEqual(arr1: unknown[], arr2: unknown[]): boolean;
-//# sourceMappingURL=path-utils.d.ts.map

package/dist/tracking/proxy-tracker.d.ts

@@ -1,88 +0,0 @@
-/**
- * Functional proxy tracker for automatic dependency tracking
- *
- * This module provides a functional approach to proxy-based dependency tracking.
- * Unlike the class-based ProxyTracker, this uses a state object pattern that's
- * easier to integrate with functional programming patterns and framework hooks.
- */
-/**
- * Check if a value can be proxied
- *
- * Returns true for plain objects and arrays only.
- * Excludes built-in objects like Date, Map, Set, etc.
- */
-export declare function isProxyable(value: unknown): value is object;
-/**
- * State container for proxy tracking
- */
-export interface ProxyTrackerState<T> {
-    /** Set of all tracked property paths */
-    trackedPaths: Set<string>;
-    /** Whether tracking is currently active */
-    isTracking: boolean;
-    /** Cache of created proxies to avoid duplicates */
-    proxyCache: WeakMap<object, any>;
-    /** Cache of bound functions to maintain referential equality */
-    boundFunctionsCache: WeakMap<Function, Function> | null;
-    /** Last state object that was proxied (for cache invalidation) */
-    lastProxiedState: T | null;
-    /** Last proxy created (for cache reuse) */
-    lastProxy: T | null;
-    /** Maximum depth for nested proxy creation */
-    maxDepth: number;
-}
-/**
- * Create a new proxy tracker state
- *
- * @example
- * const state = createProxyTrackerState<MyState>();
- * startProxyTracking(state);
- * const proxy = createProxyForTarget(state, myObject);
- * // ... use proxy ...
- * const paths = stopProxyTracking(state);
- */
-export declare function createProxyTrackerState<T>(): ProxyTrackerState<T>;
-/**
- * Start tracking property accesses
- *
- * Clears previous tracked paths and enables tracking mode.
- */
-export declare function startProxyTracking<T>(state: ProxyTrackerState<T>): void;
-/**
- * Stop tracking and return the tracked paths
- *
- * Returns a new Set containing all tracked paths.
- */
-export declare function stopProxyTracking<T>(state: ProxyTrackerState<T>): Set<string>;
-/**
- * Create a proxy for an array with property access tracking
- *
- * Tracks:
- * - Array element access (arr[0])
- * - Length access (arr.length)
- * - Array method calls (arr.map, arr.filter, etc.)
- */
-export declare function createArrayProxy<T, U>(state: ProxyTrackerState<T>, target: U[], path: string, depth?: number): U[];
-/**
- * Create a proxy for an object with property access tracking
- *
- * This is the core proxy creation function that recursively creates proxies
- * for nested objects and arrays.
- *
- * Tracks:
- * - Property access (obj.prop)
- * - Nested property access (obj.nested.prop)
- * - 'in' operator usage ('prop' in obj)
- * - Object.keys, Object.entries, etc.
- */
-export declare function createProxyInternal<T>(state: ProxyTrackerState<T>, target: T, path?: string, depth?: number): T;
-/**
- * Create a proxy for a target with caching
- *
- * If the target hasn't changed since the last call, returns the cached proxy.
- * Otherwise, creates a new proxy and caches it.
- *
- * This is the main entry point for creating tracked proxies.
- */
-export declare function createProxyForTarget<T>(state: ProxyTrackerState<T>, target: T): T;
-//# sourceMappingURL=proxy-tracker.d.ts.map

package/dist/types/branded.d.ts

@@ -1,9 +0,0 @@
-declare const brand: unique symbol;
-export type Brand<T, B> = T & {
-    [brand]: B;
-};
-export type BrandedId<B> = Brand<string, B>;
-export type InstanceId = Brand<string, 'InstanceId'>;
-export declare function instanceId(id: string): InstanceId;
-export {};
-//# sourceMappingURL=branded.d.ts.map