Implement Phase 6R-N hyperspeedcube puzzle DSL boundary

2026-05-22 18:38:58 +02:00 · 2026-05-22 18:38:58 +02:00 · 379f130930
commit 379f130930
parent 1587d876a5
11 changed files with 922 additions and 36 deletions
--- 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,
--- 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
--- 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<FString> RequiredPackageIds;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> SyntaxSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> GeneratorAuthoringSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> DiagnosticSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ProvenanceCaveats;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ExplicitExclusions;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FHyperTwistTrainingSourceAttribution SourceAttribution;
+
+	bool IsStructurallyValid() const
+	{
+		return !ContractId.IsEmpty() && !Title.IsEmpty() && SourceAttribution.IsStructurallyValid();
+	}
+};
+
+USTRUCT(BlueprintType)
+struct 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<FString> RequiredPackageIds;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ModuleSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> EvaluationSurfaceTags;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ProvenanceCaveats;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FString> ExplicitExclusions;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	FHyperTwistTrainingSourceAttribution SourceAttribution;
+
+	bool IsStructurallyValid() const
+	{
+		return !BoundaryId.IsEmpty() && !Title.IsEmpty() && SourceAttribution.IsStructurallyValid();
+	}
+};
+
 USTRUCT(BlueprintType)
 struct 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<FHyperTwistTrainingHyperspeedcubeStatsShapeContract> StatsShapeContracts;

+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingHyperspeedcubeDslContract> DslContracts;
+
+	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
+	TArray<FHyperTwistTrainingHyperspeedcubeDslBoundary> DslBoundaries;
+
 	UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "HyperTwist")
 	TArray<FHyperTwistTrainingHyperspeedcubeSolveRecordBoundary> 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,
--- 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,
--- a/UnrealHyperTwist/Source/UnrealHyperTwist/Tests/HyperTwistHyperspeedcubePhase6RNPuzzleDslContractTest.cpp
+++ 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
--- 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`

--- 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
@ -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
--- 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
@ -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
--- 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

--- 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

--- 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: