@blac/core 2.0.13 → 2.0.14

package/dist/tracking/dependency-manager.d.ts

@@ -5,33 +5,37 @@ import type { StateContainerInstance } from '../types/utilities';
  * as dependencies change between callback invocations.
  */
 export declare class DependencyManager {
-    private subscriptions;
-    private currentDeps;
-    /**
-     * 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: Set<StateContainerInstance>, onChange: () => void, exclude?: StateContainerInstance): boolean;
-    /**
-     * Add a single dependency subscription.
-     */
-    add(dep: StateContainerInstance, onChange: () => void): void;
-    /**
-     * Check if a dependency is currently subscribed.
-     */
-    has(dep: StateContainerInstance): boolean;
-    /**
-     * Get the current set of dependencies.
-     */
-    getDependencies(): Set<StateContainerInstance>;
-    /**
-     * Clean up all active subscriptions.
-     */
-    cleanup(): void;
-    private areSetsEqual;
+  private subscriptions;
+  private currentDeps;
+  /**
+   * 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: Set<StateContainerInstance>,
+    onChange: () => void,
+    exclude?: StateContainerInstance,
+  ): boolean;
+  /**
+   * Add a single dependency subscription.
+   */
+  add(dep: StateContainerInstance, onChange: () => void): void;
+  /**
+   * Check if a dependency is currently subscribed.
+   */
+  has(dep: StateContainerInstance): boolean;
+  /**
+   * Get the current set of dependencies.
+   */
+  getDependencies(): Set<StateContainerInstance>;
+  /**
+   * Clean up all active subscriptions.
+   */
+  cleanup(): void;
+  private areSetsEqual;
 }

package/dist/tracking/index.d.ts

@@ -7,7 +7,22 @@
  *
  * @packageDocumentation
  */
-export { type DependencyState, type PathInfo, createDependencyState, startDependency, createDependencyProxy, capturePaths, hasDependencyChanges, hasTrackedData, type GetterState, createGetterState, createBlocProxy, hasGetterChanges, setActiveTracker, clearActiveTracker, commitTrackedGetters, invalidateRenderCache, } from './tracking-proxy';
+export {
+  type DependencyState,
+  type PathInfo,
+  createDependencyState,
+  startDependency,
+  createDependencyProxy,
+  capturePaths,
+  hasDependencyChanges,
+  hasTrackedData,
+  type GetterState,
+  createGetterState,
+  createBlocProxy,
+  hasGetterChanges,
+  commitTrackedGetters,
+  invalidateRenderCache,
+} from './tracking-proxy';
 export { shallowEqual } from './path-utils';
 export { DependencyManager } from './dependency-manager';
 export { resolveDependencies } from './resolve-dependencies';

package/dist/tracking/iteration-perf.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tracking/path-utils.d.ts

@@ -21,20 +21,37 @@
  * ```
  */
 export declare function parsePath(path: string): string[];
+/**
+ * Sentinel value returned by `getValueAtPath` when the path cannot be fully
+ * walked because an intermediate segment is null or undefined. This is
+ * distinct from `undefined`, which is a legitimate leaf value.
+ *
+ * @internal
+ */
+declare const MISSING: unique symbol;
+export { MISSING as PATH_MISSING };
 /**
  * Get a value from an object using a path of segments
  *
+ * Returns `PATH_MISSING` (not `undefined`) when the path cannot be walked
+ * because an intermediate parent is null or undefined. This lets callers
+ * distinguish "the leaf is explicitly `undefined`" from "the path is broken".
+ *
  * @example
  * ```ts
  * const obj = { user: { name: 'Alice', age: 30 } }
  * getValueAtPath(obj, ['user', 'name']) // 'Alice'
  * getValueAtPath(obj, ['user', 'age']) // 30
  * getValueAtPath(obj, ['user', 'missing']) // undefined
