@blac/core 2.0.12 → 2.0.14

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

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

package/dist/tracking.cjs

@@ -1,18 +1,21 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_resolve_dependencies = require("./resolve-dependencies-BFZQq60Y.cjs");
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_resolve_dependencies = require('./resolve-dependencies-GJ8PNyNB.cjs');
 exports.DependencyManager = require_resolve_dependencies.DependencyManager;
 exports.capturePaths = require_resolve_dependencies.capturePaths;
-exports.clearActiveTracker = require_resolve_dependencies.clearActiveTracker;
-exports.commitTrackedGetters = require_resolve_dependencies.commitTrackedGetters;
+exports.commitTrackedGetters =
+  require_resolve_dependencies.commitTrackedGetters;
 exports.createBlocProxy = require_resolve_dependencies.createBlocProxy;
-exports.createDependencyProxy = require_resolve_dependencies.createDependencyProxy;
-exports.createDependencyState = require_resolve_dependencies.createDependencyState;
+exports.createDependencyProxy =
+  require_resolve_dependencies.createDependencyProxy;
+exports.createDependencyState =
+  require_resolve_dependencies.createDependencyState;
 exports.createGetterState = require_resolve_dependencies.createGetterState;
-exports.hasDependencyChanges = require_resolve_dependencies.hasDependencyChanges;
+exports.hasDependencyChanges =
+  require_resolve_dependencies.hasDependencyChanges;
 exports.hasGetterChanges = require_resolve_dependencies.hasGetterChanges;
 exports.hasTrackedData = require_resolve_dependencies.hasTrackedData;
-exports.invalidateRenderCache = require_resolve_dependencies.invalidateRenderCache;
+exports.invalidateRenderCache =
+  require_resolve_dependencies.invalidateRenderCache;
 exports.resolveDependencies = require_resolve_dependencies.resolveDependencies;
-exports.setActiveTracker = require_resolve_dependencies.setActiveTracker;
 exports.shallowEqual = require_resolve_dependencies.shallowEqual;
 exports.startDependency = require_resolve_dependencies.startDependency;

package/dist/tracking.js

@@ -1,2 +1,32 @@
-import { _ as setActiveTracker, a as commitTrackedGetters, c as createDependencyState, g as invalidateRenderCache, h as hasTrackedData, i as clearActiveTracker, l as createGetterState, m as hasGetterChanges, n as DependencyManager, o as createBlocProxy, p as hasDependencyChanges, r as capturePaths, s as createDependencyProxy, t as resolveDependencies, v as startDependency, x as shallowEqual } from "./resolve-dependencies-D0vTzZgs.js";
-export { DependencyManager, capturePaths, clearActiveTracker, commitTrackedGetters, createBlocProxy, createDependencyProxy, createDependencyState, createGetterState, hasDependencyChanges, hasGetterChanges, hasTrackedData, invalidateRenderCache, resolveDependencies, setActiveTracker, shallowEqual, startDependency };
+import {
+  a as createBlocProxy,
+  c as createGetterState,
+  f as hasDependencyChanges,
+  g as startDependency,
+  h as invalidateRenderCache,
+  i as commitTrackedGetters,
+  m as hasTrackedData,
+  n as DependencyManager,
+  o as createDependencyProxy,
+  p as hasGetterChanges,
+  r as capturePaths,
+  s as createDependencyState,
+  t as resolveDependencies,
+  y as shallowEqual,
+} from './resolve-dependencies-DV3HO_uH.js';
+export {
+  DependencyManager,
+  capturePaths,
+  commitTrackedGetters,
+  createBlocProxy,
+  createDependencyProxy,
+  createDependencyState,
+  createGetterState,
+  hasDependencyChanges,
+  hasGetterChanges,
+  hasTrackedData,
+  invalidateRenderCache,
+  resolveDependencies,
+  shallowEqual,
+  startDependency,
+};

package/dist/types/utilities.d.ts

