Implement Phase 6R-D tiling topology contract

2026-05-21 03:10:22 +02:00 · 2026-05-21 03:10:22 +02:00 · e0490fcf7d
commit e0490fcf7d
parent 175fdce3fb
9 changed files with 1221 additions and 26 deletions
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp
+++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp
@ -515,6 +515,11 @@ FHyperTwistTrainingLegacy4DReferenceBundle UHyperTwistTrainingRuntimeLibrary::Ge
 	return UHyperTwistTrainingLegacy4DLibrary::BuildBundledLegacy4DReferenceBundle();
 }

+FHyperTwistTrainingTilingReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetBundledTilingReferenceBundle()
+{
+	return UHyperTwistTrainingTilingLibrary::BuildBundledTilingReferenceBundle();
+}
+
 FHyperTwistTrainingSharedAssetReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetBundledSharedAssetReferenceBundle()
 {
 	return UHyperTwistTrainingSharedAssetLibrary::BuildBundledSharedAssetReferenceBundle();
@ -1098,6 +1103,49 @@ FString UHyperTwistTrainingRuntimeLibrary::BuildBundledLegacy4DPackageChecklistT
 	);
 }

+bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingTopologyContract(
+	const FString& ContractId,
+	FHyperTwistTrainingTilingTopologyContract& OutContract
+)
+{
+	return UHyperTwistTrainingTilingLibrary::TryGetTopologyContractById(
+		GetBundledTilingReferenceBundle(),
+		ContractId,
+		OutContract
+	);
+}
+
+bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingLoaderBoundary(
+	const FString& BoundaryId,
+	FHyperTwistTrainingTilingLoaderBoundary& OutBoundary
+)
+{
+	return UHyperTwistTrainingTilingLibrary::TryGetLoaderBoundaryById(
+		GetBundledTilingReferenceBundle(),
+		BoundaryId,
+		OutBoundary
+	);
+}
+
+bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingAttributionBoundary(
+	const FString& BoundaryId,
+	FHyperTwistTrainingTilingAttributionBoundary& OutBoundary
+)
+{
+	return UHyperTwistTrainingTilingLibrary::TryGetAttributionBoundaryById(
+		GetBundledTilingReferenceBundle(),
+		BoundaryId,
+		OutBoundary
+	);
+}
+
+FString UHyperTwistTrainingRuntimeLibrary::BuildBundledTilingPackageChecklistTsv()
+{
+	return UHyperTwistTrainingTilingLibrary::BuildPackageChecklistTsv(
+		GetBundledTilingReferenceBundle()
+	);
+}
+
 bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledSharedAssetFixtureReference(
 	const FString& FixtureId,
 	FHyperTwistTrainingSharedAssetFixtureReference& OutReference
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingTilingLibrary.cpp
+++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingTilingLibrary.cpp
@ -0,0 +1,418 @@
+#include "HyperTwistTraining/HyperTwistTrainingTilingLibrary.h"
+
+namespace HyperTwistTrainingTilingLibraryInternal
+{
+	const TCHAR* MagicTileLicense = TEXT("MIT");
+
+	FHyperTwistTrainingSourceAttribution MakeAttribution(
+		const FString& TrackId,
+		const FString& Notes
+	)
+	{
+		FHyperTwistTrainingSourceAttribution Attribution;
+		Attribution.SourceMode = EHyperTwistTrainingSourceMode::DirectDonor;
+		Attribution.SourceRepo = TEXT("roice3/MagicTile");
+		Attribution.SourceLicense = MagicTileLicense;
+		Attribution.SourceTrackId = TrackId;
+		Attribution.SourceNotes = Notes;
+		return Attribution;
+	}
+
+	FHyperTwistTrainingTilingPackageReference MakePackageReference(
+		const FString& PackageId,
+		const FString& Label,
+		const FString& ExportPath,
+		const FString& OwnershipRole,
+		const FString& LicensePosture,
+		const FString& Summary,
+		const TArray<FString>& RetainedSurfaceTags,
+		const TArray<FString>& RequiredNoticeActions,
+		const TArray<FString>& ExplicitExclusions,
+		const FHyperTwistTrainingSourceAttribution& SourceAttribution
+	)
+	{
+		FHyperTwistTrainingTilingPackageReference Reference;
+		Reference.PackageId = PackageId;
+		Reference.Label = Label;
+		Reference.ExportPath = ExportPath;
+		Reference.OwnershipRole = OwnershipRole;
+		Reference.LicensePosture = LicensePosture;
+		Reference.Summary = Summary;
+		Reference.RetainedSurfaceTags = RetainedSurfaceTags;
+		Reference.RequiredNoticeActions = RequiredNoticeActions;
+		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]);
+		}
+	}
+}
+
+FHyperTwistTrainingTilingReferenceBundle UHyperTwistTrainingTilingLibrary::BuildBundledTilingReferenceBundle()
+{
+	using namespace HyperTwistTrainingTilingLibraryInternal;
+
+	FHyperTwistTrainingTilingReferenceBundle Bundle;
+	Bundle.ReferenceUtc = TEXT("2026-05-21T00:30:00Z");
+	Bundle.PrimaryTopologyContractId = TEXT("tiling-topology-stack");
+	Bundle.PrimaryLoaderBoundaryId = TEXT("tiling-loader-boundary");
+	Bundle.PrimaryAttributionBoundaryId = TEXT("tiling-mit-attribution-boundary");
+
+	const TArray<FString> CommonNoticeActions =
+	{
+		TEXT("preserve the upstream MIT license text in third-party notices or equivalent release/legal materials"),
+		TEXT("preserve the upstream copyright notice for Roice Nelson")
+	};
+
+	Bundle.PackageReferences =
+	{
+		MakePackageReference(
+			TEXT("package/magictile-topology-analyzer"),
+			TEXT("MagicTile/Puzzle/TopologyAnalyzer"),
+			TEXT("./MagicTile/Puzzle/TopologyAnalyzer.cs"),
+			TEXT("tiling-topology-anchor"),
+			TEXT("direct permissive donor"),
+			TEXT("Logical face-edge-vertex identification, Euler-characteristic calculation, and merged topology analysis for tiling-driven puzzle spaces."),
+			{
+				TEXT("logical element indexing"),
+				TEXT("face edge vertex counts"),
+				TEXT("Euler characteristic"),
+				TEXT("master/slave identification merging")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("runtime-base ownership"),
+				TEXT("WinForms/OpenTK shell ownership"),
+				TEXT("macro transport ownership")
+			},
+			MakeAttribution(
+				TEXT("tiling/topology-analyzer"),
+				TEXT("Preserves MagicTile logical-element indexing, identification merging, and Euler-characteristic analysis beneath first-party HyperTwist tiling topology ownership.")
+			)
+		),
+		MakePackageReference(
+			TEXT("package/magictile-loader"),
+			TEXT("MagicTile/Puzzle/Loader"),
+			TEXT("./MagicTile/Puzzle/Loader.cs"),
+			TEXT("tiling-loader-support"),
+			TEXT("direct permissive donor"),
+			TEXT("Generalized puzzle-construction loading, master/slave cell preparation, and topology-derived construction support for tiling-driven puzzle families."),
+			{
+				TEXT("puzzle loading"),
+				TEXT("master slave cell setup"),
+				TEXT("state-calculation cell preparation"),
+				TEXT("topology-derived construction")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("runtime-base ownership"),
+				TEXT("whole legacy persistence shell"),
+				TEXT("direct WinForms host transplant")
+			},
+			MakeAttribution(
+				TEXT("tiling/loader"),
+				TEXT("Preserves MagicTile generalized puzzle-loading and topology-derived construction seams without displacing the Hyperspeedcube runtime anchor.")
+			)
+		),
+		MakePackageReference(
+			TEXT("package/magictile-puzzle-core"),
+			TEXT("MagicTile/Puzzle/Puzzle"),
+			TEXT("./MagicTile/Puzzle/Puzzle.cs"),
+			TEXT("tiling-construction-support"),
+			TEXT("direct permissive donor"),
+			TEXT("Tiling-driven puzzle construction support including master/slave cells, sticker slicing, and twist-data registration beneath first-party runtime ownership."),
+			{
+				TEXT("master cells"),
+				TEXT("slave cells"),
+				TEXT("sticker slicing"),
+				TEXT("twist-data registration")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("runtime-base ownership"),
+				TEXT("whole renderer ownership"),
+				TEXT("legacy host-shell ownership")
+			},
+			MakeAttribution(
+				TEXT("tiling/puzzle-core"),
+				TEXT("Preserves MagicTile master/slave construction, sticker slicing, and twist-data setup seams beneath first-party HyperTwist topology ownership.")
+			)
+		),
+		MakePackageReference(
+			TEXT("package/magictile-tiling-geometry"),
+			TEXT("R3.Core/Geometry/Tiling"),
+			TEXT("./R3/R3.Core/Geometry/Tiling.cs"),
+			TEXT("tiling-geometry-anchor"),
+			TEXT("direct permissive donor"),
+			TEXT("Regular-tiling, dual-tiling, and centered-projection geometry substrate for spherical, Euclidean, and hyperbolic tiling families."),
+			{
+				TEXT("regular tiling generation"),
+				TEXT("dual tiling support"),
+				TEXT("face edge vertex centered projections"),
+				TEXT("non-Euclidean tiling families")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("runtime-base ownership"),
+				TEXT("macro remapping ownership"),
+				TEXT("legacy renderer shell")
+			},
+			MakeAttribution(
+				TEXT("tiling/geometry-tiling"),
+				TEXT("Preserves MagicTile regular-tiling, dual-tiling, and projection-family seams for first-party HyperTwist tiling geometry ownership.")
+			)
+		),
+		MakePackageReference(
+			TEXT("package/magictile-polytope-geometry"),
+			TEXT("R3.Core/Geometry/Polytope"),
+			TEXT("./R3/R3.Core/Geometry/Polytope.cs"),
+			TEXT("tiling-polytope-support"),
+			TEXT("direct permissive donor"),
+			TEXT("Polytope construction support for topology-derived puzzle families that widen beyond ordinary cube spaces."),
+			{
+				TEXT("polytope construction"),
+				TEXT("cell and facet relationships"),
+				TEXT("higher-order geometry support")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("runtime-base ownership"),
+				TEXT("whole viewer shell ownership"),
+				TEXT("direct renderer transplant")
+			},
+			MakeAttribution(
+				TEXT("tiling/geometry-polytope"),
+				TEXT("Preserves MagicTile polytope-construction support for first-party HyperTwist topology and geometry-family ownership.")
+			)
+		),
+		MakePackageReference(
+			TEXT("package/magictile-h3-honeycomb"),
+			TEXT("R3.Core/Honeycombs/H3"),
+			TEXT("./R3/R3.Core/Honeycombs/H3.cs"),
+			TEXT("tiling-hyperbolic-family-support"),
+			TEXT("direct permissive donor"),
+			TEXT("Hyperbolic honeycomb-family support for later non-Euclidean tiling puzzle families beneath first-party HyperTwist ownership."),
+			{
+				TEXT("hyperbolic honeycomb families"),
+				TEXT("non-Euclidean family tags"),
+				TEXT("later topology widening support")
+			},
+			CommonNoticeActions,
+			{
+				TEXT("runtime-base ownership"),
+				TEXT("whole app-shell ownership"),
+				TEXT("macro remapping ownership")
+			},
+			MakeAttribution(
+				TEXT("tiling/h3-honeycomb"),
+				TEXT("Preserves MagicTile hyperbolic honeycomb-family seams for later first-party HyperTwist tiling and non-Euclidean topology widening.")
+			)
+		)
+	};
+
+	FHyperTwistTrainingTilingTopologyContract TopologyContract;
+	TopologyContract.ContractId = TEXT("tiling-topology-stack");
+	TopologyContract.Title = TEXT("Tiling topology and geometry-family contract");
+	TopologyContract.Summary = TEXT("First-party HyperTwist contract for tiling-driven puzzle-family descriptors, logical topology analysis, and non-Euclidean geometry-family tags beneath the Hyperspeedcube runtime anchor.");
+	TopologyContract.RequiredPackageIds =
+	{
+		TEXT("package/magictile-topology-analyzer"),
+		TEXT("package/magictile-tiling-geometry"),
+		TEXT("package/magictile-polytope-geometry"),
+		TEXT("package/magictile-h3-honeycomb")
+	};
+	TopologyContract.PuzzleFamilies =
+	{
+		TEXT("spherical tilings"),
+		TEXT("Euclidean tilings"),
+		TEXT("hyperbolic tilings"),
+		TEXT("tiling-driven non-Euclidean puzzle families")
+	};
+	TopologyContract.GeometrySurfaceTags =
+	{
+		TEXT("regular tiling generation"),
+		TEXT("dual-tiling support"),
+		TEXT("polytope geometry support"),
+		TEXT("hyperbolic honeycomb family tags"),
+		TEXT("face edge vertex centered projections")
+	};
+	TopologyContract.TopologySurfaceTags =
+	{
+		TEXT("logical face edge vertex counts"),
+		TEXT("Euler characteristic"),
+		TEXT("master slave identification merging"),
+		TEXT("topology-derived indexing"),
+		TEXT("state-calculation cell topology")
+	};
+	TopologyContract.ExplicitExclusions =
+	{
+		TEXT("Hyperspeedcube runtime-base replacement"),
+		TEXT("WinForms/OpenTK shell ownership"),
+		TEXT("transform-aware macro remapping ownership")
+	};
+	TopologyContract.SourceAttribution = MakeAttribution(
+		TEXT("tiling/topology-contract"),
+		TEXT("Preserves MagicTile tiling-family descriptors, topology analysis, and non-Euclidean geometry-family seams while keeping HyperTwist's runtime anchor and product shell first-party.")
+	);
+	Bundle.TopologyContracts = {TopologyContract};
+
+	FHyperTwistTrainingTilingLoaderBoundary LoaderBoundary;
+	LoaderBoundary.BoundaryId = TEXT("tiling-loader-boundary");
+	LoaderBoundary.Title = TEXT("Tiling loader and runtime-anchor boundary");
+	LoaderBoundary.Summary = TEXT("First-party HyperTwist boundary for generalized tiling-derived puzzle loading beneath the Hyperspeedcube runtime anchor and outside the legacy host shell.");
+	LoaderBoundary.RequiredPackageIds =
+	{
+		TEXT("package/magictile-loader"),
+		TEXT("package/magictile-puzzle-core"),
+		TEXT("package/magictile-topology-analyzer")
+	};
+	LoaderBoundary.LoaderSurfaceTags =
+	{
+		TEXT("generalized puzzle loading"),
+		TEXT("master slave cell preparation"),
+		TEXT("sticker slicing"),
+		TEXT("twist-data registration"),
+		TEXT("topology-derived construction")
+	};
+	LoaderBoundary.RuntimeBoundaryTags =
+	{
+		TEXT("Hyperspeedcube runtime anchor remains primary for runtime catalog notation replay and verification"),
+		TEXT("MagicTile widens only the tiling-derived topology and geometry-family lane"),
+		TEXT("loader enrichments stay beneath first-party runtime ownership")
+	};
+	LoaderBoundary.ExplicitExclusions =
+	{
+		TEXT("Hyperspeedcube runtime-base replacement"),
+		TEXT("whole WinForms/OpenTK shell ownership"),
+		TEXT("legacy persistence-dialog ownership"),
+		TEXT("transform-aware macro remapping ownership")
+	};
+	LoaderBoundary.SourceAttribution = MakeAttribution(
+		TEXT("tiling/loader-boundary"),
+		TEXT("Preserves MagicTile generalized puzzle-loading and topology-derived construction seams while keeping runtime, notation, replay, and verification ownership with the Hyperspeedcube anchor and first-party HyperTwist code.")
+	);
+	Bundle.LoaderBoundaries = {LoaderBoundary};
+
+	FHyperTwistTrainingTilingAttributionBoundary AttributionBoundary;
+	AttributionBoundary.BoundaryId = TEXT("tiling-mit-attribution-boundary");
+	AttributionBoundary.Title = TEXT("Tiling donor attribution boundary");
+	AttributionBoundary.Summary = TEXT("First-party HyperTwist compliance boundary for using MagicTile as a direct permissive donor for tiling topology and geometry-family contracts.");
+	AttributionBoundary.AllowedUseTags =
+	{
+		TEXT("first-party reauthored subsystem implementation"),
+		TEXT("direct permissive donor reference"),
+		TEXT("bounded tiling topology and loader contract use")
+	};
+	AttributionBoundary.RequiredNoticeActions = CommonNoticeActions;
+	AttributionBoundary.ExplicitExclusions =
+	{
+		TEXT("silent attribution removal"),
+		TEXT("whole legacy app-shell adoption"),
+		TEXT("pretending macro transport or runtime-base ownership landed in this packet")
+	};
+	AttributionBoundary.SourceAttribution = MakeAttribution(
+		TEXT("tiling/attribution-boundary"),
+		TEXT("Records MIT attribution and packet bounds for MagicTile while keeping non-owned shell and macro surfaces excluded from the first tiling contract slice.")
+	);
+	Bundle.AttributionBoundaries = {AttributionBoundary};
+
+	return Bundle;
+}
+
+bool UHyperTwistTrainingTilingLibrary::TryGetTopologyContractById(
+	const FHyperTwistTrainingTilingReferenceBundle& Bundle,
+	const FString& ContractId,
+	FHyperTwistTrainingTilingTopologyContract& OutContract
+)
+{
+	for (const FHyperTwistTrainingTilingTopologyContract& Contract : Bundle.TopologyContracts)
+	{
+		if (Contract.ContractId == ContractId)
+		{
+			OutContract = Contract;
+			return true;
+		}
+	}
+
+	OutContract = FHyperTwistTrainingTilingTopologyContract();
+	return false;
+}
+
+bool UHyperTwistTrainingTilingLibrary::TryGetLoaderBoundaryById(
+	const FHyperTwistTrainingTilingReferenceBundle& Bundle,
+	const FString& BoundaryId,
+	FHyperTwistTrainingTilingLoaderBoundary& OutBoundary
+)
+{
+	for (const FHyperTwistTrainingTilingLoaderBoundary& Boundary : Bundle.LoaderBoundaries)
+	{
+		if (Boundary.BoundaryId == BoundaryId)
+		{
+			OutBoundary = Boundary;
+			return true;
+		}
+	}
+
+	OutBoundary = FHyperTwistTrainingTilingLoaderBoundary();
+	return false;
+}
+
+bool UHyperTwistTrainingTilingLibrary::TryGetAttributionBoundaryById(
+	const FHyperTwistTrainingTilingReferenceBundle& Bundle,
+	const FString& BoundaryId,
+	FHyperTwistTrainingTilingAttributionBoundary& OutBoundary
+)
+{
+	for (const FHyperTwistTrainingTilingAttributionBoundary& Boundary : Bundle.AttributionBoundaries)
+	{
+		if (Boundary.BoundaryId == BoundaryId)
+		{
+			OutBoundary = Boundary;
+			return true;
+		}
+	}
+
+	OutBoundary = FHyperTwistTrainingTilingAttributionBoundary();
+	return false;
+}
+
+FString UHyperTwistTrainingTilingLibrary::BuildPackageChecklistTsv(
+	const FHyperTwistTrainingTilingReferenceBundle& Bundle
+)
+{
+	using namespace HyperTwistTrainingTilingLibraryInternal;
+
+	FString Output = TEXT("packageId\tlabel\texportPath\townershipRole\tlicensePosture\tretainedSurfaceTags\texplicitExclusions\n");
+	for (const FHyperTwistTrainingTilingPackageReference& Reference : Bundle.PackageReferences)
+	{
+		FString RetainedTags;
+		AppendJoined(RetainedTags, Reference.RetainedSurfaceTags);
+
+		FString ExplicitExclusions;
+		AppendJoined(ExplicitExclusions, Reference.ExplicitExclusions);
+
+		Output += FString::Printf(
+			TEXT("%s\t%s\t%s\t%s\t%s\t%s\t%s\n"),
+			*Reference.PackageId,
+			*Reference.Label,
+			*Reference.ExportPath,
+			*Reference.OwnershipRole,
+			*Reference.LicensePosture,
+			*RetainedTags,
+			*ExplicitExclusions
+		);
+	}
+
+	return Output;
+}
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h
+++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h
@ -15,6 +15,7 @@
 #include "HyperTwistTraining/HyperTwistTrainingMediaExportLibrary.h"
 #include "HyperTwistTraining/HyperTwistTrainingSharedAssetLibrary.h"
 #include "HyperTwistTraining/HyperTwistTrainingSpatialLibrary.h"
+#include "HyperTwistTraining/HyperTwistTrainingTilingLibrary.h"
 #include "HyperTwistTraining/HyperTwistTrainingViewerLibrary.h"
 #include "HyperTwistTraining/HyperTwistTrainingTypes.h"
 #include "HyperTwistSimulation/HyperTwistViewerTypes.h"
@ -174,6 +175,9 @@ public:
 	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Legacy4D")
 	static FHyperTwistTrainingLegacy4DReferenceBundle GetBundledLegacy4DReferenceBundle();

+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
+	static FHyperTwistTrainingTilingReferenceBundle GetBundledTilingReferenceBundle();
+
 	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|SharedAssets")
 	static FHyperTwistTrainingSharedAssetReferenceBundle GetBundledSharedAssetReferenceBundle();

@ -409,6 +413,27 @@ public:
 	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Legacy4D")
 	static FString BuildBundledLegacy4DPackageChecklistTsv();

+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling")
+	static bool TryGetBundledTilingTopologyContract(
+		const FString& ContractId,
+		FHyperTwistTrainingTilingTopologyContract& OutContract
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling")
+	static bool TryGetBundledTilingLoaderBoundary(
+		const FString& BoundaryId,
+		FHyperTwistTrainingTilingLoaderBoundary& OutBoundary
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling")
+	static bool TryGetBundledTilingAttributionBoundary(
+		const FString& BoundaryId,
+		FHyperTwistTrainingTilingAttributionBoundary& OutBoundary
+	);
+
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
+	static FString BuildBundledTilingPackageChecklistTsv();
+
 	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|SharedAssets")
 	static bool TryGetBundledSharedAssetFixtureReference(
 		const FString& FixtureId,
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTilingLibrary.h
+++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTilingLibrary.h
@ -0,0 +1,223 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Kismet/BlueprintFunctionLibrary.h"
+#include "HyperTwistTraining/HyperTwistTrainingTypes.h"
+#include "HyperTwistTrainingTilingLibrary.generated.h"
+
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingTilingPackageReference
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PackageId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString Label;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString ExportPath;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString OwnershipRole;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString LicensePosture;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString Summary;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> RetainedSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> RequiredNoticeActions;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ExplicitExclusions;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FHyperTwistTrainingSourceAttribution SourceAttribution;
+
+	bool IsStructurallyValid() const
+	{
+		return !PackageId.IsEmpty() && !Label.IsEmpty() && !ExportPath.IsEmpty()
+			&& !OwnershipRole.IsEmpty() && SourceAttribution.IsStructurallyValid();
+	}
+};
+
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingTilingTopologyContract
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString ContractId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString Title;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString Summary;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> RequiredPackageIds;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> PuzzleFamilies;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> GeometrySurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> TopologySurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ExplicitExclusions;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FHyperTwistTrainingSourceAttribution SourceAttribution;
+
+	bool IsStructurallyValid() const
+	{
+		return !ContractId.IsEmpty() && !Title.IsEmpty() && SourceAttribution.IsStructurallyValid();
+	}
+};
+
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingTilingLoaderBoundary
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString BoundaryId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString Title;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString Summary;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> RequiredPackageIds;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> LoaderSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> RuntimeBoundaryTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ExplicitExclusions;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FHyperTwistTrainingSourceAttribution SourceAttribution;
+
+	bool IsStructurallyValid() const
+	{
+		return !BoundaryId.IsEmpty() && !Title.IsEmpty() && SourceAttribution.IsStructurallyValid();
+	}
+};
+
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingTilingAttributionBoundary
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString BoundaryId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString Title;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString Summary;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> AllowedUseTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> RequiredNoticeActions;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ExplicitExclusions;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FHyperTwistTrainingSourceAttribution SourceAttribution;
+
+	bool IsStructurallyValid() const
+	{
+		return !BoundaryId.IsEmpty() && !Title.IsEmpty() && SourceAttribution.IsStructurallyValid();
+	}
+};
+
+USTRUCT(BlueprintType)
+struct FHyperTwistTrainingTilingReferenceBundle
+{
+	GENERATED_BODY()
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString ReferenceUtc;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PrimaryTopologyContractId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PrimaryLoaderBoundaryId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FString PrimaryAttributionBoundaryId;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingTilingPackageReference> PackageReferences;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingTilingTopologyContract> TopologyContracts;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingTilingLoaderBoundary> LoaderBoundaries;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingTilingAttributionBoundary> AttributionBoundaries;
+
+	bool IsStructurallyValid() const
+	{
+		return !PrimaryTopologyContractId.IsEmpty() && !PrimaryLoaderBoundaryId.IsEmpty()
+			&& !PrimaryAttributionBoundaryId.IsEmpty() && PackageReferences.Num() > 0;
+	}
+};
+
+UCLASS()
+class UNREALHYPERTWIST_API UHyperTwistTrainingTilingLibrary : public UBlueprintFunctionLibrary
+{
+	GENERATED_BODY()
+
+public:
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
+	static FHyperTwistTrainingTilingReferenceBundle BuildBundledTilingReferenceBundle();
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling")
+	static bool TryGetTopologyContractById(
+		const FHyperTwistTrainingTilingReferenceBundle& Bundle,
+		const FString& ContractId,
+		FHyperTwistTrainingTilingTopologyContract& OutContract
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling")
+	static bool TryGetLoaderBoundaryById(
+		const FHyperTwistTrainingTilingReferenceBundle& Bundle,
+		const FString& BoundaryId,
+		FHyperTwistTrainingTilingLoaderBoundary& OutBoundary
+	);
+
+	UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Tiling")
+	static bool TryGetAttributionBoundaryById(
+		const FHyperTwistTrainingTilingReferenceBundle& Bundle,
+		const FString& BoundaryId,
+		FHyperTwistTrainingTilingAttributionBoundary& OutBoundary
+	);
+
+	UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling")
+	static FString BuildPackageChecklistTsv(const FHyperTwistTrainingTilingReferenceBundle& Bundle);
+};
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagicTilePhase6RDTopologyContractTest.cpp
+++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagicTilePhase6RDTopologyContractTest.cpp
@ -0,0 +1,110 @@
+// Copyright HyperTwist, Inc. All Rights Reserved.
+
+#include "Misc/AutomationTest.h"
+
+#include "HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h"
+
+#if WITH_AUTOMATION_TESTS
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FHyperTwistMagicTilePhase6RDTopologyContractTest,
+	"HyperTwist.Permissive.MagicTile.Phase6R.D.TopologyContract",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter
+)
+
+bool FHyperTwistMagicTilePhase6RDTopologyContractTest::RunTest(const FString& Parameters)
+{
+	const FHyperTwistTrainingTilingReferenceBundle Bundle =
+		UHyperTwistTrainingRuntimeLibrary::GetBundledTilingReferenceBundle();
+
+	TestTrue(TEXT("The MagicTile tiling bundle must be structurally valid."), Bundle.IsStructurallyValid());
+	TestTrue(TEXT("The MagicTile tiling bundle must preserve multiple package references."), Bundle.PackageReferences.Num() >= 5);
+
+	FHyperTwistTrainingTilingTopologyContract Contract;
+	TestTrue(
+		TEXT("The primary tiling topology contract must resolve from the runtime library."),
+		UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingTopologyContract(
+			Bundle.PrimaryTopologyContractId,
+			Contract
+		)
+	);
+	TestEqual(TEXT("The topology contract id must stay stable."), Contract.ContractId, TEXT("tiling-topology-stack"));
+	TestTrue(
+		TEXT("The topology contract must preserve the topology-analyzer package as a required input."),
+		Contract.RequiredPackageIds.Contains(TEXT("package/magictile-topology-analyzer"))
+	);
+	TestTrue(
+		TEXT("The topology contract must preserve hyperbolic-family support as a geometry surface."),
+		Contract.GeometrySurfaceTags.Contains(TEXT("hyperbolic honeycomb family tags"))
+	);
+	TestTrue(
+		TEXT("The topology contract must keep Hyperspeedcube replacement explicitly excluded."),
+		Contract.ExplicitExclusions.Contains(TEXT("Hyperspeedcube runtime-base replacement"))
+	);
+	TestEqual(TEXT("The topology contract must keep the direct donor source repo."), Contract.SourceAttribution.SourceRepo, TEXT("roice3/MagicTile"));
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FHyperTwistMagicTilePhase6RDLoaderBoundaryTest,
+	"HyperTwist.Permissive.MagicTile.Phase6R.D.LoaderBoundary",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter
+)
+
+bool FHyperTwistMagicTilePhase6RDLoaderBoundaryTest::RunTest(const FString& Parameters)
+{
+	const FHyperTwistTrainingTilingReferenceBundle Bundle =
+		UHyperTwistTrainingRuntimeLibrary::GetBundledTilingReferenceBundle();
+
+	FHyperTwistTrainingTilingLoaderBoundary Boundary;
+	TestTrue(
+		TEXT("The tiling loader boundary must resolve from the runtime library."),
+		UHyperTwistTrainingRuntimeLibrary::TryGetBundledTilingLoaderBoundary(
+			Bundle.PrimaryLoaderBoundaryId,
+			Boundary
+		)
+	);
+	TestEqual(TEXT("The loader boundary id must stay stable."), Boundary.BoundaryId, TEXT("tiling-loader-boundary"));
+	TestTrue(
+		TEXT("The loader boundary must preserve generalized puzzle loading as a loader surface."),
+		Boundary.LoaderSurfaceTags.Contains(TEXT("generalized puzzle loading"))
+	);
+	TestTrue(
+		TEXT("The loader boundary must preserve the Hyperspeedcube runtime-anchor separation."),
+		Boundary.RuntimeBoundaryTags.Contains(
+			TEXT("Hyperspeedcube runtime anchor remains primary for runtime catalog notation replay and verification")
+		)
+	);
+	TestTrue(
+		TEXT("The loader boundary must keep legacy host-shell ownership explicitly excluded."),
+		Boundary.ExplicitExclusions.Contains(TEXT("whole WinForms/OpenTK shell ownership"))
+	);
+	return true;
+}
+
+IMPLEMENT_SIMPLE_AUTOMATION_TEST(
+	FHyperTwistMagicTilePhase6RDPackageChecklistTest,
+	"HyperTwist.Permissive.MagicTile.Phase6R.D.PackageChecklist",
+	EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter
+)
+
+bool FHyperTwistMagicTilePhase6RDPackageChecklistTest::RunTest(const FString& Parameters)
+{
+	const FString Checklist = UHyperTwistTrainingRuntimeLibrary::BuildBundledTilingPackageChecklistTsv();
+	TestTrue(TEXT("The tiling package checklist must not be empty."), !Checklist.IsEmpty());
+	TestTrue(
+		TEXT("The checklist must preserve the topology-analyzer package id."),
+		Checklist.Contains(TEXT("package/magictile-topology-analyzer"))
+	);
+	TestTrue(
+		TEXT("The checklist must preserve the TopologyAnalyzer export path."),
+		Checklist.Contains(TEXT("./MagicTile/Puzzle/TopologyAnalyzer.cs"))
+	);
+	TestTrue(
+		TEXT("The checklist must preserve the direct permissive donor posture."),
+		Checklist.Contains(TEXT("direct permissive donor"))
+	);
+	return true;
+}
+
+#endif
--- a/docs/REPO_LICENSE_TRACKING.md
+++ b/docs/REPO_LICENSE_TRACKING.md
@ -90,11 +90,11 @@ Practical implication:

 ## 2026-05-13 current HyperTwist implementation truth

-Status update on `2026-05-20`:
+Status update on `2026-05-21`:

 - the current canonical repo-row portfolio count is `75`
 - all `75` current portfolio rows now have explicit root-tracker coverage
- the current implemented-row count is `27`
+- the current implemented-row count is `28`
 - the four later restrictive clean-room rows now implemented after the original `2026-05-13` truth
  block are:
  - `cubing/alg.js`
@ -107,6 +107,8 @@ Status update on `2026-05-20`:
  - `kkoomen/qbr`
 - the seventh additional implemented row is the same-day bounded permissive partial row:
  - `vivaansinghvi07/rubix-cube-solver`
+- the eighth additional implemented row is the next-day bounded permissive partial row:
+  - `roice3/MagicTile`
 - the earlier first-party packet block is now confirmed landed in current code through:
  - `d4f4ad3` `Add primary coach orchestration entry lane`
  - `1860f14` `Add provider-backed recognition sidecar client`
@ -119,21 +121,24 @@ Status update on `2026-05-20`:
 - `kkoomen/qbr` remains partially incorporated
 - the bounded permissive `Phase 6R-C` `vivaansinghvi07/rubix-cube-solver` committed-face
  reconstruction and face-vote replacement packet is now landed in current code
- `vivaansinghvi07/rubix-cube-solver` remains partially incorporated; the current next bounded
-  move is a source-backed `Phase 6R-D` `roice3/MagicTile` preparation/control pass, not a new
-  restrictive packet by default
+- `vivaansinghvi07/rubix-cube-solver` remains partially incorporated
+- the bounded permissive `Phase 6R-D` `roice3/MagicTile` tiling topology and geometry-family
+  packet is now landed in current code
+- `roice3/MagicTile` remains partially incorporated; the current next bounded move is a
+  source-backed `Phase 6R-E` speech-input / voice sidecar preparation/control pass, starting with
+  `ggml-org/whisper.cpp`, not a new restrictive packet by default
 - use the repo-row README census, the portfolio standing refresh backfill, and the `2R-A`
  ownership contract for the current queue after that correction

 This file now also preserves the current truth that future models must not lose:

 - current curated HyperTwist shallow-eval set: `75` repos
