@blac/core 2.0.13 → 2.0.15

package/dist/resolve-dependencies-DV3HO_uH.js

@@ -0,0 +1,878 @@
+import {
+  l as BLAC_DEFAULTS,
+  u as BLAC_ERROR_PREFIX,
+} from './StateContainerRegistry-BqS-wpb_.js';
+import { t as getRegistry } from './config-Cd7Q-B4g.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-DV3HO_uH.js.map