@@ -9,14 +9,26 @@ export type ExtractStateMutable<T> = T extends StateContainerConstructor<infer S
  * Constructor type for StateContainer classes
  * @template S - State type managed by the container
  */
-export type StateContainerConstructor<S extends object = any> = new (...args: any[]) => StateContainer<S>;
+export type StateContainerConstructor<S extends object = any> = new (...args: any[]) => StateContainer<S, any, any>;
+/**
+ * Extract the args type (serializable construction/identity data) from a
+ * StateContainer subclass.
+ * @template T - The StateContainer constructor type
+ */
+export type ExtractArgs<T> = T extends new () => StateContainer<any, infer A, any> ? A : void;
+/**
+ * Extract the deps type (injected non-serializable handles) from a
+ * StateContainer subclass.
+ * @template T - The StateContainer constructor type
+ */
+export type ExtractDeps<T> = T extends new () => StateContainer<any, any, infer D> ? D : Record<string, never>;
 export type InstanceReadonlyState<T extends StateContainerConstructor = any> = Omit<InstanceType<T>, 'state'> & {
     state: ExtractState<T>;
 };
 export type InstanceState<T extends StateContainerConstructor = any> = Omit<InstanceType<T>, 'state'> & {
     state: ExtractStateMutable<T>;
 };