- currently verified live/implemented in checked `UnrealHyperTwist` surfaces: `27`
- permissive live lanes: `16`
+- currently verified live/implemented in checked `UnrealHyperTwist` surfaces: `28`
+- permissive live lanes: `17`
 - boundary-sensitive live lanes: `6`
 - restrictive live lanes: `5`

-The sixteen permissive live lanes are:
+The seventeen permissive live lanes are:

 - `Aarav2709/KubeTimr`
 - `HactarCE/Hyperspeedcube`
@ -151,6 +156,7 @@ The sixteen permissive live lanes are:
 - `met4citizen/TalkingHead`
 - `poliva/cubedex`
 - `newyork-anthonyng/rubiks-cross-trainer`
+- `roice3/MagicTile`

 The six boundary-sensitive live lanes are:

@ -182,7 +188,7 @@ Interpretation rule:

 Reset rule:

- preserve the twenty-six landed/live lanes
+- preserve the twenty-eight landed/live lanes
 - do not treat the remaining non-live rows as already absorbed
 - route all non-live rows only through the closed `Phase 1R` retained-set contract and the relevant `0R-*` packet

@ -221,8 +227,8 @@ Current practical interpretation:
 - the landed `PostHog/posthog` boundary-sensitive widening packet now lives in `docs/HYPERTWIST_PHASE_4R_PACKET_4R_D_POSTHOG_CONTROL_PLANE_IMPLEMENTATION_2026-05-13.md`
 - the landed `screenpipe/screenpipe` boundary-sensitive widening packet now lives in `docs/HYPERTWIST_PHASE_4R_PACKET_4R_E_SCREENPIPE_CAPTURE_HISTORY_IMPLEMENTATION_2026-05-13.md`
 - the landed `remotion-dev/remotion` boundary-sensitive widening packet now lives in `docs/HYPERTWIST_PHASE_4R_PACKET_4R_F_REMOTION_MEDIA_EXPORT_IMPLEMENTATION_2026-05-13.md`
- the next bounded move is a source-backed `Phase 6R-D` `roice3/MagicTile`
-  preparation/control pass
+- the next bounded move is a source-backed `Phase 6R-E` speech-input / voice sidecar
+  preparation/control pass, starting with `ggml-org/whisper.cpp`

 Companion docs:

@ -238,6 +244,7 @@ Companion docs:
 - `docs/HYPERTWIST_PHASE_3R_PACKET_3R_B_HYPERCUBING_XYZ_IMPLEMENTATION_2026-05-13.md`
 - `docs/HYPERTWIST_PHASE_3R_PACKET_3R_F_BROWSER_SPATIAL_SUPPORT_IMPLEMENTATION_2026-05-13.md`
 - `docs/arch/HYPERTWIST_PHASE6R_A_HYPERSPEEDCUBE_PUZZLE_CATALOG_IMPLEMENTATION_PACKET_2026-05-20.md`
+- `docs/arch/HYPERTWIST_PHASE6R_D_MAGICTILE_TILING_TOPOLOGY_IMPLEMENTATION_PACKET_2026-05-21.md`
 - `docs/HYPERTWIST_REPO_STATE_BOARD_2026-05-11.md`

 ## Landed live-lane legal records
@ -1273,10 +1280,11 @@ Approved working posture:
  permission to transplant the whole Rust application shell
 - do not let this row absorb non-Euclidean topology ownership that remains queued for
  `roice3/MagicTile`
