@blac/react 2.0.12 → 2.0.14

package/README.md

@@ -50,6 +50,126 @@ const [state, bloc, ref] = useBloc(MyBloc, options?);
 - `bloc` — bloc instance for calling methods
 - `ref` — internal component ref (advanced usage)
 
+### The Three Input Lanes
+
+BlaC blocs receive external data through three distinct channels:
+
+| Lane | Purpose | Keying | Lifetime | Example |
+|---|---|---|---|---|
+| **`args`** | Typed creation data; derives instance identity | **Yes** (structural hash or `static key`) | Once at `init()` | `userId`, `endpoint` |
+| **`deps`** | Non-serializable refs, callbacks, handles | **Never** | Live, per-consumer merged | `ref`, `onComplete` callback, `emblaApi` |
+| **events** | Values that change over time or are late-bound | N/A | Called from effects | `cubit.slidesChanged(v)` from `useEffect` |
+
+### `args`: Typed Construction Data
+
+When a bloc declares `Args`, you must pass them at the call site. Args are fed to the bloc's `init(args)` method before the first state snapshot, and they derive the instance identity by default.
+
+```tsx
+import { Cubit } from '@blac/core';
+import { useBloc } from '@blac/react';
+
+class UserCardCubit extends Cubit<UserCardState, { userId: string }> {
+  // Constructor is zero-arg; framework calls init(args) before first snapshot
+  init(args: { userId: string }) {
+    this.userId = args.userId;
+    void this.loadUser(args.userId);
+  }
+}
+
+function UserCard({ userId }: { userId: string }) {
+  // args is required and type-checked when Args != void
+  const [state, cubit] = useBloc(UserCardCubit, { args: { userId } });
+  return <div>{state.user?.name}</div>;
+}
+```
+
+**Key properties:**
+- **Required when declared** — omitting `args` or passing the wrong shape is a type error.
+- **Drives identity** — different `args` ⇒ different instance. Same `args` ⇒ same instance (dev-warn if args mismatch on same-keyed second call).
+- **Serializable only** — non-serializable values (refs, callbacks) belong in the `deps` lane (below).
+- **Per-component private instances** — use with `autoInstance: true` to give each mount its own instance, disposed on unmount:
+
+```tsx
+const [state, cubit] = useBloc(FormCubit, { args: options, autoInstance: true });
+```
+
+### `deps`: Non-Serializable Refs and Callbacks
+
+Use `deps` to inject refs, stable callbacks, and long-lived controller handles. Unlike `args`, `deps` are:
+- **Never keying** — different refs don't fork the instance
+- **Per-consumer merged** — each component contributes its own slice
+- **Read lazily** — accessed via `this.deps.x` when needed, may be undefined
+- **Live** — can change over time
+
+```tsx
+const inputRef = useRef<HTMLInputElement>(null);
+const onComplete = useCallback(() => { /* ... */ }, []);
+
+const [state, cubit] = useBloc(FileUploadCubit, {
+  args: { endpoint },
+  deps: { inputRef, onComplete },
+});
+```
+
+The bloc reads them lazily and guards for absence:
+
+```ts
+class FileUploadCubit extends Cubit<UploadState, { endpoint: string }, {
+  inputRef?: RefObject<HTMLInputElement>;
+  onComplete?: () => void;
+}> {
+  async upload() {
+    this.deps.inputRef?.current?.click?.();
+    // ... perform upload ...
+    this.deps.onComplete?.();
+  }
+}
+```
+
+**Multi-consumer merge:** when multiple components provide the same cubit with different `deps`, their keys are shallow-merged:
+
+```tsx
+// Component A provides inputRef
+useBloc(FormCubit, { args: { formId }, deps: { inputRef } });
+
+// Component B provides onSubmit
+useBloc(FormCubit, { args: { formId }, deps: { onSubmit } });
+
+// cubit.deps === { inputRef, onSubmit } (merged from both)
+```
+
+**Avoid raw callbacks** — the callback staleness gotcha. Prefer:
+1. **Don't inject callbacks — invert** (best): expose state and let React call the fresh callback in its own effect.
+2. **Stabilize at source** — wrap in `useCallback`.
+3. **As an event** — push the callback via a bloc method called from your effect.
+
+### events: Methods Called from Effects
+
+For data that changes over the instance's life (a `slides` array, a `theme` selection), call an ordinary bloc method from an effect — not a provider-owned input. This keeps ownership explicit and eliminates render-time mutation.
+
+```ts
+class CarouselCubit extends Cubit<CarouselState> {
+  slidesChanged(slides: Slide[]) {
+    this.patch({ slides, total: slides.length });
+  }
+}
+```
+
+```tsx
+function Carousel({ slides }: { slides: Slide[] }) {
+  const [state, cubit] = useBloc(CarouselCubit, { args: { id } });
+
+  // ONE component owns syncing this live value
+  useEffect(() => {
+    cubit.slidesChanged(slides);
+  }, [cubit, slides]);
+
+  return /* ... */;
+}
+```
+
+**Convention:** *one component owns syncing any given live value.* Two components calling the same event from both their effects on the same shared instance is a design smell (and rare, because keyed `args` usually route multi-consumer cases to distinct instances).
+
 ### Tracking Modes
 
 **Auto-tracking (default):** Only re-renders when accessed properties change.