-export type StateContainerInstance<S extends object = any> = Omit<StateContainer<S>, 'state'> & {
+export type StateContainerInstance<S extends object = any> = Omit<StateContainer<S, any, any>, 'state'> & {
     state: Readonly<S>;
 };
 /**
@@ -34,7 +46,7 @@ export type BlocInstanceType<T extends abstract new (...args: any) => any> = T e
  * Used for type-safe hook parameters.
  * @template TBloc - The StateContainer instance type
  */
-export type BlocConstructor<S extends object = any, T extends new (...args: any[]) => StateContainer<S> = new (...args: any[]) => StateContainer<S>> = (new (...args: any[]) => InstanceType<T>) & {
+export type BlocConstructor<S extends object = any, T extends new (...args: any[]) => StateContainer<S, any, any> = new (...args: any[]) => StateContainer<S, any, any>> = (new (...args: any[]) => InstanceType<T>) & {
     acquire(instanceKey?: string, ...args: any[]): InstanceType<T>;
     borrow(instanceKey?: string, ...args: any[]): InstanceType<T> | null;
     borrowSafe(instanceKey?: string, ...args: any[]): {

package/dist/types.cjs

@@ -1,3 +1,3 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_branded = require("./branded-DCqi3De1.cjs");
+const require_branded = require("./branded-BSeA_mZO.cjs");
 exports.instanceId = require_branded.instanceId;

package/dist/types.js

@@ -1,2 +1,2 @@
-import { t as instanceId } from "./branded-Max3xOTA.js";
+import { t as instanceId } from "./branded-DwtzSsg0.js";
 export { instanceId };

package/dist/utils/static-props.d.ts

@@ -1,6 +1,7 @@
 /**
  * Utility functions for accessing static properties on StateContainer classes
  */
+import type { EqualityFn } from '../config';
 import { StateContainerConstructor } from '../types/utilities';
 /**
  * Get a static property from a class constructor
@@ -26,3 +27,25 @@ export declare function isKeepAliveClass<T extends StateContainerConstructor>(Ty
  * @returns true if the class has `static __excludeFromDevTools = true`
  */
 export declare function isExcludedFromDevTools<T extends StateContainerConstructor>(Type: T): boolean;
+/**
+ * Check if a class is marked as isolated.
+ * Isolated classes get a fresh, per-mount instance from `useBloc`
+ * (auto-keyed via React's `useId()`), instead of sharing the default
+ * instance with sibling call sites.
+ * @param Type - The class constructor to check
+ * @returns true if the class has `static isolated = true`
+ */
+export declare function isIsolatedClass<T extends StateContainerConstructor>(Type: T): boolean;
+/**
+ * Get the per-class equality function set via `@blac({ equality })`, if any.
+ * @param Type - The class constructor to check
+ * @returns the equality function or `undefined`
+ */
+export declare function getClassEquality<T extends StateContainerConstructor>(Type: T): EqualityFn | undefined;
+/**
+ * Get the per-class key function set via `@blac({ key })` or `static key = …`, if any.
+ * Used by the registry to derive a stable instance key from `args`.
+ * @param Type - The class constructor to check
+ * @returns the key function or `undefined`
+ */
+export declare function getClassKey(Type: unknown): ((args: any) => string) | undefined;

package/dist/utils/structural-key.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Deterministic, order-independent hash of serializable args.
+ * Sorts object keys so {a,b} === {b,a}.
+ * Throws (dev) if it encounters a function or non-plain object — those belong in `deps`.
+ */
+export declare const DEFAULT_STRUCTURAL_KEY = "default";
+/**
+ * Produce a stable string key for serializable args.
+ * - `undefined` / `void` args → `'default'` sentinel (no-args blocs stay on the default key).
+ * - Object keys are sorted for order-independence.
+ * - Arrays keep their insertion order.
+ * - Functions throw — they must be passed via `deps`, not `args`.
+ */
+export declare function structuralKey(args: unknown): string;

package/dist/watch/watch.d.ts

@@ -1,5 +1,6 @@
 import type { StateContainerConstructor } from '../types/utilities';
 declare const STOP: unique symbol;
+type StopSymbol = typeof STOP;
 declare const BLOC_REF_MARKER: unique symbol;
 /**
  * Reference to a specific bloc instance by class and instance ID.
@@ -25,7 +26,6 @@ type ExtractInstance<T> = T extends BlocRef<infer C> ? InstanceType<C> : T exten
 type ExtractInstances<T extends readonly BlocInput[]> = {
     [K in keyof T]: ExtractInstance<T[K]>;
 };
-type StopSymbol = typeof STOP;
 /**
  * Watch function signature for single bloc.
  */

package/dist/watch-BpwaUL8r.cjs

@@ -0,0 +1,68 @@
+const require_StateContainerRegistry = require("./StateContainerRegistry-B4yVMYbx.cjs");
+const require_ensure = require("./ensure-BB6xHQAF.cjs");
+let _dirtytalk_structural = require("@dirtytalk/structural");
+//#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);
+	let disposed = false;
+	const subscriptions = [];
+	const cleanup = () => {
+		if (disposed) return;
+		disposed = true;
+		for (const unsub of subscriptions) unsub();
+		subscriptions.length = 0;
+	};
+	const runCallback = () => {
+		if (disposed) return;
+		if (callback(isSingle ? instances[0] : instances) === STOP) cleanup();
+	};
+	for (const inst of instances) subscriptions.push(inst.channel.subscribe(() => _dirtytalk_structural.ALL_PATHS, runCallback));
+	runCallback();
+	return cleanup;
+}
+const watch = Object.assign(watchImpl, { STOP });
+//#endregion
+Object.defineProperty(exports, "instance", {
+	enumerable: true,
+	get: function() {
+		return instance;
+	}
+});
+Object.defineProperty(exports, "watch", {
+	enumerable: true,
+	get: function() {
+		return watch;
+	}
+});
+
+//# sourceMappingURL=watch-BpwaUL8r.cjs.map

package/dist/watch-BpwaUL8r.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-BpwaUL8r.cjs","names":["ensure","BLAC_DEFAULTS","ALL_PATHS"],"sources":["../src/watch/watch.ts"],"sourcesContent":["import { ALL_PATHS } from '@dirtytalk/structural';\nimport { ensure } from '../registry';\nimport { BLAC_DEFAULTS } from '../constants';\nimport type {\n  StateContainerConstructor,\n  StateContainerInstance,\n} from '../types/utilities';\n\nconst STOP: unique symbol = Symbol('watch.STOP');\ntype StopSymbol = typeof 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\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 *\n * Thin wrapper around `container.channel.subscribe(ALL_PATHS, ...)`. The\n * callback fires once immediately, then on every state change of any of the\n * passed blocs. Returning `watch.STOP` from the callback tears down all\n * subscriptions.\n *\n * Note: subscriptions are microtask-deferred (per the DirtyChannel default\n * scheduler), so callbacks land asynchronously after `emit()`.\n *\n * @example Single bloc\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   console.log(userBloc.state.name);\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  let disposed = false;\n  const subscriptions: (() => void)[] = [];\n\n  const cleanup = () => {\n    if (disposed) return;\n    disposed = true;\n    for (const unsub of subscriptions) unsub();\n    subscriptions.length = 0;\n  };\n\n  const runCallback = () => {\n    if (disposed) return;\n    const arg = isSingle ? instances[0] : instances;\n    const result = callback(arg);\n    if (result === STOP) cleanup();\n  };\n\n  for (const inst of instances) {\n    subscriptions.push(inst.channel.subscribe(() => ALL_PATHS, runCallback));\n  }\n\n  // Fire once immediately so the consumer sees the current state.\n  runCallback();\n\n  return cleanup;\n}\n\nexport const watch: WatchFn = Object.assign(watchImpl, { STOP }) as WatchFn;\n"],"mappings":";;;;AAQA,MAAM,OAAsB,OAAO,aAAa;AAGhD,MAAM,kBAAkB,OAAO,UAAU;;;;;;;;;;;AAqBzC,SAAgB,SACd,WACA,YACY;CACZ,OAAO;GACJ,kBAAkB;EACnB,WAAW;EACX;EACD;;AAGH,SAAS,UACP,OAC6C;CAC7C,OACE,OAAO,UAAU,YAAY,UAAU,QAAQ,mBAAmB;;AAmDtE,SAAS,YAAY,OAA0C;CAC7D,IAAI,UAAU,MAAM,EAClB,OAAOA,eAAAA,OAAO,MAAM,WAAW,MAAM,WAAW;CAElD,OAAOA,eAAAA,OAAO,OAAOC,+BAAAA,cAAc,qBAAqB;;AAG1D,SAAS,QAAQ,OAA+C;CAC9D,OAAO,MAAM,QAAQ,MAAM;;AA4D7B,SAAS,UACP,aACA,UACY;CACZ,MAAM,WAAW,CAAC,QAAQ,YAAY;CAGtC,MAAM,aAFS,WAAW,CAAC,YAAY,GAAG,aAEjB,IAAI,YAAY;CAEzC,IAAI,WAAW;CACf,MAAM,gBAAgC,EAAE;CAExC,MAAM,gBAAgB;EACpB,IAAI,UAAU;EACd,WAAW;EACX,KAAK,MAAM,SAAS,eAAe,OAAO;EAC1C,cAAc,SAAS;;CAGzB,MAAM,oBAAoB;EACxB,IAAI,UAAU;EAGd,IADe,SADH,WAAW,UAAU,KAAK,UAE5B,KAAK,MAAM,SAAS;;CAGhC,KAAK,MAAM,QAAQ,WACjB,cAAc,KAAK,KAAK,QAAQ,gBAAgBC,sBAAAA,WAAW,YAAY,CAAC;CAI1E,aAAa;CAEb,OAAO;;AAGT,MAAa,QAAiB,OAAO,OAAO,WAAW,EAAE,MAAM,CAAC"}

package/dist/watch-DWCqXllW.js

@@ -0,0 +1,57 @@
+import { l as BLAC_DEFAULTS } from "./StateContainerRegistry-DmmzYa7S.js";
+import { t as ensure } from "./ensure-mkL-3qh8.js";
+import { ALL_PATHS } from "@dirtytalk/structural";
+//#region src/watch/watch.ts
+const STOP = Symbol("watch.STOP");
+const BLOC_REF_MARKER = Symbol("BlocRef");
+/**
+* Create a reference to a specific bloc instance.
+*
+* @example
+* ```ts
+* watch(instance(UserBloc, 'user-123'), (userBloc) => {
+*   console.log(userBloc.state.name);
+* });
+* ```
+*/
+function instance(BlocClass, instanceId) {
+	return {
+		[BLOC_REF_MARKER]: true,
+		blocClass: BlocClass,
+		instanceId
+	};
+}
+function isBlocRef(input) {
+	return typeof input === "object" && input !== null && BLOC_REF_MARKER in input;
+}
+function resolveBloc(input) {
+	if (isBlocRef(input)) return ensure(input.blocClass, input.instanceId);
+	return ensure(input, BLAC_DEFAULTS.DEFAULT_INSTANCE_KEY);
+}
+function isArray(input) {
+	return Array.isArray(input);
+}
+function watchImpl(blocsOrBloc, callback) {
+	const isSingle = !isArray(blocsOrBloc);
+	const instances = (isSingle ? [blocsOrBloc] : blocsOrBloc).map(resolveBloc);
+	let disposed = false;
+	const subscriptions = [];
+	const cleanup = () => {
+		if (disposed) return;
+		disposed = true;
+		for (const unsub of subscriptions) unsub();
+		subscriptions.length = 0;
+	};
+	const runCallback = () => {
+		if (disposed) return;
+		if (callback(isSingle ? instances[0] : instances) === STOP) cleanup();
+	};
+	for (const inst of instances) subscriptions.push(inst.channel.subscribe(() => ALL_PATHS, runCallback));
+	runCallback();
+	return cleanup;
+}
+const watch = Object.assign(watchImpl, { STOP });
+//#endregion
+export { watch as n, instance as t };
+
+//# sourceMappingURL=watch-DWCqXllW.js.map

package/dist/watch-DWCqXllW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-DWCqXllW.js","names":[],"sources":["../src/watch/watch.ts"],"sourcesContent":["import { ALL_PATHS } from '@dirtytalk/structural';\nimport { ensure } from '../registry';\nimport { BLAC_DEFAULTS } from '../constants';\nimport type {\n  StateContainerConstructor,\n  StateContainerInstance,\n} from '../types/utilities';\n\nconst STOP: unique symbol = Symbol('watch.STOP');\ntype StopSymbol = typeof 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\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 *\n * Thin wrapper around `container.channel.subscribe(ALL_PATHS, ...)`. The\n * callback fires once immediately, then on every state change of any of the\n * passed blocs. Returning `watch.STOP` from the callback tears down all\n * subscriptions.\n *\n * Note: subscriptions are microtask-deferred (per the DirtyChannel default\n * scheduler), so callbacks land asynchronously after `emit()`.\n *\n * @example Single bloc\n * ```ts\n * const unwatch = watch(UserBloc, (userBloc) => {\n *   console.log(userBloc.state.name);\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  let disposed = false;\n  const subscriptions: (() => void)[] = [];\n\n  const cleanup = () => {\n    if (disposed) return;\n    disposed = true;\n    for (const unsub of subscriptions) unsub();\n    subscriptions.length = 0;\n  };\n\n  const runCallback = () => {\n    if (disposed) return;\n    const arg = isSingle ? instances[0] : instances;\n    const result = callback(arg);\n    if (result === STOP) cleanup();\n  };\n\n  for (const inst of instances) {\n    subscriptions.push(inst.channel.subscribe(() => ALL_PATHS, runCallback));\n  }\n\n  // Fire once immediately so the consumer sees the current state.\n  runCallback();\n\n  return cleanup;\n}\n\nexport const watch: WatchFn = Object.assign(watchImpl, { STOP }) as WatchFn;\n"],"mappings":";;;;AAQA,MAAM,OAAsB,OAAO,aAAa;AAGhD,MAAM,kBAAkB,OAAO,UAAU;;;;;;;;;;;AAqBzC,SAAgB,SACd,WACA,YACY;CACZ,OAAO;GACJ,kBAAkB;EACnB,WAAW;EACX;EACD;;AAGH,SAAS,UACP,OAC6C;CAC7C,OACE,OAAO,UAAU,YAAY,UAAU,QAAQ,mBAAmB;;AAmDtE,SAAS,YAAY,OAA0C;CAC7D,IAAI,UAAU,MAAM,EAClB,OAAO,OAAO,MAAM,WAAW,MAAM,WAAW;CAElD,OAAO,OAAO,OAAO,cAAc,qBAAqB;;AAG1D,SAAS,QAAQ,OAA+C;CAC9D,OAAO,MAAM,QAAQ,MAAM;;AA4D7B,SAAS,UACP,aACA,UACY;CACZ,MAAM,WAAW,CAAC,QAAQ,YAAY;CAGtC,MAAM,aAFS,WAAW,CAAC,YAAY,GAAG,aAEjB,IAAI,YAAY;CAEzC,IAAI,WAAW;CACf,MAAM,gBAAgC,EAAE;CAExC,MAAM,gBAAgB;EACpB,IAAI,UAAU;EACd,WAAW;EACX,KAAK,MAAM,SAAS,eAAe,OAAO;EAC1C,cAAc,SAAS;;CAGzB,MAAM,oBAAoB;EACxB,IAAI,UAAU;EAGd,IADe,SADH,WAAW,UAAU,KAAK,UAE5B,KAAK,MAAM,SAAS;;CAGhC,KAAK,MAAM,QAAQ,WACjB,cAAc,KAAK,KAAK,QAAQ,gBAAgB,WAAW,YAAY,CAAC;CAI1E,aAAa;CAEb,OAAO;;AAGT,MAAa,QAAiB,OAAO,OAAO,WAAW,EAAE,MAAM,CAAC"}

package/dist/watch-entry.cjs

@@ -1,7 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_tracked = require("./tracked-BDVi2LKM.cjs");
-exports.TrackedContext = require_tracked.TrackedContext;
-exports.createTrackedContext = require_tracked.createTrackedContext;
-exports.instance = require_tracked.instance;
-exports.tracked = require_tracked.tracked;
-exports.watch = require_tracked.watch;
+const require_watch = require("./watch-BpwaUL8r.cjs");
+exports.instance = require_watch.instance;
+exports.watch = require_watch.watch;

package/dist/watch-entry.d.cts

@@ -8,10 +8,9 @@
  * ```typescript
  * import { watch, instance } from '@blac/core/watch';
  *
- * // Watch a bloc with automatic dependency tracking
+ * // Watch a bloc
  * const unwatch = watch(UserBloc, (userBloc) => {
  *   console.log(userBloc.state.name);
- *   console.log(userBloc.fullName); // getter also tracked
  * });
  *
  * // Watch a specific instance
@@ -23,4 +22,3 @@
  * @packageDocumentation
  */
 export { watch, instance, type WatchFn, type BlocRef } from './watch';
-export { tracked, createTrackedContext, TrackedContext, type TrackedResult, type TrackedOptions, } from './tracking/tracked';

package/dist/watch-entry.d.ts

@@ -8,10 +8,9 @@
  * ```typescript
  * import { watch, instance } from '@blac/core/watch';
  *
- * // Watch a bloc with automatic dependency tracking
+ * // Watch a bloc
  * const unwatch = watch(UserBloc, (userBloc) => {
  *   console.log(userBloc.state.name);
- *   console.log(userBloc.fullName); // getter also tracked
  * });
  *
  * // Watch a specific instance
@@ -23,4 +22,3 @@
  * @packageDocumentation
  */
 export { watch, instance, type WatchFn, type BlocRef } from './watch';
-export { tracked, createTrackedContext, TrackedContext, type TrackedResult, type TrackedOptions, } from './tracking/tracked';

package/dist/watch-entry.js

@@ -1,2 +1,2 @@
-import { a as watch, i as instance, n as createTrackedContext, r as tracked, t as TrackedContext } from "./tracked-Dcu6EATB.js";
-export { TrackedContext, createTrackedContext, instance, tracked, watch };
+import { n as watch, t as instance } from "./watch-DWCqXllW.js";
+export { instance, watch };