- after the landed puzzle-catalog slice, the landed bounded `qbr` calibration slice, and the
-  landed bounded `rubix-cube-solver` reconstruction slice, the next queue head should move to a
-  source-backed `Phase 6R-D` `roice3/MagicTile` preparation/control pass rather than pretending
-  the entire retained topology family is already closed
+- after the landed puzzle-catalog slice, the landed bounded `qbr` calibration slice, the landed
+  bounded `rubix-cube-solver` reconstruction slice, and the landed bounded `MagicTile`
+  tiling-topology slice, the next queue head should move to a source-backed `Phase 6R-E`
+  speech-input / voice sidecar preparation/control pass, starting with `ggml-org/whisper.cpp`,
+  rather than reopening the earlier retained topology queue head by default

 ### `coqui-ai/TTS`

@ -2921,6 +2929,12 @@ Current licensing judgment:
 - usable for HyperTwist
 - direct donor candidate
 - standard `MIT`
+- the first narrower bounded implementation slice is now landed in current code:
+  - tiling topology and geometry-family contract
+  - loader/runtime-anchor boundary
+  - direct-donor attribution boundary
+- the row remains only partially incorporated; transform-aware macro remapping, broad
+  non-Euclidean interaction, and host-shell ownership stay deferred

 Source basis:

@ -3008,6 +3022,10 @@ Approved working posture:
 - use the mirrored repo as the canonical local source
 - retain the local zip as duplicate source possession, not as a separate unresolved legal lane
 - keep ordinary third-party notices if code or substantial portions are incorporated
+- keep the live widening bounded to the landed tiling-topology contract family rather than
+  flattening the row into blanket permission for full host-shell or runtime replacement use
+- after the landed `Phase 6R-D` slice, move the queue head to the bounded speech-input / voice
+  sidecar set rather than reopening `MagicTile` by default

 ### `superliminal.com/andrey/mc7d`

