@blac/core 2.0.13 → 2.0.15

package/dist/tracked-C3nIS4J7.cjs

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

package/dist/tracked-C3nIS4J7.cjs.map

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

package/dist/tracked-C52awNV9.js

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