@blac/core 2.0.12 → 2.0.14

package/dist/resolve-dependencies-f-QUqYiL.js

@@ -1,649 +1,731 @@
-import { a as BLAC_DEFAULTS, o as BLAC_ERROR_PREFIX } from "./StateContainerRegistry-BhcnG0DF.js";
-import { t as getRegistry } from "./config-D4GifZQ4.js";
+import {
+  a as BLAC_DEFAULTS,
+  o as BLAC_ERROR_PREFIX,
+} from './StateContainerRegistry-BhcnG0DF.js';
+import { t as getRegistry } from './config-D4GifZQ4.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']
-* ```
-*/
+ * 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;
-}
-/**
-* Get a value from an object using a path of segments
-*
-* @example
-* ```ts
-* const obj = { user: { name: 'Alice', age: 30 } }
-* getValueAtPath(obj, ['user', 'name']) // 'Alice'
-* getValueAtPath(obj, ['user', 'age']) // 30
-* getValueAtPath(obj, ['user', 'missing']) // undefined
-* ```
-*
-* @internal
-*/
+  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;
+}
+/**
+ * Get a value from an object using a path of segments
+ *
+ * @example
+ * ```ts
+ * const obj = { user: { name: 'Alice', age: 30 } }
+ * getValueAtPath(obj, ['user', 'name']) // 'Alice'
+ * getValueAtPath(obj, ['user', 'age']) // 30
+ * getValueAtPath(obj, ['user', 'missing']) // undefined
+ * ```
+ *
+ * @internal
+ */
 function getValueAtPath(obj, segments) {
-	if (obj == null) return void 0;
-	let current = obj;
-	for (let i = 0; i < segments.length; i++) {
-		current = current[segments[i]];
-		if (current == null) return void 0;
-	}
-	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
-*/
+  if (obj == null) return void 0;
+  let current = obj;
+  for (let i = 0; i < segments.length; i++) {
+    current = current[segments[i]];
+    if (current == null) return void 0;
+  }
+  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;
+  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
-*/
+ * 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;
+  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
-*/
+ * 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
-*/
+  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();
+  state.isTracking = true;
+  state.trackedPaths.clear();
 }
 /**
-* Stop tracking and return the tracked paths
-* @internal
-*/
+ * Stop tracking and return the tracked paths
+ * @internal
+ */
 function stopProxy(state) {
-	state.isTracking = false;
-	return new Set(state.trackedPaths);
+  state.isTracking = false;
+  return new Set(state.trackedPaths);
 }
 /**
-* Create a proxy for an array with property access tracking
-* @internal
-*/
+ * Create a proxy for an array with property access tracking
+ * @internal
+ */
 function createArrayProxy(state, target, path, depth = 0) {
-	const proxy = new Proxy(target, { get: (arr, prop) => {
-		if (typeof prop === "symbol") return Reflect.get(arr, prop);
-		const value = Reflect.get(arr, prop);
-		if (typeof value === "function") {
-			if (!state.boundFunctionsCache) state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
-			const cached = state.boundFunctionsCache.get(value);
-			if (cached) return cached;
-			const bound = value.bind(arr);
-			state.boundFunctionsCache.set(value, bound);
-			return bound;
-		}
-		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 (isProxyable(value)) return createInternal(state, value, fullPath, depth + 1);
-		if (state.isTracking) state.trackedPaths.add(fullPath);
-		return value;
-	} });
-	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") {
-				if (!state.boundFunctionsCache) state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
-				const cached = state.boundFunctionsCache.get(value);
-				if (cached) return cached;
-				const bound = value.bind(obj);
-				state.boundFunctionsCache.set(value, bound);
-				return bound;
-			}
-			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
-*/
+  const proxy = new Proxy(target, {
+    get: (arr, prop) => {
+      if (typeof prop === 'symbol') return Reflect.get(arr, prop);
+      const value = Reflect.get(arr, prop);
+      if (typeof value === 'function') {
+        if (!state.boundFunctionsCache)
+          state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
+        const cached = state.boundFunctionsCache.get(value);
+        if (cached) return cached;
+        const bound = value.bind(arr);
+        state.boundFunctionsCache.set(value, bound);
+        return bound;
+      }
+      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 (isProxyable(value))
+        return createInternal(state, value, fullPath, depth + 1);
+      if (state.isTracking) state.trackedPaths.add(fullPath);
+      return value;
+    },
+  });
+  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') {
+        if (!state.boundFunctionsCache)
+          state.boundFunctionsCache = /* @__PURE__ */ new WeakMap();
+        const cached = state.boundFunctionsCache.get(value);
+        if (cached) return cached;
+        const bound = value.bind(obj);
+        state.boundFunctionsCache.set(value, bound);
+        return bound;
+      }
+      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;
+  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 + "[");
+  if (child === parent) return false;
+  return child.startsWith(parent + '.') || child.startsWith(parent + '[');
 }
 function getArrayParentPath(path) {
-	if (path.endsWith(".length")) return path.slice(0, -7);
-	const arrayIndexMatch = path.match(/^(.+?)\[\d+\]/);
-	if (arrayIndexMatch) return arrayIndexMatch[1];
-	return null;
+  if (path.endsWith('.length')) return path.slice(0, -7);
+  const arrayIndexMatch = path.match(/^(.+?)\[\d+\]/);
+  if (arrayIndexMatch) return arrayIndexMatch[1];
+  return null;
 }
 /**
-* @internal
-*/
+ * @internal
+ */
 function optimizeTrackedPaths(paths) {
-	if (paths.size === 0) return /* @__PURE__ */ new Set();
-	if (paths.size === 1) return new Set(paths);
-	const sortedPaths = Array.from(paths).sort((a, b) => b.length - a.length);
-	const optimized = /* @__PURE__ */ new Set();
-	for (const path of sortedPaths) {
-		let hasMoreSpecificChild = false;
-		for (const optimizedPath of optimized) if (isChildPath(optimizedPath, path)) {
-			hasMoreSpecificChild = true;
-			break;
-		}
-		if (!hasMoreSpecificChild) optimized.add(path);
-	}
-	const arrayParents = /* @__PURE__ */ new Set();
-	for (const path of optimized) {
-		const arrayParent = getArrayParentPath(path);
-		if (arrayParent) arrayParents.add(arrayParent);
-	}
-	for (const arrayParent of arrayParents) optimized.add(arrayParent);
-	return optimized;
-}
-/**
-* @internal
-*/
+  if (paths.size === 0) return /* @__PURE__ */ new Set();
+  if (paths.size === 1) return new Set(paths);
+  const sortedPaths = Array.from(paths).sort((a, b) => b.length - a.length);
+  const optimized = /* @__PURE__ */ new Set();
+  for (const path of sortedPaths) {
+    let hasMoreSpecificChild = false;
+    for (const optimizedPath of optimized)
+      if (isChildPath(optimizedPath, path)) {
+        hasMoreSpecificChild = true;
+        break;
+      }
+    if (!hasMoreSpecificChild) optimized.add(path);
+  }
+  const arrayParents = /* @__PURE__ */ new Set();
+  for (const path of optimized) {
+    const arrayParent = getArrayParentPath(path);
+    if (arrayParent) arrayParents.add(arrayParent);
+  }
+  for (const arrayParent of arrayParents) optimized.add(arrayParent);
+  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
-*/
+  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);
+  startProxy(tracker.proxyState);
 }
 /**
-* @internal
-*/
+ * @internal
+ */
 function createDependencyProxy(tracker, state) {
-	return createForTarget(tracker.proxyState, state);
+  return createForTarget(tracker.proxyState, state);
 }
 /**
-* @internal
-*/
+ * @internal
+ */
 function capturePaths(tracker, state) {
-	tracker.previousRenderPaths = tracker.currentRenderPaths;
-	tracker.currentRenderPaths = optimizeTrackedPaths(stopProxy(tracker.proxyState));
-	if (tracker.previousRenderPaths.size === 0 && tracker.currentRenderPaths.size === 0) return;
-	const trackedPathsUnion = new Set(tracker.previousRenderPaths);
-	for (const path of tracker.currentRenderPaths) trackedPathsUnion.add(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
-*/
+  tracker.previousRenderPaths = tracker.currentRenderPaths;
+  tracker.currentRenderPaths = optimizeTrackedPaths(
+    stopProxy(tracker.proxyState),
+  );
+  if (
+    tracker.previousRenderPaths.size === 0 &&
+    tracker.currentRenderPaths.size === 0
+  )
+    return;
+  const trackedPathsUnion = new Set(tracker.previousRenderPaths);
+  for (const path of tracker.currentRenderPaths) trackedPathsUnion.add(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
-*/
+  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;
+  return (
+    tracker.proxyState.trackedPaths.size > 0 ||
+    tracker.pathCache.size > 0 ||
+    tracker.previousRenderPaths.size > 0
+  );
 }
 const descriptorCache = /* @__PURE__ */ new WeakMap();
 const blocProxyCache = /* @__PURE__ */ new WeakMap();
 const activeTrackerMap = /* @__PURE__ */ new WeakMap();
 const MAX_GETTER_DEPTH = BLAC_DEFAULTS.MAX_GETTER_DEPTH;
 /**
-* @internal
-*/
+ * @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
-*/
+  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;
+  return getDescriptor(obj, prop)?.get !== void 0;
 }
 /**
-* @internal
-*/
+ * @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
-*/
+  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
+ */
 function setActiveTracker(bloc, tracker) {
-	activeTrackerMap.set(bloc, tracker);
+  activeTrackerMap.set(bloc, tracker);
 }
 /**
-* @internal
-*/
+ * @internal
+ */
 function clearActiveTracker(bloc) {
-	activeTrackerMap.delete(bloc);
+  activeTrackerMap.delete(bloc);
 }
 /**
-* @internal
-*/
+ * @internal
+ */
 function commitTrackedGetters(tracker) {
-	if (tracker.currentlyAccessing.size > 0) tracker.trackedGetters = new Set(tracker.currentlyAccessing);
-	tracker.currentlyAccessing.clear();
+  if (tracker.currentlyAccessing.size > 0)
+    tracker.trackedGetters = new Set(tracker.currentlyAccessing);
+  tracker.currentlyAccessing.clear();
 }
 /**
-* Execute a tracked getter with depth/circular dependency checks and context management.
-* @internal
-*/
+ * 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;
-	}
-}
-/**
-* @internal
-*/
+  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;
+  }
+}
+/**
+ * @internal
+ */
 function createBlocProxy(bloc) {
-	const cached = blocProxyCache.get(bloc);
-	if (cached) return cached;
-	const proxy = new Proxy(bloc, { get(target, prop, receiver) {
-		const tracker = activeTrackerMap.get(target);
-		if (tracker?.isTracking && isGetter(target, prop)) return executeTrackedGetter(target, prop, tracker);
-		return Reflect.get(target, prop, receiver);
-	} });
-	blocProxyCache.set(bloc, proxy);
-	return proxy;
-}
-/**
-* @internal
-*/
+  const cached = blocProxyCache.get(bloc);
+  if (cached) return cached;
+  const proxy = new Proxy(bloc, {
+    get(target, prop, receiver) {
+      const tracker = activeTrackerMap.get(target);
+      if (tracker?.isTracking && isGetter(target, prop))
+        return executeTrackedGetter(target, prop, tracker);
+      return Reflect.get(target, prop, receiver);
+    },
+  });
+  blocProxyCache.set(bloc, proxy);
+  return proxy;
+}
+/**
+ * @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
-*/
+  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;
+  tracker.cacheValid = false;
 }
 /**
-* Create a new tracking proxy state.
-*/
+ * Create a new tracking proxy state.
+ */
 function createState() {
-	return {
-		dependencyState: createDependencyState(),
-		getterState: createGetterState(),
-		dependencies: /* @__PURE__ */ new Set(),
-		isTracking: false
-	};
+  return {
+    dependencyState: createDependencyState(),
+    getterState: createGetterState(),
+    dependencies: /* @__PURE__ */ new Set(),
+    isTracking: false,
+  };
 }
 /**
-* Start tracking on a tracking proxy.
-*/
+ * Start tracking on a tracking proxy.
+ */
 function startTracking(tracker) {
-	tracker.isTracking = true;
-	tracker.dependencies.clear();
-	tracker.getterState.isTracking = true;
-	startDependency(tracker.dependencyState);
+  tracker.isTracking = true;
+  tracker.dependencies.clear();
+  tracker.getterState.isTracking = true;
+  startDependency(tracker.dependencyState);
 }
 /**
-* Stop tracking and collect all dependencies.
-*/
+ * 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);
+  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.
-*/
+ * 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.
-*/
+  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;
-	} });
+  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.
-*/
+ * 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;
-	}
+  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
-*/
+ * 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 Set();
-	const queue = [bloc];
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (!current) break;
-		for (const [Type, key] of current.dependencies) {
-			const visitKey = `${Type.name}::${key}`;
-			if (visited.has(visitKey)) continue;
-			visited.add(visitKey);
-			const dep = getRegistry().ensure(Type, key);
-			result.add(dep);
-			if (dep.dependencies.size > 0) queue.push(dep);
-		}
-	}
-	result.delete(bloc);
-	return result;
+  const result = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [bloc];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) break;
+    for (const [Type, key] of current.dependencies) {
+      const visitKey = `${Type.name}::${key}`;
+      if (visited.has(visitKey)) continue;
+      visited.add(visitKey);
+      const dep = getRegistry().ensure(Type, key);
+      result.add(dep);
+      if (dep.dependencies.size > 0) queue.push(dep);
+    }
+  }
+  result.delete(bloc);
+  return result;
 }
 //#endregion
-export { setActiveTracker as _, commitTrackedGetters as a, stopTracking as b, createDependencyState as c, createTrackingProxy as d, hasChanges as f, invalidateRenderCache as g, hasTrackedData as h, clearActiveTracker as i, createGetterState as l, hasGetterChanges as m, DependencyManager as n, createBlocProxy as o, hasDependencyChanges as p, capturePaths as r, createDependencyProxy as s, resolveDependencies as t, createState as u, startDependency as v, shallowEqual as x, startTracking as y };
+export {
+  setActiveTracker as _,
+  commitTrackedGetters as a,
+  stopTracking as b,
+  createDependencyState as c,
+  createTrackingProxy as d,
+  hasChanges as f,
+  invalidateRenderCache as g,
+  hasTrackedData as h,
+  clearActiveTracker as i,
+  createGetterState as l,
+  hasGetterChanges as m,
+  DependencyManager as n,
+  createBlocProxy as o,
+  hasDependencyChanges as p,
+  capturePaths as r,
+  createDependencyProxy as s,
+  resolveDependencies as t,
+  createState as u,
+  startDependency as v,
+  shallowEqual as x,
+  startTracking as y,
+};
 
-//# sourceMappingURL=resolve-dependencies-f-QUqYiL.js.map
+//# sourceMappingURL=resolve-dependencies-f-QUqYiL.js.map