@blac/core 2.0.14 → 2.0.16

package/dist/tracked-zAgmKIlC.js

@@ -1,212 +0,0 @@
-import { l as BLAC_DEFAULTS } from './StateContainerRegistry-WznfcA-Q.js';
-import { t as ensure } from './ensure-Dcfptl-A.js';
-import {
-  _ as startTracking,
-  d as hasChanges,
-  l as createState,
-  n as DependencyManager,
-  t as resolveDependencies,
-  u as createTrackingProxy,
-  v as stopTracking,
-} from './resolve-dependencies-DbRWlt9u.js';
-//#region src/watch/watch.ts
-const STOP = Symbol('watch.STOP');
-const BLOC_REF_MARKER = Symbol('BlocRef');
-/**
- * Create a reference to a specific bloc instance.
- *
- * @example
- * ```ts
- * watch(instance(UserBloc, 'user-123'), (userBloc) => {
- *   console.log(userBloc.state.name);
- * });
- * ```
- */
-function instance(BlocClass, instanceId) {
-  return {
-    [BLOC_REF_MARKER]: true,
-    blocClass: BlocClass,
-    instanceId,
-  };
-}
-function isBlocRef(input) {
-  return (
-    typeof input === 'object' && input !== null && BLOC_REF_MARKER in input
-  );
-}
-function resolveBloc(input) {
-  if (isBlocRef(input)) return ensure(input.blocClass, input.instanceId);
-  return ensure(input, BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY);
-}
-function isArray(input) {
-  return Array.isArray(input);
-}
-function watchImpl(blocsOrBloc, callback) {
-  const isSingle = !isArray(blocsOrBloc);
-  const instances = (isSingle ? [blocsOrBloc] : blocsOrBloc).map(resolveBloc);
-  const tracker = createState();
-  const proxiedInstances = instances.map((inst) =>
-    createTrackingProxy(inst, tracker),
-  );
-  const externalDepsManager = new DependencyManager();
-  let disposed = false;
-  let isRunning = false;
-  let pendingRerun = false;
-  const primarySubscriptions = [];
-  const cleanup = () => {
-    if (disposed) return;
-    disposed = true;
-    primarySubscriptions.forEach((unsub) => unsub());
-    externalDepsManager.cleanup();
-  };
-  const runCallback = () => {
-    if (disposed) return;
-    if (isRunning) {
-      pendingRerun = true;
-      return;
-    }
-    isRunning = true;
-    startTracking(tracker);
-    let result;
-    try {
-      result = callback(isSingle ? proxiedInstances[0] : proxiedInstances);
-    } finally {
-      const externalDeps = /* @__PURE__ */ new Set();
-      for (const inst of instances) {
-        const deps = stopTracking(tracker, inst);
-        for (const dep of deps) externalDeps.add(dep);
-        for (const dep of resolveDependencies(inst)) externalDeps.add(dep);
-      }
-      for (const inst of instances) externalDeps.delete(inst);
-      externalDepsManager.sync(externalDeps, runCallback);
-      isRunning = false;
-    }
-    if (result === STOP) {
-      cleanup();
-      return;
-    }
-    if (pendingRerun) {
-      pendingRerun = false;
-      runCallback();
-    }
-  };
-  const onChange = () => {
-    if (disposed) return;
-    runCallback();
-  };
-  for (const inst of instances)
-    primarySubscriptions.push(inst.subscribe(onChange));
-  runCallback();
-  return cleanup;
-}
-const watch = Object.assign(watchImpl, { STOP });
-//#endregion
-//#region src/tracking/tracked.ts
-/**
- * Run a callback while tracking all bloc dependencies accessed.
- * Returns both the result and the set of discovered dependencies.
- *
- * @example
- * ```ts
- * const { result, dependencies } = tracked(() => {
- *   const user = ensure(UserBloc);
- *   return user.fullName; // getter that may access other blocs
- * });
- * // dependencies contains UserBloc + any blocs accessed in fullName getter
- * ```
- */
-function tracked(callback, options) {
-  const tracker = createState();
-  startTracking(tracker);
-  let result;
-  try {
-    result = callback();
-  } finally {
-    stopTracking(tracker, { state: null });
-  }
-  const dependencies = new Set(tracker.dependencies);
-  if (options?.exclude) dependencies.delete(options.exclude);
-  return {
-    result,
-    dependencies,
-  };
-}
-/**
- * Context for running tracked callbacks with bloc proxies.
- * Provides methods to create proxies and check for changes.
- */
-var TrackedContext = class {
-  constructor() {
-    this.proxiedBlocs = /* @__PURE__ */ new WeakMap();
-    this.primaryBlocs = /* @__PURE__ */ new Set();
-    this.tracker = createState();
-  }
-  /**
-   * Get a tracking proxy for a bloc instance.
-   * The proxy will track state and getter accesses.
-   */
-  proxy(bloc) {
-    const cached = this.proxiedBlocs.get(bloc);
-    if (cached) return cached;
-    const proxied = createTrackingProxy(bloc, this.tracker);
-    this.proxiedBlocs.set(bloc, proxied);
-    this.primaryBlocs.add(bloc);
-    return proxied;
-  }
-  /**
-   * Start tracking for a new callback execution.
-   */
-  start() {
-    startTracking(this.tracker);
-  }
-  /**
-   * Stop tracking and get discovered dependencies.
-   * Excludes primary blocs (those explicitly proxied via proxy()).
-   */
-  stop() {
-    const allDeps = /* @__PURE__ */ new Set();
-    for (const bloc of this.primaryBlocs) {
-      const deps = stopTracking(this.tracker, bloc);
-      for (const dep of deps) if (!this.primaryBlocs.has(dep)) allDeps.add(dep);
-    }
-    return allDeps;
-  }
-  /**
-   * Check if any tracked state or getters have changed.
-   */
-  changed() {
-    for (const bloc of this.primaryBlocs)
-      if (hasChanges(this.tracker, bloc)) return true;
-    return false;
-  }
-  /**
-   * Get all primary blocs (those explicitly proxied).
-   */
-  getPrimaryBlocs() {
-    return new Set(this.primaryBlocs);
-  }
-  /**
-   * Reset the context for reuse.
-   */
-  reset() {
-    this.tracker = createState();
-    this.proxiedBlocs = /* @__PURE__ */ new WeakMap();
-    this.primaryBlocs.clear();
-  }
-};
-/**
- * Create a new tracked context for manual control over tracking.
- */
-function createTrackedContext() {
-  return new TrackedContext();
-}
-//#endregion
-export {
-  watch as a,
-  instance as i,
-  createTrackedContext as n,
-  tracked as r,
-  TrackedContext as t,
-};
-
-//# sourceMappingURL=tracked-zAgmKIlC.js.map

package/dist/tracked-zAgmKIlC.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tracked-zAgmKIlC.js","names":[],"sources":["../src/watch/watch.ts","../src/tracking/tracked.ts"],"sourcesContent":["import { ensure } from '../registry';\nimport type {\n  StateContainerConstructor,\n  StateContainerInstance,\n} from '../types/utilities';\nimport { BLAC_DEFAULTS } from '../constants';\nimport {\n  createState,\n  startTracking,\n  stopTracking,\n  createTrackingProxy,\n  type TrackingProxyState,\n} from '../tracking/tracking-proxy';\nimport { DependencyManager } from '../tracking/dependency-manager';\nimport { resolveDependencies } from '../tracking/resolve-dependencies';\n\nconst STOP: unique symbol = Symbol('watch.STOP');\n\nconst BLOC_REF_MARKER = Symbol('BlocRef');\n\n/**\n * Reference to a specific bloc instance by class and instance ID.\n */\nexport interface BlocRef<T extends StateContainerConstructor> {\n  [BLOC_REF_MARKER]: true;\n  blocClass: T;\n  instanceId: string;\n}\n\n/**\n * Create a reference to a specific bloc instance.\n *\n * @example\n * ```ts\n * watch(instance(UserBloc, 'user-123'), (userBloc) => {\n *   console.log(userBloc.state.name);\n * });\n * ```\n */\nexport function instance<T extends StateContainerConstructor>(\n  BlocClass: T,\n  instanceId: string,\n): BlocRef<T> {\n  return {\n    [BLOC_REF_MARKER]: true,\n    blocClass: BlocClass,\n    instanceId,\n  };\n}\n\nfunction isBlocRef(\n  input: unknown,\n): input is BlocRef<StateContainerConstructor> {\n  return (\n    typeof input === 'object' && input !== null && BLOC_REF_MARKER in input\n  );\n}\n\ntype BlocInput = StateContainerConstructor | BlocRef<StateContainerConstructor>;\n\ntype ExtractInstance<T> =\n  T extends BlocRef<infer C>\n    ? InstanceType<C>\n    : T extends StateContainerConstructor\n      ? InstanceType<T>\n      : never;\n\ntype ExtractInstances<T extends readonly BlocInput[]> = {\n  [K in keyof T]: ExtractInstance<T[K]>;\n};\n\ntype StopSymbol = typeof STOP;\n\n/**\n * Watch function signature for single bloc.\n */\nexport interface WatchSingleFn {\n  <T extends StateContainerConstructor>(\n    bloc: T | BlocRef<T>,\n    callback: (bloc: InstanceType<T>) => void | StopSymbol,\n  ): () => void;\n\n  STOP: StopSymbol;\n}\n\n/**\n * Watch function signature for multiple blocs.\n */\nexport interface WatchMultipleFn {\n  <T extends readonly BlocInput[]>(\n    blocs: T,\n    callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n  ): () => void;\n\n  STOP: StopSymbol;\n}\n\n/**\n * Combined watch function type.\n */\nexport interface WatchFn extends WatchSingleFn {\n  <T extends readonly BlocInput[]>(\n    blocs: T,\n    callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n  ): () => void;\n}\n\nfunction resolveBloc(input: BlocInput): StateContainerInstance {\n  if (isBlocRef(input)) {\n    return ensure(input.blocClass, input.instanceId);\n  }\n  return ensure(input, BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY);\n}\n\nfunction isArray(input: unknown): input is readonly BlocInput[] {\n  return Array.isArray(input);\n}\n\n/**\n * Watch one or more blocs for state changes.\n * Automatically tracks state property and getter accesses.\n *\n * @example Single bloc\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   console.log(userBloc.state.name);\n *   console.log(userBloc.fullName); // getter also tracked\n * });\n * ```\n *\n * @example Multiple blocs\n * ```ts\n * const unwatch = watch(\n *   [UserBloc, SettingsBloc] as const,\n *   ([userBloc, settingsBloc]) => {\n *     console.log(userBloc.state.name, settingsBloc.state.theme);\n *   }\n * );\n * ```\n *\n * @example With specific instance\n * ```ts\n * const unwatch = watch(\n *   instance(UserBloc, 'user-123'),\n *   (userBloc) => {\n *     console.log(userBloc.state.name);\n *   }\n * );\n * ```\n *\n * @example Stop watching from callback\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   if (userBloc.state.done) {\n *     return watch.STOP;\n *   }\n * });\n * ```\n */\nfunction watchImpl<T extends StateContainerConstructor>(\n  bloc: T | BlocRef<T>,\n  callback: (bloc: InstanceType<T>) => void | StopSymbol,\n): () => void;\n\nfunction watchImpl<T extends readonly BlocInput[]>(\n  blocs: T,\n  callback: (blocs: ExtractInstances<T>) => void | StopSymbol,\n): () => void;\n\nfunction watchImpl(\n  blocsOrBloc: BlocInput | readonly BlocInput[],\n  callback: (blocsOrBloc: any) => void | StopSymbol,\n): () => void {\n  const isSingle = !isArray(blocsOrBloc);\n  const inputs = isSingle ? [blocsOrBloc] : blocsOrBloc;\n\n  const instances = inputs.map(resolveBloc);\n\n  const tracker: TrackingProxyState = createState();\n  const proxiedInstances = instances.map((inst) =>\n    createTrackingProxy(inst, tracker),\n  );\n\n  const externalDepsManager = new DependencyManager();\n\n  let disposed = false;\n  let isRunning = false;\n  let pendingRerun = false;\n  const primarySubscriptions: (() => void)[] = [];\n\n  const cleanup = () => {\n    if (disposed) return;\n    disposed = true;\n    primarySubscriptions.forEach((unsub) => unsub());\n    externalDepsManager.cleanup();\n  };\n\n  const runCallback = () => {\n    if (disposed) return;\n\n    if (isRunning) {\n      pendingRerun = true;\n      return;\n    }\n    isRunning = true;\n\n    startTracking(tracker);\n\n    let result: void | StopSymbol;\n    try {\n      const arg = isSingle ? proxiedInstances[0] : proxiedInstances;\n      result = callback(arg);\n    } finally {\n      const externalDeps = new Set<StateContainerInstance>();\n      for (const inst of instances) {\n        const deps = stopTracking(tracker, inst);\n        for (const dep of deps) {\n          externalDeps.add(dep);\n        }\n        for (const dep of resolveDependencies(inst)) {\n          externalDeps.add(dep);\n        }\n      }\n\n      for (const inst of instances) {\n        externalDeps.delete(inst);\n      }\n\n      externalDepsManager.sync(externalDeps, runCallback);\n      isRunning = false;\n    }\n\n    if (result === STOP) {\n      cleanup();\n      return;\n    }\n\n    if (pendingRerun) {\n      pendingRerun = false;\n      runCallback();\n    }\n  };\n\n  const onChange = () => {\n    if (disposed) return;\n    runCallback();\n  };\n\n  for (const inst of instances) {\n    primarySubscriptions.push(inst.subscribe(onChange));\n  }\n\n  runCallback();\n\n  return cleanup;\n}\n\nexport const watch: WatchFn = Object.assign(watchImpl, { STOP }) as WatchFn;\n","import type { StateContainerInstance } from '../types/utilities';\nimport {\n  createState,\n  startTracking,\n  stopTracking,\n  createTrackingProxy,\n  hasChanges,\n  type TrackingProxyState,\n} from './tracking-proxy';\nimport { DependencyManager } from './dependency-manager';\n\n/**\n * Result of running a tracked callback.\n */\nexport interface TrackedResult<T> {\n  result: T;\n  dependencies: Set<StateContainerInstance>;\n}\n\n/**\n * Options for the tracked() function.\n */\nexport interface TrackedOptions {\n  exclude?: StateContainerInstance;\n}\n\n/**\n * Run a callback while tracking all bloc dependencies accessed.\n * Returns both the result and the set of discovered dependencies.\n *\n * @example\n * ```ts\n * const { result, dependencies } = tracked(() => {\n *   const user = ensure(UserBloc);\n *   return user.fullName; // getter that may access other blocs\n * });\n * // dependencies contains UserBloc + any blocs accessed in fullName getter\n * ```\n */\nexport function tracked<T>(\n  callback: () => T,\n  options?: TrackedOptions,\n): TrackedResult<T> {\n  const tracker = createState();\n  startTracking(tracker);\n\n  let result: T;\n  try {\n    result = callback();\n  } finally {\n    stopTracking(tracker, { state: null } as any);\n  }\n\n  const dependencies = new Set(tracker.dependencies);\n\n  if (options?.exclude) {\n    dependencies.delete(options.exclude);\n  }\n\n  return { result, dependencies };\n}\n\n/**\n * Context for running tracked callbacks with bloc proxies.\n * Provides methods to create proxies and check for changes.\n */\nexport class TrackedContext {\n  private tracker: TrackingProxyState;\n  private proxiedBlocs = new WeakMap<\n    StateContainerInstance,\n    StateContainerInstance\n  >();\n  private primaryBlocs = new Set<StateContainerInstance>();\n\n  constructor() {\n    this.tracker = createState();\n  }\n\n  /**\n   * Get a tracking proxy for a bloc instance.\n   * The proxy will track state and getter accesses.\n   */\n  proxy<T extends StateContainerInstance>(bloc: T): T {\n    const cached = this.proxiedBlocs.get(bloc);\n    if (cached) {\n      return cached as T;\n    }\n\n    const proxied = createTrackingProxy(bloc, this.tracker);\n    this.proxiedBlocs.set(bloc, proxied);\n    this.primaryBlocs.add(bloc);\n    return proxied;\n  }\n\n  /**\n   * Start tracking for a new callback execution.\n   */\n  start(): void {\n    startTracking(this.tracker);\n  }\n\n  /**\n   * Stop tracking and get discovered dependencies.\n   * Excludes primary blocs (those explicitly proxied via proxy()).\n   */\n  stop(): Set<StateContainerInstance> {\n    const allDeps = new Set<StateContainerInstance>();\n\n    for (const bloc of this.primaryBlocs) {\n      const deps = stopTracking(this.tracker, bloc);\n      for (const dep of deps) {\n        if (!this.primaryBlocs.has(dep)) {\n          allDeps.add(dep);\n        }\n      }\n    }\n\n    return allDeps;\n  }\n\n  /**\n   * Check if any tracked state or getters have changed.\n   */\n  changed(): boolean {\n    for (const bloc of this.primaryBlocs) {\n      if (hasChanges(this.tracker, bloc)) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Get all primary blocs (those explicitly proxied).\n   */\n  getPrimaryBlocs(): Set<StateContainerInstance> {\n    return new Set(this.primaryBlocs);\n  }\n\n  /**\n   * Reset the context for reuse.\n   */\n  reset(): void {\n    this.tracker = createState();\n    this.proxiedBlocs = new WeakMap();\n    this.primaryBlocs.clear();\n  }\n}\n\n/**\n * Create a new tracked context for manual control over tracking.\n */\nexport function createTrackedContext(): TrackedContext {\n  return new TrackedContext();\n}\n\nexport { DependencyManager };\n"],"mappings":"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"}

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

@@ -1,41 +0,0 @@
-import type { StateContainerInstance } from '../types/utilities';
-/**
- * Manages subscriptions to state container dependencies.
- * Provides efficient sync mechanism to add/remove subscriptions
- * as dependencies change between callback invocations.
- */
-export declare class DependencyManager {
-  private subscriptions;
-  private currentDeps;
-  /**
-   * Sync subscriptions with a new set of dependencies.
-   * Adds subscriptions for new deps, removes subscriptions for stale deps.
-   *
-   * @param newDeps - The new set of dependencies to subscribe to
-   * @param onChange - Callback to invoke when any dependency changes
-   * @param exclude - Optional instance to exclude from subscriptions (e.g., primary bloc)
-   * @returns true if the dependency set changed, false if unchanged
-   */
-  sync(
-    newDeps: Set<StateContainerInstance>,
-    onChange: () => void,
-    exclude?: StateContainerInstance,
-  ): boolean;
-  /**
-   * Add a single dependency subscription.
-   */
-  add(dep: StateContainerInstance, onChange: () => void): void;
-  /**
-   * Check if a dependency is currently subscribed.
-   */
-  has(dep: StateContainerInstance): boolean;
-  /**
-   * Get the current set of dependencies.
-   */
-  getDependencies(): Set<StateContainerInstance>;
-  /**
-   * Clean up all active subscriptions.
-   */
-  cleanup(): void;
-  private areSetsEqual;
-}

package/dist/tracking/index.d.ts

@@ -1,28 +0,0 @@
-/**
- * Dependency Tracking
- *
- * Framework-agnostic dependency tracking utilities for automatic reactivity.
- * These utilities are used by framework adapters (React, Vue, Angular, etc.)
- * to track property accesses and detect changes.
- *
- * @packageDocumentation
- */
-export {
-  type DependencyState,
-  type PathInfo,
-  createDependencyState,
-  startDependency,
-  createDependencyProxy,
-  capturePaths,
-  hasDependencyChanges,
-  hasTrackedData,
-  type GetterState,
-  createGetterState,
-  createBlocProxy,
-  hasGetterChanges,
-  commitTrackedGetters,
-  invalidateRenderCache,
-} from './tracking-proxy';
-export { shallowEqual } from './path-utils';
-export { DependencyManager } from './dependency-manager';
-export { resolveDependencies } from './resolve-dependencies';

package/dist/tracking/iteration-perf.bench.d.ts

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

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

@@ -1,69 +0,0 @@
-/**
- * Path utilities for dependency tracking
- *
- * Provides utilities for parsing property paths and extracting values
- * from nested objects using path strings.
- *
- * @internal
- */
-/**
- * Parse a property path string into an array of segments
- *
- * @internal
- *
- * Handles both dot notation (a.b.c) and bracket notation (a[0].b)
- *
- * @example
- * ```ts
- * 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[];
-/**
- * Sentinel value returned by `getValueAtPath` when the path cannot be fully
- * walked because an intermediate segment is null or undefined. This is
- * distinct from `undefined`, which is a legitimate leaf value.
- *
- * @internal
- */
-declare const MISSING: unique symbol;
-export { MISSING as PATH_MISSING };
-/**
- * Get a value from an object using a path of segments
- *
- * Returns `PATH_MISSING` (not `undefined`) when the path cannot be walked
- * because an intermediate parent is null or undefined. This lets callers
- * distinguish "the leaf is explicitly `undefined`" from "the path is broken".
- *
- * @example
- * ```ts
- * const obj = { user: { name: 'Alice', age: 30 } }
- * getValueAtPath(obj, ['user', 'name']) // 'Alice'
- * getValueAtPath(obj, ['user', 'age']) // 30
- * getValueAtPath(obj, ['user', 'missing']) // undefined
- * getValueAtPath({ a: null }, ['a', 'b']) // PATH_MISSING
- * ```
- *
- * @internal
- */
-export declare function getValueAtPath(
-  obj: unknown,
-  segments: string[],
-): unknown;
-/**
- * Shallow equality comparison for arrays
- *
- * Compares two arrays element-by-element using Object.is
- *
- * @example
- * ```ts
- * shallowEqual([1, 2, 3], [1, 2, 3]) // true
- * shallowEqual([1, 2, 3], [1, 2, 4]) // false
- * shallowEqual([1, 2], [1, 2, 3]) // false
- * ```
- *
- * @internal
- */
-export declare function shallowEqual(arr1: unknown[], arr2: unknown[]): boolean;

package/dist/tracking/resolve-dependencies.d.ts

@@ -1,9 +0,0 @@
-import type { StateContainerInstance } from '../types/utilities';
-/**
- * Resolve all transitive dependencies of a bloc via BFS over `dependencies` maps.
- * Uses cycle detection to avoid infinite loops.
- * @internal
- */
-export declare function resolveDependencies(
-  bloc: StateContainerInstance,
-): Set<StateContainerInstance>;

package/dist/tracking/tracked.d.ts

@@ -1,73 +0,0 @@
-import type { StateContainerInstance } from '../types/utilities';
-import { DependencyManager } from './dependency-manager';
-/**
- * Result of running a tracked callback.
- */
-export interface TrackedResult<T> {
-  result: T;
-  dependencies: Set<StateContainerInstance>;
-}
-/**
- * Options for the tracked() function.
- */
-export interface TrackedOptions {
-  exclude?: StateContainerInstance;
-}
-/**
- * Run a callback while tracking all bloc dependencies accessed.
- * Returns both the result and the set of discovered dependencies.
- *
- * @example
- * ```ts
- * const { result, dependencies } = tracked(() => {
- *   const user = ensure(UserBloc);
- *   return user.fullName; // getter that may access other blocs
- * });
- * // dependencies contains UserBloc + any blocs accessed in fullName getter
- * ```
- */
-export declare function tracked<T>(
-  callback: () => T,
-  options?: TrackedOptions,
-): TrackedResult<T>;
-/**
- * Context for running tracked callbacks with bloc proxies.
- * Provides methods to create proxies and check for changes.
- */
-export declare class TrackedContext {
-  private tracker;
-  private proxiedBlocs;
-  private primaryBlocs;
-  constructor();
-  /**
-   * Get a tracking proxy for a bloc instance.
-   * The proxy will track state and getter accesses.
-   */
-  proxy<T extends StateContainerInstance>(bloc: T): T;
-  /**
-   * Start tracking for a new callback execution.
-   */
-  start(): void;
-  /**
-   * Stop tracking and get discovered dependencies.
-   * Excludes primary blocs (those explicitly proxied via proxy()).
-   */
-  stop(): Set<StateContainerInstance>;
-  /**
-   * Check if any tracked state or getters have changed.
-   */
-  changed(): boolean;
-  /**
-   * Get all primary blocs (those explicitly proxied).
-   */
-  getPrimaryBlocs(): Set<StateContainerInstance>;
-  /**
-   * Reset the context for reuse.
-   */
-  reset(): void;
-}
-/**
- * Create a new tracked context for manual control over tracking.
- */
-export declare function createTrackedContext(): TrackedContext;
-export { DependencyManager };

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

@@ -1,230 +0,0 @@
-import type { StateContainerInstance } from '../types/utilities';
-/**
- * Check if a value can be proxied
- * Returns true for plain objects and arrays only.
- * @internal
- */
-export declare function isProxyable(value: unknown): value is object;
-/**
- * State container for proxy tracking
- * @internal
- */
-export interface ProxyState<T> {
-  trackedPaths: Set<string>;
-  isTracking: boolean;
-  proxyCache: WeakMap<object, unknown>;
-  boundFunctionsCache: WeakMap<object, WeakMap<Function, Function>> | null;
-  lastProxiedState: T | null;
-  lastProxy: T | null;
-  maxDepth: number;
-}
-/**
- * Create a new proxy tracker state
- * @internal
- */
-export declare function createProxyState<T>(): ProxyState<T>;
-/**
- * Start tracking property accesses
- * @internal
- */
-export declare function startProxy<T>(state: ProxyState<T>): void;
-/**
- * Stop tracking and return the tracked paths
- * @internal
- */
-export declare function stopProxy<T>(state: ProxyState<T>): Set<string>;
-/**
- * Create a proxy for an array with property access tracking
- * @internal
- */
-export declare function createArrayProxy<T, U>(
-  state: ProxyState<T>,
-  target: U[],
-  path: string,
-  depth?: number,
-): U[];
-/**
- * Create a proxy for an object with property access tracking
- * @internal
- */
-export declare function createInternal<T>(
-  state: ProxyState<T>,
-  target: T,
-  path?: string,
-  depth?: number,
-): T;
-/**
- * Create a proxy for a target with caching
- * @internal
- */
-export declare function createForTarget<T>(state: ProxyState<T>, target: T): T;
-/**
- * @internal
- */
-export interface PathInfo {
-  segments: string[];
-  value: unknown;
-}
-/**
- * @internal
- */
-export interface DependencyState<T> {
-  proxyState: ProxyState<T>;
-  previousRenderPaths: Set<string>;
-  currentRenderPaths: Set<string>;
-  pathCache: Map<string, PathInfo>;
-  lastCheckedState: T | null;
-  lastCheckedValues: Map<string, unknown>;
-}
-/**
- * @internal
- */
-export declare function optimizeTrackedPaths(paths: Set<string>): Set<string>;
-/**
- * @internal
- */
-export declare function createDependencyState<T>(): DependencyState<T>;
-/**
- * @internal
- */
-export declare function startDependency<T>(tracker: DependencyState<T>): void;
-/**
- * @internal
- */
-export declare function createDependencyProxy<T>(
-  tracker: DependencyState<T>,
-  state: T,
-): T;
-/**
- * @internal
- */
-export declare function capturePaths<T>(
-  tracker: DependencyState<T>,
-  state: T,
-): void;
-/**
- * @internal
- */
-export declare function hasDependencyChanges<T>(
-  tracker: DependencyState<T>,
-  state: T,
-): boolean;
-/**
- * @internal
- */
-export declare function hasTrackedData<T>(tracker: DependencyState<T>): boolean;
-/**
- * @internal
- */
-export interface GetterState {
-  trackedValues: Map<string | symbol, unknown>;
-  currentlyAccessing: Set<string | symbol>;
-  trackedGetters: Set<string | symbol>;
-  isTracking: boolean;
-  renderCache: Map<string | symbol, unknown>;
-  cacheValid: boolean;
-  depth: number;
-  visitedBlocs: Set<StateContainerInstance>;
-}
-/**
- * @internal
- */
-export declare function getDescriptor(
-  obj: any,
-  prop: string | symbol,
-): PropertyDescriptor | undefined;
-/**
- * @internal
- */
-export declare function isGetter(obj: any, prop: string | symbol): boolean;
-/**
- * @internal
- */
-export declare function createGetterState(): GetterState;
-/**
- * @internal
- */
-/**
- * Commit getters accessed during the active tracking window into the
- * authoritative `trackedGetters` set used by change-detection.
- *
- * When `currentlyAccessing` is empty (e.g. React StrictMode firing
- * `useEffect` setup → cleanup → setup for one logical render, where the
- * second setup runs with no intervening render and therefore no accesses)
- * we deliberately preserve the previous commit's `trackedGetters`. This
- * keeps consumer subscriptions stable across StrictMode double-invocation.
- *
- * The next legitimate render that records accesses replaces the set in full;
- * components that conditionally drop a getter incur at most one extra
- * re-render before `trackedGetters` self-corrects on the subsequent commit.
- *
- * @internal
- */
-export declare function commitTrackedGetters(tracker: GetterState): void;
-/**
- * Create a per-consumer bloc proxy that closes over its own getter tracker.
- *
- * Each useBloc consumer owns its own proxy and tracker, eliminating the
- * cross-component contamination that a shared module-level tracker map
- * caused under interleaved/concurrent rendering.
- *
- * @internal
- */
-export declare function createBlocProxy<TBloc extends StateContainerInstance>(
-  bloc: TBloc,
-  tracker: GetterState,
-): TBloc;
-/**
- * @internal
- */
-export declare function hasGetterChanges<TBloc extends StateContainerInstance>(
-  bloc: TBloc,
-  tracker: GetterState | null,
-): boolean;
-/**
- * @internal
- */
-export declare function invalidateRenderCache(tracker: GetterState): void;
-/**
- * @internal
- */
-export declare function resetGetterState(tracker: GetterState): void;
-/**
- * State for tracking both state property access and getter access.
- */
-export interface TrackingProxyState {
-  dependencyState: DependencyState<any>;
-  getterState: GetterState;
-  dependencies: Set<StateContainerInstance>;
-  isTracking: boolean;
-}
-/**
- * Create a new tracking proxy state.
- */
-export declare function createState(): TrackingProxyState;
-/**
- * Start tracking on a tracking proxy.
- */
-export declare function startTracking(tracker: TrackingProxyState): void;
-/**
- * Stop tracking and collect all dependencies.
- */
-export declare function stopTracking(
-  tracker: TrackingProxyState,
-  bloc: StateContainerInstance,
-): Set<StateContainerInstance>;
-/**
- * Check if tracked state or getters have changed.
- */
-export declare function hasChanges(
-  tracker: TrackingProxyState,
-  bloc: StateContainerInstance,
-): boolean;
-/**
- * Create a tracking proxy for a bloc instance.
- * Tracks both state property access and getter access.
- */
-export declare function createTrackingProxy<T extends StateContainerInstance>(
-  bloc: T,
-  tracker: TrackingProxyState,
-): T;