From e0490fcf7d0c7c33ea7cad2c26f4e3f6f6f76dbb Mon Sep 17 00:00:00 2001 From: axiomlogicnexus Date: Thu, 21 May 2026 03:10:22 +0200 Subject: [PATCH] Implement Phase 6R-D tiling topology contract --- .../HyperTwistTrainingRuntimeLibrary.cpp | 48 ++ .../HyperTwistTrainingTilingLibrary.cpp | 418 ++++++++++++++++++ .../HyperTwistTrainingRuntimeLibrary.h | 25 ++ .../HyperTwistTrainingTilingLibrary.h | 223 ++++++++++ ...tMagicTilePhase6RDTopologyContractTest.cpp | 110 +++++ docs/REPO_LICENSE_TRACKING.md | 48 +- ...POLOGY_IMPLEMENTATION_PACKET_2026-05-21.md | 153 +++++++ ..._TOPOLOGY_PREPARATION_PACKET_2026-05-21.md | 178 ++++++++ .../HyperTwist/ROADMAP.md | 44 +- 9 files changed, 1221 insertions(+), 26 deletions(-) create mode 100644 UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingTilingLibrary.cpp create mode 100644 UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTilingLibrary.h create mode 100644 UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagicTilePhase6RDTopologyContractTest.cpp create mode 100644 docs/arch/HYPERTWIST_PHASE6R_D_MAGICTILE_TILING_TOPOLOGY_IMPLEMENTATION_PACKET_2026-05-21.md create mode 100644 docs/arch/HYPERTWIST_PHASE6R_D_MAGICTILE_TOPOLOGY_PREPARATION_PACKET_2026-05-21.md diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp index 9432b06..eeeb367 100644 --- 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 diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingTilingLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingTilingLibrary.cpp new file mode 100644 index 0000000..80fa0bd --- /dev/null +++ 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& RetainedSurfaceTags, + const TArray& RequiredNoticeActions, + const TArray& 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& 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 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; +} diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h index 2393f6c..1d7c245 100644 --- 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, diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTilingLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingTilingLibrary.h new file mode 100644 index 0000000..2499962 --- /dev/null +++ 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 RetainedSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray RequiredNoticeActions; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray 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 RequiredPackageIds; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray PuzzleFamilies; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray GeometrySurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray TopologySurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray 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 RequiredPackageIds; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray LoaderSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray RuntimeBoundaryTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray 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 AllowedUseTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray RequiredNoticeActions; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray 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 PackageReferences; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray TopologyContracts; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray LoaderBoundaries; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray 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); +}; diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagicTilePhase6RDTopologyContractTest.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagicTilePhase6RDTopologyContractTest.cpp new file mode 100644 index 0000000..3f9a615 --- /dev/null +++ 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 diff --git a/docs/REPO_LICENSE_TRACKING.md b/docs/REPO_LICENSE_TRACKING.md index 8763f4f..fea471d 100644 --- 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` diff --git 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 new file mode 100644 index 0000000..42d2407 --- /dev/null +++ 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 diff --git 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 new file mode 100644 index 0000000..4976cfb --- /dev/null +++ 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. diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md index 3ebbd92..2f8ca5a 100644 --- 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