@primafuture/contrib-kit-react 1.0.0

package/src/internal/outlet-membership-boundary.ts

@@ -0,0 +1,1048 @@
+import type * as contribKitCore from "@primafuture/contrib-kit-core";
+import * as react from "react";
+
+import type * as adapterScope from "./adapter-scope.js";
+import type * as adapterConfiguration from "./adapter-configuration.js";
+import type * as implementationClassifier from "./implementation-classifier.js";
+import * as managedLazyGeneration from "./managed-lazy-generation.js";
+import type * as outletCommitLease from "./outlet-commit-lease.js";
+import * as outletErrorPipeline from "./outlet-error-pipeline.js";
+import * as outletInput from "./outlet-input.js";
+import type * as outletMembership from "./outlet-membership.js";
+import * as outletReporterBoundary from "./outlet-reporter-boundary.js";
+import type * as outletProjection from "./outlet-projection.js";
+import type * as contributionComponent from "../contribution-component.js";
+import * as reactAdapterDiagnostics from "../react-adapter-diagnostics.js";
+import type * as reactAdapterError from "../react-adapter-error.js";
+import * as reactAdapterErrorRuntime from "../react-adapter-error.js";
+import type * as reactExtensionPoint from "../react-extension-point.js";
+
+/** Props jedné interní package-owned membership boundary. */
+export interface OutletMembershipBoundaryProps<
+	Point extends reactExtensionPoint.AnyReactExtensionPoint,
+> {
+	/** Read-once outlet input pro current render snapshot. */
+	readonly input: outletInput.CapturedOutletInput<Point>;
+	/** Exact projected membership včetně retained local tokenu. */
+	readonly membership: outletMembership.OutletMembershipEntry<Point>;
+	/** Commit-owned outlet lease; server a první hydration render ji ještě nemají. */
+	readonly outletLease: outletCommitLease.OutletCommitLease | undefined;
+	/** Exact raw registry reference jako první osa identity. */
+	readonly rawRegistry: object;
+	/** Stabilní adapter scope vlastnící boundary ID allocator. */
+	readonly scope: adapterScope.AdapterScopeRuntime;
+	/** Exact provider/outlet generation pro commit acquire. */
+	readonly scopeGeneration: adapterScope.AdapterScopeGeneration;
+}
+
+/** Opaque generation token remountující pouze affected membership subtree. */
+interface OutletRetryGenerationToken {
+	/** Privátní runtime-prázdný marker. */
+	readonly kind?: never;
+}
+
+/** Render mode jedné membership retry generation. */
+type OutletMembershipRenderMode =
+	| "rendering"
+	| "captured"
+	| "hidden"
+	| "fallback"
+	| "escalating";
+
+/** Boundary-local managed-lazy presentation nezávislá na Core membership seedu. */
+type OutletManagedLazyStatus = "inactive" | "loading" | "ready" | "failed";
+
+/** Kompletní class state včetně identity a current error presentation. */
+interface OutletMembershipBoundaryState {
+	/** Přesný cause zachycený React boundary lifecyclem. */
+	readonly capturedCause: unknown;
+	/** Exact cause připravený pro host escalation. */
+	readonly escalationCause: unknown;
+	/** Opaque attempt token vzniklý pouze při captured failure. */
+	readonly errorAttemptToken: object | undefined;
+	/** Zda state skutečně nese captured cause i při undefined hodnotě. */
+	readonly hasCapturedCause: boolean;
+	/** Eager componenta vrácená current lazy generation. */
+	readonly lazyComponent: unknown;
+	/** Loader zachycený jednou při vzniku exact membership identity. */
+	readonly lazyLoad: implementationClassifier.CapturedReactLazyLoader | undefined;
+	/** Current boundary-local managed-lazy presentation. */
+	readonly lazyStatus: OutletManagedLazyStatus;
+	/** Raw registry osa current membership identity. */
+	readonly rawRegistry: object;
+	/** Opaque Core registration osa current membership identity. */
+	readonly registrationId: string;
+	/** Retained local membership token current identity. */
+	readonly membershipToken: outletMembership.OutletMembershipToken;
+	/** Aktuální render/policy větev. */
+	readonly mode: OutletMembershipRenderMode;
+	/** Frozen primary event pro hidden/fallback/escalation evidenci. */
+	readonly primaryError: reactAdapterDiagnostics.ReactAdapterErrorEvent | undefined;
+	/** Generation-bound retry capability current primary failure. */
+	readonly retry: (() => void) | undefined;
+	/** Monotonická retry generation začínající nulou. */
+	readonly retryGeneration: number;
+	/** Opaque token exact retry generation. */
+	readonly retryToken: OutletRetryGenerationToken;
+	/** Monotonická subtree identita měněná při registry/membership resetu. */
+	readonly subtreeGeneration: number;
+}
+
+/** Mutable interní authority jednoho primary failure attemptu. */
+interface OutletPrimaryFailureAttempt {
+	/** Sync invalidace před accepted retry nebo lifecycle cleanupem. */
+	authoritative: boolean;
+	/** Exact boundary lease bránící oživení capability v nové scope epoše. */
+	readonly boundaryLease: outletCommitLease.OutletCommitLease;
+	/** At-most-once guard celé committed primary pipeline. */
+	published: boolean;
+	/** Exact error attempt token z React/synthetic capture. */
+	readonly errorAttemptToken: object;
+	/** Exact membership token chránící identity switch. */
+	readonly membershipToken: outletMembership.OutletMembershipToken;
+	/** Public capability s vlastní at-most-once autoritou. */
+	retry: () => void;
+	/** Exact retry generation token chránící ordinary rerender. */
+	readonly retryToken: OutletRetryGenerationToken;
+}
+
+/** Commit-time safe channel jednoho managed-lazy attemptu. */
+interface OutletManagedLazyDiagnosticChannel {
+	/** Opaque boundary identita přidělená před loader startem. */
+	readonly boundaryId: string;
+	/** Effective read-once sink konfigurace owning outlet generation. */
+	readonly configuration: adapterConfiguration.AdapterScopeConfiguration;
+	/** Bezpečná contribution metadata bez dat nebo implementation. */
+	readonly contribution: reactAdapterDiagnostics.ReadonlyContributionMetadata;
+	/** Exact outlet lease, jejíž retirement umlčí pozdní settlement. */
+	readonly outletLease: outletCommitLease.OutletCommitLease;
+	/** Volitelná bezpečná point metadata bez runtime capability. */
+	readonly point?: reactAdapterDiagnostics.ReadonlyPointMetadata;
+	/** Exact raw registry pouze pro live retirement gate, nikdy pro event payload. */
+	readonly rawRegistry: object;
+	/** Public retry generation původního loader attemptu. */
+	readonly retryGeneration: number;
+	/** Stabilní scope, který vlastní diagnostickou epochu. */
+	readonly scope: adapterScope.AdapterScopeRuntime;
+	/** Exact scope generation owning loader start. */
+	readonly scopeGeneration: adapterScope.AdapterScopeGeneration;
+}
+
+/** Props čistého contribution/loading rendereru uvnitř primary boundary. */
+interface OutletMembershipRendererProps<
+	Point extends reactExtensionPoint.AnyReactExtensionPoint,
+> {
+	/** Current read-once outlet callback set. */
+	readonly input: outletInput.CapturedOutletInput<Point>;
+	/** Current ready nebo loading projected seed. */
+	readonly seed:
+		| outletProjection.OutletReadyMembershipSeed<Point>
+		| outletProjection.OutletLoadingMembershipSeed<Point>;
+}
+
+/** Props host fallback rendereru izolovaného reporter boundary. */
+interface OutletContributionFallbackRendererProps<
+	Point extends reactExtensionPoint.AnyReactExtensionPoint,
+> {
+	/** Frozen public error event current primary failure. */
+	readonly error: reactAdapterDiagnostics.ReactAdapterErrorEvent;
+	/** Read-once captured fallback callback. */
+	readonly renderContributionError: outletInput.CapturedOutletCallback<unknown, react.ReactNode>;
+	/** Current membership render seed s logical placementem. */
+	readonly seed: outletProjection.OutletProjectedMembershipSeed<Point>;
+	/** Generation-bound retry capability. */
+	readonly retry: () => void;
+}
+
+/** Vytvoří nový render-pure opaque retry generation token. */
+function createRetryGenerationToken(): OutletRetryGenerationToken {
+	return Object.freeze({});
+}
+
+/** Vytvoří počáteční nebo identity-reset state před renderem nové membership. */
+function createMembershipBoundaryState<
+	Point extends reactExtensionPoint.AnyReactExtensionPoint,
+>(
+	props: OutletMembershipBoundaryProps<Point>,
+	subtreeGeneration = 0,
+): OutletMembershipBoundaryState {
+	const seed = props.membership.seed;
+	return {
+		capturedCause: undefined,
+		escalationCause: undefined,
+		errorAttemptToken: undefined,
+		hasCapturedCause: false,
+		lazyComponent: undefined,
+		lazyLoad: seed.kind === "loading" ? seed.load : undefined,
+		lazyStatus: seed.kind === "loading" ? "loading" : "inactive",
+		rawRegistry: props.rawRegistry,
+		registrationId: props.membership.seed.registrationId,
+		membershipToken: props.membership.token,
+		mode: "rendering",
+		primaryError: undefined,
+		retry: undefined,
+		retryGeneration: 0,
+		retryToken: createRetryGenerationToken(),
+		subtreeGeneration,
+	};
+}
+
+/** Renderuje ready nebo loading větev uvnitř package class boundary. */
+function OutletMembershipRenderer<
+	Point extends reactExtensionPoint.AnyReactExtensionPoint,
+>(
+	props: OutletMembershipRendererProps<Point>,
+): react.ReactElement | null {
+	const seed = props.seed;
+	if (seed.kind === "loading") {
+		if (props.input.renderLoading === undefined) {
+			return null;
+		}
+		const rendered = outletInput.callCapturedOutletCallback(
+			props.input.renderLoading,
+			seed.renderState,
+		);
+		return react.createElement(react.Fragment, null, rendered);
+	}
+	if (props.input.renderContribution !== undefined) {
+		const rendered = outletInput.callCapturedOutletCallback(
+			props.input.renderContribution,
+			seed.renderState,
+		);
+		return react.createElement(react.Fragment, null, rendered);
+	}
+	return react.createElement(seed.renderState.component, seed.renderState.componentProps);
+}
+
+/** Volá contribution fallback uvnitř samostatné reporter class boundary. */
+function OutletContributionFallbackRenderer<
+	Point extends reactExtensionPoint.AnyReactExtensionPoint,
+>(
+	props: OutletContributionFallbackRendererProps<Point>,
+): react.ReactElement {
+	const state = Object.freeze({
+		...props.seed.renderState,
+		error: props.error,
+		retry: props.retry,
+	});
+	const rendered = outletInput.callCapturedOutletCallback(
+		props.renderContributionError,
+		state,
+	);
+	return react.createElement(react.Fragment, null, rendered);
+}
+
+/** Vrátí exact synthetic cause, nebo původní classifier cause ReactAdapterErroru. */
+function resolveProjectedFailureCause(error: reactAdapterError.ReactAdapterError): unknown {
+	return Object.hasOwn(error, "cause") ? error.cause : error;
+}
+
+/** Odvodí public phase z bezpečných details, jinak použije render. */
+function resolveProjectedFailurePhase(
+	error: reactAdapterError.ReactAdapterError,
+): reactAdapterError.ReactAdapterErrorPhase {
+	const phase = error.details.phase;
+	return phase === "configuration"
+		|| phase === "resolve"
+		|| phase === "load"
+		|| phase === "render"
+		|| phase === "customRender"
+		|| phase === "fallback"
+		|| phase === "policy"
+		|| phase === "projection"
+		|| phase === "callback"
+		|| phase === "lifecycle"
+		? phase
+		: "render";
+}
+
+/** Projektuje pouze bezpečnou identitu current managed-lazy contribution. */
+function createManagedLazyContributionMetadata<
+	Point extends reactExtensionPoint.AnyReactExtensionPoint,
+>(
+	seed: outletProjection.OutletLoadingMembershipSeed<Point>,
+): reactAdapterDiagnostics.ReadonlyContributionMetadata {
+	const contribution = seed.renderState.contribution;
+	return Object.freeze({
+		registrationId: seed.registrationId,
+		contributionId: contribution.contributionId,
+		...(contribution.contributorId === undefined
+			? {}
+			: { contributorId: contribution.contributorId }),
+		...(contribution.label === undefined ? {} : { label: contribution.label }),
+		...(contribution.localName === undefined
+			? {}
+			: { localName: contribution.localName }),
+	});
+}
+
+/** Ověří active live registry bez propouštění hostile state accessoru. */
+function isManagedLazyRegistryActive(rawRegistry: object): boolean {
+	try {
+		return Reflect.get(rawRegistry, "state", rawRegistry) === "active";
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Interní class error boundary jedné exact Core membership.
+ */
+export class OutletMembershipBoundary<
+	Point extends reactExtensionPoint.AnyReactExtensionPoint,
+> extends react.Component<
+	OutletMembershipBoundaryProps<Point>,
+	OutletMembershipBoundaryState
+> {
+	/** Current identity/generation/presentation state. */
+	public override state: OutletMembershipBoundaryState;
+
+	/** Current commit-owned boundary ID lease. */
+	#boundaryLease: outletCommitLease.OutletCommitLease | undefined;
+	/** Membership token, pro který current lease vznikla. */
+	#boundaryLeaseToken: outletMembership.OutletMembershipToken | undefined;
+	/** Current mutable primary attempt authority. */
+	#primaryAttempt: OutletPrimaryFailureAttempt | undefined;
+	/** Poslední retry generation již doručená onRetry callbacku. */
+	#reportedRetryGeneration = 0;
+	/** Current resource-free nebo started managed-lazy operation. */
+	#lazyOperation: managedLazyGeneration.ManagedLazyGenerationOperation | undefined;
+	/** Membership token owning current lazy operation. */
+	#lazyOperationMembershipToken: outletMembership.OutletMembershipToken | undefined;
+	/** Retry token owning current lazy operation. */
+	#lazyOperationRetryToken: OutletRetryGenerationToken | undefined;
+	/** Zabraňuje novému attemptu během loading-error invalidace a abortu. */
+	#lazyStartBarrier = 0;
+	/** Terminální guard skutečného unmountu i Strict grace mezery. */
+	#unmounted = false;
+
+	/** Vytvoří resource-free initial state a operation bez loader side effectu. */
+	public constructor(props: OutletMembershipBoundaryProps<Point>) {
+		super(props);
+		this.state = createMembershipBoundaryState(props);
+		this.#synchronizeLazyOperation();
+	}
+
+	/** Capture descendant error bez sinku, callbacku, policy nebo Core callu. */
+	public static getDerivedStateFromError(cause: unknown): Partial<OutletMembershipBoundaryState> {
+		return {
+			capturedCause: cause,
+			errorAttemptToken: Object.freeze({}),
+			hasCapturedCause: true,
+			mode: "captured",
+			primaryError: undefined,
+			retry: undefined,
+		};
+	}
+
+	/** Resetuje celý boundary state před renderem jiné identity tuple. */
+	public static getDerivedStateFromProps(
+		props: OutletMembershipBoundaryProps<reactExtensionPoint.AnyReactExtensionPoint>,
+		state: OutletMembershipBoundaryState,
+	): OutletMembershipBoundaryState | null {
+		return props.rawRegistry === state.rawRegistry
+			&& props.membership.seed.registrationId === state.registrationId
+			&& props.membership.token === state.membershipToken
+			? null
+			: createMembershipBoundaryState(props, state.subtreeGeneration + 1);
+	}
+
+	/** Commit acquire boundary identity a případné synthetic seed failure. */
+	public override componentDidMount(): void {
+		this.#unmounted = false;
+		this.#synchronizeBoundaryLease();
+		this.#reactivatePreservedPrimaryAttempt();
+		const operationChanged = this.#synchronizeLazyOperation();
+		this.#commitProjectedFailure();
+		if (operationChanged) {
+			this.forceUpdate();
+		}
+	}
+
+	/** Synchronizuje identity switch, committed retry event a current seed failure. */
+	public override componentDidUpdate(
+		_previousProps: OutletMembershipBoundaryProps<Point>,
+		previousState: OutletMembershipBoundaryState,
+	): void {
+		if (previousState.membershipToken !== this.state.membershipToken
+			|| previousState.rawRegistry !== this.state.rawRegistry
+			|| previousState.registrationId !== this.state.registrationId) {
+			this.#invalidatePrimaryAttempt();
+			const dispatchAbort = this.#invalidateLazyOperation();
+			dispatchAbort();
+			this.#reportedRetryGeneration = 0;
+		}
+		this.#synchronizeBoundaryLease();
+		this.#reactivatePreservedPrimaryAttempt();
+		const operationChanged = this.#synchronizeLazyOperation();
+		if (previousState.retryGeneration !== this.state.retryGeneration) {
+			this.#reportCommittedRetry();
+		}
+		this.#commitProjectedFailure();
+		if (operationChanged) {
+			this.forceUpdate();
+		}
+	}
+
+	/** Commit point primary render chyby spustí pipeline právě jednou. */
+	public override componentDidCatch(cause: unknown, info: react.ErrorInfo): void {
+		const attemptToken = this.state.errorAttemptToken;
+		if (!this.state.hasCapturedCause || attemptToken === undefined) {
+			return;
+		}
+		const phase = this.#readRenderFailurePhase();
+		const reactComponentStack = outletErrorPipeline.normalizeReactComponentStack(
+			info.componentStack,
+		);
+		if (this.state.lazyStatus !== "loading") {
+			this.#commitPrimaryFailure(
+				attemptToken,
+				"REACT_RENDER_FAILED",
+				phase,
+				cause,
+				reactComponentStack,
+			);
+			return;
+		}
+
+		const dispatchAbort = this.#invalidateLazyOperation();
+		this.#lazyStartBarrier += 1;
+		try {
+			this.#commitPrimaryFailure(
+				attemptToken,
+				"REACT_RENDER_FAILED",
+				phase,
+				cause,
+				reactComponentStack,
+			);
+		} finally {
+			try {
+				dispatchAbort();
+			} finally {
+				this.#lazyStartBarrier -= 1;
+			}
+		}
+	}
+
+	/** Synchronous invalidace před release commit-owned boundary lease. */
+	public override componentWillUnmount(): void {
+		this.#unmounted = true;
+		this.#invalidatePrimaryAttempt();
+		this.#releaseBoundaryLease();
+	}
+
+	/** Renderuje current membership, provisional null, fallback nebo exact escalation. */
+	public override render(): react.ReactNode {
+		if (this.state.mode === "escalating") {
+			throw this.state.escalationCause;
+		}
+		if (this.state.mode === "captured" || this.state.mode === "hidden") {
+			return null;
+		}
+		if (this.state.mode === "fallback") {
+			return this.#renderFallback();
+		}
+		const seed = this.props.membership.seed;
+		if (seed.kind === "failed") {
+			return null;
+		}
+		if (seed.kind === "loading" && this.state.lazyStatus === "failed") {
+			return null;
+		}
+		const rendered = react.createElement(OutletMembershipRenderer<Point>, {
+			key: `${this.state.subtreeGeneration}:${this.state.retryGeneration}`,
+			input: this.props.input,
+			seed: this.#createCurrentRenderSeed(seed),
+		});
+		const operation = this.#readCurrentLazyOperation();
+		return operation === undefined
+			? rendered
+			: react.createElement(
+				managedLazyGeneration.ManagedLazyCommitLease,
+				{ children: rendered, operation },
+			);
+	}
+
+	/**
+	 * Převede loaded lazy componentu na ready seed s nejnovějším render inputem.
+	 */
+	#createCurrentRenderSeed(
+		seed:
+			| outletProjection.OutletReadyMembershipSeed<Point>
+			| outletProjection.OutletLoadingMembershipSeed<Point>,
+	):
+		| outletProjection.OutletReadyMembershipSeed<Point>
+		| outletProjection.OutletLoadingMembershipSeed<Point> {
+		if (seed.kind !== "loading" || this.state.lazyStatus !== "ready") {
+			return seed;
+		}
+		const component = this.state.lazyComponent as contributionComponent.ReactContributionComponent<
+			contribKitCore.ExtensionPointContext<Point>,
+			contribKitCore.ExtensionPointData<Point>
+		>;
+		const componentProps = Object.freeze({
+			context: seed.renderState.context,
+			contribution: seed.renderState.contribution,
+			placement: seed.renderState.placement,
+		});
+		return Object.freeze({
+			kind: "ready",
+			registrationId: seed.registrationId,
+			renderState: Object.freeze({
+				...seed.renderState,
+				component,
+				componentProps,
+			}),
+		});
+	}
+
+	/** Vrátí operation pouze pro exact renderovanou loading generation. */
+	#readCurrentLazyOperation(): managedLazyGeneration.ManagedLazyGenerationOperation | undefined {
+		return this.state.lazyStatus === "loading"
+			&& this.#lazyStartBarrier === 0
+			&& this.#lazyOperationMembershipToken === this.state.membershipToken
+			&& this.#lazyOperationRetryToken === this.state.retryToken
+			? this.#lazyOperation
+			: undefined;
+	}
+
+	/**
+	 * Vytvoří nejvýše jednu resource-free operation pro exact retry generation.
+	 */
+	#synchronizeLazyOperation(): boolean {
+		const load = this.state.lazyLoad;
+		const seed = this.props.membership.seed;
+		const outletLease = this.props.outletLease;
+		if (outletLease === undefined
+			|| this.state.lazyStatus !== "loading" || load === undefined
+			|| seed.kind !== "loading" || this.#lazyStartBarrier > 0) {
+			return false;
+		}
+		if (this.#lazyOperation !== undefined
+			&& this.#lazyOperationMembershipToken === this.state.membershipToken
+			&& this.#lazyOperationRetryToken === this.state.retryToken) {
+			this.#lazyOperation.requestStartRecheck();
+			return false;
+		}
+
+		const dispatchPreviousAbort = this.#invalidateLazyOperation();
+		dispatchPreviousAbort();
+		const membershipToken = this.state.membershipToken;
+		const retryToken = this.state.retryToken;
+		const retryGeneration = this.state.retryGeneration;
+		const scope = this.props.scope;
+		const scopeGeneration = this.props.scopeGeneration;
+		const rawRegistry = this.props.rawRegistry;
+		const configuration = this.props.input.configuration;
+		const contribution = createManagedLazyContributionMetadata(seed);
+		const point = reactAdapterDiagnostics.createPointMetadata(seed.renderState.point);
+		let diagnosticChannel: OutletManagedLazyDiagnosticChannel | undefined;
+		let lifecycleFailureReported = false;
+		let operation: managedLazyGeneration.ManagedLazyGenerationOperation;
+		/** Otestuje current operation včetně committed outlet a scope lease. */
+		function isCurrentOperation(boundary: OutletMembershipBoundary<Point>): boolean {
+			return boundary.#lazyOperation === operation
+				&& boundary.state.lazyStatus === "loading"
+				&& boundary.#lazyStartBarrier === 0
+				&& boundary.#isGenerationCurrent(membershipToken, retryToken);
+		}
+		operation = new managedLazyGeneration.ManagedLazyGenerationOperation(
+			retryGeneration,
+			load,
+			Object.freeze({
+				isCurrent: (): boolean => isCurrentOperation(this),
+				onResolved: (component: unknown): void => {
+					this.#publishLazyComponent(operation, membershipToken, retryToken, component);
+				},
+				onFailed: (failure: managedLazyGeneration.ManagedLazyGenerationFailure): void => {
+					this.#publishLazyFailure(operation, membershipToken, retryToken, failure);
+				},
+				onLate: (outcome: "resolved" | "rejected"): void => {
+					this.#reportLateLazyResult(operation, diagnosticChannel, outcome);
+				},
+				onLifecycleFailure: (cause: unknown): void => {
+					if (lifecycleFailureReported) {
+						return;
+					}
+					lifecycleFailureReported = true;
+					this.#reportLazyLifecycleFailure(diagnosticChannel, cause);
+				},
+				registerInvalidation: (
+					invalidate: () => managedLazyGeneration.ManagedLazyAbortDispatch,
+				): contribKitCore.Unsubscribe => {
+					const boundaryLease = this.#boundaryLease;
+					if (boundaryLease !== undefined
+						&& boundaryLease.isCurrent()
+						&& outletLease.isCurrent()
+						&& scope.isGenerationActive(scopeGeneration)) {
+						diagnosticChannel = Object.freeze({
+							boundaryId: boundaryLease.id,
+							configuration,
+							contribution,
+							outletLease,
+							...(point === undefined ? {} : { point }),
+							rawRegistry,
+							retryGeneration,
+							scope,
+							scopeGeneration,
+						});
+					}
+					return scope.registerEpochAbortable(
+						scopeGeneration,
+						(): managedLazyGeneration.ManagedLazyAbortDispatch => {
+							if (this.#lazyOperation === operation) {
+								this.#lazyOperation = undefined;
+								this.#lazyOperationMembershipToken = undefined;
+								this.#lazyOperationRetryToken = undefined;
+							}
+							return invalidate();
+						},
+					);
+				},
+			}),
+		);
+		this.#lazyOperation = operation;
+		this.#lazyOperationMembershipToken = membershipToken;
+		this.#lazyOperationRetryToken = retryToken;
+		return true;
+	}
+
+	/** Doručí jeden safe late-result event pouze do stále vlastněného channelu. */
+	#reportLateLazyResult(
+		operation: managedLazyGeneration.ManagedLazyGenerationOperation,
+		channel: OutletManagedLazyDiagnosticChannel | undefined,
+		outcome: "resolved" | "rejected",
+	): void {
+		if (channel === undefined
+			|| !channel.scope.isGenerationActive(channel.scopeGeneration)
+			|| !channel.outletLease.isCurrent()
+			|| !isManagedLazyRegistryActive(channel.rawRegistry)
+			|| !channel.scope.claimDiagnosticAttempt(operation.loadAttemptToken)) {
+			return;
+		}
+		reactAdapterDiagnostics.reportReactAdapterDiagnostic(
+			reactAdapterDiagnostics.createLateLazyResultDiagnostic({
+				boundaryId: channel.boundaryId,
+				contribution: channel.contribution,
+				outcome,
+				outletId: channel.outletLease.id,
+				...(channel.point === undefined ? {} : { point: channel.point }),
+				retryGeneration: channel.retryGeneration,
+			}),
+			channel.configuration,
+		);
+	}
+
+	/** Publikuje abort/unsubscribe failure bez UI, callback nebo policy autority. */
+	#reportLazyLifecycleFailure(
+		channel: OutletManagedLazyDiagnosticChannel | undefined,
+		cause: unknown,
+	): void {
+		if (channel === undefined
+			|| !channel.scope.isGenerationActive(channel.scopeGeneration)
+			|| !channel.outletLease.isCurrent()
+			|| !isManagedLazyRegistryActive(channel.rawRegistry)) {
+			return;
+		}
+		const error = reactAdapterDiagnostics.createReactAdapterErrorEvent({
+			boundaryId: channel.boundaryId,
+			code: "REACT_CALLBACK_FAILED",
+			cause,
+			contribution: channel.contribution,
+			outletId: channel.outletLease.id,
+			phase: "lifecycle",
+			...(channel.point === undefined ? {} : { point: channel.point }),
+			retryGeneration: channel.retryGeneration,
+		});
+		reactAdapterDiagnostics.reportReactAdapterDiagnostic(
+			reactAdapterDiagnostics.createErrorDiagnostic(error),
+			channel.configuration,
+		);
+	}
+
+	/** Publikuje validní componentu pouze do exact current loading generation. */
+	#publishLazyComponent(
+		operation: managedLazyGeneration.ManagedLazyGenerationOperation,
+		membershipToken: outletMembership.OutletMembershipToken,
+		retryToken: OutletRetryGenerationToken,
+		component: unknown,
+	): void {
+		if (this.#lazyOperation !== operation
+			|| this.state.lazyStatus !== "loading"
+			|| !this.#isGenerationCurrent(membershipToken, retryToken)) {
+			return;
+		}
+		this.setState({ lazyComponent: component, lazyStatus: "ready" });
+	}
+
+	/** Převede current lazy failure do committed contribution error pipeline. */
+	#publishLazyFailure(
+		operation: managedLazyGeneration.ManagedLazyGenerationOperation,
+		membershipToken: outletMembership.OutletMembershipToken,
+		retryToken: OutletRetryGenerationToken,
+		failure: managedLazyGeneration.ManagedLazyGenerationFailure,
+	): void {
+		if (this.#lazyOperation !== operation
+			|| this.state.lazyStatus !== "loading"
+			|| !this.#isGenerationCurrent(membershipToken, retryToken)) {
+			return;
+		}
+		const cause = Object.hasOwn(failure, "cause")
+			? failure.cause
+			: new reactAdapterErrorRuntime.ReactAdapterError(
+				"REACT_POINT_IMPLEMENTATION_INVALID",
+				"The managed React contribution loader returned a non-component value.",
+				{ details: { field: "loader.result", phase: "load" } },
+			);
+		const errorAttemptToken = Object.freeze({});
+		this.setState(
+			{ lazyComponent: undefined, lazyStatus: "failed" },
+			/** Pipeline smí začít až po commitu failed presentation. */
+			(): void => {
+				if (this.#lazyOperation !== operation
+					|| this.state.lazyStatus !== "failed"
+					|| !this.#isGenerationCurrent(membershipToken, retryToken)) {
+					return;
+				}
+				this.#commitPrimaryFailure(
+					errorAttemptToken,
+					failure.code,
+					"load",
+					cause,
+					undefined,
+				);
+			},
+		);
+	}
+
+	/** Zneplatní current lazy operation a vrátí oddělený abort dispatch. */
+	#invalidateLazyOperation(): managedLazyGeneration.ManagedLazyAbortDispatch {
+		const operation = this.#lazyOperation;
+		this.#lazyOperation = undefined;
+		this.#lazyOperationMembershipToken = undefined;
+		this.#lazyOperationRetryToken = undefined;
+		return operation?.invalidate() ?? managedLazyGeneration.skipManagedLazyAbortDispatch;
+	}
+
+	/** Ověří a případně obnoví commit lease current membership tokenu. */
+	#synchronizeBoundaryLease(): void {
+		const membershipToken = this.state.membershipToken;
+		if (this.props.outletLease?.isCurrent() !== true) {
+			this.#releaseBoundaryLease();
+			return;
+		}
+		if (this.#boundaryLeaseToken === membershipToken
+			&& this.#boundaryLease?.isCurrent() === true) {
+			return;
+		}
+		this.#releaseBoundaryLease();
+		this.#boundaryLease = this.props.scope.acquireCommitLease(
+			this.props.scopeGeneration,
+			"boundary",
+			membershipToken,
+		);
+		this.#boundaryLeaseToken = membershipToken;
+	}
+
+	/** Idempotentně release boundary lease bez změny Core registry. */
+	#releaseBoundaryLease(): void {
+		this.#boundaryLease?.release();
+		this.#boundaryLease = undefined;
+		this.#boundaryLeaseToken = undefined;
+	}
+
+	/** Ověří current committed membership, retry generation, outlet i scope lease. */
+	#isGenerationCurrent(
+		membershipToken: outletMembership.OutletMembershipToken,
+		retryToken: OutletRetryGenerationToken,
+	): boolean {
+		return !this.#unmounted
+		&& this.state.membershipToken === membershipToken
+		&& this.state.retryToken === retryToken
+		&& this.props.rawRegistry === this.state.rawRegistry
+		&& this.props.membership.token === membershipToken
+		&& this.props.membership.seed.registrationId === this.state.registrationId
+		&& this.#boundaryLeaseToken === membershipToken
+		&& this.#boundaryLease?.isCurrent() === true
+		&& this.props.outletLease?.isCurrent() === true;
+	}
+
+	/** Ověří celý primary attempt včetně sync retry invalidace. */
+	#isPrimaryAttemptCurrent(attempt: OutletPrimaryFailureAttempt): boolean {
+		return attempt.authoritative
+			&& this.#primaryAttempt === attempt
+			&& this.#boundaryLease === attempt.boundaryLease
+			&& attempt.boundaryLease.isCurrent()
+			&& this.#isGenerationCurrent(attempt.membershipToken, attempt.retryToken);
+	}
+
+	/** Vytvoří retry capability svázanou s current boundary lease a UI generation. */
+	#createPrimaryAttempt(
+		errorAttemptToken: object,
+		boundaryLease: outletCommitLease.OutletCommitLease,
+	): OutletPrimaryFailureAttempt {
+		const attempt: OutletPrimaryFailureAttempt = {
+			authoritative: true,
+			boundaryLease,
+			published: false,
+			errorAttemptToken,
+			membershipToken: this.state.membershipToken,
+			retry: (): void => {},
+			retryToken: this.state.retryToken,
+		};
+		const boundary = this;
+		/** Přijme právě první current retry call dané primary capability. */
+		function retry(): void {
+			boundary.#acceptRetry(attempt);
+		}
+		attempt.retry = Object.freeze(retry);
+		return attempt;
+	}
+
+	/** Zneplatní primary capability dříve než začne další lifecycle práce. */
+	#invalidatePrimaryAttempt(): void {
+		if (this.#primaryAttempt !== undefined) {
+			this.#primaryAttempt.authoritative = false;
+			this.#primaryAttempt = undefined;
+		}
+	}
+
+	/**
+	 * Naváže zachovanou failed presentation na novou Activity epochu bez replaye pipeline.
+	 */
+	#reactivatePreservedPrimaryAttempt(): void {
+		if (this.state.primaryError === undefined
+			|| this.state.retry === undefined
+			|| (this.state.mode !== "fallback" && this.state.mode !== "hidden")) {
+			return;
+		}
+		const currentAttempt = this.#primaryAttempt;
+		if (currentAttempt !== undefined && this.#isPrimaryAttemptCurrent(currentAttempt)) {
+			return;
+		}
+		this.#invalidatePrimaryAttempt();
+		const boundaryLease = this.#boundaryLease;
+		if (boundaryLease === undefined
+			|| !this.#isGenerationCurrent(this.state.membershipToken, this.state.retryToken)) {
+			return;
+		}
+		const attempt = this.#createPrimaryAttempt(Object.freeze({}), boundaryLease);
+		attempt.published = true;
+		this.#primaryAttempt = attempt;
+		this.setState({ retry: attempt.retry });
+	}
+
+	/** Převede current failed projection na committed primary pipeline. */
+	#commitProjectedFailure(): void {
+		const seed = this.props.membership.seed;
+		if (seed.kind !== "failed" || this.state.mode !== "rendering") {
+			return;
+		}
+		this.#commitPrimaryFailure(
+			Object.freeze({}),
+			seed.error.code,
+			resolveProjectedFailurePhase(seed.error),
+			resolveProjectedFailureCause(seed.error),
+			undefined,
+		);
+	}
+
+	/** Spustí at-most-once pipeline jednoho exact membership/error attemptu. */
+	#commitPrimaryFailure(
+		errorAttemptToken: object,
+		code: reactAdapterError.ReactAdapterErrorCode,
+		phase: reactAdapterError.ReactAdapterErrorPhase,
+		cause: unknown,
+		reactComponentStack: string | undefined,
+	): void {
+		this.#synchronizeBoundaryLease();
+		const membershipToken = this.state.membershipToken;
+		const retryToken = this.state.retryToken;
+		if (!this.#isGenerationCurrent(membershipToken, retryToken)) {
+			return;
+		}
+		if (this.#primaryAttempt?.errorAttemptToken === errorAttemptToken) {
+			return;
+		}
+		this.#invalidatePrimaryAttempt();
+		const lease = this.#boundaryLease;
+		const outletLease = this.props.outletLease;
+		if (lease === undefined || outletLease === undefined) {
+			return;
+		}
+		const attempt = this.#createPrimaryAttempt(errorAttemptToken, lease);
+		this.#primaryAttempt = attempt;
+		if (!this.props.scope.claimDiagnosticAttempt(errorAttemptToken)) {
+			attempt.authoritative = false;
+			return;
+		}
+		attempt.published = true;
+		const seed = this.props.membership.seed;
+		const decision = outletErrorPipeline.runOutletPrimaryErrorPipeline({
+			boundaryId: lease.id,
+			code,
+			configuration: this.props.input.configuration,
+			context: seed.renderState.context,
+			contribution: seed.renderState.contribution,
+			cause,
+			hasFallback: this.props.input.renderContributionError !== undefined,
+			isolateErrors: this.props.input.isolateErrors,
+			isCurrent: (): boolean => this.#isPrimaryAttemptCurrent(attempt),
+			onError: this.props.input.onError as outletInput.CapturedOutletCallback<
+				outletErrorPipeline.OutletContributionErrorEmission,
+				unknown
+			> | undefined,
+			outletId: outletLease.id,
+			phase,
+			point: seed.renderState.point,
+			...(reactComponentStack === undefined ? {} : { reactComponentStack }),
+			registrationId: seed.registrationId,
+			retry: attempt.retry,
+			retryGeneration: this.state.retryGeneration,
+		});
+		if (decision.kind === "stale" || !this.#isPrimaryAttemptCurrent(attempt)) {
+			return;
+		}
+		if (decision.kind === "hide") {
+			this.setState({ mode: "hidden", primaryError: decision.error, retry: attempt.retry });
+			return;
+		}
+		if (decision.kind === "renderFallback") {
+			this.setState({
+				mode: "fallback",
+				primaryError: decision.error,
+				retry: attempt.retry,
+			});
+			return;
+		}
+		this.setState({
+			escalationCause: decision.cause,
+			mode: "escalating",
+			primaryError: decision.error,
+			retry: attempt.retry,
+		});
+	}
+
+	/** Sync accepted retry invaliduje starý attempt a naplánuje novou subtree generation. */
+	#acceptRetry(attempt: OutletPrimaryFailureAttempt): void {
+		if (!this.#isPrimaryAttemptCurrent(attempt)) {
+			return;
+		}
+		attempt.authoritative = false;
+		this.#primaryAttempt = undefined;
+		const dispatchAbort = this.#invalidateLazyOperation();
+		dispatchAbort();
+		this.setState((state): Pick<
+			OutletMembershipBoundaryState,
+			| "capturedCause"
+			| "escalationCause"
+			| "errorAttemptToken"
+			| "hasCapturedCause"
+			| "lazyComponent"
+			| "lazyStatus"
+			| "mode"
+			| "primaryError"
+			| "retry"
+			| "retryGeneration"
+			| "retryToken"
+		> => ({
+			capturedCause: undefined,
+			escalationCause: undefined,
+			errorAttemptToken: undefined,
+			hasCapturedCause: false,
+			lazyComponent: undefined,
+			lazyStatus: state.lazyLoad === undefined ? "inactive" : "loading",
+			mode: "rendering",
+			primaryError: undefined,
+			retry: undefined,
+			retryGeneration: state.retryGeneration + 1,
+			retryToken: createRetryGenerationToken(),
+		}));
+	}
+
+	/** Doručí onRetry až po commitu nové current generation. */
+	#reportCommittedRetry(): void {
+		if (this.state.retryGeneration <= this.#reportedRetryGeneration) {
+			return;
+		}
+		this.#reportedRetryGeneration = this.state.retryGeneration;
+		const lease = this.#boundaryLease;
+		const outletLease = this.props.outletLease;
+		const membershipToken = this.state.membershipToken;
+		const retryToken = this.state.retryToken;
+		if (lease === undefined
+			|| outletLease === undefined
+			|| !this.#isGenerationCurrent(membershipToken, retryToken)) {
+			return;
+		}
+		const seed = this.props.membership.seed;
+		outletErrorPipeline.dispatchOutletRetryCallback({
+			boundaryId: lease.id,
+			configuration: this.props.input.configuration,
+			context: seed.renderState.context,
+			contribution: seed.renderState.contribution,
+			isCurrent: (): boolean => this.#isGenerationCurrent(membershipToken, retryToken),
+			onRetry: this.props.input.onRetry as outletInput.CapturedOutletCallback<
+				outletErrorPipeline.OutletRetryEvent,
+				unknown
+			> | undefined,
+			outletId: outletLease.id,
+			point: seed.renderState.point,
+			registrationId: seed.registrationId,
+			retryGeneration: this.state.retryGeneration,
+		});
+	}
+
+	/** Odliší default render od custom ready/loading rendereru. */
+	#readRenderFailurePhase(): "render" | "customRender" {
+		if (this.props.membership.seed.kind === "loading"
+			&& this.state.lazyStatus !== "ready") {
+			return this.props.input.renderLoading === undefined ? "render" : "customRender";
+		}
+		return this.props.input.renderContribution === undefined ? "render" : "customRender";
+	}
+
+	/** Renderuje current fallback pod sink-only reporter boundary. */
+	#renderFallback(): react.ReactElement | null {
+		const renderContributionError = this.props.input.renderContributionError;
+		const error = this.state.primaryError;
+		const retry = this.state.retry;
+		const lease = this.#boundaryLease;
+		const outletLease = this.props.outletLease;
+		if (renderContributionError === undefined
+			|| error === undefined
+			|| retry === undefined
+			|| lease === undefined
+			|| outletLease === undefined) {
+			return null;
+		}
+		const seed = this.props.membership.seed;
+		const membershipToken = this.state.membershipToken;
+		const retryToken = this.state.retryToken;
+		const reporterInput = {
+			boundaryId: lease.id,
+			configuration: this.props.input.configuration,
+			context: seed.renderState.context,
+			contribution: seed.renderState.contribution,
+			isCurrent: (): boolean => this.#isGenerationCurrent(membershipToken, retryToken),
+			outletId: outletLease.id,
+			point: seed.renderState.point,
+			registrationId: seed.registrationId,
+			retryGeneration: this.state.retryGeneration,
+		};
+		const children = react.createElement(OutletContributionFallbackRenderer<Point>, {
+			error,
+			renderContributionError,
+			retry,
+			seed,
+		});
+		return react.createElement(
+			outletReporterBoundary.OutletReporterBoundary<Point>,
+			{
+				children,
+				errorInput: reporterInput,
+				generationToken: retryToken,
+			},
+		);
+	}
+}