@primafuture/contrib-kit-react 1.0.0

package/src/internal/adapter-registry-bridge.ts

@@ -0,0 +1,723 @@
+import type * as contribKitCore from "@primafuture/contrib-kit-core";
+
+import * as adapterRegistryProtocol from "./adapter-registry-protocol.js";
+import * as reactAdapterError from "../react-adapter-error.js";
+
+/** Listener tvar kompatibilní s React external-store subscribe callbackem. */
+export type AdapterExternalStoreListener = () => unknown;
+
+/** Immutable point-specific snapshot token vytvořený pouze mimo render. */
+export interface AdapterPointSnapshotToken {
+	/** Rozlišuje committed point cell od pre-subscribe primitive. */
+	readonly kind: "point";
+	/** Bridge-local monotonní změna bez veřejného identity kontraktu. */
+	readonly serial: number;
+}
+
+/** Hybridní client snapshot před a po committed point bindu. */
+export type AdapterExternalStoreSnapshot =
+	| adapterRegistryProtocol.AdapterRegistrySnapshotToken
+	| AdapterPointSnapshotToken
+	| "contrib-kit-react:server";
+
+/** Constant logical SSR/hydration sentinel bez request-local identity. */
+export const ADAPTER_SERVER_SNAPSHOT = "contrib-kit-react:server";
+
+/** Interní host lifecycle oddělující bridge od konkrétního React hooku. */
+export interface AdapterRegistryBridgeHost {
+	/** Ověří current scope epoch po každém reentrantním Core seam. */
+	readonly checkpoint: () => void;
+	/** Povolí ordinary last-consumer detach pouze během aktivní scope epochy. */
+	readonly canFinalizeDetach: () => boolean;
+	/** Deterministicky naplánuje nejbližší microtask finalizaci. */
+	readonly scheduleMicrotask: (callback: () => void) => void;
+	/** Best-effort seam pro committed lifecycle diagnostiku. */
+	readonly reportLifecycleFailure: (error: reactAdapterError.ReactAdapterError) => void;
+	/** Odstraní fyzicky detached bridge z owning epoch mapy. */
+	readonly onDetached: (bridge: AdapterRegistryBridge) => void;
+}
+
+/** Mutable committed cell jedné exact canonical point reference. */
+interface AdapterPointCell {
+	/** Přesná canonical point capability. */
+	readonly point: contribKitCore.AnyExtensionPoint;
+	/** Insertion-ordered committed React listeners. */
+	readonly listeners: Map<AdapterExternalStoreListener, number>;
+	/** Poslední immutable token viditelný všem consumerům pointu. */
+	token: AdapterPointSnapshotToken;
+}
+
+/** Opaque idempotentní membership jednoho committed subscribe callu. */
+interface AdapterBridgeConsumerRecord {
+	/** Určuje, zda cleanup ještě smí změnit ownership. */
+	active: boolean;
+	/** Point cell sdílený dalšími consumery stejného pointu. */
+	readonly cell: AdapterPointCell;
+	/** Přesný listener předaný React external-store contractem. */
+	readonly listener: AdapterExternalStoreListener;
+}
+
+/** Validovaný immutable event snapshot před jakoukoli bridge mutací. */
+interface CapturedRegistryEvent {
+	/** Exact public Core event kind. */
+	readonly kind: contribKitCore.RegistryEventKind;
+	/** Canonical point references v public committed pořadí. */
+	readonly affectedPoints: readonly contribKitCore.AnyExtensionPoint[];
+}
+
+/** Public Core event kinds přijímané strukturálním subscriberem. */
+const registryEventKinds: ReadonlySet<contribKitCore.RegistryEventKind> = new Set([
+	"pointRegistered",
+	"pointPolicyUpdated",
+	"pointDefinitionRefreshed",
+	"contributionActivated",
+	"contributionDisposed",
+	"contributionReplaced",
+	"pointClosed",
+	"registryDisposing",
+	"registryDisposed",
+]);
+
+/**
+ * Vytvoří stabilní lifecycle chybu bez raw registry, eventu nebo listeneru.
+ */
+function createBridgeError(
+	code: "REACT_REGISTRY_INVALID" | "REACT_REGISTRY_UNAVAILABLE" | "REACT_CALLBACK_FAILED",
+	message: string,
+	field: string,
+	cause?: unknown,
+	preserveCause = false,
+): reactAdapterError.ReactAdapterError {
+	return new reactAdapterError.ReactAdapterError(
+		code,
+		message,
+		preserveCause
+			? { cause, details: { field, phase: "lifecycle" } }
+			: { details: { field, phase: "lifecycle" } },
+	);
+}
+
+/**
+ * Pohltí sync throw, throwing thenable i async rejection cleanup callbacku.
+ */
+function consumeCleanupResult(
+	callback: () => unknown,
+	reportFailure: (cause: unknown) => void,
+): void {
+	let result: unknown;
+	try {
+		result = callback();
+	} catch (cause: unknown) {
+		reportFailure(cause);
+		return;
+	}
+
+	try {
+		void Promise.resolve(result).catch(reportFailure);
+	} catch (cause: unknown) {
+		reportFailure(cause);
+	}
+}
+
+/**
+ * Bezpečně doručí external-store listener bez úniku host failure.
+ */
+function notifyListener(
+	listener: AdapterExternalStoreListener,
+	reportFailure: (cause: unknown) => void,
+): void {
+	consumeCleanupResult(listener, reportFailure);
+}
+
+/**
+ * Přečte jedno event pole právě jednou se zachovaným returned receiverem.
+ */
+function readEventProperty(event: object, property: PropertyKey): unknown {
+	try {
+		return Reflect.get(event, property, event);
+	} catch (cause: unknown) {
+		throw createBridgeError(
+			"REACT_REGISTRY_INVALID",
+			"Unable to read a committed registry event field.",
+			`registryEvent.${String(property)}`,
+			cause,
+			true,
+		);
+	}
+}
+
+/**
+ * Přečte jeden array index bez spreadu nebo iterator user code.
+ */
+function readArrayIndex(values: readonly unknown[], index: number, field: string): unknown {
+	try {
+		return Reflect.get(values, index, values);
+	} catch (cause: unknown) {
+		throw createBridgeError(
+			"REACT_REGISTRY_INVALID",
+			"Unable to read a committed registry event array entry.",
+			`${field}[${index}]`,
+			cause,
+			true,
+		);
+	}
+}
+
+/**
+ * Zachytí a plně validuje event dříve, než změní jediný point token.
+ */
+function captureRegistryEvent(value: unknown): CapturedRegistryEvent {
+	if (typeof value !== "object" || value === null) {
+		throw createBridgeError(
+			"REACT_REGISTRY_INVALID",
+			"Committed registry event must be a non-null object.",
+			"registryEvent",
+		);
+	}
+
+	const revision = readEventProperty(value, "revision");
+	const kind = readEventProperty(value, "kind");
+	const affectedPoints = readEventProperty(value, "affectedPoints");
+	const pointRevisions = readEventProperty(value, "pointRevisions");
+	if (typeof revision !== "number" || !Number.isSafeInteger(revision) || revision < 1) {
+		throw createBridgeError(
+			"REACT_REGISTRY_INVALID",
+			"Committed registry event revision is invalid.",
+			"registryEvent.revision",
+		);
+	}
+	if (typeof kind !== "string" || !registryEventKinds.has(kind as contribKitCore.RegistryEventKind)) {
+		throw createBridgeError(
+			"REACT_REGISTRY_INVALID",
+			"Committed registry event kind is invalid.",
+			"registryEvent.kind",
+		);
+	}
+	if (!Array.isArray(affectedPoints) || !Array.isArray(pointRevisions)) {
+		throw createBridgeError(
+			"REACT_REGISTRY_INVALID",
+			"Committed registry event point collections must be arrays.",
+			"registryEvent.affectedPoints",
+		);
+	}
+	if (affectedPoints.length !== pointRevisions.length) {
+		throw createBridgeError(
+			"REACT_REGISTRY_INVALID",
+			"Committed registry event point collections have different lengths.",
+			"registryEvent.pointRevisions",
+		);
+	}
+
+	const capturedPoints: contribKitCore.AnyExtensionPoint[] = [];
+	for (let index = 0; index < affectedPoints.length; index += 1) {
+		const point = readArrayIndex(affectedPoints, index, "registryEvent.affectedPoints");
+		const entry = readArrayIndex(pointRevisions, index, "registryEvent.pointRevisions");
+		if (typeof point !== "object" || point === null
+			|| typeof entry !== "object" || entry === null) {
+			throw createBridgeError(
+				"REACT_REGISTRY_INVALID",
+				"Committed registry event point entry is invalid.",
+				`registryEvent.pointRevisions[${index}]`,
+			);
+		}
+		const entryPoint = readEventProperty(entry, "point");
+		const pointRevision = readEventProperty(entry, "pointRevision");
+		if (entryPoint !== point
+			|| typeof pointRevision !== "number"
+			|| !Number.isSafeInteger(pointRevision)
+			|| pointRevision < 1) {
+			throw createBridgeError(
+				"REACT_REGISTRY_INVALID",
+				"Committed registry event point revision is invalid.",
+				`registryEvent.pointRevisions[${index}]`,
+			);
+		}
+		capturedPoints.push(point as contribKitCore.AnyExtensionPoint);
+	}
+
+	return Object.freeze({
+		kind: kind as contribKitCore.RegistryEventKind,
+		affectedPoints: Object.freeze(capturedPoints),
+	});
+}
+
+/**
+ * Scope-owned multiplexer jednoho Core subscriberu a exact point cells.
+ */
+export class AdapterRegistryBridge {
+	/** First committed read-once registry protocol držený do detach. */
+	readonly #protocol: adapterRegistryProtocol.AdapterRegistryProtocolSnapshot;
+	/** Owning epoch callbacks a deterministic scheduler. */
+	readonly #host: AdapterRegistryBridgeHost;
+	/** Weak lookup canonical pointu bez process-global retention. */
+	readonly #cellsByPoint = new WeakMap<object, AdapterPointCell>();
+	/** Enumerovatelný bounded set pouze pro global invalidaci a detach. */
+	readonly #cells = new Set<AdapterPointCell>();
+	/** Všechny committed consumer records současné epochy. */
+	readonly #consumers = new Set<AdapterBridgeConsumerRecord>();
+	/** Zachycený Core unsubscribe callback právě aktivního subscriberu. */
+	#unsubscribe: (() => unknown) | undefined;
+	/** Zabrání reentrantnímu druhému fyzickému subscribe pokusu. */
+	#subscribing = false;
+	/** Terminální bridge detach po skutečném grace drainu. */
+	#detached = false;
+	/** Monotónní token rušící stale detach microtask. */
+	#detachGeneration = 0;
+	/** Monotónní serial immutable point snapshotů. */
+	#snapshotSerial = 0;
+	/** První malformed/setup fault sdílený všemi point cells. */
+	#fault: reactAdapterError.ReactAdapterError | undefined;
+	/** Poslední validní registry lifecycle stav z Core eventů. */
+	#registryState: contribKitCore.ExtensionRegistryState = "active";
+
+	/** Vytvoří lazy bridge bez subscriberu, cellu nebo microtasku. */
+	public constructor(
+		protocol: adapterRegistryProtocol.AdapterRegistryProtocolSnapshot,
+		host: AdapterRegistryBridgeHost,
+	) {
+		this.#protocol = protocol;
+		this.#host = host;
+	}
+
+	/** Vrátí přesnou raw registry identity používanou owning mapou. */
+	public readRawRegistry(): object {
+		return this.#protocol.rawRegistry;
+	}
+
+	/** Vrátí první stabilní fault pro následnou hook error projekci. */
+	public readFault(): reactAdapterError.ReactAdapterError | undefined {
+		return this.#fault;
+	}
+
+	/** Vrátí poslední validní registry-wide lifecycle stav. */
+	public readRegistryState(): contribKitCore.ExtensionRegistryState {
+		return this.#registryState;
+	}
+
+	/** Pure lookup již committed point cellu bez vytvoření cache state. */
+	public peekSnapshot(
+		point: contribKitCore.AnyExtensionPoint,
+	): AdapterPointSnapshotToken | undefined {
+		return this.#cellsByPoint.get(point)?.token;
+	}
+
+	/**
+	 * Commit-time acquire jednoho React listeneru se subscription rollbackem.
+	 */
+	public subscribe(
+		point: contribKitCore.AnyExtensionPoint,
+		listener: AdapterExternalStoreListener,
+	): contribKitCore.Unsubscribe {
+		if (typeof listener !== "function") {
+			throw new reactAdapterError.ReactAdapterError(
+				"REACT_INVALID_ARGUMENT",
+				"External-store listener must be callable.",
+				{ details: { field: "listener", phase: "lifecycle" } },
+			);
+		}
+		if (this.#detached) {
+			return function releaseDetachedSubscribe(): void {
+				// Terminálně detached bridge stale subscribe znovu neaktivuje.
+			};
+		}
+
+		this.#host.checkpoint();
+		this.#cancelPendingDetach();
+		if (this.#fault !== undefined || this.#registryState !== "active") {
+			return this.#notifyRejectedSubscribe(listener);
+		}
+
+		const cell = this.#getOrCreateCell(point);
+		const record: AdapterBridgeConsumerRecord = {
+			active: true,
+			cell,
+			listener,
+		};
+		this.#consumers.add(record);
+		cell.listeners.set(listener, (cell.listeners.get(listener) ?? 0) + 1);
+
+		if (this.#unsubscribe === undefined && !this.#establishSubscription()) {
+			this.#removeConsumer(record);
+			return function releaseRejectedProvisionalSubscribe(): void {
+				// Fault už provisional listener invalidoval; stale scope jej nedoručuje.
+			};
+		}
+
+		try {
+			this.#host.checkpoint();
+		} catch {
+			this.#removeConsumer(record);
+			this.#scheduleDetachIfEmpty();
+			return function releaseStaleSubscribe(): void {
+				// Reentrant scope invalidace již provisional membership odstranila.
+			};
+		}
+
+		this.#notifyOne(listener);
+		const bridge = this;
+		/** Idempotentně uvolní právě tuto committed membership. */
+		function releaseConsumer(): void {
+			bridge.#releaseConsumer(record);
+		}
+
+		return releaseConsumer;
+	}
+
+	/**
+	 * Scope cleanup okamžitě revokuje listeners a odloží fyzický unsubscribe.
+	 */
+	public prepareEpochDeactivation(): void {
+		if (this.#detached) {
+			return;
+		}
+		for (const record of [...this.#consumers]) {
+			this.#removeConsumer(record);
+		}
+		this.#scheduleDetach();
+	}
+
+	/** Zruší Strict grace detach před vznikem nového consumeru stejné epochy. */
+	public reactivateEpoch(): void {
+		if (!this.#detached) {
+			this.#cancelPendingDetach();
+		}
+	}
+
+	/** Terminálně odpojí bridge při generation switchi bez grace. */
+	public forceDetach(): void {
+		if (this.#detached) {
+			return;
+		}
+		this.#detachGeneration += 1;
+		for (const record of [...this.#consumers]) {
+			this.#removeConsumer(record);
+		}
+		this.#finalizeDetach();
+	}
+
+	/** Vytvoří immutable point token pouze v commit-time cestě. */
+	#createPointToken(): AdapterPointSnapshotToken {
+		this.#snapshotSerial += 1;
+		return Object.freeze({ kind: "point", serial: this.#snapshotSerial });
+	}
+
+	/** Vrátí existující cell nebo commit-time vytvoří bounded nový cell. */
+	#getOrCreateCell(point: contribKitCore.AnyExtensionPoint): AdapterPointCell {
+		const existing = this.#cellsByPoint.get(point);
+		if (existing !== undefined) {
+			return existing;
+		}
+
+		const created: AdapterPointCell = {
+			point,
+			listeners: new Map(),
+			token: this.#createPointToken(),
+		};
+		this.#cellsByPoint.set(point, created);
+		this.#cells.add(created);
+		return created;
+	}
+
+	/** Připojí jediný Core subscriber a atomicky přijme jeho cleanup capability. */
+	#establishSubscription(): boolean {
+		if (this.#unsubscribe !== undefined) {
+			return true;
+		}
+		if (this.#subscribing) {
+			this.#commitFault(createBridgeError(
+				"REACT_REGISTRY_INVALID",
+				"Registry subscribe reentered before completion.",
+				"registry.subscribe",
+			));
+			return false;
+		}
+
+		this.#subscribing = true;
+		let candidate: unknown;
+		let accepted = false;
+		try {
+			/** Přeloží jeden Core event do no-throw atomic bridge invalidace. */
+			const handleRegistryEvent = (event: contribKitCore.RegistryCommittedEvent): void => {
+				this.#handleRegistryEvent(event);
+			};
+			candidate = adapterRegistryProtocol.subscribeAdapterRegistry(
+				this.#protocol,
+				handleRegistryEvent,
+			);
+			if (typeof candidate !== "function") {
+				throw createBridgeError(
+					"REACT_REGISTRY_INVALID",
+					"Registry subscribe must return a callable unsubscribe.",
+					"registry.subscribe",
+				);
+			}
+
+			this.#host.checkpoint();
+			adapterRegistryProtocol.requireAdapterRegistryAvailable(
+				this.#protocol,
+				"lifecycle",
+				this.#host.checkpoint,
+			);
+			if (this.#fault !== undefined) {
+				throw this.#fault;
+			}
+			this.#unsubscribe = candidate as () => unknown;
+			accepted = true;
+			return true;
+		} catch (cause: unknown) {
+			if (typeof candidate === "function" && !accepted) {
+				this.#consumeUnsubscribe(candidate as () => unknown);
+			}
+			const classified = this.#classifySubscribeFailure(cause);
+			if (classified !== undefined) {
+				this.#commitFault(classified);
+			}
+			return false;
+		} finally {
+			this.#subscribing = false;
+		}
+	}
+
+	/** Zachová lifecycle precedence po throwing nebo reentrantním subscribe seamu. */
+	#classifySubscribeFailure(
+		cause: unknown,
+	): reactAdapterError.ReactAdapterError | undefined {
+		try {
+			this.#host.checkpoint();
+		} catch {
+			return undefined;
+		}
+
+		try {
+			adapterRegistryProtocol.requireAdapterRegistryAvailable(
+				this.#protocol,
+				"lifecycle",
+				this.#host.checkpoint,
+			);
+		} catch (availabilityError: unknown) {
+			if (availabilityError instanceof reactAdapterError.ReactAdapterError) {
+				return availabilityError;
+			}
+			return createBridgeError(
+				"REACT_REGISTRY_UNAVAILABLE",
+				"Registry became unavailable during subscribe.",
+				"registry.state",
+				availabilityError,
+				true,
+			);
+		}
+
+		if (cause instanceof reactAdapterError.ReactAdapterError) {
+			return cause;
+		}
+		return createBridgeError(
+			"REACT_REGISTRY_INVALID",
+			"Registry subscribe failed.",
+			"registry.subscribe",
+			cause,
+			true,
+		);
+	}
+
+	/** No-throw subscriber boundary s atomic capture-before-commit chováním. */
+	#handleRegistryEvent(value: unknown): void {
+		if (this.#detached || this.#fault !== undefined) {
+			return;
+		}
+
+		let event: CapturedRegistryEvent;
+		try {
+			event = captureRegistryEvent(value);
+		} catch (error: unknown) {
+			this.#commitFault(error instanceof reactAdapterError.ReactAdapterError
+				? error
+				: createBridgeError(
+					"REACT_REGISTRY_INVALID",
+					"Committed registry event capture failed.",
+					"registryEvent",
+					error,
+					true,
+				));
+			return;
+		}
+
+		if (event.kind === "registryDisposing" || event.kind === "registryDisposed") {
+			this.#registryState = event.kind === "registryDisposing" ? "disposing" : "disposed";
+			for (const cell of this.#cells) {
+				this.#bumpCell(cell);
+			}
+			if (event.kind === "registryDisposed") {
+				this.#detachPhysicalSubscription();
+			}
+			return;
+		}
+
+		const affected = new Set(event.affectedPoints);
+		for (const cell of this.#cells) {
+			if (affected.has(cell.point)) {
+				this.#bumpCell(cell);
+			}
+		}
+	}
+
+	/** Atomicky faultne bridge, posune všechny cells a odpojí event autoritu. */
+	#commitFault(error: reactAdapterError.ReactAdapterError): void {
+		if (this.#fault !== undefined || this.#detached) {
+			return;
+		}
+		this.#fault = error;
+		for (const cell of this.#cells) {
+			this.#bumpCell(cell);
+		}
+		this.#detachPhysicalSubscription();
+		this.#reportLifecycleFailure(error);
+	}
+
+	/** Posune jeden cell token a doručí snapshot současných listeners. */
+	#bumpCell(cell: AdapterPointCell): void {
+		cell.token = this.#createPointToken();
+		for (const listener of [...cell.listeners.keys()]) {
+			this.#notifyOne(listener);
+		}
+	}
+
+	/** Bezpečně doručí jeden listener a izoluje jeho případné selhání. */
+	#notifyOne(listener: AdapterExternalStoreListener): void {
+		notifyListener(listener, (cause: unknown): void => {
+			this.#reportLifecycleFailure(createBridgeError(
+				"REACT_CALLBACK_FAILED",
+				"External-store listener failed.",
+				"listener",
+				cause,
+				true,
+			));
+		});
+	}
+
+	/** Vrátí stable no-op cleanup a synchronně vynutí snapshot recheck. */
+	#notifyRejectedSubscribe(listener: AdapterExternalStoreListener): contribKitCore.Unsubscribe {
+		this.#notifyOne(listener);
+		return function releaseRejectedSubscribe(): void {
+			// Rejected membership nikdy nezískala bridge ownership.
+		};
+	}
+
+	/** Idempotentně uvolní jeden committed consumer record. */
+	#releaseConsumer(record: AdapterBridgeConsumerRecord): void {
+		if (!record.active) {
+			return;
+		}
+		this.#removeConsumer(record);
+		this.#scheduleDetachIfEmpty();
+	}
+
+	/** Odstraní membership bez spuštění detach policy. */
+	#removeConsumer(record: AdapterBridgeConsumerRecord): void {
+		if (!record.active) {
+			return;
+		}
+		record.active = false;
+		this.#consumers.delete(record);
+		const listenerCount = record.cell.listeners.get(record.listener);
+		if (listenerCount === 1) {
+			record.cell.listeners.delete(record.listener);
+		} else if (listenerCount !== undefined) {
+			record.cell.listeners.set(record.listener, listenerCount - 1);
+		}
+		if (record.cell.listeners.size === 0) {
+			this.#cells.delete(record.cell);
+			this.#cellsByPoint.delete(record.cell.point);
+		}
+	}
+
+	/** Naplánuje bridge detach pouze po skutečně posledním consumeru. */
+	#scheduleDetachIfEmpty(): void {
+		if (this.#consumers.size === 0) {
+			this.#scheduleDetach();
+		}
+	}
+
+	/** Naplánuje tokenově guarded microtask fyzického detach. */
+	#scheduleDetach(): void {
+		if (this.#detached) {
+			return;
+		}
+		this.#detachGeneration += 1;
+		const generation = this.#detachGeneration;
+		this.#host.scheduleMicrotask((): void => {
+			if (this.#detached
+				|| generation !== this.#detachGeneration
+				|| this.#consumers.size !== 0
+				|| !this.#host.canFinalizeDetach()) {
+				return;
+			}
+			this.#finalizeDetach();
+		});
+	}
+
+	/** Zruší stale last-release nebo epoch-deactivation drain. */
+	#cancelPendingDetach(): void {
+		this.#detachGeneration += 1;
+	}
+
+	/** Terminálně vyčistí bridge a oznámí owning epoch mapě detach. */
+	#finalizeDetach(): void {
+		if (this.#detached) {
+			return;
+		}
+		this.#detached = true;
+		this.#detachPhysicalSubscription();
+		for (const cell of this.#cells) {
+			this.#cellsByPoint.delete(cell.point);
+			cell.listeners.clear();
+		}
+		this.#cells.clear();
+		this.#consumers.clear();
+		try {
+			this.#host.onDetached(this);
+		} catch (cause: unknown) {
+			this.#reportLifecycleFailure(createBridgeError(
+				"REACT_CALLBACK_FAILED",
+				"Bridge detach callback failed.",
+				"bridge.onDetached",
+				cause,
+				true,
+			));
+		}
+	}
+
+	/** Vyjme Core unsubscribe před best-effort voláním s undefined receiverem. */
+	#detachPhysicalSubscription(): void {
+		const unsubscribe = this.#unsubscribe;
+		if (unsubscribe === undefined) {
+			return;
+		}
+		this.#unsubscribe = undefined;
+		this.#consumeUnsubscribe(unsubscribe);
+	}
+
+	/** Spotřebuje všechny cleanup outcomes bez druhého lifecycle outcome. */
+	#consumeUnsubscribe(unsubscribe: () => unknown): void {
+		consumeCleanupResult(
+			(): unknown => Reflect.apply(unsubscribe, undefined, []),
+			(cause: unknown): void => {
+				this.#reportLifecycleFailure(createBridgeError(
+					"REACT_CALLBACK_FAILED",
+					"Registry unsubscribe failed.",
+					"registry.unsubscribe",
+					cause,
+					true,
+				));
+			},
+		);
+	}
+
+	/** Izoluje lifecycle reporter jako poslední best-effort hranici. */
+	#reportLifecycleFailure(error: reactAdapterError.ReactAdapterError): void {
+		try {
+			this.#host.reportLifecycleFailure(error);
+		} catch {
+			// Diagnostic seam nemá business ani lifecycle autoritu.
+		}
+	}
+}