--- a/docs/arch/HYPERTWIST_PHASE6R_D_MAGICTILE_TILING_TOPOLOGY_IMPLEMENTATION_PACKET_2026-05-21.md
+++ b/docs/arch/HYPERTWIST_PHASE6R_D_MAGICTILE_TILING_TOPOLOGY_IMPLEMENTATION_PACKET_2026-05-21.md
@ -0,0 +1,153 @@
+# HyperTwist Phase 6R-D MagicTile tiling topology implementation packet
+
+Created on `2026-05-21`
+
+## Status
+
+- first-party HyperTwist packet
+- bounded permissive `Phase 6R-D` implementation slice
+
+## Purpose
+
+This packet lands the first narrower bounded slice from the retained `roice3/MagicTile`
+non-Euclidean topology row.
+
+The landed slice is:
+
+- first-party tiling topology and geometry-family contract plus loader/runtime-anchor boundary
+
+It is not:
+
+- a full `MagicTile` row transplant
+- a `Hyperspeedcube` runtime-base replacement
+- a transform-aware macro remapping packet
+- a WinForms/OpenTK host-shell packet
+- a broad non-Euclidean interaction shell
+- the speech-input / voice sidecar packet
+
+## Current authority basis
+
+This implementation packet stands on:
+
+- `docs/HYPERTWIST_PHASE_0R_PACKET_0R_A_EVALUATION_2026-05-12.md`
+- `docs/HYPERTWIST_PHASE_2R_PACKET_2R_A_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md`
+- `docs/REPO_LICENSE_TRACKING.md`
+- `docs/arch/HYPERTWIST_PHASE6R_D_MAGICTILE_TOPOLOGY_PREPARATION_PACKET_2026-05-21.md`
+
+The retained owner remains:
+
+- `roice3/MagicTile`
+
+The granted family remains bounded to:
+
+- tiling topology analysis
+- non-Euclidean geometry-family descriptors
+- topology-derived loader boundary
+- direct-donor attribution boundary
+
+This packet lands only the first narrower family in that granted set.
+
+## Landed scope
+
+The current code now owns a retained tiling-topology contract through:
+
+- new first-party tiling contract types for:
+  - package references
+  - topology contract
+  - loader boundary
+  - attribution boundary
+  - reference bundle
+- bundled `MagicTile` reference-bundle construction in:
+  - `UHyperTwistTrainingTilingLibrary`
+- runtime-library accessors for:
+  - bundled tiling reference bundle
+  - topology-contract lookup
+  - loader-boundary lookup
+  - attribution-boundary lookup
+  - package checklist export
+- focused automation coverage in:
+  - `HyperTwistMagicTilePhase6RDTopologyContractTest.cpp`
+
+The landed bundle preserves the bounded donor package basis:
+
+- `package/magictile-topology-analyzer`
+- `package/magictile-loader`
+- `package/magictile-puzzle-core`
+- `package/magictile-tiling-geometry`
+- `package/magictile-polytope-geometry`
+- `package/magictile-h3-honeycomb`
+
+## Why this is still intentionally bounded
+
+This packet lands the first donor-backed topology and geometry-family contract seam, but it does
+not widen into the neighboring retained families.
+
+Still deferred:
+
+- transform-aware macro remapping
+- broad non-Euclidean viewer or editor shell
+- WinForms/OpenTK host-shell ownership
+- runtime-base replacement above `Hyperspeedcube`
+- the speech-input / voice sidecar queue
+
+## Validation
+
+Build validation:
+
+- `Build.bat UnrealHyperTwistEditor Win64 Development -Project='C:\HyperTwist\UnrealHyperTwist\UnrealHyperTwist.uproject' -WaitMutex -NoHotReloadFromIDE`
+
+Focused automation validation:
+
+- `Automation RunTests HyperTwist.Permissive.MagicTile.Phase6R.D`
+
+Regression automation validation:
+
+- `Automation RunTests HyperTwist.Permissive.Qbr.Phase6R.B`
+- `Automation RunTests HyperTwist.Permissive.Hyperspeedcube.Phase6R.A`
+- `Automation RunTests HyperTwist.CleanRoom.CubeDesk`
+
+Expected covered tests:
+
+- `TopologyContract`
+- `LoaderBoundary`
+- `PackageChecklist`
+- `CalibrationSessionConfig`
+- `PreviewObservation`
+- `CommitObservation`
+- `CatalogLookup`
+- `SampleDefinition`
+- `TrainingRunDefinition`
+- existing `CubeDesk` clean-room regression suite
+
+## Queue effect
+
+This packet consumes the current `Phase 6R-D` implementation slice.
+
+`roice3/MagicTile` remains only partially incorporated:
+
+- landed now:
+  - tiling topology and geometry-family contract
+  - loader/runtime-anchor boundary
+  - direct-donor attribution boundary
+- still deferred:
+  - transform-aware macro remapping
+  - broad non-Euclidean interaction shell
+  - WinForms/OpenTK host shell
+
+The next clean move is not another immediate `MagicTile` widening by default.
+
+The next queue head should be:
+
+- a source-backed `Phase 6R-E` speech-input / voice sidecar preparation/control pass, starting
+  with `ggml-org/whisper.cpp`
+
+Keep the future sequencing guards visible:
+
+- `Phase 6R-B` `kkoomen/qbr`
+  - do not copy or redistribute `src/assets/arial-unicode-ms.ttf` without separate confirmation
+    or replacement if any future widening ships that asset
+- `Phase 6R-C` `vivaansinghvi07/rubix-cube-solver`
+  - do not copy or redistribute `frontend/lib/twistysim.min.js` without preserving or replacing
+    its upstream provenance/license if any future widening ships that dependency
+- `Phase 6R-E` speech-input / voice sidecar set
+  - keep code-license judgments separate from model, voice, or payload-license review
--- a/docs/arch/HYPERTWIST_PHASE6R_D_MAGICTILE_TOPOLOGY_PREPARATION_PACKET_2026-05-21.md
+++ b/docs/arch/HYPERTWIST_PHASE6R_D_MAGICTILE_TOPOLOGY_PREPARATION_PACKET_2026-05-21.md
@ -0,0 +1,178 @@
+# HyperTwist Phase 6R-D MagicTile tiling topology preparation packet
+
+Created on `2026-05-21`
+
+## Status
+
+- historical same-day preparation authority
+- bounded post-Phase-`6R-C` preparation slice
+- the first bounded implementation slice now lands separately under:
+  - `docs/arch/HYPERTWIST_PHASE6R_D_MAGICTILE_TILING_TOPOLOGY_IMPLEMENTATION_PACKET_2026-05-21.md`
+
+## Purpose
+
+This packet freezes the next widening order after the landed `Phase 6R-C`
+`vivaansinghvi07/rubix-cube-solver` reconstruction slice.
+
+The open task was:
+
+- define the first bounded source-backed widening packet for `roice3/MagicTile` as the retained
+  `Phase 6R-D` tiling-topology and geometry-family seam
+
+It is not:
+
+- a full `MagicTile` row transplant
+- a `Hyperspeedcube` runtime-base replacement packet
+- a transform-aware macro remapping packet
+- a WinForms/OpenTK host-shell packet
+- a broad non-Euclidean runtime or viewer-shell transplant
+- the next speech-input / voice sidecar packet
+
+## Current authority basis
+
+This preparation packet stands on already-closed authority:
+
+- `docs/HYPERTWIST_PHASE_0R_PACKET_0R_A_EVALUATION_2026-05-12.md`
+- `docs/HYPERTWIST_PHASE_2R_PACKET_2R_A_OWNERSHIP_AND_ACCEPTANCE_CONTRACT_2026-05-13.md`
+- `docs/REPO_LICENSE_TRACKING.md`
+- `docs/arch/HYPERTWIST_PHASE6R_C_RUBIX_CUBE_SOLVER_RECONSTRUCTION_IMPLEMENTATION_PACKET_2026-05-20.md`
+
+The key accepted routing facts are:
+
+- `roice3/MagicTile` is the retained non-Euclidean topology and geometry-family donor immediately
+  after the landed `6R-C` slice
+- earliest widening route is `Phase 6R / Packet 6R-D`
+- the retained donor value there is:
+  - tiling topology analysis
+  - non-Euclidean geometry-family descriptors
+  - generalized tiling-derived puzzle loader seam
+  - explicit donor attribution boundary for direct permissive use
+- ownership denied there is:
+  - do not let the row replace the `Hyperspeedcube` runtime anchor
+  - do not widen into the WinForms/OpenTK host shell
+  - do not widen into transform-aware macro remapping in the first packet
+  - do not widen into broad viewer-shell or persistence-shell ownership
+
+## Why this was the next packet
+
+The earlier retained queue heads were already landed:
+
+- `Phase 6R-A` `HactarCE/Hyperspeedcube`
+- `Phase 6R-B` `kkoomen/qbr`
+- `Phase 6R-C` `vivaansinghvi07/rubix-cube-solver`
+
+That advanced the live queue to:
+
+- `Phase 6R-D` `roice3/MagicTile`
+
+with the later adjacent retained rows ordered behind it:
+
+- the bounded speech-input / voice sidecar set
+
+## Required result
+
+The source-backed control pass for this packet is now complete.
+
+The first actual `6R-D` implementation packet should:
+
+- use the retained `0R-A` and `2R-A` authority surfaces plus the inspected `MagicTile` source
+  basis
+- define one bounded retained slice from `MagicTile`
+- keep the slice inside the accepted non-Euclidean topology and geometry-family ownership
+- widen only the first topology contract family that can stand on its own without dragging in
+  macro remapping or legacy host-shell scope
+- explicitly state which neighboring retained rows stay closed in that packet
+
+## Source-backed retained basis
+
+The queue-head decision is now source-backed rather than README-only.
+
+Inspected retained donor basis:
+
+- `README.md`
+- `Puzzle/TopologyAnalyzer.cs`
+- `Puzzle/Loader.cs`
+- `Puzzle/Puzzle.cs`
+- `Puzzle/Twisting/Macro.cs`
+- `R3/R3.Core/Geometry/Tiling.cs`
+- `R3/R3.Core/Geometry/Polytope.cs`
+- `R3/R3.Core/Honeycombs/H3.cs`
+
+Inspected first-party receiving basis:
+
+- `UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingLegacy4DLibrary.h`
+- `UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingLegacy4DLibrary.cpp`
+- `UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h`
+- `UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp`
+- `UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistCore/HyperTwistCoreTypes.h`
+
+## Narrowed 6R-D slice decision
+
+The first widening slice was fixed as:
+
+1. tiling topology and geometry-family contract plus loader/runtime-anchor boundary
+
+not as the broader non-Euclidean interaction bundle.
+
+That narrowed slice covers:
+
+- first-party tiling package references and package checklist export
+- first-party topology contract for:
+  - logical face-edge-vertex counts
+  - Euler characteristic
+  - identification merging
+  - topology-derived indexing
+  - non-Euclidean geometry-family tags
+- first-party loader boundary for:
+  - generalized puzzle loading
+  - master/slave cell preparation
+  - topology-derived construction
+  - runtime-anchor separation
+- first-party attribution boundary for direct permissive donor use
+- runtime-library accessors and focused automation coverage
+
+## Deferred neighboring families
+
+The first `6R-D` implementation packet must keep these capability families closed:
+
+- transform-aware macro remapping
+- deeper non-Euclidean interaction or viewer ownership
+- WinForms/OpenTK host shell
+- broad runtime-base replacement
+- speech-input / voice sidecar work
+
+Why this slice is first:
+
+- `MagicTile` exposes the strongest narrow retained seam at tiling topology, geometry-family tags,
+  and topology-derived loader boundaries
+- current first-party code already has a separate `legacy4d` macro lane, so macro transport
+  widening here would blur ownership rather than clarify it
+- the runtime library lacked a dedicated tiling/topology contract even though the puzzle-family
+  space already included `Tiling`
+
+## Out of scope for the first 6R-D packet
+
+- transform-aware macro remapping
+- broad non-Euclidean viewer or editor shell
+- legacy persistence shell
+- runtime-base replacement above `Hyperspeedcube`
+- the next speech-input / voice sidecar queue head
+
+## Acceptance criteria
+
+- the packet records why the live queue advanced from landed `6R-C` to `6R-D`
+- the packet records that the first `6R-D` widening slice is tiling topology plus loader boundary
+  only
+- the packet states exact out-of-scope families for the first `6R-D` pass
+- the packet preserves the direct-donor MIT attribution boundary explicitly
+- the packet leaves transform-aware macros and host-shell ownership deferred
+
+## Validation checklist
+
+1. confirm the landed `Phase 6R-C` packet is the consumed prior queue head
+2. confirm the retained `MagicTile` seam narrows cleanly to tiling topology, geometry-family tags,
+   and loader/runtime-anchor boundary
+3. confirm the next implementation packet is framed as bounded source-backed widening rather than a
+   broad non-Euclidean transplant
+
+That is the packet.
--- a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md
+++ b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md
@ -1,9 +1,9 @@
 # HyperTwist — ROADMAP.md