@@ -59,11 +179,11 @@ const [state] = useBloc(UserBloc);
 return <h1>{state.name}</h1>; // only re-renders when name changes
 ```
 
-**Manual dependencies:** Explicit dependency array (disables auto-tracking).
+**Manual dependencies (select):** Explicit dependency array (disables auto-tracking).
 
 ```tsx
 const [state] = useBloc(CounterCubit, {
-  dependencies: (state) => [state.count],
+  select: (state) => [state.count],
 });
 ```
 
@@ -77,21 +197,55 @@ const [state] = useBloc(MyBloc, { autoTrack: false });
 
 | Option         | Type                         | Description                                          |
 | -------------- | ---------------------------- | ---------------------------------------------------- |
+| `args`         | `Args` type                  | Required when bloc declares `Args != void`; forbidden when `void` |
+| `deps`         | `{ [key]: value }`           | Per-consumer slice of non-serializable handles |
 | `autoTrack`    | `boolean`                    | Enable proxy-based auto-tracking (default: `true`)   |
-| `dependencies` | `(state, bloc) => unknown[]` | Manual dependency selector                           |
-| `instanceId`   | `string \| number`           | Use a named instance instead of the shared singleton |
+| `select`       | `(state, bloc) => unknown[]` | Manual dependency selector (renamed from `dependencies`) |
+| `autoInstance` | `boolean`                    | Per-mount instance keyed by `useId()` instead of shared (default: `false`) |
+| `instanceId`   | `string \| number`           | Explicit identity key (overrides args-derived keying) |
 | `onMount`      | `(bloc) => void`             | Called when component mounts                         |
 | `onUnmount`    | `(bloc) => void`             | Called when component unmounts                       |
 
-### Instance Sharing
+### Identity and Keying
 
-By default, all components using `useBloc(MyBloc)` share the same instance. Use `instanceId` for separate instances:
+Instance identity is resolved in precedence order:
+
+1. **Explicit `instanceId`** — hard override if provided
+2. **`autoInstance: true`** — per-mount instance keyed by `useId()`
+3. **`static key(args)` → structural hash of `args`** — default when bloc declares `Args` (if `static key` is defined on the class, it takes precedence; otherwise a stable hash of all `args`)
+4. **`<BlocProvider>` context id** — inherited from parent provider
+5. **`'default'`** — singleton fallback
+
+Blocs declare explicit identity via a static class property:
+
+```ts
+class DocumentCubit extends Cubit<DocState, { docId: string; readonly: boolean }> {
+  static key = (args) => args.docId;
+  // Identity is docId; readonly config rides along but doesn't fork instances
+}
+```
+
+### Instance Sharing and Lifecycle
+
+By default, all components using `useBloc(MyBloc)` with the same identity share one instance. Use `autoInstance` for per-component private instances:
 
 ```tsx
-useBloc(EditorCubit, { instanceId: 'editor-1' }); // instance A
-useBloc(EditorCubit, { instanceId: 'editor-2' }); // instance B
+// All users with userId=123 share one instance
+useBloc(UserCardCubit, { args: { userId: 123 } });
+
+// Each component mount gets its own instance, disposed on unmount
+useBloc(FormCubit, { args: options, autoInstance: true });
+
+// Explicit id (escape hatch for non-derivable identity)
+useBloc(EditorCubit, { instanceId: 'editor-1' });
 ```
 
+### Breaking Changes (v2)
+
+- **`dependencies` option renamed to `select`** — avoids confusion with the new `deps` (non-serializable handles) lane.
+- **Zero-arg constructor + `init(args)` lifecycle** — all blocs now use `new Type()` with no constructor args. Blocs that declare `Args` receive them via `init(args)` called by the framework before the first state snapshot.
+- **`args` is required when declared, forbidden when void** — enforced by the type system; no runtime guard needed.
+
 ## Configuration
 
 ```tsx

package/dist/BlocProvider.d.ts

@@ -0,0 +1,33 @@
+import { type ReactElement, type ReactNode } from 'react';
+/**
+ * Props for {@link BlocProvider}.
+ */
+export interface BlocProviderProps {
+    /**
+     * Instance id that descendants' `useBloc(C)` calls will resolve to when no
+     * explicit `instanceId` is given.
+     */
+    instanceId: string | number;
+    children: ReactNode;
+}
+/**
+ * Provides an `instanceId` to descendant `useBloc` calls via React context.
+ *
+ * Descendants calling `useBloc(C)` without an `instanceId` resolve to the id
+ * supplied here. An explicit `instanceId` on the `useBloc` call still wins.
+ * `autoInstance` / `static isolated = true` also override the context, because
+ * those force a per-mount auto-key.
+ *
+ * @example
+ * ```tsx
+ * <BlocProvider instanceId="customer-42">
+ *   <CustomerView />
+ * </BlocProvider>
+ * ```
+ */
+export declare function BlocProvider({ instanceId, children, }: BlocProviderProps): ReactElement;
+/**
+ * Reads the nearest {@link BlocProvider} instance id, or `undefined` when
+ * called outside a provider.
+ */
+export declare function useInstanceIdFromContext(): string | undefined;

package/dist/config.d.ts

@@ -1,24 +1,19 @@
 /**
- * Global configuration for @blac/react
+ * Global configuration for `@blac/react`.
+ *
+ * The hook's tracking model is fixed: when `useBloc` is called without a
+ * `select`, render-time auto-tracking is used (via
+ * `@dirtytalk/structural`'s `trackRender`). When `select` is provided,
+ * re-renders are driven by per-index `Object.is` over the returned array.
+ *
+ * Reserved for forwards-compatible knobs; currently empty.
  */
 export interface BlacReactConfig {
-    /** Enable automatic property tracking via Proxy (default: true) */
-    autoTrack: boolean;
 }
 /**
- * Configure global defaults for @blac/react hooks.
- *
- * @example
- * ```ts
- * import { configureBlacReact } from '@blac/react';
- *
- * // Disable auto-tracking globally
- * configureBlacReact({
- *   autoTrack: false
- * });
- * ```
+ * Configure global defaults for `@blac/react` hooks.
  *
- * @param config - Partial configuration to merge with defaults
+ * @param config - Partial configuration to merge with current globals
  */
 export declare function configureBlacReact(config: Partial<BlacReactConfig>): void;
 /**

package/dist/index.cjs

@@ -1,191 +1,187 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
 let react = require("react");
-react = __toESM(react);
-let _blac_adapter = require("@blac/adapter");
-let globalConfig = { autoTrack: true };
+let _blac_core = require("@blac/core");
+let _dirtytalk_structural = require("@dirtytalk/structural");
+let react_jsx_runtime = require("react/jsx-runtime");
+//#region src/BlocProvider.tsx
+const InstanceIdContext = (0, react.createContext)(void 0);
 /**
-* Configure global defaults for @blac/react hooks.
+* Provides an `instanceId` to descendant `useBloc` calls via React context.
 *
-* @example
-* ```ts
-* import { configureBlacReact } from '@blac/react';
+* Descendants calling `useBloc(C)` without an `instanceId` resolve to the id
+* supplied here. An explicit `instanceId` on the `useBloc` call still wins.
+* `autoInstance` / `static isolated = true` also override the context, because
+* those force a per-mount auto-key.
 *
-* // Disable auto-tracking globally
-* configureBlacReact({
-*   autoTrack: false
-* });
+* @example
+* ```tsx
+* <BlocProvider instanceId="customer-42">
+*   <CustomerView />
+* </BlocProvider>
 * ```
-*
-* @param config - Partial configuration to merge with defaults
 */
-function configureBlacReact(config) {
-	globalConfig = {
-		...globalConfig,
-		...config
-	};
+function BlocProvider({ instanceId, children }) {
+	return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(InstanceIdContext.Provider, {
+		value: String(instanceId),
+		children
+	});
 }
 /**
-* Get the current global configuration.
-* @internal
+* Reads the nearest {@link BlocProvider} instance id, or `undefined` when
+* called outside a provider.
 */
-function getBlacReactConfig() {
-	return globalConfig;
+function useInstanceIdFromContext() {
+	return (0, react.useContext)(InstanceIdContext);
 }
 //#endregion
 //#region src/useBloc.ts
 let nextConsumerId = 0;
-function getComponentName() {
-	try {
-		const owner = (react.default.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE ?? react.default.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED)?.ReactCurrentOwner?.current;
-		if (owner?.type) return owner.type.displayName || owner.type.name || void 0;
-	} catch {}
-}
-function determineTrackingMode(options) {
-	const globalConfig = getBlacReactConfig();
-	const autoTrackEnabled = options?.autoTrack !== void 0 ? options.autoTrack : globalConfig.autoTrack;
-	return {
-		useManualDeps: options?.dependencies !== void 0,
-		autoTrackEnabled
-	};
-}
 /**
-* React hook that connects a component to a state container with automatic re-render on state changes.
+* React hook that connects a component to a state container with automatic
+* re-render on state changes.
+*
+* Two tracking modes:
+* - **Auto-tracking** (default): the returned state value is a proxy that
+*   records read paths during render. The component re-renders when any
+*   recorded path changes. Backed by `@dirtytalk/structural`'s
+*   {@link trackRender} + the container's path-scoped `DirtyChannel`.
+* - **Manual select**: pass `options.select` to opt out of auto-tracking.
+*   The hook re-renders only when the returned array's elements change
+*   (per-index `Object.is`). This replaces the v1 `dependencies` option.
 *
-* Supports three tracking modes:
-* - **Auto-tracking** (default): Automatically detects accessed state properties via Proxy
-* - **Manual dependencies**: Explicit dependency array like useEffect
-* - **No tracking**: Returns full state without optimization
+* Lifecycle:
+* - The bloc is acquired from the registry on mount and released on
+*   unmount. The instance key is the explicit `options.instanceId`, then
+*   the surrounding {@link BlocProvider} context, then the default key.
+* - `options.onMount` fires after the bloc is acquired; `options.onUnmount`
+*   fires *before* the registry releases its ref, so the bloc is still
+*   alive when the callback runs.
 *
 * @template T - The state container constructor type (inferred from BlocClass)
 * @param BlocClass - The state container class to connect to
-* @param options - Configuration options for tracking mode and instance management
-* @returns Tuple with [state, bloc instance, ref]
+* @param options - Configuration options
+* @returns Tuple of `[state, bloc, ref]`
 *
 * @example Basic usage
 * ```ts
-* const [state, myBloc, ref] = useBloc(MyBloc);
+* const [state, bloc] = useBloc(MyBloc);
 * ```
 *
-* @example With manual dependencies
+* @example Manual select (replaces v1 `dependencies`)
 * ```ts
-* const [state, myBloc] = useBloc(MyBloc, {
-*   dependencies: (state) => [state.count]
+* const [state, bloc] = useBloc(MyBloc, {
+*   select: (state) => [state.count],
 * });
 * ```
 *
-* @example With named instance
+* @example Named instance
 * ```ts
-* const [state, myBloc] = useBloc(MyBloc, {
-*   instanceId: 'unique-id'
-* });
+* const [state, bloc] = useBloc(MyBloc, { instanceId: 'cart-42' });
 * ```
 */
 function useBloc(BlocClass, options) {
 	const componentRef = (0, react.useRef)({});
 	const consumerIdRef = (0, react.useRef)(null);
-	if (consumerIdRef.current === null) consumerIdRef.current = String(nextConsumerId++);
-	const componentNameRef = (0, react.useRef)(null);
-	if (componentNameRef.current === null) componentNameRef.current = getComponentName() || null;
-	const depsRef = (0, react.useRef)(options?.dependencies);
-	depsRef.current = options?.dependencies;
-	const instanceId = options?.instanceId;
-	const autoTrack = options?.autoTrack;
-	const dependencies = options?.dependencies;
-	const [bloc, subscribe, getSnapshot, instanceKey, adapterState, rawInstance] = (0, react.useMemo)(() => {
-		const instanceKey = instanceId !== void 0 ? String(instanceId) : void 0;
-		const instance = (0, _blac_adapter.acquire)(BlocClass, instanceKey, `useBloc@${componentNameRef.current ?? "Unknown"}-${consumerIdRef.current}`);
-		const { useManualDeps, autoTrackEnabled } = determineTrackingMode({
-			autoTrack,
-			dependencies
-		});
-		let subscribeFn;
-		let getSnapshotFn;
-		let adapterState;
-		if (useManualDeps && dependencies) {
-			adapterState = (0, _blac_adapter.manualDepsInit)(instance);
-			const stableConfig = { dependencies: (state, bloc) => {
-				const deps = depsRef.current;
-				return deps ? deps(state, bloc) : [];
-			} };
-			subscribeFn = (0, _blac_adapter.manualDepsSubscribe)(instance, adapterState, stableConfig);
-			getSnapshotFn = (0, _blac_adapter.manualDepsSnapshot)(instance, adapterState, stableConfig);
-		} else if (!autoTrackEnabled) {
-			adapterState = (0, _blac_adapter.noTrackInit)(instance);
-			subscribeFn = (0, _blac_adapter.noTrackSubscribe)(instance);
-			getSnapshotFn = (0, _blac_adapter.noTrackSnapshot)(instance);
-		} else {
-			adapterState = (0, _blac_adapter.autoTrackInit)(instance);
-			subscribeFn = (0, _blac_adapter.autoTrackSubscribe)(instance, adapterState);
-			getSnapshotFn = (0, _blac_adapter.autoTrackSnapshot)(instance, adapterState);
-		}
-		const safeSubscribeFn = (callback) => {
-			if (instance.isDisposed) return () => {};
-			return subscribeFn(callback);
+	if (consumerIdRef.current === null) consumerIdRef.current = `useBloc-${nextConsumerId++}`;
+	const consumerId = consumerIdRef.current;
+	(0, react.useId)();
+	const selectRef = (0, react.useRef)(options?.select);
+	selectRef.current = options?.select;
+	const onMountRef = (0, react.useRef)(options?.onMount);
+	onMountRef.current = options?.onMount;
+	const onUnmountRef = (0, react.useRef)(options?.onUnmount);
+	onUnmountRef.current = options?.onUnmount;
+	const args = options?.args;
+	const argsRef = (0, react.useRef)(args);
+	argsRef.current = args;
+	const argsKey = args === void 0 ? void 0 : JSON.stringify(args);
+	const explicitInstanceId = options?.instanceId;
+	const ctxInstanceId = useInstanceIdFromContext();
+	const { bloc, instanceKey } = (0, react.useMemo)(() => {
+		const resolvedKey = (0, _blac_core.resolveInstanceKey)(BlocClass, explicitInstanceId !== void 0 ? String(explicitInstanceId) : ctxInstanceId, argsRef.current);
+		return {
+			bloc: (0, _blac_core.acquire)(BlocClass, resolvedKey, `useBloc@${consumerId}`, argsRef.current),
+			instanceKey: resolvedKey
 		};
-		return [
-			adapterState.proxiedBloc,
-			safeSubscribeFn,
-			getSnapshotFn,
-			instanceKey,
-			adapterState,
-			instance
-		];
-	}, [BlocClass, instanceId]);
-	const state = (0, react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
-	const [, forceUpdate] = (0, react.useReducer)((x) => x + 1, 0);
-	const externalDepsManager = (0, react.useRef)(new _blac_adapter.ExternalDepsManager());
-	(0, react.useEffect)(() => {
-		const manager = externalDepsManager.current;
-		(0, _blac_adapter.disableGetterTracking)(adapterState, rawInstance);
-		manager.updateSubscriptions(adapterState.getterState, rawInstance, forceUpdate);
 	}, [
-		adapterState,
-		rawInstance,
-		forceUpdate
+		BlocClass,
+		explicitInstanceId,
+		ctxInstanceId,
+		argsKey
 	]);
+	const [, force] = (0, react.useReducer)((x) => x + 1, 0);
+	const pathRef = (0, react.useRef)((0, _dirtytalk_structural.emptyPathSet)());
+	const lastSelectionRef = (0, react.useRef)(null);
 	(0, react.useEffect)(() => {
-		const manager = externalDepsManager.current;
-		const devtools = typeof window !== "undefined" ? window.__BLAC_DEVTOOLS__ : void 0;
-		if (devtools?.registerConsumer && rawInstance) devtools.registerConsumer(rawInstance.instanceId, consumerIdRef.current, componentNameRef.current || "Unknown");
-		if (options?.onMount) options.onMount(bloc);
+		const channel = bloc.channel;
+		if (selectRef.current !== void 0) return channel.subscribe(() => _dirtytalk_structural.ALL_PATHS, () => {
+			const select = selectRef.current;
+			if (!select) {
+				force();
+				return;
+			}
+			const next = select(bloc.state, bloc);
+			const prev = lastSelectionRef.current;
+			if (prev !== null && shallowArrayEqual(prev, next)) return;
+			lastSelectionRef.current = next;
+			force();
+		});
+		const unsub = channel.subscribe(() => pathRef.current, () => force());
+		bloc.registerConsumerPaths(consumerId, pathRef.current);
 		return () => {
-			if (devtools?.unregisterConsumer && rawInstance) devtools.unregisterConsumer(rawInstance.instanceId, consumerIdRef.current);
-			manager.cleanup();
-			if (options?.onUnmount) options.onUnmount(bloc);
-			(0, _blac_adapter.release)(BlocClass, instanceKey, false, `useBloc@${componentNameRef.current ?? "Unknown"}-${consumerIdRef.current}`);
+			unsub();
+			bloc.unregisterConsumer(consumerId);
 		};
-	}, []);
+	}, [bloc, consumerId]);
+	(0, react.useEffect)(() => {
+		onMountRef.current?.(bloc);
+		return () => {
+			onUnmountRef.current?.(bloc);
+			(0, _blac_core.release)(BlocClass, instanceKey, false, `useBloc@${consumerId}`);
+		};
+	}, [bloc, instanceKey]);
+	const rawState = bloc.state;
+	let state;
+	if (selectRef.current !== void 0) {
+		state = rawState;
+		if (lastSelectionRef.current === null) lastSelectionRef.current = selectRef.current(rawState, bloc);
+	} else {
+		const tracked = (0, _dirtytalk_structural.trackRender)(rawState, bloc.interner);
+		state = tracked.value;
+		pathRef.current = tracked.paths;
+	}
+	(0, react.useLayoutEffect)(() => {
+		if (selectRef.current !== void 0) return;
+		bloc.registerConsumerPaths(consumerId, pathRef.current);
+	});
 	return [
 		state,
 		bloc,
 		componentRef
 	];
 }
+const shallowArrayEqual = (a, b) => {
+	if (a === b) return true;
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
+	return true;
+};
+let globalConfig = {};
+/**
+* Configure global defaults for `@blac/react` hooks.
+*
+* @param config - Partial configuration to merge with current globals
+*/
+function configureBlacReact(config) {
+	globalConfig = {
+		...globalConfig,
+		...config
+	};
+}
 //#endregion
-exports.__toESM = __toESM;
+exports.BlocProvider = BlocProvider;
 exports.configureBlacReact = configureBlacReact;
 exports.useBloc = useBloc;
+exports.useInstanceIdFromContext = useInstanceIdFromContext;
 
 //# sourceMappingURL=index.cjs.map