#include "HyperTwistTraining/HyperTwistTrainingImmersiveEnvironmentLibrary.h"

namespace HyperTwistTrainingImmersiveEnvironmentLibraryInternal
{
	FHyperTwistTrainingSourceAttribution MakeFirstPartyAttribution(
		const FString& TrackId,
		const FString& Notes
	)
	{
		FHyperTwistTrainingSourceAttribution Attribution;
		Attribution.SourceMode = EHyperTwistTrainingSourceMode::FirstParty;
		Attribution.SourceTrackId = TrackId;
		Attribution.SourceNotes = Notes;
		return Attribution;
	}

	FHyperTwistTrainingImmersiveEnvironmentPackageReference MakePackageReference(
		const FString& PackageId,
		const FString& Label,
		const FString& OwnershipRole,
		const FString& Summary,
		const TArray<FString>& RetainedSurfaceTags,
		const TArray<FString>& ExplicitExclusions,
		const FHyperTwistTrainingSourceAttribution& SourceAttribution
	)
	{
		FHyperTwistTrainingImmersiveEnvironmentPackageReference Reference;
		Reference.PackageId = PackageId;
		Reference.Label = Label;
		Reference.OwnershipRole = OwnershipRole;
		Reference.Summary = Summary;
		Reference.RetainedSurfaceTags = RetainedSurfaceTags;
		Reference.ExplicitExclusions = ExplicitExclusions;
		Reference.SourceAttribution = SourceAttribution;
		return Reference;
	}

	void AppendJoined(FString& OutText, const TArray<FString>& Values)
	{
		for (int32 Index = 0; Index < Values.Num(); ++Index)
		{
			if (Index > 0)
			{
				OutText.Append(TEXT(", "));
			}

			OutText.Append(Values[Index]);
		}
	}
}

