From 379f1309300ed80cc11829f73660ec3833309e0c Mon Sep 17 00:00:00 2001 From: axiomlogicnexus Date: Fri, 22 May 2026 18:38:58 +0200 Subject: [PATCH] Implement Phase 6R-N hyperspeedcube puzzle DSL boundary --- ...yperTwistTrainingHyperspeedcubeLibrary.cpp | 398 +++++++++++++++++- .../HyperTwistTrainingRuntimeLibrary.cpp | 24 ++ .../HyperTwistTrainingHyperspeedcubeLibrary.h | 107 +++++ .../HyperTwistTrainingRuntimeLibrary.h | 12 + ...speedcubePhase6RNPuzzleDslContractTest.cpp | 135 ++++++ docs/REPO_LICENSE_TRACKING.md | 37 +- ...ON_DSL_IMPLEMENTATION_PACKET_2026-05-22.md | 140 ++++++ ...ITION_DSL_PREPARATION_PACKET_2026-05-22.md | 62 +++ ...PERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md | 11 +- .../HyperTwist/FEATURE_REGISTRY.md | 2 +- .../HyperTwist/ROADMAP.md | 30 +- 11 files changed, 922 insertions(+), 36 deletions(-) create mode 100644 UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHyperspeedcubePhase6RNPuzzleDslContractTest.cpp create mode 100644 docs/arch/HYPERTWIST_PHASE6R_N_HYPERSPEEDCUBE_PUZZLE_DEFINITION_DSL_IMPLEMENTATION_PACKET_2026-05-22.md create mode 100644 docs/arch/HYPERTWIST_PHASE6R_N_HYPERSPEEDCUBE_PUZZLE_DEFINITION_DSL_PREPARATION_PACKET_2026-05-22.md diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.cpp index 170d90b..d1c3432 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.cpp @@ -65,12 +65,14 @@ UHyperTwistTrainingHyperspeedcubeLibrary::BuildBundledHyperspeedcubeReferenceBun using namespace HyperTwistTrainingHyperspeedcubeLibraryInternal; FHyperTwistTrainingHyperspeedcubeReferenceBundle Bundle; - Bundle.ReferenceUtc = TEXT("2026-05-22T22:40:00Z"); + Bundle.ReferenceUtc = TEXT("2026-05-22T16:08:48Z"); Bundle.PrimaryNotationContractId = TEXT("hyperspeedcube-notation-contract"); Bundle.PrimarySerializationBoundaryId = TEXT("hyperspeedcube-log-serialization-boundary"); Bundle.PrimaryReplayVerificationContractId = TEXT("hyperspeedcube-replay-verification-contract"); Bundle.PrimaryReplayVerificationBoundaryId = TEXT("hyperspeedcube-replay-verification-boundary"); Bundle.PrimaryStatsShapeContractId = TEXT("hyperspeedcube-stats-shape-contract"); + Bundle.PrimaryDslContractId = TEXT("hyperspeedcube-dsl-authoring-contract"); + Bundle.PrimaryDslBoundaryId = TEXT("hyperspeedcube-dsl-module-evaluation-boundary"); Bundle.PrimarySolveRecordBoundaryId = TEXT("hyperspeedcube-solve-record-boundary"); Bundle.PrimaryAttributionBoundaryId = TEXT("hyperspeedcube-dual-license-attribution-boundary"); @@ -369,6 +371,234 @@ UHyperTwistTrainingHyperspeedcubeLibrary::BuildBundledHyperspeedcubeReferenceBun TEXT("hyperspeedcube/solve-summary-shape"), TEXT("Preserves the retained solve-summary qualifier seam as bounded evidence for stats and solve-record routing without importing the donor modal, leaderboards shell, or broader desktop application behavior.") ) + ), + MakePackageReference( + TEXT("package/hyperspeedcube-hps-entrypoints"), + TEXT("crates/hyperpuzzlescript/src/lib.rs"), + TEXT("./crates/hyperpuzzlescript/src/lib.rs"), + TEXT("hyper-dsl-contract-anchor"), + TEXT("direct dual-license donor"), + TEXT("Retained Hyperpuzzlescript entrypoint surface for language naming, builtin file-extension rules, bundled file extraction, engine callback exports, and diagnostic type exports beneath the first-party HyperTwist runtime anchor."), + { + TEXT("Hyperpuzzlescript language name"), + TEXT(".hps file extension"), + TEXT("index-file module rule"), + TEXT("built-in HPS extraction"), + TEXT("puzzle engine callback export"), + TEXT("full diagnostic export") + }, + CommonNoticeActions, + { + TEXT("whole runtime-anchor ownership"), + TEXT("generic scripting-platform ownership"), + TEXT("viewer or editor shell ownership") + }, + MakeAttribution( + TEXT("hyperspeedcube/dsl-entrypoints"), + TEXT("Preserves the retained Hyperpuzzlescript entrypoint and bundled-file seam for the bounded DSL authoring lane without promoting the donor scripting runtime or editor shell into first-party product truth.") + ) + ), + MakePackageReference( + TEXT("package/hyperspeedcube-hps-modules"), + TEXT("crates/hyperpuzzlescript/src/runtime/file_store.rs"), + TEXT("./crates/hyperpuzzlescript/src/runtime/file_store.rs"), + TEXT("hyper-dsl-module-store-support"), + TEXT("direct dual-license donor"), + TEXT("Retained module-store seam for built-in HPS loading, user file discovery, module-path normalization, index-file folding, and submodule tree construction beneath the bounded HyperTwist DSL lane."), + { + TEXT("built-in file store load"), + TEXT("user file discovery"), + TEXT("module path normalization"), + TEXT("index-file folding"), + TEXT("submodule tree build"), + TEXT("duplicate module-path warning") + }, + CommonNoticeActions, + { + TEXT("host filesystem configuration ownership"), + TEXT("whole runtime-anchor ownership"), + TEXT("workspace recall or notebook ownership") + }, + MakeAttribution( + TEXT("hyperspeedcube/dsl-modules"), + TEXT("Preserves the retained Hyperpuzzlescript module tree and file-discovery seam while keeping top-level file custody, workspace memory, and broader runtime ownership first-party.") + ) + ), + MakePackageReference( + TEXT("package/hyperspeedcube-hps-runtime-core"), + TEXT("crates/hyperpuzzlescript/src/runtime/mod.rs"), + TEXT("./crates/hyperpuzzlescript/src/runtime/mod.rs"), + TEXT("hyper-dsl-runtime-evaluation-support"), + TEXT("direct dual-license donor"), + TEXT("Retained runtime seam for builtins scope injection, parse-all or exec-all file loading, puzzle-engine and twist-system registries, and diagnostic callback routing beneath the bounded DSL authoring lane."), + { + TEXT("builtins scope injection"), + TEXT("parse_all preload"), + TEXT("exec_all_files preload"), + TEXT("puzzle engine registry"), + TEXT("twist-system engine registry"), + TEXT("diagnostic callback routing") + }, + CommonNoticeActions, + { + TEXT("whole runtime-anchor ownership"), + TEXT("generic simulation-platform ownership"), + TEXT("host shell ownership") + }, + MakeAttribution( + TEXT("hyperspeedcube/dsl-runtime-core"), + TEXT("Preserves the retained Hyperpuzzlescript runtime registration and diagnostic seam without promoting the donor simulation platform or host shell into first-party ownership.") + ) + ), + MakePackageReference( + TEXT("package/hyperspeedcube-hps-engines"), + TEXT("crates/hyperpuzzlescript/src/engines.rs"), + TEXT("./crates/hyperpuzzlescript/src/engines.rs"), + TEXT("hyper-dsl-engine-bridge-support"), + TEXT("direct dual-license donor"), + TEXT("Retained engine callback seam for named puzzle or twist-system registration and lazy catalog construction beneath the bounded HyperTwist DSL authoring contract."), + { + TEXT("puzzle engine callback"), + TEXT("twist-system engine callback"), + TEXT("engine name registration"), + TEXT("lazy catalog constructor"), + TEXT("build deferral to catalog") + }, + CommonNoticeActions, + { + TEXT("whole puzzle engine ownership"), + TEXT("viewer shell ownership"), + TEXT("whole runtime-anchor ownership") + }, + MakeAttribution( + TEXT("hyperspeedcube/dsl-engines"), + TEXT("Preserves the retained engine-registration and lazy-build seam without transferring whole puzzle-engine, viewer, or runtime-anchor ownership.") + ) + ), + MakePackageReference( + TEXT("package/hyperspeedcube-hps-request-bridge"), + TEXT("crates/hyperpuzzlescript/src/request.rs"), + TEXT("./crates/hyperpuzzlescript/src/request.rs"), + TEXT("hyper-dsl-eval-thread-bridge"), + TEXT("direct dual-license donor"), + TEXT("Retained HPS-thread request seam for blocking runtime evaluation and result handoff beneath the bounded HyperTwist DSL lane."), + { + TEXT("eval request channel"), + TEXT("blocking HPS-thread eval"), + TEXT("result handoff channel"), + TEXT("non-reentrant eval rule") + }, + CommonNoticeActions, + { + TEXT("generic background job system ownership"), + TEXT("provider or network orchestration ownership"), + TEXT("whole runtime-anchor ownership") + }, + MakeAttribution( + TEXT("hyperspeedcube/dsl-request-bridge"), + TEXT("Preserves the retained HPS-thread evaluation bridge without promoting it into HyperTwist's generic job system or broader runtime ownership.") + ) + ), + MakePackageReference( + TEXT("package/hyperspeedcube-hps-parser"), + TEXT("crates/hyperpuzzlescript/src/parse/parser.rs"), + TEXT("./crates/hyperpuzzlescript/src/parse/parser.rs"), + TEXT("hyper-dsl-grammar-support"), + TEXT("direct dual-license donor"), + TEXT("Retained Hyperpuzzlescript grammar seam for statement blocks, lists, maps, string interpolation, function parameters, and nested syntax recovery beneath the bounded HyperTwist DSL authoring lane."), + { + TEXT("statement block parse"), + TEXT("list and map literal parse"), + TEXT("string interpolation parse"), + TEXT("function parameter parse"), + TEXT("special identifier parse"), + TEXT("nested syntax recovery labels") + }, + CommonNoticeActions, + { + TEXT("generic scripting-platform ownership"), + TEXT("notation contract ownership"), + TEXT("whole runtime-anchor ownership") + }, + MakeAttribution( + TEXT("hyperspeedcube/dsl-parser"), + TEXT("Preserves the retained Hyperpuzzlescript grammar seam for bounded DSL authoring without collapsing it into generic scripting-platform or broader runtime ownership.") + ) + ), + MakePackageReference( + TEXT("package/hyperspeedcube-hps-catalog-builtins"), + TEXT("crates/hyperpuzzlescript/src/builtins/catalog/puzzles.rs"), + TEXT("./crates/hyperpuzzlescript/src/builtins/catalog/puzzles.rs"), + TEXT("hyper-dsl-generator-authoring-support"), + TEXT("direct dual-license donor"), + TEXT("Retained puzzle-authoring builtin seam for add_puzzle, add_puzzle_generator, generator parameter maps, example expansion, tag inheritance, and engine keyword routing beneath the bounded HyperTwist DSL authoring contract."), + { + TEXT("add_puzzle built-in"), + TEXT("add_puzzle_generator built-in"), + TEXT("generator parameter schema"), + TEXT("generator example expansion"), + TEXT("tag inheritance on generated puzzles"), + TEXT("engine kwarg routing") + }, + CommonNoticeActions, + { + TEXT("puzzle catalog contract ownership"), + TEXT("whole runtime-anchor ownership"), + TEXT("viewer or editor shell ownership") + }, + MakeAttribution( + TEXT("hyperspeedcube/dsl-catalog-builtins"), + TEXT("Preserves the retained Hyperpuzzlescript puzzle-authoring builtin seam while keeping catalog ownership, runtime ownership, and donor shell behavior outside this bounded packet.") + ) + ), + MakePackageReference( + TEXT("package/hyperspeedcube-hps-codegen"), + TEXT("crates/hyperpuzzlescript/src/codegen.rs"), + TEXT("./crates/hyperpuzzlescript/src/codegen.rs"), + TEXT("hyper-dsl-source-emission-support"), + TEXT("direct dual-license donor"), + TEXT("Retained source-emission seam for escaped string literals, quoted map keys, and orbit HPS code generation beneath the bounded HyperTwist DSL authoring lane."), + { + TEXT("HPS string literal escaping"), + TEXT("map key quoting"), + TEXT("orbit HPS code emission"), + TEXT("compact orbit name emission") + }, + CommonNoticeActions, + { + TEXT("editor code-action ownership"), + TEXT("export shell ownership"), + TEXT("whole runtime-anchor ownership") + }, + MakeAttribution( + TEXT("hyperspeedcube/dsl-codegen"), + TEXT("Preserves the retained HPS source-emission seam without promoting editor code actions, export shell behavior, or broader runtime ownership into first-party product truth.") + ) + ), + MakePackageReference( + TEXT("package/hyperspeedcube-hps-ft-cube-example"), + TEXT("hps/puzzles/ft_cube.hps"), + TEXT("./hps/puzzles/ft_cube.hps"), + TEXT("hyper-dsl-builtin-authoring-example"), + TEXT("direct dual-license donor"), + TEXT("Retained built-in authoring example for facet-turning cube generators, parameter lists, puzzle tags, example metadata, twist-system declarations, and vantage declarations beneath the bounded HyperTwist DSL lane."), + { + TEXT("add_puzzle_generator example"), + TEXT("parameterized generator example"), + TEXT("example alias tags"), + TEXT("twist-system declaration example"), + TEXT("vantage-set declaration example") + }, + CommonNoticeActions, + { + TEXT("whole puzzle corpus ownership"), + TEXT("whole runtime-anchor ownership"), + TEXT("donor shell ownership") + }, + MakeAttribution( + TEXT("hyperspeedcube/dsl-ft-cube-example"), + TEXT("Preserves the retained FT-cube built-in authoring example as bounded DSL evidence without transferring whole puzzle-corpus, runtime, or donor shell ownership.") + ) ) }; @@ -634,6 +864,123 @@ UHyperTwistTrainingHyperspeedcubeLibrary::BuildBundledHyperspeedcubeReferenceBun ); Bundle.StatsShapeContracts = {StatsShapeContract}; + FHyperTwistTrainingHyperspeedcubeDslContract DslContract; + DslContract.ContractId = TEXT("hyperspeedcube-dsl-authoring-contract"); + DslContract.Title = TEXT("Hyperspeedcube puzzle-definition DSL authoring contract"); + DslContract.Summary = TEXT("First-party HyperTwist contract for retained Hyperpuzzlescript syntax, generator-authoring builtins, example authoring surfaces, and bounded diagnostics beneath the broader Hyperspeedcube runtime anchor."); + DslContract.RequiredPackageIds = + { + TEXT("package/hyperspeedcube-hps-entrypoints"), + TEXT("package/hyperspeedcube-hps-parser"), + TEXT("package/hyperspeedcube-hps-engines"), + TEXT("package/hyperspeedcube-hps-catalog-builtins"), + TEXT("package/hyperspeedcube-hps-codegen"), + TEXT("package/hyperspeedcube-hps-ft-cube-example") + }; + DslContract.SyntaxSurfaceTags = + { + TEXT("Hyperpuzzlescript language name"), + TEXT(".hps file extension"), + TEXT("statement block parse"), + TEXT("list and map literal parse"), + TEXT("string interpolation parse"), + TEXT("function parameter parse"), + TEXT("special identifier parse"), + TEXT("nested syntax recovery labels") + }; + DslContract.GeneratorAuthoringSurfaceTags = + { + TEXT("add_puzzle built-in"), + TEXT("add_puzzle_generator built-in"), + TEXT("generator parameter schema"), + TEXT("generator example expansion"), + TEXT("tag inheritance on generated puzzles"), + TEXT("engine kwarg routing"), + TEXT("orbit HPS code emission"), + TEXT("add_puzzle_generator example") + }; + DslContract.DiagnosticSurfaceTags = + { + TEXT("full diagnostic export"), + TEXT("warning surface"), + TEXT("invalid version warning"), + TEXT("unknown engine diagnostic") + }; + DslContract.ProvenanceCaveats = + { + TEXT("the retained Hyperpuzzlescript DSL stays bounded to authoring and diagnostics rather than transferring whole runtime-anchor ownership"), + TEXT("the retained FT-cube file is evidence for bounded authoring shape rather than a transfer of whole puzzle-corpus ownership"), + TEXT("notation, replay verification, stats-shape, and broader hyper-runtime ownership remain separately packetized even when the same donor row supplies adjacent evidence") + }; + DslContract.ExplicitExclusions = + { + TEXT("whole runtime-anchor ownership"), + TEXT("puzzle catalog contract ownership"), + TEXT("notation contract ownership"), + TEXT("replay verification ownership"), + TEXT("stats-shape ownership"), + TEXT("viewer or editor shell ownership") + }; + DslContract.SourceAttribution = MakeAttribution( + TEXT("hyperspeedcube/dsl-authoring-contract"), + TEXT("Preserves the retained Hyperpuzzlescript authoring, generator, and diagnostics seam while keeping runtime, catalog, notation, replay, and stats ownership separately packetized.") + ); + Bundle.DslContracts = {DslContract}; + + FHyperTwistTrainingHyperspeedcubeDslBoundary DslBoundary; + DslBoundary.BoundaryId = TEXT("hyperspeedcube-dsl-module-evaluation-boundary"); + DslBoundary.Title = TEXT("Hyperspeedcube puzzle-definition DSL module and evaluation boundary"); + DslBoundary.Summary = TEXT("First-party HyperTwist boundary for retained HPS file loading, module-path normalization, engine registration, and HPS-thread evaluation behavior above the bounded DSL authoring contract."); + DslBoundary.RequiredPackageIds = + { + TEXT("package/hyperspeedcube-hps-entrypoints"), + TEXT("package/hyperspeedcube-hps-modules"), + TEXT("package/hyperspeedcube-hps-runtime-core"), + TEXT("package/hyperspeedcube-hps-engines"), + TEXT("package/hyperspeedcube-hps-request-bridge") + }; + DslBoundary.ModuleSurfaceTags = + { + TEXT("built-in HPS extraction"), + TEXT("built-in file store load"), + TEXT("user file discovery"), + TEXT("module path normalization"), + TEXT("index-file folding"), + TEXT("submodule tree build"), + TEXT("duplicate module-path warning") + }; + DslBoundary.EvaluationSurfaceTags = + { + TEXT("builtins scope injection"), + TEXT("puzzle engine registry"), + TEXT("twist-system engine registry"), + TEXT("eval request channel"), + TEXT("blocking HPS-thread eval"), + TEXT("non-reentrant eval rule"), + TEXT("parse_all preload"), + TEXT("exec_all_files preload") + }; + DslBoundary.ProvenanceCaveats = + { + TEXT("the donor module tree may load user files from a donor-configured path, but HyperTwist keeps top-level file custody first-party"), + TEXT("engine callbacks defer object construction until build time and do not transfer whole runtime ownership"), + TEXT("blocking eval requests are a bounded HPS-thread bridge rather than HyperTwist's generic job system"), + TEXT("built-in HPS bundles remain bounded authoring support rather than first-party shell content") + }; + DslBoundary.ExplicitExclusions = + { + TEXT("whole runtime-anchor ownership"), + TEXT("host filesystem configuration ownership"), + TEXT("generic background job system ownership"), + TEXT("viewer or editor shell ownership"), + TEXT("whole puzzle-runtime ownership") + }; + DslBoundary.SourceAttribution = MakeAttribution( + TEXT("hyperspeedcube/dsl-module-evaluation-boundary"), + TEXT("Preserves the retained Hyperpuzzlescript file-loading and HPS-thread evaluation seam without promoting donor filesystem, background-job, or whole-runtime ownership into first-party product truth.") + ); + Bundle.DslBoundaries = {DslBoundary}; + FHyperTwistTrainingHyperspeedcubeSolveRecordBoundary SolveRecordBoundary; SolveRecordBoundary.BoundaryId = TEXT("hyperspeedcube-solve-record-boundary"); SolveRecordBoundary.Title = TEXT("Hyperspeedcube solve-record and PB persistence boundary"); @@ -687,14 +1034,15 @@ UHyperTwistTrainingHyperspeedcubeLibrary::BuildBundledHyperspeedcubeReferenceBun FHyperTwistTrainingHyperspeedcubeAttributionBoundary AttributionBoundary; AttributionBoundary.BoundaryId = TEXT("hyperspeedcube-dual-license-attribution-boundary"); AttributionBoundary.Title = TEXT("Hyperspeedcube dual-license donor attribution boundary"); - AttributionBoundary.Summary = TEXT("First-party HyperTwist compliance boundary for using Hyperspeedcube as a direct dual-license donor for the bounded puzzle-catalog, notation, serialization, replay-verification, and stats-shape slices."); + AttributionBoundary.Summary = TEXT("First-party HyperTwist compliance boundary for using Hyperspeedcube as a direct dual-license donor for the bounded puzzle-catalog, notation, serialization, replay-verification, stats-shape, and DSL slices."); AttributionBoundary.AllowedUseTags = { TEXT("first-party reauthored subsystem implementation"), TEXT("direct permissive donor reference"), TEXT("bounded notation and serialization contract use"), TEXT("bounded replay verification contract use"), - TEXT("bounded stats-shape and solve-record contract use") + TEXT("bounded stats-shape and solve-record contract use"), + TEXT("bounded puzzle-definition DSL authoring use") }; AttributionBoundary.RequiredNoticeActions = CommonNoticeActions; AttributionBoundary.ProvenanceCaveats = @@ -703,7 +1051,7 @@ UHyperTwistTrainingHyperspeedcubeLibrary::BuildBundledHyperspeedcubeReferenceBun TEXT("the landed puzzle-catalog contract remains a separate bounded Phase 6R-A slice"), TEXT("the landed replay verification contract remains a separate bounded Phase 6R-L slice"), TEXT("the landed stats-shape contract remains a separate bounded Phase 6R-M slice"), - TEXT("later DSL authoring remains a separate packet"), + TEXT("the landed DSL authoring contract remains a separate bounded Phase 6R-N slice"), TEXT("the retained dual-license posture does not transfer generic hyper-runtime, analytics, publication, or host-shell ownership") }; AttributionBoundary.ExplicitExclusions = @@ -711,11 +1059,11 @@ UHyperTwistTrainingHyperspeedcubeLibrary::BuildBundledHyperspeedcubeReferenceBun TEXT("silent attribution removal"), TEXT("pretending broad analytics or publication ownership landed in these packets"), TEXT("pretending whole-app runtime ownership transferred"), - TEXT("treating DSL authoring as already incorporated") + TEXT("pretending viewer or editor shell ownership transferred") }; AttributionBoundary.SourceAttribution = MakeAttribution( TEXT("hyperspeedcube/attribution-boundary"), - TEXT("Records dual-license attribution and packet bounds for the retained Hyperspeedcube catalog, notation, serialization, replay-verification, and stats-shape slices without overclaiming whole-row incorporation.") + TEXT("Records dual-license attribution and packet bounds for the retained Hyperspeedcube catalog, notation, serialization, replay-verification, stats-shape, and DSL slices without overclaiming whole-row incorporation.") ); Bundle.AttributionBoundaries = {AttributionBoundary}; @@ -817,6 +1165,44 @@ bool UHyperTwistTrainingHyperspeedcubeLibrary::TryGetStatsShapeContractById( return false; } +bool UHyperTwistTrainingHyperspeedcubeLibrary::TryGetDslContractById( + const FHyperTwistTrainingHyperspeedcubeReferenceBundle& Bundle, + const FString& ContractId, + FHyperTwistTrainingHyperspeedcubeDslContract& OutContract +) +{ + for (const FHyperTwistTrainingHyperspeedcubeDslContract& Contract : Bundle.DslContracts) + { + if (Contract.ContractId == ContractId) + { + OutContract = Contract; + return true; + } + } + + OutContract = FHyperTwistTrainingHyperspeedcubeDslContract(); + return false; +} + +bool UHyperTwistTrainingHyperspeedcubeLibrary::TryGetDslBoundaryById( + const FHyperTwistTrainingHyperspeedcubeReferenceBundle& Bundle, + const FString& BoundaryId, + FHyperTwistTrainingHyperspeedcubeDslBoundary& OutBoundary +) +{ + for (const FHyperTwistTrainingHyperspeedcubeDslBoundary& Boundary : Bundle.DslBoundaries) + { + if (Boundary.BoundaryId == BoundaryId) + { + OutBoundary = Boundary; + return true; + } + } + + OutBoundary = FHyperTwistTrainingHyperspeedcubeDslBoundary(); + return false; +} + bool UHyperTwistTrainingHyperspeedcubeLibrary::TryGetSolveRecordBoundaryById( const FHyperTwistTrainingHyperspeedcubeReferenceBundle& Bundle, const FString& BoundaryId, diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp index 68d908e..92ee31f 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Private/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.cpp @@ -1179,6 +1179,30 @@ bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHyperspeedcubeStatsShapeCon ); } +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHyperspeedcubeDslContract( + const FString& ContractId, + FHyperTwistTrainingHyperspeedcubeDslContract& OutContract +) +{ + return UHyperTwistTrainingHyperspeedcubeLibrary::TryGetDslContractById( + GetBundledHyperspeedcubeReferenceBundle(), + ContractId, + OutContract + ); +} + +bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHyperspeedcubeDslBoundary( + const FString& BoundaryId, + FHyperTwistTrainingHyperspeedcubeDslBoundary& OutBoundary +) +{ + return UHyperTwistTrainingHyperspeedcubeLibrary::TryGetDslBoundaryById( + GetBundledHyperspeedcubeReferenceBundle(), + BoundaryId, + OutBoundary + ); +} + bool UHyperTwistTrainingRuntimeLibrary::TryGetBundledHyperspeedcubeSolveRecordBoundary( const FString& BoundaryId, FHyperTwistTrainingHyperspeedcubeSolveRecordBoundary& OutBoundary diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.h index d5fb3fa..b664eff 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingHyperspeedcubeLibrary.h @@ -243,6 +243,85 @@ struct FHyperTwistTrainingHyperspeedcubeStatsShapeContract } }; +USTRUCT(BlueprintType) +struct FHyperTwistTrainingHyperspeedcubeDslContract +{ + 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 SyntaxSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray GeneratorAuthoringSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray DiagnosticSurfaceTags; + + 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 !ContractId.IsEmpty() && !Title.IsEmpty() && SourceAttribution.IsStructurallyValid(); + } +}; + +USTRUCT(BlueprintType) +struct FHyperTwistTrainingHyperspeedcubeDslBoundary +{ + 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 ModuleSurfaceTags; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray EvaluationSurfaceTags; + + 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 FHyperTwistTrainingHyperspeedcubeSolveRecordBoundary { @@ -339,6 +418,12 @@ struct FHyperTwistTrainingHyperspeedcubeReferenceBundle UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") FString PrimaryStatsShapeContractId; + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryDslContractId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + FString PrimaryDslBoundaryId; + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") FString PrimarySolveRecordBoundaryId; @@ -363,6 +448,12 @@ struct FHyperTwistTrainingHyperspeedcubeReferenceBundle UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") TArray StatsShapeContracts; + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray DslContracts; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") + TArray DslBoundaries; + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist") TArray SolveRecordBoundaries; @@ -376,6 +467,8 @@ struct FHyperTwistTrainingHyperspeedcubeReferenceBundle && !PrimaryReplayVerificationContractId.IsEmpty() && !PrimaryReplayVerificationBoundaryId.IsEmpty() && !PrimaryStatsShapeContractId.IsEmpty() + && !PrimaryDslContractId.IsEmpty() + && !PrimaryDslBoundaryId.IsEmpty() && !PrimarySolveRecordBoundaryId.IsEmpty() && !PrimaryAttributionBoundaryId.IsEmpty() && PackageReferences.Num() > 0; @@ -426,6 +519,20 @@ public: FHyperTwistTrainingHyperspeedcubeStatsShapeContract& OutContract ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Hyperspeedcube") + static bool TryGetDslContractById( + const FHyperTwistTrainingHyperspeedcubeReferenceBundle& Bundle, + const FString& ContractId, + FHyperTwistTrainingHyperspeedcubeDslContract& OutContract + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Hyperspeedcube") + static bool TryGetDslBoundaryById( + const FHyperTwistTrainingHyperspeedcubeReferenceBundle& Bundle, + const FString& BoundaryId, + FHyperTwistTrainingHyperspeedcubeDslBoundary& OutBoundary + ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Hyperspeedcube") static bool TryGetSolveRecordBoundaryById( const FHyperTwistTrainingHyperspeedcubeReferenceBundle& Bundle, diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h index 78adce9..8b3c211 100644 --- a/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Public/HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h @@ -455,6 +455,18 @@ public: FHyperTwistTrainingHyperspeedcubeStatsShapeContract& OutContract ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Hyperspeedcube") + static bool TryGetBundledHyperspeedcubeDslContract( + const FString& ContractId, + FHyperTwistTrainingHyperspeedcubeDslContract& OutContract + ); + + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Hyperspeedcube") + static bool TryGetBundledHyperspeedcubeDslBoundary( + const FString& BoundaryId, + FHyperTwistTrainingHyperspeedcubeDslBoundary& OutBoundary + ); + UFUNCTION(BlueprintCallable, Category = "HyperTwist|Training|Hyperspeedcube") static bool TryGetBundledHyperspeedcubeSolveRecordBoundary( const FString& BoundaryId, diff --git a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHyperspeedcubePhase6RNPuzzleDslContractTest.cpp b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHyperspeedcubePhase6RNPuzzleDslContractTest.cpp new file mode 100644 index 0000000..632d31f --- /dev/null +++ b/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHyperspeedcubePhase6RNPuzzleDslContractTest.cpp @@ -0,0 +1,135 @@ +// Copyright HyperTwist, Inc. All Rights Reserved. + +#include "Misc/AutomationTest.h" + +#include "HyperTwistTraining/HyperTwistTrainingRuntimeLibrary.h" + +#if WITH_AUTOMATION_TESTS + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistHyperspeedcubePhase6RNDslContractTest, + "HyperTwist.Permissive.Hyperspeedcube.Phase6R.N.DslContract", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistHyperspeedcubePhase6RNDslContractTest::RunTest(const FString& Parameters) +{ + const FHyperTwistTrainingHyperspeedcubeReferenceBundle Bundle = + UHyperTwistTrainingRuntimeLibrary::GetBundledHyperspeedcubeReferenceBundle(); + + TestTrue(TEXT("The Hyperspeedcube bundle must stay structurally valid."), Bundle.IsStructurallyValid()); + TestTrue( + TEXT("The Hyperspeedcube bundle must preserve the expanded donor package set."), + Bundle.PackageReferences.Num() >= 20 + ); + + FHyperTwistTrainingHyperspeedcubeDslContract Contract; + TestTrue( + TEXT("The Hyperspeedcube DSL contract must resolve from the runtime library."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledHyperspeedcubeDslContract( + Bundle.PrimaryDslContractId, + Contract + ) + ); + TestEqual( + TEXT("The DSL contract id must stay stable."), + Contract.ContractId, + TEXT("hyperspeedcube-dsl-authoring-contract") + ); + TestTrue( + TEXT("The DSL contract must require the retained parser package."), + Contract.RequiredPackageIds.Contains(TEXT("package/hyperspeedcube-hps-parser")) + ); + TestTrue( + TEXT("The DSL contract must preserve string interpolation parsing."), + Contract.SyntaxSurfaceTags.Contains(TEXT("string interpolation parse")) + ); + TestTrue( + TEXT("The DSL contract must preserve generator authoring builtins."), + Contract.GeneratorAuthoringSurfaceTags.Contains(TEXT("add_puzzle_generator built-in")) + ); + TestTrue( + TEXT("The DSL contract must keep runtime-anchor ownership excluded."), + Contract.ExplicitExclusions.Contains(TEXT("whole runtime-anchor ownership")) + ); + TestEqual( + TEXT("The DSL contract must keep the direct donor source repo."), + Contract.SourceAttribution.SourceRepo, + TEXT("HactarCE/Hyperspeedcube") + ); + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistHyperspeedcubePhase6RNDslBoundaryTest, + "HyperTwist.Permissive.Hyperspeedcube.Phase6R.N.DslBoundary", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistHyperspeedcubePhase6RNDslBoundaryTest::RunTest(const FString& Parameters) +{ + const FHyperTwistTrainingHyperspeedcubeReferenceBundle Bundle = + UHyperTwistTrainingRuntimeLibrary::GetBundledHyperspeedcubeReferenceBundle(); + + FHyperTwistTrainingHyperspeedcubeDslBoundary Boundary; + TestTrue( + TEXT("The Hyperspeedcube DSL boundary must resolve from the runtime library."), + UHyperTwistTrainingRuntimeLibrary::TryGetBundledHyperspeedcubeDslBoundary( + Bundle.PrimaryDslBoundaryId, + Boundary + ) + ); + TestEqual( + TEXT("The DSL boundary id must stay stable."), + Boundary.BoundaryId, + TEXT("hyperspeedcube-dsl-module-evaluation-boundary") + ); + TestTrue( + TEXT("The DSL boundary must preserve index-file folding."), + Boundary.ModuleSurfaceTags.Contains(TEXT("index-file folding")) + ); + TestTrue( + TEXT("The DSL boundary must preserve the non-reentrant eval rule."), + Boundary.EvaluationSurfaceTags.Contains(TEXT("non-reentrant eval rule")) + ); + TestTrue( + TEXT("The DSL boundary must preserve the file-custody provenance caveat."), + Boundary.ProvenanceCaveats.Contains(TEXT("the donor module tree may load user files from a donor-configured path, but HyperTwist keeps top-level file custody first-party")) + ); + TestTrue( + TEXT("The DSL boundary must keep generic background job ownership excluded."), + Boundary.ExplicitExclusions.Contains(TEXT("generic background job system ownership")) + ); + return true; +} + +IMPLEMENT_SIMPLE_AUTOMATION_TEST( + FHyperTwistHyperspeedcubePhase6RNPackageChecklistTest, + "HyperTwist.Permissive.Hyperspeedcube.Phase6R.N.PackageChecklist", + EAutomationTestFlags::EditorContext | EAutomationTestFlags::EngineFilter +) + +bool FHyperTwistHyperspeedcubePhase6RNPackageChecklistTest::RunTest(const FString& Parameters) +{ + const FString Checklist = UHyperTwistTrainingRuntimeLibrary::BuildBundledHyperspeedcubePackageChecklistTsv(); + TestTrue(TEXT("The Hyperspeedcube package checklist must not be empty."), !Checklist.IsEmpty()); + TestTrue( + TEXT("The checklist must preserve the DSL parser package id."), + Checklist.Contains(TEXT("package/hyperspeedcube-hps-parser")) + ); + TestTrue( + TEXT("The checklist must preserve the puzzle builtin export path."), + Checklist.Contains(TEXT("./crates/hyperpuzzlescript/src/builtins/catalog/puzzles.rs")) + ); + TestTrue( + TEXT("The checklist must preserve the FT cube builtin example path."), + Checklist.Contains(TEXT("./hps/puzzles/ft_cube.hps")) + ); + TestTrue( + TEXT("The checklist must preserve the direct dual-license donor posture."), + Checklist.Contains(TEXT("direct dual-license donor")) + ); + return true; +} + +#endif diff --git a/docs/REPO_LICENSE_TRACKING.md b/docs/REPO_LICENSE_TRACKING.md index f12bd99..952b28b 100644 --- a/docs/REPO_LICENSE_TRACKING.md +++ b/docs/REPO_LICENSE_TRACKING.md @@ -146,16 +146,19 @@ Status update on `2026-05-21`: - the bounded permissive `Phase 6R-G` `rhasspy/piper` local narration sidecar packet is now landed in current code - `rhasspy/piper` remains partially incorporated -- the current next bounded move is a source-backed `Phase 6R-N` `HactarCE/Hyperspeedcube` - puzzle-definition DSL preparation/control pass, not a new restrictive packet by default +- the bounded permissive `Phase 6R-N` `HactarCE/Hyperspeedcube` puzzle-definition DSL packet is + now landed in current code +- `HactarCE/Hyperspeedcube` is now closed for the currently justified retained families +- the current next bounded move is a source-backed `Phase 6R-O` `kkoomen/qbr` webcam UI shell + preparation/control pass, 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: `31` -- permissive live lanes: `20` +- currently verified live/implemented in checked `UnrealHyperTwist` surfaces: `34` +- permissive live lanes: `23` - boundary-sensitive live lanes: `6` - restrictive live lanes: `5` @@ -251,8 +254,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-G` `rhasspy/piper` preparation/control pass - for a bounded voice-output sidecar seam +- the next bounded move is a source-backed `Phase 6R-O` `kkoomen/qbr` preparation/control pass + for a bounded webcam UI shell seam Companion docs: @@ -1272,7 +1275,9 @@ Current licensing judgment: - replay-log serialization boundary - replay verification boundary - stats-shape and solve-record boundary -- the row remains only partially incorporated; only DSL authoring remains deferred + - puzzle-definition DSL authoring contract and module/evaluation boundary +- the row is now closed for the currently justified retained families; no further widening is + justified from this row by default Source basis: @@ -1290,6 +1295,15 @@ Source basis: - `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzle_view\src\simulation\mod.rs` - `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzle_view\src\replay_event.rs` - `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperspeedcube\src\app.rs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzlescript\src\lib.rs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzlescript\src\runtime\file_store.rs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzlescript\src\runtime\mod.rs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzlescript\src\engines.rs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzlescript\src\request.rs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzlescript\src\parse\parser.rs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzlescript\src\builtins\catalog\puzzles.rs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\crates\hyperpuzzlescript\src\codegen.rs` +- `C:\Workspaces\HyperTwist\mirrors\permissive\HactarCE\Hyperspeedcube\hps\puzzles\ft_cube.hps` Important distinction: @@ -1297,7 +1311,7 @@ Important distinction: shell, packaging, or every neighboring hyper-puzzle lane - keep the live widening inside the already accepted `2R-A` contract: - puzzle catalog contract - - puzzle-definition DSL boundary + - puzzle-definition DSL authoring contract and module/evaluation boundary - notation grammar and serialization boundary - replay-event taxonomy and verification boundary - stats-shape and solve-record contract @@ -1306,6 +1320,7 @@ Important distinction: - notation grammar and replay-log serialization boundary - replay verification and solve-proof diagnostics boundary - stats-shape and solve-record boundary + - puzzle-definition DSL authoring contract and module/evaluation boundary - the workspace includes a `hypercubing_leaderboards_client` crate, but that does not transfer remote service ownership or reorder the queued `Phase 6R-A` packet by itself @@ -1321,10 +1336,8 @@ 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, notation, replay-verification, and stats-shape slices, the - next queue head for this retained row should narrow to a source-backed `Phase 6R-N` - puzzle-definition DSL preparation/control pass rather than widening into broader runtime, - leaderboard, analytics, or shell ownership +- after the landed puzzle-catalog, notation, replay-verification, stats-shape, and DSL slices, do + not reopen this retained row by default unless a new bounded family is justified explicitly ### `coqui-ai/TTS` diff --git a/docs/arch/HYPERTWIST_PHASE6R_N_HYPERSPEEDCUBE_PUZZLE_DEFINITION_DSL_IMPLEMENTATION_PACKET_2026-05-22.md b/docs/arch/HYPERTWIST_PHASE6R_N_HYPERSPEEDCUBE_PUZZLE_DEFINITION_DSL_IMPLEMENTATION_PACKET_2026-05-22.md new file mode 100644 index 0000000..846ffe1 --- /dev/null +++ b/docs/arch/HYPERTWIST_PHASE6R_N_HYPERSPEEDCUBE_PUZZLE_DEFINITION_DSL_IMPLEMENTATION_PACKET_2026-05-22.md @@ -0,0 +1,140 @@ +# HyperTwist Phase 6R-N HactarCE/Hyperspeedcube puzzle-definition DSL implementation packet + +Created on `2026-05-22` + +## Status + +- first-party HyperTwist packet +- bounded permissive `Phase 6R-N` implementation slice + +## Purpose + +This packet lands the final currently justified retained family from the `HactarCE/Hyperspeedcube` +runtime-anchor row: + +- first-party hyper puzzle-definition DSL authoring contract and module/evaluation boundary + +It is not: + +- a whole `Hyperspeedcube` runtime transplant +- a donor viewer or editor shell packet +- a generic scripting-platform packet +- a broader analytics, publication, or host-shell ownership 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_N_HYPERSPEEDCUBE_PUZZLE_DEFINITION_DSL_PREPARATION_PACKET_2026-05-22.md` + +The retained owner remains: + +- `HactarCE/Hyperspeedcube` + +The top-level runtime-anchor owner does not change here: + +- first-party HyperTwist remains the broader runtime owner +- this packet keeps `HactarCE/Hyperspeedcube` bounded to the narrower `A1 / R1 / F2` + puzzle-definition DSL authoring slice + +## Landed scope + +The current code now owns a retained `Hyperspeedcube` DSL contract through: + +- the existing first-party `UHyperTwistTrainingHyperspeedcubeLibrary` +- retained package references for: + - Hyperpuzzlescript entrypoints + - module/file-store loading + - runtime registration + - engine callbacks + - HPS-thread request bridging + - parser grammar + - puzzle-authoring builtins + - source-emission helpers + - built-in FT-cube authoring example +- one bounded DSL contract for: + - syntax and grammar shape + - generator-authoring builtins + - bounded diagnostics + - example authoring evidence +- one bounded DSL boundary for: + - built-in HPS extraction + - module-path normalization and `index.hps` folding + - engine registry routing + - blocking HPS-thread evaluation and non-reentrant request rules +- updated donor-attribution boundary +- runtime-library accessors and package-checklist export through: + - `UHyperTwistTrainingRuntimeLibrary` +- focused automation coverage in: + - `HyperTwistHyperspeedcubePhase6RNPuzzleDslContractTest.cpp` + +## Why this is still intentionally bounded + +This packet lands the retained DSL seam, but it does not widen into neighboring families or +broader product ownership. + +Still excluded: + +- whole runtime-anchor ownership +- whole puzzle catalog ownership +- whole puzzle corpus ownership +- viewer or editor shell ownership +- generic scripting-platform ownership + +## Validation + +Build validation: + +- `C:\Program Files\Epic Games\UE_5.7\Engine\Build\BatchFiles\Build.bat UnrealHyperTwistEditor Win64 Development -Project='C:\HyperTwist\UnrealHyperTwist\UnrealHyperTwist.uproject' -WaitMutex -NoHotReloadFromIDE` + +Focused automation validation: + +- `C:\Program Files\Epic Games\UE_5.7\Engine\Binaries\Win64\UnrealEditor-Cmd.exe C:\HyperTwist\UnrealHyperTwist\UnrealHyperTwist.uproject -unattended -nop4 -nosplash -NullRHI -log -stdout -FullStdOutLogOutput -AbsLog=C:\HyperTwist\UnrealHyperTwist\Saved\Logs\Phase6R-N-Hyperspeedcube-Verify.log -ReportExportPath=C:\HyperTwist\UnrealHyperTwist\Saved\AutomationReports\Phase6R-N-Hyperspeedcube-Verify -ExecCmds="Automation RunTests HyperTwist.Permissive.Hyperspeedcube.Phase6R.N; Quit" -TestExit="Automation Test Queue Empty"` + +Regression automation validation: + +- `HyperTwist.Permissive.Hyperspeedcube.Phase6R.M` +- `HyperTwist.Permissive.Hyperspeedcube.Phase6R.L` +- `HyperTwist.Permissive.Hyperspeedcube.Phase6R.K` +- `HyperTwist.Permissive.Hyperspeedcube.Phase6R.A` +- `HyperTwist.Permissive.MagicCube5D.Phase6R.J` +- `HyperTwist.Permissive.Magic120Cell.Phase6R.I` +- `HyperTwist.Permissive.MagicTile.Phase6R.D` +- `HyperTwist.CleanRoom.CubeDesk` + +Expected covered tests: + +- `DslContract` +- `DslBoundary` +- `PackageChecklist` +- existing `Hyperspeedcube`, `MagicCube5D`, `Magic120Cell`, `MagicTile`, and `CubeDesk` + regression suites + +## Queue effect + +This packet consumes the current `Phase 6R-N` implementation slice. + +`HactarCE/Hyperspeedcube` is now closed for the currently justified retained families: + +- landed now: + - puzzle catalog contract + - notation contract + - replay-log serialization boundary + - replay verification boundary + - stats-shape and solve-record boundary + - puzzle-definition DSL authoring contract + - puzzle-definition DSL module/evaluation boundary +- no current additional widening is justified from this row by default + +The next clean move is: + +- source-backed `Phase 6R-O` `kkoomen/qbr` webcam UI shell preparation/control pass + +Keep the future sequencing guards visible: + +- keep the next widening slice on `qbr` webcam UI shell rather than widening directly into bundled + font redistribution, multilingual solve shell, or multi-face correction/explanation ownership +- preserve the existing legal guard that `src/assets/arial-unicode-ms.ttf` must be confirmed or + replaced before any redistribution path ships it diff --git a/docs/arch/HYPERTWIST_PHASE6R_N_HYPERSPEEDCUBE_PUZZLE_DEFINITION_DSL_PREPARATION_PACKET_2026-05-22.md b/docs/arch/HYPERTWIST_PHASE6R_N_HYPERSPEEDCUBE_PUZZLE_DEFINITION_DSL_PREPARATION_PACKET_2026-05-22.md new file mode 100644 index 0000000..ef9f4d3 --- /dev/null +++ b/docs/arch/HYPERTWIST_PHASE6R_N_HYPERSPEEDCUBE_PUZZLE_DEFINITION_DSL_PREPARATION_PACKET_2026-05-22.md @@ -0,0 +1,62 @@ +# HyperTwist Phase 6R-N HactarCE/Hyperspeedcube puzzle-definition DSL preparation packet + +Created on `2026-05-22` + +## Status + +- first-party HyperTwist packet +- source-backed bounded permissive control pass + +## Purpose + +This packet narrows the last unresolved retained `Hyperspeedcube` family inside the accepted +runtime-anchor row: + +- puzzle-definition DSL authoring + +It does not reopen: + +- whole runtime-anchor ownership +- viewer or editor shell ownership +- broader analytics or publication ownership +- generic scripting-platform ownership outside the retained HyperTwist puzzle lane + +## Source basis reread + +The control result was narrowed from these retained donor surfaces: + +- `crates/hyperpuzzlescript/src/lib.rs` +- `crates/hyperpuzzlescript/src/runtime/file_store.rs` +- `crates/hyperpuzzlescript/src/runtime/mod.rs` +- `crates/hyperpuzzlescript/src/engines.rs` +- `crates/hyperpuzzlescript/src/request.rs` +- `crates/hyperpuzzlescript/src/parse/parser.rs` +- `crates/hyperpuzzlescript/src/builtins/catalog/puzzles.rs` +- `crates/hyperpuzzlescript/src/codegen.rs` +- `hps/puzzles/ft_cube.hps` + +## Narrowed decision + +The strongest next retained slice is not another runtime, replay, stats, or shell widening packet. +It is one bounded first-party DSL packet with: + +- Hyperpuzzlescript syntax and diagnostics contract +- generator-authoring builtin contract +- bounded module-path, file-store, and HPS-thread evaluation boundary +- direct-donor package references and attribution updates + +## Explicit exclusions + +Keep out of this packet: + +- whole puzzle catalog ownership +- whole runtime-anchor ownership +- broader hyper puzzle corpus ownership +- viewer or editor shell ownership +- generic scripting-platform ownership + +## Implementation authorization + +This preparation pass authorizes one bounded implementation packet: + +- `Phase 6R-N` puzzle-definition DSL authoring contract and module/evaluation boundary diff --git a/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md b/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md index 172edff..ab96172 100644 --- a/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md +++ b/docs/ops/HYPERTWIST_IMPLEMENTATION_PHASE_1_KICKOFF.md @@ -92,11 +92,12 @@ The next bounded move is now: implementation packet is now landed in current code 3. the bounded permissive `Phase 6R-M` `HactarCE/Hyperspeedcube` stats-shape and solve-record implementation packet is now landed in current code -4. source-backed `Phase 6R-N` `HactarCE/Hyperspeedcube` puzzle-definition DSL - preparation/control pass is now the next bounded move -5. keep it after the landed `Phase 6R-K`, `Phase 6R-L`, and `Phase 6R-M` bounded seams rather - than widening back into broader runtime ownership in the same packet -6. keep broader runtime-anchor widening separate from the DSL packet +4. the bounded permissive `Phase 6R-N` `HactarCE/Hyperspeedcube` puzzle-definition DSL + implementation packet is now landed in current code +5. source-backed `Phase 6R-O` `kkoomen/qbr` webcam UI shell preparation/control pass is now the + next bounded move +6. keep it narrower than bundled-font redistribution, multilingual solve shell, and broader + correction/explanation ownership in the same packet ## 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 faef539..4d2fe3d 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/FEATURE_REGISTRY.md @@ -134,7 +134,7 @@ repo. | Hyper notation and replay-log serialization | Implemented now | landed `Hyperspeedcube` `Phase 6R-K` | Retained notation parse/format and log-serialization boundary are live. | | Hyper replay verification and solve-proof diagnostics | Implemented now | landed `Hyperspeedcube` `Phase 6R-L` | Retained replay verification, timestamp proof routing, and bounded solve diagnostics are live. | | Hyper stats-shape and solve-record boundary | Implemented now | landed `Hyperspeedcube` `Phase 6R-M` | Retained PB categories, solve-record qualifiers, and bounded solve-proof result shape are live. | -| Hyper puzzle DSL authoring | Deep-source grounded retained | `Hyperspeedcube` retained row | Still deferred after the bounded `Phase 6R-M` landing. | +| Hyper puzzle DSL authoring | Implemented now | landed `Hyperspeedcube` `Phase 6R-N` | Retained Hyperpuzzlescript authoring, module/evaluation boundary, and bounded diagnostics are live. | ### 2. Physical recognition and reconstruction diff --git a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md index fbe5e5b..464e02c 100644 --- a/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md +++ b/docs/v6_5_deep_manual_pack/HyperTwist/ROADMAP.md @@ -54,7 +54,11 @@ Canonical discovery surfaces for roadmap interpretation: - the generic source-backed `Phase 6R-M` `HactarCE/Hyperspeedcube` control pass is now consumed - the bounded permissive `Phase 6R-M` `HactarCE/Hyperspeedcube` stats-shape and solve-record packet is now landed in current code -- `HactarCE/Hyperspeedcube` remains partially incorporated; only DSL authoring stays deferred +- the generic source-backed `Phase 6R-N` `HactarCE/Hyperspeedcube` control pass is now consumed +- the bounded permissive `Phase 6R-N` `HactarCE/Hyperspeedcube` puzzle-definition DSL packet is + now landed in current code +- `HactarCE/Hyperspeedcube` is now closed for the currently justified retained families; no new + widening is justified from that row by default - the generic source-backed `Phase 6R-B` `kkoomen/qbr` control pass is now consumed - the bounded permissive `Phase 6R-B` `kkoomen/qbr` classic-cube recognition calibration and ordered face-observation packet is now landed in current code @@ -110,9 +114,9 @@ Canonical discovery surfaces for roadmap interpretation: landed in current code - the bounded permissive `Phase 6R-M` `HactarCE/Hyperspeedcube` stats-shape and solve-record packet is now landed in current code -- `HactarCE/Hyperspeedcube` remains partially incorporated; only DSL authoring stays deferred -- the current next bounded move is a source-backed `Phase 6R-N` `HactarCE/Hyperspeedcube` - puzzle-definition DSL preparation/control pass for one bounded runtime-anchor widening slice +- `HactarCE/Hyperspeedcube` is now closed for the currently justified retained families +- the current next bounded move is a source-backed `Phase 6R-O` `kkoomen/qbr` webcam UI shell + preparation/control pass for one bounded recognition-shell 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 @@ -174,23 +178,24 @@ Current routing truth: - 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-N` -`HactarCE/Hyperspeedcube` puzzle-definition DSL preparation/control pass. +The next bounded move is a source-backed `Phase 6R-O` +`kkoomen/qbr` webcam UI shell 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 retained hyper-engine deepening set -- `HactarCE/Hyperspeedcube` remains a partially landed row rather than a closed row: + - the retained classic-cube recognition shell set +- `HactarCE/Hyperspeedcube` is now closed for the currently justified retained row: - landed: - puzzle catalog contract - notation contract - replay-log serialization boundary - replay verification - stats-shape and solve-record contract - - still deferred: - - DSL + - puzzle-definition DSL authoring contract + - puzzle-definition DSL module/evaluation boundary + - no current additional widening is justified from this row by default - `kkoomen/qbr` remains a partially landed row rather than a closed row: - landed: - classic-cube recognition calibration contract @@ -296,9 +301,10 @@ Queue interpretation after that packet: - viseme / gesture runtime integration - broad assistant-platform scope - the next queue shape is now: - - `HactarCE/Hyperspeedcube` deferred runtime-anchor remainder + - `kkoomen/qbr` deferred recognition-shell remainder - the next bounded packet should stay narrow: - - stats-shape and solve-record contract before reopening DSL authoring in the same packet + - webcam UI shell preparation/control before widening into bundled-font redistribution, + multilingual solve shell, or multi-face correction/explanation ownership - 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: