@blac/core 2.0.15 → 2.0.17

package/dist/resolve-dependencies-DXwMhP0Y.js

@@ -1,878 +0,0 @@
-import {
-  l as BLAC_DEFAULTS,
-  u as BLAC_ERROR_PREFIX,
-} from './StateContainerRegistry-CXnnf2-l.js';
-import { t as getRegistry } from './config-CGo__MAt.js';
-//#region src/tracking/path-utils.ts
-/**
- * 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']
- * ```
- */
-function parsePath(path) {
-  const segments = [];
-  let current = '';
-  let i = 0;
-  while (i < path.length) {
-    const char = path[i];
-    if (char === '.') {
-      if (current) segments.push(current);
-      current = '';
-    } else if (char === '[') {
-      if (current) segments.push(current);
-      current = '';
-      i++;
-      while (i < path.length && path[i] !== ']') current += path[i++];
-      if (current) segments.push(current);
-      current = '';
-    } else current += char;
-    i++;
-  }
-  if (current) segments.push(current);
-  return segments;
-}
-/**
- * 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
- */
-const MISSING = Symbol('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
- */
-function getValueAtPath(obj, segments) {
-  let current = obj;
-  for (let i = 0; i < segments.length; i++) {
-    if (current === null || current === void 0) return MISSING;
-    current = current[segments[i]];
-  }
-  return current;
-}
-/**
- * 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
- */
-function shallowEqual(arr1, arr2) {
-  if (arr1.length !== arr2.length) return false;
-  for (let i = 0; i < arr1.length; i++)
-    if (!Object.is(arr1[i], arr2[i])) return false;
-  return true;
-}
-//#endregion
-//#region src/tracking/tracking-proxy.ts
-/**
- * Consolidated Tracking System
- *
- * This module provides all dependency and getter tracking functionality:
- * - Proxy creation for automatic property access tracking
- * - Dependency path tracking and change detection
- * - Getter execution tracking for computed properties
- * - Combined tracking proxy for watch/waitUntil use cases
- */
-/**
- * Check if a value can be proxied
- * Returns true for plain objects and arrays only.
- * @internal
- */
-function isProxyable(value) {
-  if (typeof value !== 'object' || value === null) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === Array.prototype;
-}
-/**
- * Create a new proxy tracker state
- * @internal
- */
-function createProxyState() {
-  return {
-    trackedPaths: /* @__PURE__ */ new Set(),
-    isTracking: false,
-    proxyCache: /* @__PURE__ */ new WeakMap(),
-    boundFunctionsCache: null,
-    lastProxiedState: null,
-    lastProxy: null,
-    maxDepth: 10,
-  };
-}
-/**
- * Start tracking property accesses
- * @internal
- */
-function startProxy(state) {
-  state.isTracking = true;
-  state.trackedPaths.clear();
-}
-/**
- * Stop tracking and return the tracked paths
- * @internal
- */
-function stopProxy(state) {
-  state.isTracking = false;
-  const paths = state.trackedPaths;
-  state.trackedPaths = /* @__PURE__ */ new Set();
-  return paths;
-}
-/**
- * Cache (or create + cache) a function keyed by (target, fn). The cached
- * value is whatever `factory()` returns the first time the pair is seen.
- *
- * Used for both:
- *   - plain bound copies (see `getBoundFunction`)
- *   - custom wrappers (e.g. iterating-array-method wrappers in
- *     `createArrayProxy`) that need stable identity across renders
- * @internal
- */
-function getOrCacheBound(state, target, fn, factory) {
-  if (!state.boundFunctionsCache)
-    state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
-  let perTarget = state.boundFunctionsCache.get(target);
-  if (!perTarget) {
-    perTarget = /* @__PURE__ */ new WeakMap();
-    state.boundFunctionsCache.set(target, perTarget);
-  }
-  const cached = perTarget.get(fn);
-  if (cached) return cached;
-  const made = factory();
-  perTarget.set(fn, made);
-  return made;
-}
-/**
- * Return a bound copy of `fn` keyed by (target, fn) so that the same
- * prototype method (e.g. Array.prototype.map) bound to different targets
- * produces different cached values.
- * @internal
- */
-function getBoundFunction(state, target, fn) {
-  return getOrCacheBound(state, target, fn, () => fn.bind(target));
-}
-/**
- * Array methods whose callback we wrap so each item is proxied at its
- * own per-index path. Excludes mutators, derived-array returners, and
- * the iterator-returning helpers (handled elsewhere).
- * @internal
- */
-const ITERATING_METHODS = new Set([
-  'forEach',
-  'map',
-  'filter',
-  'find',
-  'findIndex',
-  'findLast',
-  'findLastIndex',
-  'some',
-  'every',
-  'flatMap',
-]);
-/**
- * Array folding methods whose callback has the reduce signature
- * (acc, item, index, arr) => acc. Items are proxied; accumulator passes raw.
- * @internal
- */
-const REDUCING_METHODS = new Set(['reduce', 'reduceRight']);
-/**
- * Create a proxy for an array with property access tracking
- * @internal
- */
-function createArrayProxy(state, target, path, depth = 0) {
-  let proxyRef;
-  function makeIteratingWrapper(methodName) {
-    const realMethod = Array.prototype[methodName];
-    return function (callback, thisArg) {
-      return realMethod.call(target, (item, index) => {
-        const indexPath = path ? `${path}[${index}]` : `[${index}]`;
-        if (state.isTracking) state.trackedPaths.add(indexPath);
-        const proxiedItem = isProxyable(item)
-          ? createInternal(state, item, indexPath, depth + 1)
-          : item;
-        return callback.call(thisArg, proxiedItem, index, proxyRef);
-      });
-    };
-  }
-  /**
-   * Iterator-returning array methods whose yielded items need to be proxied.
-   * `keys()` is excluded — it yields numeric indices (primitives, no proxying needed).
-   */
-  const ITERATOR_METHODS = new Set(['values', 'entries']);
-  function makeIteratorMethod(methodName) {
-    return function () {
-      return (function* () {
-        const len = target.length;
-        if (state.isTracking && path) state.trackedPaths.add(`${path}.length`);
-        for (let i = 0; i < len; i++) {
-          const indexPath = path ? `${path}[${i}]` : `[${i}]`;
-          if (state.isTracking) state.trackedPaths.add(indexPath);
-          const item = target[i];
-          const proxied = isProxyable(item)
-            ? createInternal(state, item, indexPath, depth + 1)
-            : item;
-          if (methodName === 'entries') yield [i, proxied];
-          else yield proxied;
-        }
-      })();
-    };
-  }
-  function makeReducingWrapper(methodName) {
-    const realMethod = Array.prototype[methodName];
-    return function (callback, ...rest) {
-      const wrapped = (acc, item, index) => {
-        const indexPath = path ? `${path}[${index}]` : `[${index}]`;
-        if (state.isTracking) state.trackedPaths.add(indexPath);
-        return callback(
-          acc,
-          isProxyable(item)
-            ? createInternal(state, item, indexPath, depth + 1)
-            : item,
-          index,
-          proxyRef,
-        );
-      };
-      return rest.length > 0
-        ? realMethod.call(target, wrapped, rest[0])
-        : realMethod.call(target, wrapped);
-    };
-  }
-  const proxy = new Proxy(target, {
-    get: (arr, prop) => {
-      if (prop === Symbol.iterator)
-        return function* () {
-          const len = arr.length;
-          if (state.isTracking && path)
-            state.trackedPaths.add(`${path}.length`);
-          for (let i = 0; i < len; i++) {
-            const indexPath = path ? `${path}[${i}]` : `[${i}]`;
-            if (state.isTracking) state.trackedPaths.add(indexPath);
-            const item = arr[i];
-            yield isProxyable(item)
-              ? createInternal(state, item, indexPath, depth + 1)
-              : item;
-          }
-        };
-      if (typeof prop === 'symbol') return Reflect.get(arr, prop);
-      const value = Reflect.get(arr, prop);
-      if (typeof value === 'function') {
-        if (typeof prop === 'string' && ITERATING_METHODS.has(prop))
-          return getOrCacheBound(state, arr, value, () =>
-            makeIteratingWrapper(prop),
-          );
-        if (typeof prop === 'string' && REDUCING_METHODS.has(prop))
-          return getOrCacheBound(state, arr, value, () =>
-            makeReducingWrapper(prop),
-          );
-        if (typeof prop === 'string' && ITERATOR_METHODS.has(prop))
-          return getOrCacheBound(state, arr, value, () =>
-            makeIteratorMethod(prop),
-          );
-        return getBoundFunction(state, arr, value);
-      }
-      if (prop === 'length') {
-        if (state.isTracking) {
-          const fullPath = path ? `${path}.length` : 'length';
-          state.trackedPaths.add(fullPath);
-        }
-        return value;
-      }
-      let fullPath;
-      if (typeof prop === 'string') {
-        const index = Number(prop);
-        if (!isNaN(index) && index >= 0)
-          fullPath = path ? `${path}[${index}]` : `[${index}]`;
-        else fullPath = path ? `${path}.${prop}` : prop;
-      } else return value;
-      if (state.isTracking) state.trackedPaths.add(fullPath);
-      if (isProxyable(value))
-        return createInternal(state, value, fullPath, depth + 1);
-      return value;
-    },
-  });
-  proxyRef = proxy;
-  state.proxyCache.set(target, proxy);
-  return proxy;
-}
-/**
- * Create a proxy for an object with property access tracking
- * @internal
- */
-function createInternal(state, target, path = '', depth = 0) {
-  if (!state.isTracking || !isProxyable(target)) return target;
-  if (depth >= state.maxDepth) {
-    console.warn(
-      `${BLAC_ERROR_PREFIX} Proxy depth limit (${state.maxDepth}) reached at path "${path}". Deeper property accesses won't be tracked for re-renders.`,
-    );
-    return target;
-  }
-  if (state.proxyCache.has(target)) return state.proxyCache.get(target);
-  if (Array.isArray(target))
-    return createArrayProxy(state, target, path, depth);
-  const proxy = new Proxy(target, {
-    get: (obj, prop) => {
-      if (typeof prop === 'symbol') return Reflect.get(obj, prop);
-      const value = Reflect.get(obj, prop);
-      if (typeof value === 'function')
-        return getBoundFunction(state, obj, value);
-      const fullPath = path ? `${path}.${String(prop)}` : String(prop);
-      if (typeof prop === 'string' && state.isTracking) {
-        if (!prop.startsWith('_') && !prop.startsWith('$$'))
-          state.trackedPaths.add(fullPath);
-      }
-      if (isProxyable(value))
-        return createInternal(state, value, fullPath, depth + 1);
-      return value;
-    },
-    has: (obj, prop) => {
-      if (typeof prop === 'string' && state.isTracking) {
-        const fullPath = path ? `${path}.${prop}` : prop;
-        state.trackedPaths.add(fullPath);
-      }
-      return Reflect.has(obj, prop);
-    },
-    ownKeys: (obj) => {
-      if (state.isTracking && path) state.trackedPaths.add(path);
-      return Reflect.ownKeys(obj);
-    },
-  });
-  state.proxyCache.set(target, proxy);
-  return proxy;
-}
-/**
- * Create a proxy for a target with caching
- * @internal
- */
-function createForTarget(state, target) {
-  if (state.lastProxiedState === target && state.lastProxy)
-    return state.lastProxy;
-  state.proxyCache = /* @__PURE__ */ new WeakMap();
-  state.boundFunctionsCache = null;
-  const proxy = createInternal(state, target, '', 0);
-  state.lastProxiedState = target;
-  state.lastProxy = proxy;
-  return proxy;
-}
-function isChildPath(child, parent) {
-  if (child === parent) return false;
-  return child.startsWith(parent + '.') || child.startsWith(parent + '[');
-}
-/**
- * @internal
- */
-function optimizeTrackedPaths(paths) {
-  if (paths.size <= 1) return paths;
-  let allFlat = true;
-  for (const path of paths)
-    if (path.charCodeAt(path.length - 1) === 93 || path.includes('.')) {
-      allFlat = false;
-      break;
-    }
-  if (allFlat) return paths;
-  const sortedPaths = Array.from(paths).sort((a, b) =>
-    a > b ? -1 : a < b ? 1 : 0,
-  );
-  const optimized = /* @__PURE__ */ new Set();
-  let lastKept;
-  for (const path of sortedPaths) {
-    if (lastKept !== void 0 && isChildPath(lastKept, path)) continue;
-    optimized.add(path);
-    lastKept = path;
-  }
-  return optimized;
-}
-/**
- * @internal
- */
-function createDependencyState() {
-  return {
-    proxyState: createProxyState(),
-    previousRenderPaths: /* @__PURE__ */ new Set(),
-    currentRenderPaths: /* @__PURE__ */ new Set(),
-    pathCache: /* @__PURE__ */ new Map(),
-    lastCheckedState: null,
-    lastCheckedValues: /* @__PURE__ */ new Map(),
-  };
-}
-/**
- * @internal
- */
-function startDependency(tracker) {
-  startProxy(tracker.proxyState);
-}
-/**
- * @internal
- */
-function createDependencyProxy(tracker, state) {
-  return createForTarget(tracker.proxyState, state);
-}
-/**
- * @internal
- */
-function capturePaths(tracker, state) {
-  tracker.previousRenderPaths = tracker.currentRenderPaths;
-  tracker.currentRenderPaths = optimizeTrackedPaths(
-    stopProxy(tracker.proxyState),
-  );
-  if (
-    tracker.previousRenderPaths.size === 0 &&
-    tracker.currentRenderPaths.size === 0
-  ) {
-    tracker.pathCache.clear();
-    tracker.lastCheckedValues.clear();
-    return;
-  }
-  const trackedPathsUnion = new Set(tracker.previousRenderPaths);
-  for (const path of tracker.currentRenderPaths) trackedPathsUnion.add(path);
-  if (tracker.pathCache.size > trackedPathsUnion.size) {
-    for (const path of tracker.pathCache.keys())
-      if (!trackedPathsUnion.has(path)) tracker.pathCache.delete(path);
-  }
-  const canReuseCache = tracker.lastCheckedState === state;
-  for (const path of trackedPathsUnion)
-    if (!tracker.pathCache.has(path)) {
-      const segments = parsePath(path);
-      const value =
-        canReuseCache && tracker.lastCheckedValues.has(path)
-          ? tracker.lastCheckedValues.get(path)
-          : getValueAtPath(state, segments);
-      tracker.pathCache.set(path, {
-        segments,
-        value,
-      });
-    } else {
-      const info = tracker.pathCache.get(path);
-      if (!info) continue;
-      info.value =
-        canReuseCache && tracker.lastCheckedValues.has(path)
-          ? tracker.lastCheckedValues.get(path)
-          : getValueAtPath(state, info.segments);
-    }
-  tracker.lastCheckedValues.clear();
-}
-/**
- * @internal
- */
-function hasDependencyChanges(tracker, state) {
-  if (tracker.pathCache.size === 0) return true;
-  tracker.lastCheckedValues.clear();
-  for (const [path, info] of tracker.pathCache.entries()) {
-    const currentValue = getValueAtPath(state, info.segments);
-    tracker.lastCheckedValues.set(path, currentValue);
-    if (!Object.is(currentValue, info.value)) {
-      tracker.lastCheckedState = state;
-      return true;
-    }
-  }
-  tracker.lastCheckedState = state;
-  return false;
-}
-/**
- * @internal
- */
-function hasTrackedData(tracker) {
-  return (
-    tracker.proxyState.trackedPaths.size > 0 ||
-    tracker.pathCache.size > 0 ||
-    tracker.previousRenderPaths.size > 0
-  );
-}
-const descriptorCache = /* @__PURE__ */ new WeakMap();
-const MAX_GETTER_DEPTH = BLAC_DEFAULTS.MAX_GETTER_DEPTH;
-/**
- * @internal
- */
-function getDescriptor(obj, prop) {
-  const constructor = obj.constructor;
-  let constructorCache = descriptorCache.get(constructor);
-  if (constructorCache?.has(prop)) return constructorCache.get(prop);
-  let current = obj;
-  let descriptor;
-  while (current && current !== Object.prototype) {
-    descriptor = Object.getOwnPropertyDescriptor(current, prop);
-    if (descriptor) break;
-    current = Object.getPrototypeOf(current);
-  }
-  if (!constructorCache) {
-    constructorCache = /* @__PURE__ */ new Map();
-    descriptorCache.set(constructor, constructorCache);
-  }
-  constructorCache.set(prop, descriptor);
-  return descriptor;
-}
-/**
- * @internal
- */
-function isGetter(obj, prop) {
-  return getDescriptor(obj, prop)?.get !== void 0;
-}
-/**
- * @internal
- */
-function createGetterState() {
-  return {
-    trackedValues: /* @__PURE__ */ new Map(),
-    currentlyAccessing: /* @__PURE__ */ new Set(),
-    trackedGetters: /* @__PURE__ */ new Set(),
-    isTracking: false,
-    renderCache: /* @__PURE__ */ new Map(),
-    cacheValid: false,
-    depth: 0,
-    visitedBlocs: /* @__PURE__ */ new Set(),
-  };
-}
-/**
- * @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
- */
-function commitTrackedGetters(tracker) {
-  if (tracker.currentlyAccessing.size === 0) return;
-  tracker.trackedGetters = new Set(tracker.currentlyAccessing);
-  tracker.currentlyAccessing.clear();
-}
-/**
- * Execute a tracked getter with depth/circular dependency checks and context management.
- * @internal
- */
-function executeTrackedGetter(target, prop, tracker) {
-  tracker.currentlyAccessing.add(prop);
-  if (tracker.cacheValid && tracker.renderCache.has(prop)) {
-    const cachedValue = tracker.renderCache.get(prop);
-    tracker.trackedValues.set(prop, cachedValue);
-    return cachedValue;
-  }
-  if (tracker.depth >= MAX_GETTER_DEPTH)
-    throw new Error(
-      `${BLAC_ERROR_PREFIX} Maximum getter depth (${MAX_GETTER_DEPTH}) exceeded. Possible circular dependency in getter "${String(prop)}" on ${target.constructor.name}.`,
-    );
-  if (tracker.visitedBlocs.has(target))
-    throw new Error(
-      `${BLAC_ERROR_PREFIX} Circular dependency detected: getter "${String(prop)}" on ${target.constructor.name}.`,
-    );
-  const prevDepth = tracker.depth;
-  const prevVisited = new Set(tracker.visitedBlocs);
-  tracker.depth++;
-  tracker.visitedBlocs.add(target);
-  try {
-    const descriptor = getDescriptor(target, prop);
-    if (!descriptor?.get) return target[prop];
-    const value = descriptor.get.call(target);
-    tracker.trackedValues.set(prop, value);
-    return value;
-  } catch (error) {
-    tracker.currentlyAccessing.delete(prop);
-    throw error;
-  } finally {
-    tracker.depth = prevDepth;
-    tracker.visitedBlocs = prevVisited;
-  }
-}
-/**
- * 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
- */
-function createBlocProxy(bloc, tracker) {
-  return new Proxy(bloc, {
-    get(target, prop, receiver) {
-      if (tracker.isTracking && isGetter(target, prop))
-        return executeTrackedGetter(target, prop, tracker);
-      return Reflect.get(target, prop, receiver);
-    },
-  });
-}
-/**
- * @internal
- */
-function hasGetterChanges(bloc, tracker) {
-  if (!tracker || tracker.trackedGetters.size === 0) return false;
-  tracker.renderCache.clear();
-  let hasAnyChange = false;
-  for (const prop of tracker.trackedGetters)
-    try {
-      const descriptor = getDescriptor(bloc, prop);
-      if (!descriptor?.get) continue;
-      const newValue = descriptor.get.call(bloc);
-      const oldValue = tracker.trackedValues.get(prop);
-      tracker.renderCache.set(prop, newValue);
-      tracker.trackedValues.set(prop, newValue);
-      if (!Object.is(newValue, oldValue)) hasAnyChange = true;
-    } catch (error) {
-      console.warn(
-        `${BLAC_ERROR_PREFIX} Getter "${String(prop)}" threw error during change detection. Stopping tracking for this getter.`,
-        error,
-      );
-      tracker.trackedGetters.delete(prop);
-      tracker.trackedValues.delete(prop);
-      tracker.cacheValid = false;
-      return true;
-    }
-  tracker.cacheValid = true;
-  return hasAnyChange;
-}
-/**
- * @internal
- */
-function invalidateRenderCache(tracker) {
-  tracker.cacheValid = false;
-}
-/**
- * Create a new tracking proxy state.
- */
-function createState() {
-  return {
-    dependencyState: createDependencyState(),
-    getterState: createGetterState(),
-    dependencies: /* @__PURE__ */ new Set(),
-    isTracking: false,
-  };
-}
-/**
- * Start tracking on a tracking proxy.
- */
-function startTracking(tracker) {
-  tracker.isTracking = true;
-  tracker.dependencies.clear();
-  tracker.getterState.isTracking = true;
-  startDependency(tracker.dependencyState);
-}
-/**
- * Stop tracking and collect all dependencies.
- */
-function stopTracking(tracker, bloc) {
-  tracker.isTracking = false;
-  tracker.getterState.isTracking = false;
-  capturePaths(tracker.dependencyState, bloc.state);
-  commitTrackedGetters(tracker.getterState);
-  return new Set(tracker.dependencies);
-}
-/**
- * Check if tracked state or getters have changed.
- */
-function hasChanges(tracker, bloc) {
-  invalidateRenderCache(tracker.getterState);
-  const stateChanged = hasDependencyChanges(
-    tracker.dependencyState,
-    bloc.state,
-  );
-  const getterChanged = hasGetterChanges(bloc, tracker.getterState);
-  return stateChanged || getterChanged;
-}
-/**
- * Create a tracking proxy for a bloc instance.
- * Tracks both state property access and getter access.
- */
-function createTrackingProxy(bloc, tracker) {
-  tracker.dependencies.add(bloc);
-  const stateProxyCache = /* @__PURE__ */ new WeakMap();
-  return new Proxy(bloc, {
-    get(target, prop, receiver) {
-      if (prop === 'state') {
-        if (!tracker.isTracking) return target.state;
-        const rawState = target.state;
-        if (rawState === null || typeof rawState !== 'object') return rawState;
-        if (stateProxyCache.has(rawState)) return stateProxyCache.get(rawState);
-        const stateProxy = createDependencyProxy(
-          tracker.dependencyState,
-          rawState,
-        );
-        stateProxyCache.set(rawState, stateProxy);
-        return stateProxy;
-      }
-      if (typeof prop === 'symbol') return Reflect.get(target, prop, receiver);
-      const value = Reflect.get(target, prop, receiver);
-      if (typeof value === 'function') return value.bind(target);
-      if (tracker.isTracking && isGetter(target, prop))
-        return executeTrackedGetter(target, prop, tracker.getterState);
-      return value;
-    },
-  });
-}
-//#endregion
-//#region src/tracking/dependency-manager.ts
-/**
- * Manages subscriptions to state container dependencies.
- * Provides efficient sync mechanism to add/remove subscriptions
- * as dependencies change between callback invocations.
- */
-var DependencyManager = class {
-  constructor() {
-    this.subscriptions = /* @__PURE__ */ new Map();
-    this.currentDeps = /* @__PURE__ */ new Set();
-  }
-  /**
-   * 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, onChange, exclude) {
-    const filteredNewDeps = /* @__PURE__ */ new Set();
-    for (const dep of newDeps)
-      if (dep !== exclude && !dep.isDisposed) filteredNewDeps.add(dep);
-    if (this.areSetsEqual(this.currentDeps, filteredNewDeps)) return false;
-    for (const dep of this.currentDeps)
-      if (!filteredNewDeps.has(dep)) {
-        const unsub = this.subscriptions.get(dep);
-        if (unsub) {
-          unsub();
-          this.subscriptions.delete(dep);
-        }
-      }
-    for (const dep of filteredNewDeps)
-      if (!this.currentDeps.has(dep) && !this.subscriptions.has(dep)) {
-        const unsub = dep.subscribe(onChange);
-        this.subscriptions.set(dep, unsub);
-      }
-    this.currentDeps = filteredNewDeps;
-    return true;
-  }
-  /**
-   * Add a single dependency subscription.
-   */
-  add(dep, onChange) {
-    if (this.subscriptions.has(dep) || dep.isDisposed) return;
-    const unsub = dep.subscribe(onChange);
-    this.subscriptions.set(dep, unsub);
-    this.currentDeps.add(dep);
-  }
-  /**
-   * Check if a dependency is currently subscribed.
-   */
-  has(dep) {
-    return this.currentDeps.has(dep);
-  }
-  /**
-   * Get the current set of dependencies.
-   */
-  getDependencies() {
-    return new Set(this.currentDeps);
-  }
-  /**
-   * Clean up all active subscriptions.
-   */
-  cleanup() {
-    for (const unsub of this.subscriptions.values()) unsub();
-    this.subscriptions.clear();
-    this.currentDeps.clear();
-  }
-  areSetsEqual(a, b) {
-    if (a.size !== b.size) return false;
-    for (const item of a) if (!b.has(item)) return false;
-    return true;
-  }
-};
-//#endregion
-//#region src/tracking/resolve-dependencies.ts
-/**
- * Resolve all transitive dependencies of a bloc via BFS over `dependencies` maps.
- * Uses cycle detection to avoid infinite loops.
- * @internal
- */
-function resolveDependencies(bloc) {
-  const result = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Map();
-  const queue = [bloc];
-  let head = 0;
-  while (head < queue.length) {
-    const current = queue[head++];
-    for (const [Type, key] of current.dependencies) {
-      let keys = visited.get(Type);
-      if (!keys) {
-        keys = /* @__PURE__ */ new Set();
-        visited.set(Type, keys);
-      }
-      if (keys.has(key)) continue;
-      keys.add(key);
-      const dep = getRegistry().ensure(Type, key);
-      result.add(dep);
-      if (dep.dependencies.size > 0) queue.push(dep);
-    }
-  }
-  result.delete(bloc);
-  return result;
-}
-//#endregion
-export {
-  startTracking as _,
-  createBlocProxy as a,
-  createGetterState as c,
-  hasChanges as d,
-  hasDependencyChanges as f,
-  startDependency as g,
-  invalidateRenderCache as h,
-  commitTrackedGetters as i,
-  createState as l,
-  hasTrackedData as m,
-  DependencyManager as n,
-  createDependencyProxy as o,
-  hasGetterChanges as p,
-  capturePaths as r,
-  createDependencyState as s,
-  resolveDependencies as t,
-  createTrackingProxy as u,
-  stopTracking as v,
-  shallowEqual as y,
-};
-
-//# sourceMappingURL=resolve-dependencies-DXwMhP0Y.js.map