FHyperTwistTrainingImmersiveEnvironmentReferenceBundle
UHyperTwistTrainingImmersiveEnvironmentLibrary::BuildBundledImmersiveEnvironmentReferenceBundle()
{
	using namespace HyperTwistTrainingImmersiveEnvironmentLibraryInternal;

	FHyperTwistTrainingImmersiveEnvironmentReferenceBundle Bundle;
	Bundle.ReferenceUtc = TEXT("2026-05-31T16:10:00Z");
	Bundle.PrimaryEnvironmentProfileContractId = TEXT("immersive-training-environment-profile");
	Bundle.PrimaryLightingPresetBoundaryId = TEXT("immersive-training-lighting-preset-boundary");
	Bundle.PrimaryAmbientAudioBoundaryId = TEXT("immersive-training-ambient-audio-boundary");
	Bundle.PrimaryWorldAnchorContractId = TEXT("immersive-training-world-anchor-contract");
	Bundle.PrimaryPresenceControlContractId = TEXT("immersive-training-presence-control-contract");
	Bundle.PrimaryComfortBoundaryId = TEXT("immersive-training-comfort-boundary");
	Bundle.PrimaryPostureVariantContractId = TEXT("immersive-training-posture-variant-contract");
	Bundle.PrimarySessionRecallBoundaryId = TEXT("immersive-training-session-recall-boundary");
	Bundle.PrimaryCoachCueAnchorContractId = TEXT("immersive-training-coach-cue-anchor-contract");
	Bundle.PrimaryGhostTargetBoundaryId = TEXT("immersive-training-ghost-target-boundary");
	Bundle.PrimaryReplayEmphasisBoundaryId = TEXT("immersive-training-replay-emphasis-boundary");
	Bundle.PrimaryLessonStateContractId = TEXT("immersive-training-lesson-state-contract");
	Bundle.PrimarySessionStateCueContractId = TEXT("immersive-training-session-state-cue-contract");
	Bundle.PrimaryLightingReactionBoundaryId = TEXT("immersive-training-lighting-reaction-boundary");
	Bundle.PrimaryAudioPacingBoundaryId = TEXT("immersive-training-audio-pacing-boundary");
	Bundle.PrimaryModeDifferentiationContractId = TEXT("immersive-training-mode-differentiation-contract");
	Bundle.PrimaryTransitionSafetyBoundaryId = TEXT("immersive-training-transition-safety-boundary");
	Bundle.PrimaryAccessibilityLegibilityContractId = TEXT("immersive-training-accessibility-legibility-contract");
	Bundle.PrimaryPerformanceBudgetBoundaryId = TEXT("immersive-training-performance-budget-boundary");
	Bundle.PrimaryFallbackModeContractId = TEXT("immersive-training-fallback-mode-contract");

	Bundle.PackageReferences =
	{
		MakePackageReference(
			TEXT("package/hypertwist-immersive-environment-shell"),
			TEXT("HyperTwist immersive environment shell"),
			TEXT("environment-family-foundation-owner"),
			TEXT("First-party scenic training environment shell for alpine ridge, summit chamber, observatory, and focus-arena runtime presentation around puzzle practice, replay, and coaching."),
			{
				TEXT("scenic environment family selection"),
				TEXT("training-safe bounded world shell"),
				TEXT("place-based focus posture"),
				TEXT("immersive training session activation")
			},
			{
				TEXT("generic productivity workspace shell"),
				TEXT("floating monitor desktop ownership"),
				TEXT("donor showroom shell ownership")
			},
			MakeFirstPartyAttribution(
				TEXT("first-party/immersive-environment-shell"),
				TEXT("Owns the HyperTwist-native scenic training shell without inheriting a productivity-workspace or donor showroom posture.")
			)
		),
		MakePackageReference(
			TEXT("package/hypertwist-immersive-lighting-presets"),
			TEXT("HyperTwist immersive lighting presets"),
			TEXT("legibility-first-lighting-foundation-owner"),
			TEXT("First-party lighting preset family for day, dusk, night, and focus-biased scenic training presentation with puzzle and coach legibility preserved."),
			{
				TEXT("puzzle-face legibility bias"),
				TEXT("coach-anchor fill light"),
				TEXT("review-safe highlight reserve"),
				TEXT("session-tone lighting presets")
			},
			{
				TEXT("full weather simulation ownership"),
				TEXT("planet-scale diurnal simulation ownership"),
				TEXT("theatrical VFX spectacle ownership")
			},
			MakeFirstPartyAttribution(
				TEXT("first-party/immersive-lighting-presets"),
				TEXT("Owns bounded scenic lighting presets for HyperTwist training presence and legibility without widening into general weather or spectacle systems.")
			)
		),
		MakePackageReference(
			TEXT("package/hypertwist-immersive-ambient-audio"),
			TEXT("HyperTwist immersive ambient audio foundation"),
			TEXT("ambient-audio-foundation-owner"),
			TEXT("First-party ambient audio foundation for calm scenic presence during warm-up, drill, review, mastery, and cooldown states."),
			{
				TEXT("low-motion ambient beds"),
				TEXT("coach-safe attenuation posture"),
				TEXT("replay-safe ducking"),
				TEXT("session-state audio tone support")
			},
			{
				TEXT("full music platform ownership"),
				TEXT("voice-assistant playback ownership"),
				TEXT("lyric soundtrack ownership")
			},
			MakeFirstPartyAttribution(
				TEXT("first-party/immersive-ambient-audio"),
				TEXT("Owns calm scenic ambience for the HyperTwist training runtime without reopening voice, soundtrack, or entertainment-platform lanes.")
			)
		),
		MakePackageReference(
			TEXT("package/hypertwist-immersive-world-anchors"),
			TEXT("HyperTwist immersive world anchors"),
			TEXT("stable-world-anchor-owner"),
			TEXT("First-party world-anchor foundation for puzzle, replay, coach, and orientation staging inside scenic immersive training sessions."),
			{
				TEXT("puzzle dais anchor"),
				TEXT("replay ribbon anchor"),
				TEXT("coach cue anchor"),
				TEXT("orientation ring anchor")
			},
			{
				TEXT("generic productivity pane anchors"),
				TEXT("floating browser dashboard ownership"),
				TEXT("room-scale social hub ownership")
			},
			MakeFirstPartyAttribution(
				TEXT("first-party/immersive-world-anchors"),
				TEXT("Owns stable training-world anchors for puzzle, replay, and coaching surfaces without widening into generic dashboard or social-hub layout ownership.")
			)
		),
		MakePackageReference(
			TEXT("package/hypertwist-immersive-focus-presence-controls"),
			TEXT("HyperTwist immersive focus-presence controls"),
			TEXT("presence-control-and-recall-owner"),
			TEXT("First-party intensity, reduced-distraction, comfort, posture, and session-local recall control surface for the scenic immersive training lane."),
			{
				TEXT("immersion intensity ladder"),
				TEXT("reduced-distraction presets"),
				TEXT("comfort and vignette posture"),
				TEXT("posture variants and session recall")
			},
			{
				TEXT("generic VR system settings ownership"),
				TEXT("cross-product identity profile ownership"),
				TEXT("platform-level locomotion shell ownership")
			},
			MakeFirstPartyAttribution(
				TEXT("first-party/immersive-focus-presence-controls"),
				TEXT("Owns bounded scenic presence controls for HyperTwist training sessions without widening into platform-global XR settings or cross-product profile lanes.")
			)
		),
		MakePackageReference(
			TEXT("package/hypertwist-immersive-coaching-tutorial-staging"),
			TEXT("HyperTwist immersive coaching and tutorial staging"),
			TEXT("coach-cue-ghost-target-and-lesson-state-owner"),
			TEXT("First-party spatial coaching, ghost target, replay emphasis, and drill-state staging surface for the scenic immersive training lane."),
			{
				TEXT("coach cue anchors"),
				TEXT("ghost target staging"),
				TEXT("replay path emphasis"),
				TEXT("drill spotlight and lesson-state staging")
			},
			{
				TEXT("generic cutscene system ownership"),
				TEXT("broad cinematic timeline ownership"),
				TEXT("cross-product tutorial engine ownership")
			},
			MakeFirstPartyAttribution(
				TEXT("first-party/immersive-coaching-tutorial-staging"),
				TEXT("Owns bounded immersive coaching and tutorial staging for HyperTwist training sessions without widening into cinematic timelines or cross-product tutorial engines.")
			)
		),
		MakePackageReference(
			TEXT("package/hypertwist-immersive-session-state-cues"),
			TEXT("HyperTwist immersive session-state cues"),
			TEXT("reactive-state-cue-owner"),
			TEXT("First-party reactive environment cue surface for review, mastery, correction, failure, and study-versus-challenge differentiation inside scenic immersive training sessions."),
			{
				TEXT("session-state transition cues"),
				TEXT("lighting reaction posture"),
				TEXT("audio pacing response"),
				TEXT("study and challenge mode differentiation")
			},
			{
				TEXT("generic VFX system ownership"),
				TEXT("broad soundtrack scoring ownership"),
				TEXT("cross-product mode framework ownership")
			},
			MakeFirstPartyAttribution(
				TEXT("first-party/immersive-session-state-cues"),
				TEXT("Owns bounded reactive environment cues for HyperTwist training sessions without widening into generic VFX, soundtrack scoring, or cross-product mode frameworks.")
			)
		),
		MakePackageReference(
			TEXT("package/hypertwist-immersive-hardening"),
			TEXT("HyperTwist immersive hardening lane"),
			TEXT("comfort-accessibility-performance-hardening-owner"),
			TEXT("First-party HyperTwist hardening layer for comfort-safe transitions, accessibility legibility review, reduced-effects fallback, and immersive performance budgets."),
			{
				TEXT("comfort-safe transition review"),
				TEXT("legibility and contrast audit"),
				TEXT("performance budget posture"),
				TEXT("reduced-effects compatibility path")
			},
			{
				TEXT("engine-global scalability ownership"),
				TEXT("platform-global accessibility shell ownership"),
				TEXT("generic renderer pipeline ownership")
			},
			MakeFirstPartyAttribution(
				TEXT("first-party/immersive-hardening"),
				TEXT("Owns the bounded HyperTwist immersive hardening lane without widening into renderer-pipeline, engine-global scalability, or platform-global accessibility ownership.")
			)
		)
	};

	FHyperTwistTrainingImmersiveEnvironmentProfileContract ProfileContract;
	ProfileContract.ContractId = TEXT("immersive-training-environment-profile");
	ProfileContract.Title = TEXT("Scenic immersive training environment profile");
	ProfileContract.Summary = TEXT("First-party HyperTwist profile for bounded scenic world shells that strengthen embodied focus, puzzle presence, replay staging, and coaching legibility without becoming a generic virtual desktop.");
	ProfileContract.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-environment-shell"),
		TEXT("package/hypertwist-immersive-lighting-presets"),
		TEXT("package/hypertwist-immersive-ambient-audio"),
		TEXT("package/hypertwist-immersive-world-anchors")
	};
	ProfileContract.EnvironmentFamilyIds =
	{
		TEXT("environment/alpine-ridge"),
		TEXT("environment/summit-chamber"),
		TEXT("environment/observatory"),
		TEXT("environment/focus-arena")
	};
	ProfileContract.PresenceSurfaceTags =
	{
		TEXT("scenic training shell"),
		TEXT("place-based focus posture"),
		TEXT("bounded immersive runtime"),
		TEXT("world-anchored puzzle presence")
	};
	ProfileContract.ExplicitExclusions =
	{
		TEXT("generic virtual desktop shell"),
		TEXT("floating monitor productivity shell"),
		TEXT("donor workspace-shell ownership")
	};
	ProfileContract.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-environment-profile"),
		TEXT("Reauthors the immersive lane as a HyperTwist-native scenic training profile rather than a productivity or donor workspace-shell surface.")
	);
	Bundle.EnvironmentProfileContracts = {ProfileContract};

	FHyperTwistTrainingImmersiveLightingPresetBoundary LightingBoundary;
	LightingBoundary.BoundaryId = TEXT("immersive-training-lighting-preset-boundary");
	LightingBoundary.Title = TEXT("Scenic immersive lighting preset boundary");
	LightingBoundary.Summary = TEXT("First-party HyperTwist boundary for puzzle-safe scenic lighting presets that reinforce session tone without overwhelming puzzle and coaching legibility.");
	LightingBoundary.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-environment-shell"),
		TEXT("package/hypertwist-immersive-lighting-presets")
	};
	LightingBoundary.LightingPresetIds =
	{
		TEXT("preset/dawn-focus"),
		TEXT("preset/review-neutral-daylight"),
		TEXT("preset/dusk-mastery-glow"),
		TEXT("preset/observatory-night-clarity")
	};
	LightingBoundary.LegibilitySurfaceTags =
	{
		TEXT("puzzle-face legibility bias"),
		TEXT("replay-path highlight reserve"),
		TEXT("coach-anchor fill light"),
		TEXT("low-glare horizon contrast")
	};
	LightingBoundary.MoodSurfaceTags =
	{
		TEXT("dawn warm-up posture"),
		TEXT("neutral deliberate-drill daylight"),
		TEXT("mastery dusk accent"),
		TEXT("observatory stillness")
	};
	LightingBoundary.ExplicitExclusions =
	{
		TEXT("full weather simulation ownership"),
		TEXT("photorealistic planet-scale daylight simulation"),
		TEXT("theatrical spectacle lighting ownership")
	};
	LightingBoundary.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-lighting-preset-boundary"),
		TEXT("Owns bounded scenic lighting presets for the HyperTwist training runtime without widening into weather, astronomy, or spectacle systems.")
	);
	Bundle.LightingPresetBoundaries = {LightingBoundary};

	FHyperTwistTrainingImmersiveAmbientAudioBoundary AudioBoundary;
	AudioBoundary.BoundaryId = TEXT("immersive-training-ambient-audio-boundary");
	AudioBoundary.Title = TEXT("Scenic immersive ambient audio boundary");
	AudioBoundary.Summary = TEXT("First-party HyperTwist boundary for calm scenic ambient beds that support warm-up, drill, review, mastery, and cooldown without becoming a soundtrack or voice lane.");
	AudioBoundary.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-environment-shell"),
		TEXT("package/hypertwist-immersive-ambient-audio")
	};
	AudioBoundary.AudioFamilyIds =
	{
		TEXT("audio/alpine-wind-bed"),
		TEXT("audio/summit-hush-bed"),
		TEXT("audio/observatory-low-hum"),
		TEXT("audio/focus-arena-breath-bed")
	};
	AudioBoundary.ComfortSurfaceTags =
	{
		TEXT("low-motion stereo bed"),
		TEXT("distraction-safe dynamic range"),
		TEXT("replay-safe ducking"),
		TEXT("coach-cue sidechain reserve")
	};
	AudioBoundary.SessionStateSurfaceTags =
	{
		TEXT("warm-up calm bed"),
		TEXT("deliberate-drill steady bed"),
		TEXT("review-safe attenuation"),
		TEXT("cooldown release bed")
	};
	AudioBoundary.ExplicitExclusions =
	{
		TEXT("full music platform ownership"),
		TEXT("voice-assistant playback ownership"),
		TEXT("lyric soundtrack ownership")
	};
	AudioBoundary.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-ambient-audio-boundary"),
		TEXT("Owns bounded scenic ambient audio for the HyperTwist training runtime without widening into soundtrack or speech-output platform ownership.")
	);
	Bundle.AmbientAudioBoundaries = {AudioBoundary};

	FHyperTwistTrainingImmersiveWorldAnchorContract WorldAnchorContract;
	WorldAnchorContract.ContractId = TEXT("immersive-training-world-anchor-contract");
	WorldAnchorContract.Title = TEXT("Scenic immersive world-anchor contract");
	WorldAnchorContract.Summary = TEXT("First-party HyperTwist contract for stable puzzle, replay, coaching, and orientation anchors inside scenic immersive training sessions.");
	WorldAnchorContract.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-environment-shell"),
		TEXT("package/hypertwist-immersive-world-anchors")
	};
	WorldAnchorContract.AnchorIds =
	{
		TEXT("anchor/puzzle-dais"),
		TEXT("anchor/replay-ribbon"),
		TEXT("anchor/coach-cue-ring"),
		TEXT("anchor/orientation-horizon")
	};
	WorldAnchorContract.TargetSurfaceTags =
	{
		TEXT("primary puzzle locus"),
		TEXT("replay path staging"),
		TEXT("coach cue staging"),
		TEXT("orientation and scale reinforcement")
	};
	WorldAnchorContract.StabilitySurfaceTags =
	{
		TEXT("comfort-safe forward anchor"),
		TEXT("seated-standing compatible anchor offsets"),
		TEXT("non-drifting session origin"),
		TEXT("legibility-preserving depth bands")
	};
	WorldAnchorContract.ExplicitExclusions =
	{
		TEXT("generic productivity dashboard anchors"),
		TEXT("floating browser pane ownership"),
		TEXT("room-scale social hub ownership")
	};
	WorldAnchorContract.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-world-anchor-contract"),
		TEXT("Owns bounded scenic world-anchor rules for puzzle, replay, and coaching surfaces without reopening generic pane-layout or social-hub lanes.")
	);
	Bundle.WorldAnchorContracts = {WorldAnchorContract};

	FHyperTwistTrainingImmersivePresenceControlContract PresenceContract;
	PresenceContract.ContractId = TEXT("immersive-training-presence-control-contract");
	PresenceContract.Title = TEXT("Scenic immersive presence-control contract");
	PresenceContract.Summary = TEXT("First-party HyperTwist contract for user-tuned immersion intensity and reduced-distraction scenic focus posture inside immersive training sessions.");
	PresenceContract.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-environment-shell"),
		TEXT("package/hypertwist-immersive-focus-presence-controls")
	};
	PresenceContract.ImmersionIntensityIds =
	{
		TEXT("intensity/low-blend"),
		TEXT("intensity/focus-balanced"),
		TEXT("intensity/deep-presence")
	};
	PresenceContract.ReducedDistractionPresetIds =
	{
		TEXT("preset/reduced-distraction-review"),
		TEXT("preset/reduced-distraction-drill"),
		TEXT("preset/calm-focus-minimal")
	};
	PresenceContract.PresenceSurfaceTags =
	{
		TEXT("user-controlled scenic intensity"),
		TEXT("reduced-distraction focus posture"),
		TEXT("session-local presence tuning"),
		TEXT("training-safe presence blend")
	};
	PresenceContract.ExplicitExclusions =
	{
		TEXT("generic virtual desktop opacity control"),
		TEXT("platform-global XR settings ownership"),
		TEXT("cross-product workspace profile ownership")
	};
	PresenceContract.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-presence-control-contract"),
		TEXT("Owns bounded scenic intensity and reduced-distraction controls for HyperTwist training sessions without widening into platform-global XR settings or productivity-workspace opacity control.")
	);
	Bundle.PresenceControlContracts = {PresenceContract};

	FHyperTwistTrainingImmersiveComfortBoundary ComfortBoundary;
	ComfortBoundary.BoundaryId = TEXT("immersive-training-comfort-boundary");
	ComfortBoundary.Title = TEXT("Scenic immersive comfort boundary");
	ComfortBoundary.Summary = TEXT("First-party HyperTwist comfort and vignette boundary for scenic immersive sessions, with reduced strain and transition-safe presentation bias.");
	ComfortBoundary.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-environment-shell"),
		TEXT("package/hypertwist-immersive-focus-presence-controls")
	};
	ComfortBoundary.ComfortOptionIds =
	{
		TEXT("comfort/soft-vignette"),
		TEXT("comfort/strong-vignette"),
		TEXT("comfort/reduced-horizon-motion"),
		TEXT("comfort/low-stimulus-lighting-lock")
	};
	ComfortBoundary.VignetteSurfaceTags =
	{
		TEXT("edge-softening vignette"),
		TEXT("focus-centered vignette envelope"),
		TEXT("review-safe vignette reserve")
	};
	ComfortBoundary.TransitionSafetySurfaceTags =
	{
		TEXT("fade-safe preset transitions"),
		TEXT("anchor-preserving comfort swap"),
		TEXT("low-acceleration mode switching")
	};
	ComfortBoundary.ExplicitExclusions =
	{
		TEXT("platform-level locomotion shell ownership"),
		TEXT("generic accessibility settings ownership"),
		TEXT("global headset guardian ownership")
	};
	ComfortBoundary.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-comfort-boundary"),
		TEXT("Owns bounded comfort and vignette posture for HyperTwist scenic training sessions without widening into global locomotion or headset-safety platform settings.")
	);
	Bundle.ComfortBoundaries = {ComfortBoundary};

	FHyperTwistTrainingImmersivePostureVariantContract PostureContract;
	PostureContract.ContractId = TEXT("immersive-training-posture-variant-contract");
	PostureContract.Title = TEXT("Scenic immersive posture-variant contract");
	PostureContract.Summary = TEXT("First-party HyperTwist contract for seated and standing scenic training postures with stable anchor adjustments and comfort-safe presentation offsets.");
	PostureContract.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-world-anchors"),
		TEXT("package/hypertwist-immersive-focus-presence-controls")
	};
	PostureContract.PostureVariantIds =
	{
		TEXT("posture/seated-stable"),
		TEXT("posture/standing-balanced"),
		TEXT("posture/stool-lean-focus")
	};
	PostureContract.AnchorAdjustmentSurfaceTags =
	{
		TEXT("puzzle dais height offset"),
		TEXT("coach cue ring reach normalization"),
		TEXT("orientation horizon eye-line alignment")
	};
	PostureContract.ComfortSurfaceTags =
	{
		TEXT("seated-standing compatible anchors"),
		TEXT("low-reach adjustment posture"),
		TEXT("comfort-safe recentering")
	};
	PostureContract.ExplicitExclusions =
	{
		TEXT("full locomotion rig ownership"),
		TEXT("room-scale guardian ownership"),
		TEXT("platform avatar-body calibration ownership")
	};
	PostureContract.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-posture-variant-contract"),
		TEXT("Owns bounded scenic posture variants for HyperTwist training sessions without widening into locomotion rigs, guardian systems, or avatar-body calibration lanes.")
	);
	Bundle.PostureVariantContracts = {PostureContract};

	FHyperTwistTrainingImmersiveSessionRecallBoundary RecallBoundary;
	RecallBoundary.BoundaryId = TEXT("immersive-training-session-recall-boundary");
	RecallBoundary.Title = TEXT("Scenic immersive session recall boundary");
	RecallBoundary.Summary = TEXT("First-party HyperTwist boundary for session-local scenic environment recall so users can return to the same focus posture without broad profile or cloud-setting ownership.");
	RecallBoundary.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-environment-shell"),
		TEXT("package/hypertwist-immersive-focus-presence-controls")
	};
	RecallBoundary.RecallScopeIds =
	{
		TEXT("recall/session-local"),
		TEXT("recall/current-training-run"),
		TEXT("recall/current-review-block")
	};
	RecallBoundary.PreferenceFieldTags =
	{
		TEXT("environment family id"),
		TEXT("immersion intensity id"),
		TEXT("reduced-distraction preset id"),
		TEXT("comfort option id"),
		TEXT("posture variant id")
	};
	RecallBoundary.ResetSurfaceTags =
	{
		TEXT("manual reset to default focus posture"),
		TEXT("review-block scoped restore"),
		TEXT("session-end discard posture")
	};
	RecallBoundary.ExplicitExclusions =
	{
		TEXT("cross-session cloud profile ownership"),
		TEXT("cross-product identity memory ownership"),
		TEXT("account-level preference sync ownership")
	};
	RecallBoundary.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-session-recall-boundary"),
		TEXT("Owns bounded session-local scenic recall for HyperTwist training sessions without widening into account-level, cloud, or cross-product preference memory lanes.")
	);
	Bundle.SessionRecallBoundaries = {RecallBoundary};

	FHyperTwistTrainingImmersiveCoachCueAnchorContract CoachCueContract;
	CoachCueContract.ContractId = TEXT("immersive-training-coach-cue-anchor-contract");
	CoachCueContract.Title = TEXT("Scenic immersive coach-cue anchor contract");
	CoachCueContract.Summary = TEXT("First-party HyperTwist contract for stable coach cue anchors and training-triggered callout staging inside scenic immersive sessions.");
	CoachCueContract.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-world-anchors"),
		TEXT("package/hypertwist-immersive-coaching-tutorial-staging")
	};
	CoachCueContract.CueAnchorIds =
	{
		TEXT("anchor/coach-cue-ring"),
		TEXT("anchor/coach-callout-arc"),
		TEXT("anchor/tutorial-focus-beacon")
	};
	CoachCueContract.CueSurfaceTags =
	{
		TEXT("coach hint callout staging"),
		TEXT("follow-up cue placement"),
		TEXT("error-correction emphasis")
	};
	CoachCueContract.TriggerSurfaceTags =
	{
		TEXT("missed target trigger"),
		TEXT("review checkpoint trigger"),
		TEXT("guided lesson-step trigger")
	};
	CoachCueContract.ExplicitExclusions =
	{
		TEXT("generic UI tooltip ownership"),
		TEXT("broad cinematic callout ownership"),
		TEXT("cross-product tutorial beacon ownership")
	};
	CoachCueContract.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-coach-cue-anchor-contract"),
		TEXT("Owns bounded spatial coach cue staging for HyperTwist immersive training without widening into generic tooltip or cinematic callout systems.")
	);
	Bundle.CoachCueAnchorContracts = {CoachCueContract};

	FHyperTwistTrainingImmersiveGhostTargetBoundary GhostTargetBoundary;
	GhostTargetBoundary.BoundaryId = TEXT("immersive-training-ghost-target-boundary");
	GhostTargetBoundary.Title = TEXT("Scenic immersive ghost-target boundary");
	GhostTargetBoundary.Summary = TEXT("First-party HyperTwist boundary for ghosted target positions during tutorial and drill staging inside scenic immersive sessions.");
	GhostTargetBoundary.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-world-anchors"),
		TEXT("package/hypertwist-immersive-coaching-tutorial-staging")
	};
	GhostTargetBoundary.TargetModeIds =
	{
		TEXT("ghost-target/puzzle-orientation"),
		TEXT("ghost-target/hand-placement"),
		TEXT("ghost-target/drill-end-state")
	};
	GhostTargetBoundary.VisualizationSurfaceTags =
	{
		TEXT("semi-transparent target pose"),
		TEXT("step-local target highlight"),
		TEXT("ghost silhouette fade")
	};
	GhostTargetBoundary.AlignmentSurfaceTags =
	{
		TEXT("puzzle-local alignment"),
		TEXT("coach cue linked alignment"),
		TEXT("review-step anchor alignment")
	};
	GhostTargetBoundary.ExplicitExclusions =
	{
		TEXT("full animation-rig ownership"),
		TEXT("generic object-placement trainer ownership"),
		TEXT("cross-product pose ghosting ownership")
	};
	GhostTargetBoundary.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-ghost-target-boundary"),
		TEXT("Owns bounded ghost-target staging for HyperTwist immersive training without widening into animation rigs or generic object-placement trainers.")
	);
	Bundle.GhostTargetBoundaries = {GhostTargetBoundary};

	FHyperTwistTrainingImmersiveReplayEmphasisBoundary ReplayBoundary;
	ReplayBoundary.BoundaryId = TEXT("immersive-training-replay-emphasis-boundary");
	ReplayBoundary.Title = TEXT("Scenic immersive replay-emphasis boundary");
	ReplayBoundary.Summary = TEXT("First-party HyperTwist boundary for immersive replay-path emphasis and review-local attention guidance inside scenic training sessions.");
	ReplayBoundary.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-world-anchors"),
		TEXT("package/hypertwist-immersive-coaching-tutorial-staging")
	};
	ReplayBoundary.EmphasisModeIds =
	{
		TEXT("replay-emphasis/path-ribbon"),
		TEXT("replay-emphasis/focus-pulse"),
		TEXT("replay-emphasis/checkpoint-freeze")
	};
	ReplayBoundary.ReplaySurfaceTags =
	{
		TEXT("replay path ribbon"),
		TEXT("move-cluster emphasis"),
		TEXT("error-turn highlight")
	};
	ReplayBoundary.AttentionSurfaceTags =
	{
		TEXT("review-local gaze steering"),
		TEXT("coach-linked replay focus"),
		TEXT("step-isolated attention pulse")
	};
	ReplayBoundary.ExplicitExclusions =
	{
		TEXT("full cinematic replay ownership"),
		TEXT("generic video editing timeline ownership"),
		TEXT("cross-product review choreography ownership")
	};
	ReplayBoundary.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-replay-emphasis-boundary"),
		TEXT("Owns bounded immersive replay emphasis for HyperTwist training without widening into cinematic replay, video editing, or choreography systems.")
	);
	Bundle.ReplayEmphasisBoundaries = {ReplayBoundary};

	FHyperTwistTrainingImmersiveLessonStateContract LessonStateContract;
	LessonStateContract.ContractId = TEXT("immersive-training-lesson-state-contract");
	LessonStateContract.Title = TEXT("Scenic immersive lesson-state contract");
	LessonStateContract.Summary = TEXT("First-party HyperTwist contract for drill-target spotlighting and lesson-specific environmental states inside scenic immersive training sessions.");
	LessonStateContract.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-environment-shell"),
		TEXT("package/hypertwist-immersive-coaching-tutorial-staging")
	};
	LessonStateContract.LessonStateIds =
	{
		TEXT("lesson-state/introduction"),
		TEXT("lesson-state/drill-focus"),
		TEXT("lesson-state/error-correction"),
		TEXT("lesson-state/mastery-confirmation")
	};
	LessonStateContract.SpotlightSurfaceTags =
	{
		TEXT("drill-target spotlight"),
		TEXT("lesson-step focal cone"),
		TEXT("correction target isolate")
	};
	LessonStateContract.StateSurfaceTags =
	{
		TEXT("lesson-specific environment tone"),
		TEXT("coach-led state transition"),
		TEXT("drill-stage visual reset")
	};
	LessonStateContract.ExplicitExclusions =
	{
		TEXT("full cutscene state machine ownership"),
		TEXT("generic mission scripting ownership"),
		TEXT("cross-product lesson engine ownership")
	};
	LessonStateContract.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-lesson-state-contract"),
		TEXT("Owns bounded lesson-state and spotlight staging for HyperTwist immersive training without widening into cutscenes, mission scripting, or cross-product lesson engines.")
	);
	Bundle.LessonStateContracts = {LessonStateContract};

	FHyperTwistTrainingImmersiveSessionStateCueContract SessionStateCueContract;
	SessionStateCueContract.ContractId = TEXT("immersive-training-session-state-cue-contract");
	SessionStateCueContract.Title = TEXT("Scenic immersive session-state cue contract");
	SessionStateCueContract.Summary = TEXT("First-party HyperTwist contract for subtle environment transitions across review, mastery, correction, and failure-oriented training states.");
	SessionStateCueContract.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-environment-shell"),
		TEXT("package/hypertwist-immersive-session-state-cues")
	};
	SessionStateCueContract.SessionStateIds =
	{
		TEXT("session-state/review"),
		TEXT("session-state/mastery"),
		TEXT("session-state/error-correction"),
		TEXT("session-state/failure-recovery")
	};
	SessionStateCueContract.TransitionCueIds =
	{
		TEXT("transition-cue/review-cool-fade"),
		TEXT("transition-cue/mastery-settle-glow"),
		TEXT("transition-cue/correction-focus-tighten"),
		TEXT("transition-cue/failure-reset-soften")
	};
	SessionStateCueContract.TransitionSurfaceTags =
	{
		TEXT("subtle state transition cadence"),
		TEXT("review-safe environmental fade"),
		TEXT("failure-recovery calm reset")
	};
	SessionStateCueContract.ExplicitExclusions =
	{
		TEXT("generic cutscene transition ownership"),
		TEXT("theatrical spectacle transition ownership"),
		TEXT("cross-product dramatic state engine ownership")
	};
	SessionStateCueContract.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-session-state-cue-contract"),
		TEXT("Owns bounded reactive scenic session-state cues for HyperTwist training without widening into cutscenes, spectacle transitions, or cross-product state engines.")
	);
	Bundle.SessionStateCueContracts = {SessionStateCueContract};

	FHyperTwistTrainingImmersiveLightingReactionBoundary LightingReactionBoundary;
	LightingReactionBoundary.BoundaryId = TEXT("immersive-training-lighting-reaction-boundary");
	LightingReactionBoundary.Title = TEXT("Scenic immersive lighting reaction boundary");
	LightingReactionBoundary.Summary = TEXT("First-party HyperTwist boundary for pacing-aware lighting reactions tied to review, mastery, correction, and challenge-study posture.");
	LightingReactionBoundary.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-lighting-presets"),
		TEXT("package/hypertwist-immersive-session-state-cues")
	};
	LightingReactionBoundary.ReactionModeIds =
	{
		TEXT("lighting-reaction/review-soft-cool"),
		TEXT("lighting-reaction/mastery-warm-resolve"),
		TEXT("lighting-reaction/correction-tight-focus"),
		TEXT("lighting-reaction/challenge-high-contrast")
	};
	LightingReactionBoundary.LightingSurfaceTags =
	{
		TEXT("pacing-aware key light shifts"),
		TEXT("challenge-mode contrast push"),
		TEXT("study-mode softness reserve")
	};
	LightingReactionBoundary.LegibilityGuardTags =
	{
		TEXT("puzzle-face visibility clamp"),
		TEXT("coach-anchor readability guard"),
		TEXT("replay highlight legibility floor")
	};
	LightingReactionBoundary.ExplicitExclusions =
	{
		TEXT("generic shader FX ownership"),
		TEXT("full weather pulse ownership"),
		TEXT("broad color-grading pipeline ownership")
	};
	LightingReactionBoundary.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-lighting-reaction-boundary"),
		TEXT("Owns bounded reactive scenic lighting for HyperTwist training without widening into generic shader, weather, or grading pipelines.")
	);
	Bundle.LightingReactionBoundaries = {LightingReactionBoundary};

	FHyperTwistTrainingImmersiveAudioPacingBoundary AudioPacingBoundary;
	AudioPacingBoundary.BoundaryId = TEXT("immersive-training-audio-pacing-boundary");
	AudioPacingBoundary.Title = TEXT("Scenic immersive audio pacing boundary");
	AudioPacingBoundary.Summary = TEXT("First-party HyperTwist boundary for session-state-aware ambience pacing and ducking across review, mastery, correction, and study-versus-challenge modes.");
	AudioPacingBoundary.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-ambient-audio"),
		TEXT("package/hypertwist-immersive-session-state-cues")
	};
	AudioPacingBoundary.AudioPacingModeIds =
	{
		TEXT("audio-pacing/review-slow-breath"),
		TEXT("audio-pacing/mastery-release-rise"),
		TEXT("audio-pacing/correction-focus-mute"),
		TEXT("audio-pacing/challenge-steadied-drive")
	};
	AudioPacingBoundary.AudioSurfaceTags =
	{
		TEXT("ambient tempo shaping"),
		TEXT("correction-state ducking"),
		TEXT("mastery-state release swell")
	};
	AudioPacingBoundary.PacingSurfaceTags =
	{
		TEXT("study-mode calm pacing"),
		TEXT("challenge-mode tightened pacing"),
		TEXT("failure-recovery audio reset")
	};
	AudioPacingBoundary.ExplicitExclusions =
	{
		TEXT("full soundtrack scoring ownership"),
		TEXT("generic music system ownership"),
		TEXT("cross-product rhythm engine ownership")
	};
	AudioPacingBoundary.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-audio-pacing-boundary"),
		TEXT("Owns bounded reactive ambient audio pacing for HyperTwist training without widening into soundtrack scoring, generic music systems, or cross-product rhythm engines.")
	);
	Bundle.AudioPacingBoundaries = {AudioPacingBoundary};

	FHyperTwistTrainingImmersiveModeDifferentiationContract ModeDifferentiationContract;
	ModeDifferentiationContract.ContractId = TEXT("immersive-training-mode-differentiation-contract");
	ModeDifferentiationContract.Title = TEXT("Scenic immersive mode-differentiation contract");
	ModeDifferentiationContract.Summary = TEXT("First-party HyperTwist contract for study-mode versus challenge-mode environmental differentiation without destabilizing puzzle legibility or training focus.");
	ModeDifferentiationContract.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-environment-shell"),
		TEXT("package/hypertwist-immersive-session-state-cues")
	};
	ModeDifferentiationContract.ModeIds =
	{
		TEXT("mode/study"),
		TEXT("mode/challenge"),
		TEXT("mode/review")
	};
	ModeDifferentiationContract.DifferentiationSurfaceTags =
	{
		TEXT("study-mode atmospheric softness"),
		TEXT("challenge-mode tightened contrast"),
		TEXT("review-mode decompressed pacing")
	};
	ModeDifferentiationContract.GuardSurfaceTags =
	{
		TEXT("no-theatrical-overreaction guard"),
		TEXT("puzzle-legibility first guard"),
		TEXT("coach-readability priority guard")
	};
	ModeDifferentiationContract.ExplicitExclusions =
	{
		TEXT("generic game mode framework ownership"),
		TEXT("cross-product difficulty shell ownership"),
		TEXT("broad narrative mode ownership")
	};
	ModeDifferentiationContract.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-mode-differentiation-contract"),
		TEXT("Owns bounded study-versus-challenge scenic differentiation for HyperTwist training without widening into generic game-mode, difficulty-shell, or narrative-mode ownership.")
	);
	Bundle.ModeDifferentiationContracts = {ModeDifferentiationContract};

	FHyperTwistTrainingImmersiveTransitionSafetyBoundary TransitionSafetyBoundary;
	TransitionSafetyBoundary.BoundaryId = TEXT("immersive-training-transition-safety-boundary");
	TransitionSafetyBoundary.Title = TEXT("Scenic immersive transition-safety boundary");
	TransitionSafetyBoundary.Summary = TEXT("First-party HyperTwist boundary for comfort-safe scenic transition timing, fade rules, and motion restraint during immersive training.");
	TransitionSafetyBoundary.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-session-state-cues"),
		TEXT("package/hypertwist-immersive-hardening")
	};
	TransitionSafetyBoundary.ComfortTransitionIds =
	{
		TEXT("transition-safety/slow-fade-floor"),
		TEXT("transition-safety/no-snap-teleport-shift"),
		TEXT("transition-safety/review-reset-soft-blend"),
		TEXT("transition-safety/failure-recovery-motion-clamp")
	};
	TransitionSafetyBoundary.SafetySurfaceTags =
	{
		TEXT("motion-safe transition cadence"),
		TEXT("vignette-compatible state shift"),
		TEXT("vestibular calm scenic reset")
	};
	TransitionSafetyBoundary.GuardSurfaceTags =
	{
		TEXT("no-abrupt-camera-displacement guard"),
		TEXT("no-flash-pulse transition guard"),
		TEXT("posture-safe anchor retention")
	};
	TransitionSafetyBoundary.ExplicitExclusions =
	{
		TEXT("generic locomotion framework ownership"),
		TEXT("full comfort-settings platform ownership"),
		TEXT("broad camera-system ownership")
	};
	TransitionSafetyBoundary.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-transition-safety-boundary"),
		TEXT("Owns bounded comfort-safe scenic transition rules for HyperTwist immersive training without widening into generic locomotion, camera, or platform comfort frameworks.")
	);
	Bundle.TransitionSafetyBoundaries = {TransitionSafetyBoundary};

	FHyperTwistTrainingImmersiveAccessibilityLegibilityContract AccessibilityLegibilityContract;
	AccessibilityLegibilityContract.ContractId = TEXT("immersive-training-accessibility-legibility-contract");
	AccessibilityLegibilityContract.Title = TEXT("Scenic immersive accessibility-legibility contract");
	AccessibilityLegibilityContract.Summary = TEXT("First-party HyperTwist contract for immersive text, puzzle-face, contrast, and reduced-effects accessibility review across scenic training environments.");
	AccessibilityLegibilityContract.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-lighting-presets"),
		TEXT("package/hypertwist-immersive-hardening")
	};
	AccessibilityLegibilityContract.AccessibilityModeIds =
	{
		TEXT("accessibility/high-contrast-puzzle-focus"),
		TEXT("accessibility/reduced-effects-training-view"),
		TEXT("accessibility/coach-caption-priority"),
		TEXT("accessibility/low-clutter-review-view")
	};
	AccessibilityLegibilityContract.LegibilitySurfaceTags =
	{
		TEXT("puzzle-face contrast audit"),
		TEXT("coach-caption readability floor"),
		TEXT("ghost-target visibility reserve")
	};
	AccessibilityLegibilityContract.ReducedEffectsSurfaceTags =
	{
		TEXT("reduced-bloom scenic path"),
		TEXT("reduced-parallax environment path"),
		TEXT("nonessential ambience suppression")
	};
	AccessibilityLegibilityContract.ExplicitExclusions =
	{
		TEXT("platform-global accessibility profile ownership"),
		TEXT("generic UI theme engine ownership"),
		TEXT("cross-product legibility doctrine ownership")
	};
	AccessibilityLegibilityContract.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-accessibility-legibility-contract"),
		TEXT("Owns bounded immersive accessibility and legibility review for HyperTwist training without widening into platform-global accessibility shells or generic theme engines.")
	);
	Bundle.AccessibilityLegibilityContracts = {AccessibilityLegibilityContract};

	FHyperTwistTrainingImmersivePerformanceBudgetBoundary PerformanceBudgetBoundary;
	PerformanceBudgetBoundary.BoundaryId = TEXT("immersive-training-performance-budget-boundary");
	PerformanceBudgetBoundary.Title = TEXT("Scenic immersive performance-budget boundary");
	PerformanceBudgetBoundary.Summary = TEXT("First-party HyperTwist boundary for immersive performance budgets, scenic-cost ceilings, and fallback trigger posture during training sessions.");
	PerformanceBudgetBoundary.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-environment-shell"),
		TEXT("package/hypertwist-immersive-hardening")
	};
	PerformanceBudgetBoundary.BudgetProfileIds =
	{
		TEXT("performance-budget/steady-training-default"),
		TEXT("performance-budget/replay-review-headroom"),
		TEXT("performance-budget/reduced-effects-safe"),
		TEXT("performance-budget/challenge-mode-cap")
	};
	PerformanceBudgetBoundary.PerformanceSurfaceTags =
	{
		TEXT("stable frame-time priority"),
		TEXT("nonessential ambience cost ceiling"),
		TEXT("coach-and-puzzle first render budget")
	};
	PerformanceBudgetBoundary.FallbackTriggerTags =
	{
		TEXT("frame-time regression trigger"),
		TEXT("thermal or device-headroom trigger"),
		TEXT("effect-simplification escalation trigger")
	};
	PerformanceBudgetBoundary.ExplicitExclusions =
	{
		TEXT("engine-global scalability system ownership"),
		TEXT("renderer feature-matrix ownership"),
		TEXT("cross-product device certification ownership")
	};
	PerformanceBudgetBoundary.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-performance-budget-boundary"),
		TEXT("Owns bounded immersive performance-budget posture for HyperTwist training without widening into engine-global scalability, renderer feature matrices, or certification ownership.")
	);
	Bundle.PerformanceBudgetBoundaries = {PerformanceBudgetBoundary};

	FHyperTwistTrainingImmersiveFallbackModeContract FallbackModeContract;
	FallbackModeContract.ContractId = TEXT("immersive-training-fallback-mode-contract");
	FallbackModeContract.Title = TEXT("Scenic immersive fallback-mode contract");
	FallbackModeContract.Summary = TEXT("First-party HyperTwist contract for reduced-effects and compatibility-safe fallback environment modes when scenic cost, comfort, or accessibility demands it.");
	FallbackModeContract.RequiredPackageIds =
	{
		TEXT("package/hypertwist-immersive-environment-shell"),
		TEXT("package/hypertwist-immersive-hardening")
	};
	FallbackModeContract.FallbackModeIds =
	{
		TEXT("fallback-mode/focus-arena-minimal"),
		TEXT("fallback-mode/reduced-effects-scenic"),
		TEXT("fallback-mode/high-contrast-training"),
		TEXT("fallback-mode/replay-clarity-priority")
	};
	FallbackModeContract.ReducedEffectsPathTags =
	{
		TEXT("reduced-effects fallback path"),
		TEXT("ambient-layer suppression path"),
		TEXT("minimal-skybox compatibility path")
	};
	FallbackModeContract.CompatibilitySurfaceTags =
	{
		TEXT("puzzle-and-coach continuity guarantee"),
		TEXT("session-state cue preservation floor"),
		TEXT("study-mode fallback calm reserve")
	};
	FallbackModeContract.ExplicitExclusions =
	{
		TEXT("generic graphics settings menu ownership"),
		TEXT("platform launch-profile ownership"),
		TEXT("broad device compatibility matrix ownership")
	};
	FallbackModeContract.SourceAttribution = MakeFirstPartyAttribution(
		TEXT("first-party/immersive-fallback-mode-contract"),
		TEXT("Owns bounded reduced-effects and compatibility-safe immersive fallback modes for HyperTwist training without widening into generic graphics menus, launch profiles, or device matrices.")
	);
	Bundle.FallbackModeContracts = {FallbackModeContract};

	return Bundle;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetEnvironmentProfileContractById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingImmersiveEnvironmentProfileContract& OutContract
)
{
	for (const FHyperTwistTrainingImmersiveEnvironmentProfileContract& Contract : Bundle.EnvironmentProfileContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingImmersiveEnvironmentProfileContract();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetLightingPresetBoundaryById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingImmersiveLightingPresetBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingImmersiveLightingPresetBoundary& Boundary : Bundle.LightingPresetBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingImmersiveLightingPresetBoundary();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetAmbientAudioBoundaryById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingImmersiveAmbientAudioBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingImmersiveAmbientAudioBoundary& Boundary : Bundle.AmbientAudioBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingImmersiveAmbientAudioBoundary();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetWorldAnchorContractById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingImmersiveWorldAnchorContract& OutContract
)
{
	for (const FHyperTwistTrainingImmersiveWorldAnchorContract& Contract : Bundle.WorldAnchorContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingImmersiveWorldAnchorContract();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetPresenceControlContractById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingImmersivePresenceControlContract& OutContract
)
{
	for (const FHyperTwistTrainingImmersivePresenceControlContract& Contract : Bundle.PresenceControlContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingImmersivePresenceControlContract();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetComfortBoundaryById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingImmersiveComfortBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingImmersiveComfortBoundary& Boundary : Bundle.ComfortBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingImmersiveComfortBoundary();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetPostureVariantContractById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingImmersivePostureVariantContract& OutContract
)
{
	for (const FHyperTwistTrainingImmersivePostureVariantContract& Contract : Bundle.PostureVariantContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingImmersivePostureVariantContract();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetSessionRecallBoundaryById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingImmersiveSessionRecallBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingImmersiveSessionRecallBoundary& Boundary : Bundle.SessionRecallBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingImmersiveSessionRecallBoundary();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetCoachCueAnchorContractById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingImmersiveCoachCueAnchorContract& OutContract
)
{
	for (const FHyperTwistTrainingImmersiveCoachCueAnchorContract& Contract : Bundle.CoachCueAnchorContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingImmersiveCoachCueAnchorContract();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetGhostTargetBoundaryById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingImmersiveGhostTargetBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingImmersiveGhostTargetBoundary& Boundary : Bundle.GhostTargetBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingImmersiveGhostTargetBoundary();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetReplayEmphasisBoundaryById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingImmersiveReplayEmphasisBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingImmersiveReplayEmphasisBoundary& Boundary : Bundle.ReplayEmphasisBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingImmersiveReplayEmphasisBoundary();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetLessonStateContractById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingImmersiveLessonStateContract& OutContract
)
{
	for (const FHyperTwistTrainingImmersiveLessonStateContract& Contract : Bundle.LessonStateContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingImmersiveLessonStateContract();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetSessionStateCueContractById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingImmersiveSessionStateCueContract& OutContract
)
{
	for (const FHyperTwistTrainingImmersiveSessionStateCueContract& Contract : Bundle.SessionStateCueContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingImmersiveSessionStateCueContract();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetLightingReactionBoundaryById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingImmersiveLightingReactionBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingImmersiveLightingReactionBoundary& Boundary : Bundle.LightingReactionBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingImmersiveLightingReactionBoundary();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetAudioPacingBoundaryById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingImmersiveAudioPacingBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingImmersiveAudioPacingBoundary& Boundary : Bundle.AudioPacingBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingImmersiveAudioPacingBoundary();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetModeDifferentiationContractById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingImmersiveModeDifferentiationContract& OutContract
)
{
	for (const FHyperTwistTrainingImmersiveModeDifferentiationContract& Contract : Bundle.ModeDifferentiationContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingImmersiveModeDifferentiationContract();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetTransitionSafetyBoundaryById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingImmersiveTransitionSafetyBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingImmersiveTransitionSafetyBoundary& Boundary : Bundle.TransitionSafetyBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingImmersiveTransitionSafetyBoundary();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetAccessibilityLegibilityContractById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingImmersiveAccessibilityLegibilityContract& OutContract
)
{
	for (const FHyperTwistTrainingImmersiveAccessibilityLegibilityContract& Contract : Bundle.AccessibilityLegibilityContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingImmersiveAccessibilityLegibilityContract();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetPerformanceBudgetBoundaryById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& BoundaryId,
	FHyperTwistTrainingImmersivePerformanceBudgetBoundary& OutBoundary
)
{
	for (const FHyperTwistTrainingImmersivePerformanceBudgetBoundary& Boundary : Bundle.PerformanceBudgetBoundaries)
	{
		if (Boundary.BoundaryId == BoundaryId)
		{
			OutBoundary = Boundary;
			return true;
		}
	}

	OutBoundary = FHyperTwistTrainingImmersivePerformanceBudgetBoundary();
	return false;
}

bool UHyperTwistTrainingImmersiveEnvironmentLibrary::TryGetFallbackModeContractById(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle,
	const FString& ContractId,
	FHyperTwistTrainingImmersiveFallbackModeContract& OutContract
)
{
	for (const FHyperTwistTrainingImmersiveFallbackModeContract& Contract : Bundle.FallbackModeContracts)
	{
		if (Contract.ContractId == ContractId)
		{
			OutContract = Contract;
			return true;
		}
	}

	OutContract = FHyperTwistTrainingImmersiveFallbackModeContract();
	return false;
}

FString UHyperTwistTrainingImmersiveEnvironmentLibrary::BuildPackageChecklistTsv(
	const FHyperTwistTrainingImmersiveEnvironmentReferenceBundle& Bundle
)
{
	using namespace HyperTwistTrainingImmersiveEnvironmentLibraryInternal;

	FString Checklist = TEXT("PackageId\tLabel\tOwnershipRole\tRetainedSurfaceTags\tExplicitExclusions\tSummary\n");
	for (const FHyperTwistTrainingImmersiveEnvironmentPackageReference& Reference : Bundle.PackageReferences)
	{
		FString RetainedSurfaceTags;
		AppendJoined(RetainedSurfaceTags, Reference.RetainedSurfaceTags);

		FString Exclusions;
		AppendJoined(Exclusions, Reference.ExplicitExclusions);

		Checklist += FString::Printf(
			TEXT("%s\t%s\t%s\t%s\t%s\t%s\n"),
			*Reference.PackageId,
			*Reference.Label,
			*Reference.OwnershipRole,
			*RetainedSurfaceTags,
			*Exclusions,
			*Reference.Summary.Replace(TEXT("\t"), TEXT(" "))
		);
	}

	return Checklist;
}