-Status update on `2026-05-20`:
+Status update on `2026-05-21`:

 - the canonical HyperTwist repo-row portfolio is now treated as `75` rows, not `71`
- currently implemented rows are now `27`, not `20`
+- currently implemented rows are now `28`, not `20`
 - four of the additional current implemented rows are the later-landed restrictive clean-room lanes:
  - `cubing/alg.js`
  - `cubing/twisty.js`
@ -15,6 +15,8 @@ Status update on `2026-05-20`:
  - `kkoomen/qbr`
 - the seventh additional current implemented row is the same-day bounded permissive partial row:
  - `vivaansinghvi07/rubix-cube-solver`
+- the eighth additional current implemented row is the next-day bounded permissive partial row:
+  - `roice3/MagicTile`
 - the current next bounded move is **not** another restrictive packet by default
 - the earlier first-party packet block that was still being treated as next is now confirmed landed:
  - `d4f4ad3` `Add primary coach orchestration entry lane`
@ -37,8 +39,13 @@ Status update on `2026-05-20`:
  reconstruction and face-vote replacement packet is now landed in current code
 - `vivaansinghvi07/rubix-cube-solver` remains partially incorporated; browser/webcam shell, broad
  solve explanation, and bundled `twistysim.min.js` redistribution stay deferred
- the current next bounded move is a source-backed `Phase 6R-D` `roice3/MagicTile`
-  preparation/control pass
+- the generic source-backed `Phase 6R-D` `roice3/MagicTile` control pass is now consumed
+- the bounded permissive `Phase 6R-D` `roice3/MagicTile` tiling topology and geometry-family
+  packet is now landed in current code
+- `roice3/MagicTile` remains partially incorporated; transform-aware macro remapping, broader
+  non-Euclidean interaction, and host-shell ownership stay deferred
+- the current next bounded move is a source-backed `Phase 6R-E` speech-input / voice sidecar
+  preparation/control pass, starting with `ggml-org/whisper.cpp`
 - the repo-row implementation queue is now live from that `Phase 6R-A` entry point rather than
  waiting on another first-party packet

@ -66,8 +73,8 @@ Donor-strength rule:
 - route difficulty changes how retained value may enter the product, not whether it may win technically

 - current shallow-eval set: `75` repos
- currently verified live/implemented in checked Unreal surfaces: `27`
- permissive live lanes: `16`
+- currently verified live/implemented in checked Unreal surfaces: `28`
+- permissive live lanes: `17`
 - boundary-sensitive live lanes: `6`
 - restrictive live lanes: `5`
 - the restrictive landed lanes are:
@ -77,7 +84,7 @@ Donor-strength rule:
  - `HactarCE/2x2x2x2-Scrambler`
  - `kash/cubedesk`
 - each restrictive landed lane is to be treated as properly clean-roomed and implemented afterward
- `Phase 0R` is now closed for the remaining `48` non-live rows
+- `Phase 0R` is now closed for the remaining `47` non-live rows
 - `Phase 1R` is now closed as the retained-set contract and handoff overhaul
 - `Phase 2R` is now closed as the retained-set ownership and acceptance packet sequence
 - `Phase 3R-A` is now closed as the landed `Aarav2709/KubeTimr` timer subsystem widening packet
@ -97,17 +104,16 @@ Current routing truth:

 - retained rows total: `68`
 - discarded from the active retained set: `3`
- active non-live implementation-board rows: `36`
+- active non-live implementation-board rows: `35`
 - retained benchmark, oracle, or clean-room-later rows outside the active implementation board: `9`

-The next bounded move is a source-backed `Phase 6R-D` `roice3/MagicTile`
-preparation/control pass.
+The next bounded move is a source-backed `Phase 6R-E` speech-input / voice sidecar
+preparation/control pass, starting with `ggml-org/whisper.cpp`.

 Queue interpretation after that packet:

 - then continue with the retained repo-row queue
 - highest current repo-row queue pressure sits in:
-  - `roice3/MagicTile`
  - the bounded speech-input / voice sidecar set
 - `HactarCE/Hyperspeedcube` remains a partially landed row rather than a closed row:
  - landed:
@ -138,6 +144,22 @@ Queue interpretation after that packet:
  - `vivaansinghvi07/rubix-cube-solver`
    - do not copy or redistribute `frontend/lib/twistysim.min.js` without preserving or replacing
      its upstream provenance/license in any future widening that would ship that asset
+- `roice3/MagicTile` remains a partially landed row rather than a closed row:
+  - landed:
+    - tiling topology and geometry-family contract
+    - loader/runtime-anchor boundary
+    - direct-donor attribution boundary
+  - still deferred:
+    - transform-aware macro remapping
+    - broad non-Euclidean interaction shell
+    - WinForms/OpenTK host shell
+- after the `Phase 6R-D` implementation packet, keep the next queue shape explicit:
+  - `ggml-org/whisper.cpp`
+  - `SYSTRAN/faster-whisper`
+  - `rhasspy/piper`
+  - `coqui-ai/TTS`
+- keep the speech-input / voice sidecar legal sequencing guard visible:
+  - keep code-license judgments separate from model, voice, and payload-license review
 - keep the optional `Phase 3R-G` browser comparison lane deferred unless the landed primary browser
  spatial stack exposes a real gap