+ * getValueAtPath({ a: null }, ['a', 'b']) // PATH_MISSING
  * ```
  *
  * @internal
  */
-export declare function getValueAtPath(obj: unknown, segments: string[]): unknown;
+export declare function getValueAtPath(
+  obj: unknown,
+  segments: string[],
+): unknown;
 /**
  * Shallow equality comparison for arrays
  *

package/dist/tracking/resolve-dependencies.d.ts

@@ -4,4 +4,6 @@ import type { StateContainerInstance } from '../types/utilities';
  * Uses cycle detection to avoid infinite loops.
  * @internal
  */
-export declare function resolveDependencies(bloc: StateContainerInstance): Set<StateContainerInstance>;
+export declare function resolveDependencies(
+  bloc: StateContainerInstance,
+): Set<StateContainerInstance>;

package/dist/tracking/tracked.d.ts

@@ -4,14 +4,14 @@ import { DependencyManager } from './dependency-manager';
  * Result of running a tracked callback.
  */
 export interface TrackedResult<T> {
-    result: T;
-    dependencies: Set<StateContainerInstance>;
+  result: T;
+  dependencies: Set<StateContainerInstance>;
 }
 /**
  * Options for the tracked() function.
  */
 export interface TrackedOptions {
-    exclude?: StateContainerInstance;
+  exclude?: StateContainerInstance;
 }
 /**
  * Run a callback while tracking all bloc dependencies accessed.
@@ -26,42 +26,45 @@ export interface TrackedOptions {
  * // dependencies contains UserBloc + any blocs accessed in fullName getter
  * ```
  */
-export declare function tracked<T>(callback: () => T, options?: TrackedOptions): TrackedResult<T>;
+export declare function tracked<T>(
+  callback: () => T,
+  options?: TrackedOptions,
+): TrackedResult<T>;
 /**
  * Context for running tracked callbacks with bloc proxies.
  * Provides methods to create proxies and check for changes.
  */
 export declare class TrackedContext {
-    private tracker;
-    private proxiedBlocs;
-    private primaryBlocs;
-    constructor();
-    /**
-     * Get a tracking proxy for a bloc instance.
-     * The proxy will track state and getter accesses.
-     */
-    proxy<T extends StateContainerInstance>(bloc: T): T;
-    /**
-     * Start tracking for a new callback execution.
-     */
-    start(): void;
-    /**
-     * Stop tracking and get discovered dependencies.
-     * Excludes primary blocs (those explicitly proxied via proxy()).
-     */
-    stop(): Set<StateContainerInstance>;
-    /**
-     * Check if any tracked state or getters have changed.
-     */
-    changed(): boolean;
-    /**
-     * Get all primary blocs (those explicitly proxied).
-     */
-    getPrimaryBlocs(): Set<StateContainerInstance>;
-    /**
-     * Reset the context for reuse.
-     */
-    reset(): void;
+  private tracker;
+  private proxiedBlocs;
+  private primaryBlocs;
+  constructor();
+  /**
+   * Get a tracking proxy for a bloc instance.
+   * The proxy will track state and getter accesses.
+   */
+  proxy<T extends StateContainerInstance>(bloc: T): T;
+  /**
+   * Start tracking for a new callback execution.
+   */
+  start(): void;
+  /**
+   * Stop tracking and get discovered dependencies.
+   * Excludes primary blocs (those explicitly proxied via proxy()).
+   */
+  stop(): Set<StateContainerInstance>;
+  /**
+   * Check if any tracked state or getters have changed.
+   */
+  changed(): boolean;
+  /**
+   * Get all primary blocs (those explicitly proxied).
+   */
+  getPrimaryBlocs(): Set<StateContainerInstance>;
+  /**
+   * Reset the context for reuse.
+   */
+  reset(): void;
 }
 /**
  * Create a new tracked context for manual control over tracking.

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-Dfdp_DZd.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-B6JDXvpr.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
@@ -35,3 +36,16 @@ export declare function isExcludedFromDevTools<T extends StateContainerConstruct
  * @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.
  */