From 9ed01a33faa0a0d8d513615f7d5fbb25f1eecfcf Mon Sep 17 00:00:00 2001 From: axiomlogicnexus Date: Fri, 22 May 2026 04:29:57 +0200 Subject: [PATCH] Implement Phase 6R-I Magic120Cell runtime profile boundary --- .../HyperTwistTrainingMagic120CellLibrary.cpp | 418 ++++++++++++++++++ .../HyperTwistTrainingRuntimeLibrary.cpp | 48 ++ .../HyperTwistTrainingMagic120CellLibrary.h | 231 ++++++++++ .../HyperTwistTrainingRuntimeLibrary.h | 25 ++ ...CellPhase6RIRuntimeProfileContractTest.cpp | 116 +++++ docs/REPO_LICENSE_TRACKING.md | 11 +- ...STENCE_IMPLEMENTATION_PACKET_2026-05-22.md | 139 ++++++ ...RSISTENCE_PREPARATION_PACKET_2026-05-22.md | 93 ++++ ...PERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md | 9 +- .../HyperTwist/FEATURE_REGISTRY.md | 1 + .../HyperTwist/ROADMAP.md | 30 +- 11 files changed, 1105 insertions(+), 16 deletions(-) create mode 100644 UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.cpp create mode 100644 UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.h create mode 100644 UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagic120CellPhase6RIRuntimeProfileContractTest.cpp create mode 100644 docs/arch/HYPERTWIST_PHASE6R_I_MAGIC120CELL_RUNTIME_PROFILE_AND_PERSISTENCE_IMPLEMENTATION_PACKET_2026-05-22.md create mode 100644 docs/arch/HYPERTWIST_PHASE6R_I_MAGIC120CELL_RUNTIME_PROFILE_AND_PERSISTENCE_PREPARATION_PACKET_2026-05-22.md diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.cpp new file mode 100644 index 0000000..d4106d5 --- /dev/null +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.cpp @@ -0,0 +1,418 @@ +#include "HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.h" + +namespace HyperTwistTrainingMagic120CellLibraryInternal +{ + const TCHAR* Magic120CellLicense = TEXT("MIT"); + + FHyperTwistTrainingSourceAttribution MakeAttribution( + const FString& TrackId, + const FString& Notes + ) + { + FHyperTwistTrainingSourceAttribution Attribution; + Attribution.SourceMode = EHyperTwistTrainingSourceMode::DirectDonor; + Attribution.SourceRepo = TEXT("roice3/Magic120Cell"); + Attribution.SourceLicense = Magic120CellLicense; + Attribution.SourceTrackId = TrackId; + Attribution.SourceNotes = Notes; + return Attribution; + } + + FHyperTwistTrainingMagic120CellPackageReference 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 + ) + { + FHyperTwistTrainingMagic120CellPackageReference 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]); + } + } +} + +FHyperTwistTrainingMagic120CellReferenceBundle +UHyperTwistTrainingMagic120CellLibrary::BuildBundledMagic120CellReferenceBundle() +{ + using namespace HyperTwistTrainingMagic120CellLibraryInternal; + + FHyperTwistTrainingMagic120CellReferenceBundle Bundle; + Bundle.ReferenceUtc = TEXT("2026-05-22T09:15:00Z"); + Bundle.PrimaryRuntimeProfileContractId = TEXT("magic120cell-runtime-profile"); + Bundle.PrimaryPersistenceBoundaryId = TEXT("magic120cell-persistence-boundary"); + Bundle.PrimaryAttributionBoundaryId = TEXT("magic120cell-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/magic120cell-family-core"), + TEXT("Magic120Cell/workFiles/magic120Cell"), + TEXT("./Magic120Cell/workFiles/magic120Cell.cpp"), + TEXT("120-cell-runtime-profile-anchor"), + TEXT("direct permissive donor"), + TEXT("Family-specific 120-cell organization, symmetry maps, hypercube overlay grouping, center-cell view control, and puzzle-type mode routing for the dedicated 4D megaminx analogue lane."), + { + TEXT("12-ring 120-cell organization"), + TEXT("torus symmetry groups"), + TEXT("hypercube symmetry groups"), + TEXT("layer symmetry groups"), + TEXT("ring symmetry groups"), + TEXT("center-cell view recentering") + }, + CommonNoticeActions, + { + TEXT("Hyperspeedcube runtime-base replacement"), + TEXT("generic non-Euclidean topology ownership"), + TEXT("WinForms/OpenGL host-shell ownership") + }, + MakeAttribution( + TEXT("magic120cell/family-core"), + TEXT("Preserves the dedicated Magic120Cell family runtime profile beneath first-party HyperTwist runtime ownership without widening into a generic non-Euclidean shell.") + ) + ), + MakePackageReference( + TEXT("package/magic120cell-settings"), + TEXT("Magic120Cell/workFiles/settings"), + TEXT("./Magic120Cell/workFiles/settings.cpp"), + TEXT("120-cell-mode-default-support"), + TEXT("direct permissive donor"), + TEXT("Family defaults for puzzle-type mode, symmetry mode, logical-visibility depth, center-cell selection, and physical visibility toggles."), + { + TEXT("full-color default"), + TEXT("layer-display default"), + TEXT("logical layer-depth default"), + TEXT("center-cell default"), + TEXT("group-visibility toggles") + }, + CommonNoticeActions, + { + TEXT("broad settings-platform ownership"), + TEXT("UI settings-dialog ownership"), + TEXT("provider-profile ownership") + }, + MakeAttribution( + TEXT("magic120cell/settings"), + TEXT("Preserves the bounded Magic120Cell runtime-mode defaults without importing the legacy settings UI shell.") + ) + ), + MakePackageReference( + TEXT("package/magic120cell-loader"), + TEXT("Magic120Cell/workFiles/loader"), + TEXT("./Magic120Cell/workFiles/loader.cpp"), + TEXT("120-cell-persistence-support"), + TEXT("direct permissive donor"), + TEXT("Family-specific header, scrambled-state persistence, hex facelet serialization, and twist-history load/save support for the dedicated Magic120Cell lane."), + { + TEXT("Magic120Cell Version1 header"), + TEXT("puzzle-type persistence"), + TEXT("scrambled-flag persistence"), + TEXT("hex facelet state serialization"), + TEXT("full_scramble.log cache") + }, + CommonNoticeActions, + { + TEXT("first-party canonical replay ownership"), + TEXT("host file-dialog ownership"), + TEXT("generic notation ownership") + }, + MakeAttribution( + TEXT("magic120cell/loader"), + TEXT("Preserves the dedicated Magic120Cell persistence seam without adopting the host-dialog shell or promoting the format to a generic product-wide replay contract.") + ) + ), + MakePackageReference( + TEXT("package/magic120cell-twist"), + TEXT("geometryLib/puzzle/twist"), + TEXT("./geometryLib/puzzle/twist.h"), + TEXT("120-cell-twist-ledger-support"), + TEXT("direct permissive donor"), + TEXT("Family-specific twist-hash and view-rotation support for Magic120Cell persistence and twist-history replay, including the explicit slicemask caveat."), + { + TEXT("twist-hash encoding"), + TEXT("view-rotation flag"), + TEXT("left-click direction flag"), + TEXT("slicemask caveat") + }, + CommonNoticeActions, + { + TEXT("generic move-notation ownership"), + TEXT("whole transformation-platform ownership"), + TEXT("generic puzzle-family twist ledger ownership") + }, + MakeAttribution( + TEXT("magic120cell/twist"), + TEXT("Preserves the dedicated Magic120Cell twist-hash and view-rotation persistence seam without treating it as the generic transformation contract for all retained puzzle families.") + ) + ), + MakePackageReference( + TEXT("package/magic120cell-twist-history"), + TEXT("geometryLib/puzzle/twistHistory"), + TEXT("./geometryLib/puzzle/twistHistory.cpp"), + TEXT("120-cell-history-undo-redo-support"), + TEXT("direct permissive donor"), + TEXT("Undo/redo and accumulated twist-ledger support for the dedicated Magic120Cell scramble and persistence lane."), + { + TEXT("undo ledger"), + TEXT("redo ledger"), + TEXT("twist accumulation"), + TEXT("scramble-history persistence") + }, + CommonNoticeActions, + { + TEXT("whole review-history ownership"), + TEXT("first-party analytics ownership"), + TEXT("generic persistence-platform ownership") + }, + MakeAttribution( + TEXT("magic120cell/twist-history"), + TEXT("Preserves the dedicated Magic120Cell undo/redo and scramble-ledger seam without promoting it into the broader HyperTwist review or analytics stack.") + ) + ) + }; + + FHyperTwistTrainingMagic120CellRuntimeProfileContract RuntimeProfile; + RuntimeProfile.ContractId = TEXT("magic120cell-runtime-profile"); + RuntimeProfile.Title = TEXT("Magic120Cell family runtime profile"); + RuntimeProfile.Summary = TEXT("First-party HyperTwist contract for dedicated 120-cell family puzzle-type modes, symmetry-scoped visibility groups, and center-cell view semantics beneath the Hyperspeedcube runtime anchor."); + RuntimeProfile.RequiredPackageIds = + { + TEXT("package/magic120cell-family-core"), + TEXT("package/magic120cell-settings") + }; + RuntimeProfile.PuzzleTypeSurfaceTags = + { + TEXT("ring-color puzzle type"), + TEXT("layer-color puzzle type"), + TEXT("torus-color puzzle type"), + TEXT("hypercube-color puzzle type"), + TEXT("full-color puzzle type"), + TEXT("antipodal-color puzzle type") + }; + RuntimeProfile.SymmetrySurfaceTags = + { + TEXT("torus visibility groups"), + TEXT("hypercube visibility groups"), + TEXT("layer visibility groups"), + TEXT("ring visibility groups"), + TEXT("hypercube overlay points") + }; + RuntimeProfile.VisibilitySurfaceTags = + { + TEXT("logical layer-depth visibility"), + TEXT("physical group visibility toggles"), + TEXT("center-cell recentering"), + TEXT("view-rotation guard rails") + }; + RuntimeProfile.ExplicitExclusions = + { + TEXT("Hyperspeedcube runtime-base replacement"), + TEXT("generic non-Euclidean topology ownership"), + TEXT("WinForms/OpenGL host-shell ownership"), + TEXT("broad renderer ownership") + }; + RuntimeProfile.SourceAttribution = MakeAttribution( + TEXT("magic120cell/runtime-profile"), + TEXT("Preserves the dedicated Magic120Cell runtime-profile lane while keeping HyperTwist first-party for the broader runtime, notation, replay, and viewer shell.") + ); + Bundle.RuntimeProfileContracts = {RuntimeProfile}; + + FHyperTwistTrainingMagic120CellPersistenceBoundary PersistenceBoundary; + PersistenceBoundary.BoundaryId = TEXT("magic120cell-persistence-boundary"); + PersistenceBoundary.Title = TEXT("Magic120Cell persistence and twist-history boundary"); + PersistenceBoundary.Summary = TEXT("First-party HyperTwist boundary for the dedicated Magic120Cell file header, state serialization, scramble cache, and twist-history persistence seam."); + PersistenceBoundary.RequiredPackageIds = + { + TEXT("package/magic120cell-loader"), + TEXT("package/magic120cell-twist"), + TEXT("package/magic120cell-twist-history") + }; + PersistenceBoundary.PersistenceSurfaceTags = + { + TEXT("Magic120Cell Version1 header"), + TEXT("puzzle-type persistence"), + TEXT("scrambled-flag persistence"), + TEXT("hex facelet state serialization"), + TEXT("full_scramble.log cache") + }; + PersistenceBoundary.TwistHistorySurfaceTags = + { + TEXT("twist-hash serialization"), + TEXT("view-rotation and direction flags"), + TEXT("undo/redo twist ledger"), + TEXT("scramble-history replay") + }; + PersistenceBoundary.ProvenanceCaveats = + { + TEXT("slice mask is not persisted in twist hash"), + TEXT("save/load dialog filter text still says MagicCube5D log files"), + TEXT("the full scramble shortcut assumes a sidecar full_scramble.log cache") + }; + PersistenceBoundary.ExplicitExclusions = + { + TEXT("first-party canonical replay or verification ownership"), + TEXT("host file-dialog ownership"), + TEXT("generic puzzle-state persistence ownership"), + TEXT("generic move-notation ownership") + }; + PersistenceBoundary.SourceAttribution = MakeAttribution( + TEXT("magic120cell/persistence-boundary"), + TEXT("Preserves the dedicated Magic120Cell persistence seam while keeping HyperTwist first-party for canonical replay, verification, and broader product-wide persistence contracts.") + ); + Bundle.PersistenceBoundaries = {PersistenceBoundary}; + + FHyperTwistTrainingMagic120CellAttributionBoundary AttributionBoundary; + AttributionBoundary.BoundaryId = TEXT("magic120cell-mit-attribution-boundary"); + AttributionBoundary.Title = TEXT("Magic120Cell donor attribution boundary"); + AttributionBoundary.Summary = TEXT("First-party HyperTwist compliance boundary for using Magic120Cell as a direct permissive donor for the bounded family runtime-profile and persistence slice."); + AttributionBoundary.AllowedUseTags = + { + TEXT("first-party reauthored subsystem implementation"), + TEXT("direct permissive donor reference"), + TEXT("bounded family runtime-profile and persistence contract use") + }; + AttributionBoundary.RequiredNoticeActions = CommonNoticeActions; + AttributionBoundary.ProvenanceCaveats = + { + TEXT("Magic120Cell is a dedicated 4D megaminx-analogue donor, not a generic topology platform"), + TEXT("MagicTile remains the generalized tiling and topology donor lane"), + TEXT("Hyperspeedcube remains the primary runtime anchor for retained hyper puzzle ownership") + }; + AttributionBoundary.ExplicitExclusions = + { + TEXT("silent attribution removal"), + TEXT("pretending a broad non-Euclidean shell landed in this packet"), + TEXT("treating legacy host or renderer surfaces as incorporated") + }; + AttributionBoundary.SourceAttribution = MakeAttribution( + TEXT("magic120cell/attribution-boundary"), + TEXT("Records MIT attribution and packet bounds for Magic120Cell while keeping the first slice narrowly scoped to the dedicated runtime-profile and persistence seam.") + ); + Bundle.AttributionBoundaries = {AttributionBoundary}; + + return Bundle; +} + +bool UHyperTwistTrainingMagic120CellLibrary::TryGetRuntimeProfileContractById( + const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle, + const FString& ContractId, + FHyperTwistTrainingMagic120CellRuntimeProfileContract& OutContract +) +{ + for (const FHyperTwistTrainingMagic120CellRuntimeProfileContract& Contract : Bundle.RuntimeProfileContracts) + { + if (Contract.ContractId == ContractId) + { + OutContract = Contract; + return true; + } + } + + OutContract = FHyperTwistTrainingMagic120CellRuntimeProfileContract(); + return false; +} + +bool UHyperTwistTrainingMagic120CellLibrary::TryGetPersistenceBoundaryById( + const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle, + const FString& BoundaryId, + FHyperTwistTrainingMagic120CellPersistenceBoundary& OutBoundary +) +{ + for (const FHyperTwistTrainingMagic120CellPersistenceBoundary& Boundary : Bundle.PersistenceBoundaries) + { + if (Boundary.BoundaryId == BoundaryId) + { + OutBoundary = Boundary; + return true; + } + } + + OutBoundary = FHyperTwistTrainingMagic120CellPersistenceBoundary(); + return false; +} + +bool UHyperTwistTrainingMagic120CellLibrary::TryGetAttributionBoundaryById( + const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle, + const FString& BoundaryId, + FHyperTwistTrainingMagic120CellAttributionBoundary& OutBoundary +) +{ + for (const FHyperTwistTrainingMagic120CellAttributionBoundary& Boundary : Bundle.AttributionBoundaries) + { + if (Boundary.BoundaryId == BoundaryId) + { + OutBoundary = Boundary; + return true; + } + } + + OutBoundary = FHyperTwistTrainingMagic120CellAttributionBoundary(); + return false; +} + +FString UHyperTwistTrainingMagic120CellLibrary::BuildPackageChecklistTsv( + const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle +) +{ + using namespace HyperTwistTrainingMagic120CellLibraryInternal; + + FString Checklist = TEXT("PackageId\tLabel\tExportPath\tOwnershipRole\tLicensePosture\tRetainedSurfaceTags\tRequiredNoticeActions\tExplicitExclusions\n"); + for (const FHyperTwistTrainingMagic120CellPackageReference& Reference : Bundle.PackageReferences) + { + FString RetainedSurfaceTags; + AppendJoined(RetainedSurfaceTags, Reference.RetainedSurfaceTags); + + FString NoticeActions; + AppendJoined(NoticeActions, Reference.RequiredNoticeActions); + + FString Exclusions; + AppendJoined(Exclusions, Reference.ExplicitExclusions); + + Checklist += FString::Printf( + TEXT("%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n"), + *Reference.PackageId, + *Reference.Label, + *Reference.ExportPath, + *Reference.OwnershipRole, + *Reference.LicensePosture, + *RetainedSurfaceTags, + *NoticeActions, + *Exclusions + ); + } + + return Checklist; +} diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp index eeeb367..1187644 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp @@ -520,6 +520,11 @@ FHyperTwistTrainingTilingReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetB return UHyperTwistTrainingTilingLibrary::BuildBundledTilingReferenceBundle(); } +FHyperTwistTrainingMagic120CellReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetBundledMagic120CellReferenceBundle() +{ + return UHyperTwistTrainingMagic120CellLibrary::BuildBundledMagic120CellReferenceBundle(); +} + FHyperTwistTrainingSharedAssetReferenceBundle UHyperTwistTrainingRuntimeLibrary::GetBundledSharedAssetReferenceBundle() { return UHyperTwistTrainingSharedAssetLibrary::BuildBundledSharedAssetReferenceBundle(); @@ -1146,6 +1151,49 @@ FString UHyperTwistTrainingRuntimeLibrary::BuildBundledTilingPackageChecklistTsv ); } +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledMagic120CellRuntimeProfileContract( + const FString& ContractId, + FHyperTwistTrainingMagic120CellRuntimeProfileContract& OutContract +) +{ + return UHyperTwistTrainingMagic120CellLibrary::TryGetRuntimeProfileContractById( + GetBundledMagic120CellReferenceBundle(), + ContractId, + OutContract + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledMagic120CellPersistenceBoundary( + const FString& BoundaryId, + FHyperTwistTrainingMagic120CellPersistenceBoundary& OutBoundary +) +{ + return UHyperTwistTrainingMagic120CellLibrary::TryGetPersistenceBoundaryById( + GetBundledMagic120CellReferenceBundle(), + BoundaryId, + OutBoundary + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledMagic120CellAttributionBoundary( + const FString& BoundaryId, + FHyperTwistTrainingMagic120CellAttributionBoundary& OutBoundary +) +{ + return UHyperTwistTrainingMagic120CellLibrary::TryGetAttributionBoundaryById( + GetBundledMagic120CellReferenceBundle(), + BoundaryId, + OutBoundary + ); +} + +FString UHyperTwistTrainingRuntimeLibrary::BuildBundledMagic120CellPackageChecklistTsv() +{ + return UHyperTwistTrainingMagic120CellLibrary::BuildPackageChecklistTsv( + GetBundledMagic120CellReferenceBundle() + ); +} + bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledSharedAssetFixtureReference( const FString& FixtureId, FHyperTwistTrainingSharedAssetFixtureReference& OutReference diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.h new file mode 100644 index 0000000..15dee2c --- /dev/null +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.h @@ -0,0 +1,231 @@ +#pragma once + +#include "CoreMinimal.h" +#include "Kismet/BlueprintFunctionLibrary.h" +#include "HyperTwistTraining/HyperTwistTrainingTypes.h" +#include "HyperTwistTrainingMagic120CellLibrary.generated.h" + +USTRUCT(BlueprintType) +struct FHyperTwistTrainingMagic120CellPackageReference +{ + 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 FHyperTwistTrainingMagic120CellRuntimeProfileContract +{ + 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 PuzzleTypeSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray SymmetrySurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray VisibilitySurfaceTags; + + 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 FHyperTwistTrainingMagic120CellPersistenceBoundary +{ + 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 PersistenceSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray TwistHistorySurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray ProvenanceCaveats; + + 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 FHyperTwistTrainingMagic120CellAttributionBoundary +{ + 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 ProvenanceCaveats; + + 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 FHyperTwistTrainingMagic120CellReferenceBundle +{ + GENERATED_BODY() + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString ReferenceUtc; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryRuntimeProfileContractId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryPersistenceBoundaryId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryAttributionBoundaryId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray PackageReferences; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray RuntimeProfileContracts; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray PersistenceBoundaries; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray AttributionBoundaries; + + bool IsStructurallyValid() const + { + return !PrimaryRuntimeProfileContractId.IsEmpty() + && !PrimaryPersistenceBoundaryId.IsEmpty() + && !PrimaryAttributionBoundaryId.IsEmpty() + && PackageReferences.Num() > 0; + } +}; + +UCLASS() +class UNREALHYPERTWIST_API UHyperTwistTrainingMagic120CellLibrary : public UBlueprintFunctionLibrary +{ + GENERATED_BODY() + +public: + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Magic120Cell") + static FHyperTwistTrainingMagic120CellReferenceBundle BuildBundledMagic120CellReferenceBundle(); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Magic120Cell") + static bool TryGetRuntimeProfileContractById( + const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle, + const FString& ContractId, + FHyperTwistTrainingMagic120CellRuntimeProfileContract& OutContract + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Magic120Cell") + static bool TryGetPersistenceBoundaryById( + const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle, + const FString& BoundaryId, + FHyperTwistTrainingMagic120CellPersistenceBoundary& OutBoundary + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Magic120Cell") + static bool TryGetAttributionBoundaryById( + const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle, + const FString& BoundaryId, + FHyperTwistTrainingMagic120CellAttributionBoundary& OutBoundary + ); + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Magic120Cell") + static FString BuildPackageChecklistTsv(const FHyperTwistTrainingMagic120CellReferenceBundle& Bundle); +}; diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h index 1d7c245..eff0cc5 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h @@ -12,6 +12,7 @@ #include "HyperTwistTraining/HyperTwistTrainingCoachLibrary.h" #include "HyperTwistTraining/HyperTwistTrainingKnowledgeLibrary.h" #include "HyperTwistTraining/HyperTwistTrainingLegacy4DLibrary.h" +#include "HyperTwistTraining/HyperTwistTrainingMagic120CellLibrary.h" #include "HyperTwistTraining/HyperTwistTrainingMediaExportLibrary.h" #include "HyperTwistTraining/HyperTwistTrainingSharedAssetLibrary.h" #include "HyperTwistTraining/HyperTwistTrainingSpatialLibrary.h" @@ -178,6 +179,9 @@ public: UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling") static FHyperTwistTrainingTilingReferenceBundle GetBundledTilingReferenceBundle(); + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Magic120Cell") + static FHyperTwistTrainingMagic120CellReferenceBundle GetBundledMagic120CellReferenceBundle(); + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|SharedAssets") static FHyperTwistTrainingSharedAssetReferenceBundle GetBundledSharedAssetReferenceBundle(); @@ -434,6 +438,27 @@ public: UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Tiling") static FString BuildBundledTilingPackageChecklistTsv(); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Magic120Cell") + static bool TryGetBundledMagic120CellRuntimeProfileContract( + const FString& ContractId, + FHyperTwistTrainingMagic120CellRuntimeProfileContract& OutContract + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Magic120Cell") + static bool TryGetBundledMagic120CellPersistenceBoundary( + const FString& BoundaryId, + FHyperTwistTrainingMagic120CellPersistenceBoundary& OutBoundary + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Magic120Cell") + static bool TryGetBundledMagic120CellAttributionBoundary( + const FString& BoundaryId, + FHyperTwistTrainingMagic120CellAttributionBoundary& OutBoundary + ); + + UFUNCTION(BlueprintPure, Category = "HyperTwist|Training|Magic120Cell") + static FString BuildBundledMagic120CellPackageChecklistTsv(); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|SharedAssets") static bool TryGetBundledSharedAssetFixtureReference( const FString& FixtureId, diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagic120CellPhase6RIRuntimeProfileContractTest.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagic120CellPhase6RIRuntimeProfileContractTest.cpp new file mode 100644 index 0000000..a775ec2 --- /dev/null +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistMagic120CellPhase6RIRuntimeProfileContractTest.cpp @@ -0,0 +1,116 @@ +// Copyright HyperTwist, Inc. All Rights Reserved. + +#include "Misc/AutomationTest.h" + +#include "HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h" + +#if WITH_AUTOMATION_TESTS + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistMagic120CellPhase6RIRuntimeProfileTest, + "HyperTwist.Permissive.Magic120Cell.Phase6R.I.RuntimeProfile", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistMagic120CellPhase6RIRuntimeProfileTest::RunTest(const FString& Parameters) +{ + const FHyperTwistTrainingMagic120CellReferenceBundle Bundle = + UHyperTwistTrainingRuntimeLibrary::GetBundledMagic120CellReferenceBundle(); + + TestTrue(TEXT("The Magic120Cell bundle must be structurally valid."), Bundle.IsStructurallyValid()); + TestTrue(TEXT("The Magic120Cell bundle must preserve multiple package references."), Bundle.PackageReferences.Num() >= 5); + + FHyperTwistTrainingMagic120CellRuntimeProfileContract Contract; + TestTrue( + TEXT("The primary Magic120Cell runtime profile must resolve from the runtime library."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledMagic120CellRuntimeProfileContract( + Bundle.PrimaryRuntimeProfileContractId, + Contract + ) + ); + TestEqual(TEXT("The runtime profile id must stay stable."), Contract.ContractId, TEXT("magic120cell-runtime-profile")); + TestTrue( + TEXT("The runtime profile must keep the family-core package as a required input."), + Contract.RequiredPackageIds.Contains(TEXT("package/magic120cell-family-core")) + ); + TestTrue( + TEXT("The runtime profile must preserve hypercube visibility groups."), + Contract.SymmetrySurfaceTags.Contains(TEXT("hypercube visibility groups")) + ); + TestTrue( + TEXT("The runtime profile must preserve logical layer-depth visibility."), + Contract.VisibilitySurfaceTags.Contains(TEXT("logical layer-depth visibility")) + ); + TestTrue( + TEXT("The runtime profile must keep generic non-Euclidean topology ownership excluded."), + Contract.ExplicitExclusions.Contains(TEXT("generic non-Euclidean topology ownership")) + ); + TestEqual(TEXT("The runtime profile must keep the direct donor source repo."), Contract.SourceAttribution.SourceRepo, TEXT("roice3/Magic120Cell")); + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistMagic120CellPhase6RIPersistenceBoundaryTest, + "HyperTwist.Permissive.Magic120Cell.Phase6R.I.PersistenceBoundary", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistMagic120CellPhase6RIPersistenceBoundaryTest::RunTest(const FString& Parameters) +{ + const FHyperTwistTrainingMagic120CellReferenceBundle Bundle = + UHyperTwistTrainingRuntimeLibrary::GetBundledMagic120CellReferenceBundle(); + + FHyperTwistTrainingMagic120CellPersistenceBoundary Boundary; + TestTrue( + TEXT("The Magic120Cell persistence boundary must resolve from the runtime library."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledMagic120CellPersistenceBoundary( + Bundle.PrimaryPersistenceBoundaryId, + Boundary + ) + ); + TestEqual(TEXT("The persistence boundary id must stay stable."), Boundary.BoundaryId, TEXT("magic120cell-persistence-boundary")); + TestTrue( + TEXT("The persistence boundary must preserve the Magic120Cell Version1 header tag."), + Boundary.PersistenceSurfaceTags.Contains(TEXT("Magic120Cell Version1 header")) + ); + TestTrue( + TEXT("The persistence boundary must preserve twist-hash serialization."), + Boundary.TwistHistorySurfaceTags.Contains(TEXT("twist-hash serialization")) + ); + TestTrue( + TEXT("The persistence boundary must preserve the slicemask provenance caveat."), + Boundary.ProvenanceCaveats.Contains(TEXT("slice mask is not persisted in twist hash")) + ); + TestTrue( + TEXT("The persistence boundary must keep canonical replay ownership excluded."), + Boundary.ExplicitExclusions.Contains(TEXT("first-party canonical replay or verification ownership")) + ); + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistMagic120CellPhase6RIPackageChecklistTest, + "HyperTwist.Permissive.Magic120Cell.Phase6R.I.PackageChecklist", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistMagic120CellPhase6RIPackageChecklistTest::RunTest(const FString& Parameters) +{ + const FString Checklist = UHyperTwistTrainingRuntimeLibrary::BuildBundledMagic120CellPackageChecklistTsv(); + TestTrue(TEXT("The Magic120Cell package checklist must not be empty."), !Checklist.IsEmpty()); + TestTrue( + TEXT("The checklist must preserve the family-core package id."), + Checklist.Contains(TEXT("package/magic120cell-family-core")) + ); + TestTrue( + TEXT("The checklist must preserve the loader export path."), + Checklist.Contains(TEXT("./Magic120Cell/workFiles/loader.cpp")) + ); + 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 9d2463a..96d7be7 100644 --- a/docs/REPO_LICENSE_TRACKING.md +++ b/docs/REPO_LICENSE_TRACKING.md @@ -2986,16 +2986,19 @@ Current licensing judgment: - 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 + - dedicated `120-cell` family runtime-profile contract + - family persistence and twist-history 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 +- the row remains only partially incorporated; host-shell ownership, broad renderer ownership, + generic topology ownership, and broad interaction-shell widening stay deferred Source basis: - `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\Magic120Cell\LICENSE` - `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\Magic120Cell\README.md` +- `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\Magic120Cell\Magic120Cell\workFiles\magic120Cell.cpp` +- `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\Magic120Cell\Magic120Cell\workFiles\loader.cpp` +- `C:\Workspaces\HyperTwist\mirrors\permissive\roice3\Magic120Cell\geometryLib\puzzle\twist.h` Practical obligations: diff --git a/docs/arch/HYPERTWIST_PHASE6R_I_MAGIC120CELL_RUNTIME_PROFILE_AND_PERSISTENCE_IMPLEMENTATION_PACKET_2026-05-22.md b/docs/arch/HYPERTWIST_PHASE6R_I_MAGIC120CELL_RUNTIME_PROFILE_AND_PERSISTENCE_IMPLEMENTATION_PACKET_2026-05-22.md new file mode 100644 index 0000000..918cd91 --- /dev/null +++ b/docs/arch/HYPERTWIST_PHASE6R_I_MAGIC120CELL_RUNTIME_PROFILE_AND_PERSISTENCE_IMPLEMENTATION_PACKET_2026-05-22.md @@ -0,0 +1,139 @@ +# HyperTwist Phase 6R-I roice3/Magic120Cell runtime profile and persistence implementation packet + +Created on `2026-05-22` + +## Status + +- first-party HyperTwist packet +- bounded permissive `Phase 6R-I` implementation slice + +## Purpose + +This packet lands the first narrower bounded slice from the retained `roice3/Magic120Cell` +hyper-engine row. + +The landed slice is: + +- first-party dedicated `120-cell` family runtime-profile and persistence boundary + +It is not: + +- a broad non-Euclidean platform packet +- a renderer or viewer-shell packet +- a generic topology packet +- a generic notation or replay packet +- a `MagicCube5D` widening packet + +## Current authority basis + +This implementation packet stands on: + +- `docs/REPO_LICENSE_TRACKING.md` +- `docs/ops/HYPERTWIST_CROSS_LANE_AUTHORITY_HIERARCHY_AND_RECONCILIATION_2026-05-20.md` +- `docs/arch/HYPERTWIST_PHASE6R_I_MAGIC120CELL_RUNTIME_PROFILE_AND_PERSISTENCE_PREPARATION_PACKET_2026-05-22.md` + +The retained owner remains: + +- `roice3/Magic120Cell` + +The top-level runtime-anchor owner does not change here: + +- first-party HyperTwist with the retained `Hyperspeedcube` runtime anchor remains the broader + runtime owner +- this packet keeps `roice3/Magic120Cell` bounded to the narrower `A1 / R1 / F2` dedicated + `120-cell` runtime-profile and persistence slice + +## Landed scope + +The current code now owns a retained `Magic120Cell` contract through: + +- a dedicated first-party `UHyperTwistTrainingMagic120CellLibrary` +- retained package references for: + - family core + - settings defaults + - loader + - twist encoding + - twist-history ledger +- one bounded runtime-profile contract for: + - puzzle-type modes + - symmetry-scoped visibility groups + - center-cell recentering and visibility guard rails +- one bounded persistence boundary for: + - `Magic120Cell Version1` header semantics + - scramble-cache semantics + - twist-hash and undo/redo history caveats +- one bounded donor-attribution boundary +- runtime-library accessors and package-checklist export through: + - `UHyperTwistTrainingRuntimeLibrary` +- focused automation coverage in: + - `HyperTwistMagic120CellPhase6RIRuntimeProfileContractTest.cpp` + +## Why this is still intentionally bounded + +This packet lands a dedicated family-specific donor seam, but it does not widen into neighboring +retained families. + +Still deferred: + +- WinForms/OpenGL host-shell ownership +- broad renderer ownership +- generic non-Euclidean topology ownership +- generic notation or replay ownership +- broad interaction-shell widening +- `MagicCube5D` deepening + +## Validation + +Build validation: + +- `Build.bat UnrealHyperTwistEditor Win64 Development -Project='C:\HyperTwist\UnrealHyperTwist\UnrealHyperTwist.uproject' -WaitMutex -NoHotReloadFromIDE` + +Focused automation validation: + +- `Automation RunTests HyperTwist.Permissive.Magic120Cell.Phase6R.I` + +Regression automation validation: + +- `Automation RunTests HyperTwist.Permissive.MagicTile.Phase6R.D` +- `Automation RunTests HyperTwist.Permissive.Hyperspeedcube.Phase6R.A` +- `Automation RunTests HyperTwist.CleanRoom.CubeDesk` + +Expected covered tests: + +- `RuntimeProfile` +- `PersistenceBoundary` +- `PackageChecklist` +- existing `MagicTile`, `Hyperspeedcube`, and `CubeDesk` regression suites + +## Queue effect + +This packet consumes the current `Phase 6R-I` implementation slice. + +`roice3/Magic120Cell` remains only partially incorporated: + +- landed now: + - dedicated `120-cell` family runtime profile + - puzzle-type mode taxonomy + - symmetry and visibility group taxonomy + - persistence header and scramble-cache boundary + - twist-history caveat capture + - direct-donor attribution boundary +- still deferred: + - WinForms/OpenGL host shell + - broad renderer ownership + - generic topology ownership + - generic notation or replay ownership + - broad interaction-shell widening + +The next clean move is: + +- source-backed `Phase 6R-J` `roice3/MagicCube5D` preparation/control pass + +Keep the future sequencing guards visible: + +- `roice3/Magic120Cell` + - keep the landed slice bounded to the dedicated `120-cell` family lane rather than a broad + non-Euclidean shell +- `roice3/MagicCube5D` + - keep the code-license judgment anchored on the mirrored `MIT` repo while preserving the older + zip only as provenance context diff --git a/docs/arch/HYPERTWIST_PHASE6R_I_MAGIC120CELL_RUNTIME_PROFILE_AND_PERSISTENCE_PREPARATION_PACKET_2026-05-22.md b/docs/arch/HYPERTWIST_PHASE6R_I_MAGIC120CELL_RUNTIME_PROFILE_AND_PERSISTENCE_PREPARATION_PACKET_2026-05-22.md new file mode 100644 index 0000000..79332b1 --- /dev/null +++ b/docs/arch/HYPERTWIST_PHASE6R_I_MAGIC120CELL_RUNTIME_PROFILE_AND_PERSISTENCE_PREPARATION_PACKET_2026-05-22.md @@ -0,0 +1,93 @@ +# HyperTwist Phase 6R-I roice3/Magic120Cell runtime profile and persistence preparation packet + +Created on `2026-05-22` + +## Status + +- first-party HyperTwist packet +- source-backed permissive `Phase 6R-I` preparation/control slice + +## Purpose + +This packet narrows the retained `roice3/Magic120Cell` row before implementation. + +The retained first slice is: + +- dedicated `120-cell` family runtime-profile and persistence boundary beneath the retained + `Hyperspeedcube` runtime anchor + +It is not: + +- a broad non-Euclidean platform packet +- a renderer or viewer-shell packet +- a generalized topology packet +- a generic notation or replay packet +- a `MagicCube5D` widening packet + +## Source-backed basis + +Primary donor surfaces inspected: + +- `README.md` +- `Magic120Cell/workFiles/magic120Cell.h` +- `Magic120Cell/workFiles/magic120Cell.cpp` +- `Magic120Cell/workFiles/settings.cpp` +- `Magic120Cell/workFiles/loader.cpp` +- `geometryLib/puzzle/twist.h` +- `geometryLib/puzzle/twistHistory.cpp` + +## Narrowing decision + +The strongest bounded donor seam is not the host shell or the broad non-Euclidean interaction +surface. `MagicTile` already owns the generalized tiling/topology lane and `Hyperspeedcube` +already owns the primary retained runtime anchor. + +The smallest stronger `Magic120Cell` seam is: + +- dedicated `120-cell` family puzzle-type modes +- symmetry-scoped visibility groups +- center-cell recentering and bounded view-rotation guard rails +- family-specific file-header, scramble-cache, and twist-history persistence + +The first bounded implementation packet should therefore land only: + +- a first-party `Magic120Cell` reference bundle with: + - source package references + - one runtime-profile contract + - one persistence boundary + - one attribution boundary +- runtime-library accessors for that bounded reference bundle +- focused automation around: + - runtime profile + - persistence boundary + - package checklist + +## Explicit deferrals + +Still deferred after this control pass: + +- WinForms/OpenGL host-shell ownership +- broad renderer ownership +- generic non-Euclidean topology ownership +- generic notation or replay ownership +- broad interaction-shell widening +- `MagicCube5D` deepening + +## Queue effect + +This preparation packet authorizes one bounded permissive implementation packet: + +- `Phase 6R-I` dedicated `Magic120Cell` family runtime-profile and persistence boundary + +After that packet, move the queue head to: + +- source-backed `Phase 6R-J` `roice3/MagicCube5D` preparation/control pass + +Keep the legal and routing guards visible: + +- `roice3/Magic120Cell` + - keep the landed slice bounded to the dedicated `120-cell` family lane rather than a broad + non-Euclidean shell +- `roice3/MagicCube5D` + - keep the code-license judgment anchored on the mirrored `MIT` repo while preserving the older + zip only as provenance context diff --git a/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md b/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md index 62276e3..7113f9a 100644 --- a/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md +++ b/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md @@ -80,10 +80,11 @@ Use these as the current governing docs: The next bounded move is now: -1. source-backed `Phase 6R-I` `roice3/Magic120Cell` preparation/control pass -2. keep it after the landed `whisper.cpp`, `faster-whisper`, `piper`, and `coqui-ai/TTS` bounded slices -3. narrow the first widening slice to one bounded hyper-engine topology/runtime-anchor seam -4. keep later non-Euclidean shell widening separate from the code-license judgment and retained row ownership +1. source-backed `Phase 6R-J` `roice3/MagicCube5D` preparation/control pass +2. keep it after the landed `Magic120Cell` family runtime-profile and persistence slice +3. narrow the first widening slice to one bounded `5D` runtime/persistence seam +4. keep later renderer, shell, and broad platform widening separate from the code-license judgment + and retained row ownership ## Memory-specific sequencing rule diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md b/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md index 685fb4c..947f274 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md @@ -173,6 +173,7 @@ repo. |---|---|---|---| | Legacy `4D` interaction/history/macro/provenance boundary | Implemented now | landed `magiccube4d` packet | Already part of current product truth. | | Tiling topology and geometry-family contract | Implemented now | landed `MagicTile` packet | New bounded widening is live. | +| Dedicated `120-cell` family runtime profile and persistence boundary | Implemented now | landed `Magic120Cell` packet | Current bounded family-specific widening is live beneath the retained `Hyperspeedcube` runtime anchor. | | Transform-aware macro remapping and broad non-Euclidean interaction shell | Deep-source grounded retained | `MagicTile` retained remainder | Not yet promoted into live broad interaction ownership. | ### 7. Speech input and voice sidecars diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md index 7124489..17cf821 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md @@ -83,7 +83,11 @@ Canonical discovery surfaces for roadmap interpretation: landed in current code - `coqui-ai/TTS` remains partially incorporated; downloadable voice/model review, bundled voice asset shipping, voice conversion, and broad voice-platform ownership stay deferred -- the current next bounded move is a source-backed `Phase 6R-I` `roice3/Magic120Cell` +- the bounded permissive `Phase 6R-I` `roice3/Magic120Cell` family runtime-profile and + persistence packet is now landed in current code +- `roice3/Magic120Cell` remains partially incorporated; host shell, renderer, generic topology, + and broad interaction-shell widening stay deferred +- the current next bounded move is a source-backed `Phase 6R-J` `roice3/MagicCube5D` preparation/control pass for one bounded hyper-engine widening slice - the repo-row implementation queue is now live from that `Phase 6R-A` entry point rather than waiting on another first-party packet @@ -112,8 +116,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: `31` -- permissive live lanes: `20` +- currently verified live/implemented in checked Unreal surfaces: `32` +- permissive live lanes: `21` - boundary-sensitive live lanes: `6` - restrictive live lanes: `5` - the restrictive landed lanes are: @@ -143,17 +147,17 @@ Current routing truth: - retained rows total: `68` - discarded from the active retained set: `3` -- active non-live implementation-board rows: `35` +- active non-live implementation-board rows: `34` - retained benchmark, oracle, or clean-room-later rows outside the active implementation board: `9` -The next bounded move is a source-backed `Phase 6R-I` -`roice3/Magic120Cell` preparation/control pass. +The next bounded move is a source-backed `Phase 6R-J` +`roice3/MagicCube5D` preparation/control pass. Queue interpretation after that packet: - then continue with the retained repo-row queue - highest current repo-row queue pressure sits in: - - the bounded speech-input / voice sidecar set + - the retained hyper-engine deepening set - `HactarCE/Hyperspeedcube` remains a partially landed row rather than a closed row: - landed: - puzzle catalog contract @@ -168,6 +172,16 @@ Queue interpretation after that packet: - ordered face-observation contract - still deferred: - webcam UI shell +- `roice3/Magic120Cell` remains a partially landed row rather than a closed row: + - landed: + - dedicated `120-cell` family runtime profile + - symmetry and visibility taxonomy + - persistence and twist-history boundary + - still deferred: + - host shell + - renderer ownership + - generic topology ownership + - broad interaction-shell widening - bundled-font redistribution and multilingual solve shell - multi-face reconstruction / correction / explanation - `vivaansinghvi07/rubix-cube-solver` remains a partially landed row rather than a closed row: @@ -247,7 +261,7 @@ Queue interpretation after that packet: - viseme / gesture runtime integration - broad assistant-platform scope - the next queue shape is now: - - `roice3/Magic120Cell` + - `roice3/MagicCube5D` - keep the speech-input / voice sidecar legal sequencing guard visible: - keep code-license judgments separate from model, voice, and payload-license review - keep the provider-neutral speech-lane guard visible: