com.robotsquid.squidhub 0.5.6 → 0.5.8

package/CHANGELOG.md

@@ -1,5 +1,75 @@
 # Changelog
 
+## 0.5.8
+
+**The game fills the frame, and Unity's chrome is gone.**
+
+The portal already does the letterboxing: `game-frame.tsx` measures its box,
+clamps it to the aspect window in `manifest.json` and hands the iframe an
+element of exactly that size. Unity's Default template then rendered a fixed
+960×600 box centred inside that — letterboxing a second time, at the wrong size,
+on a white page, under a Unity logo, a build title and a second fullscreen
+button. Measured in a browser at a 1555×1290 frame: the canvas was 960×600 at
+offset (298, 326), using 29% of the area it was given.
+
+The post-build step now injects a stylesheet that fills the frame and hides
+`#unity-footer`. Verified in Chrome on a real build: the canvas fills the
+viewport exactly, no scrollbars, and the WebGL render target follows at
+3110×2580 for devicePixelRatio 2 — full resolution, not an upscale.
+
+⚠️ **The footer is HIDDEN, never removed.** The stock bootstrap assigns
+`document.querySelector("#unity-fullscreen-button").onclick` inside the promise
+that resolves the instance. Delete the element and that throws, the chain falls
+into `.catch(alert)`, and the player gets a modal dialog instead of a game.
+
+⚠️ **The loading bar stays.** The portal draws no loading UI of its own, so it
+is the only progress a player sees while a 30 MB build downloads.
+
+⚠️ **The engine splash screen is untouched.** "Made with Unity" is a licence
+term of Unity Personal and is not template chrome; this strips the template's
+own logo bar, nothing else.
+
+**Uploading an older build now warns rather than staying quiet** — one warning
+for a build with no bridge at all, another for a bridged build made before frame
+fitting. Neither refuses: both upload and register perfectly, they just play
+badly, and the fix is a rebuild. It cannot be repaired at upload time — writing
+a bridge tag for a file that is not in the folder trades the handshake for a 404.
+
+## 0.5.7
+
+**The manifest is a form now, and a build can go out in one action.**
+
+`SquidHub → Game Manifest…` edits `manifest.json` beside `Assets/` — id, title,
+capabilities, save schema, orientations, aspect window, sound. It is the same
+file `squidhub-release` reads, so the Editor and the CLI cannot disagree about
+what a game declares.
+
+`SquidHub → Build and Upload…` picks a build profile, builds it, and uploads the
+result through the same refusals a hand-picked folder goes through.
+
+**The post-build step now writes `manifest.json` into the output.** Without it a
+build declares nothing — the server reads the manifest out of the uploaded bytes
+and ignores anything posted alongside the upload, so every Unity build made
+before this one carried save schema 1 and no display constraints regardless of
+what the project's manifest said.
+
+⚠️ **"Publish the build" is ticked by default and works on DEV ONLY.** On prod
+the server refuses a key-authorised publish and the Editor says so; the upload
+still succeeds and the build arrives registered, not live. Promoting a build for
+every player is an owner decision made by a person in the console — an upload
+key lives in CI configs and Editor preferences, and letting one promote on prod
+would mean a leaked key can replace the live build for everyone. `keyMayPublish`
+is an allowlist, so an environment invented later is refused by default rather
+than inheriting the dangerous answer.
+
+⚠️ **The manifest editor preserves keys it does not model.** `skus`,
+`achievements` and `rewardTable` survive a save untouched. Round-tripping
+through a typed model would have deleted a publisher's catalogue declaration and
+they would have found out one release later.
+
+⚠️ **A capability tick is a declaration, not a grant.** The dialog says so beside
+the boxes that need review.
+
 ## 0.5.6
 
 ⚠️ **Fixes an upload that did nothing and said nothing.** `SquidHub → Upload

package/Editor/SquidHubBuildProcessor.cs

@@ -83,12 +83,48 @@ namespace SquidHub.Editor
             File.WriteAllText(indexPath, result.Html);
             foreach (var note in result.Notes) log.Append("  ✓ ").Append(note).Append('\n');
 
+            WriteManifest(outDir, log);
+
             log.Append("\nPush it with:\n  node src/cli.mjs push --game <slug> --dir ")
                .Append(outDir).Append(" --env=dev --verify");
 
             Debug.Log(log.ToString());
         }
 
+        /// <summary>
+        /// Writes the game's declaration into the build.
+        ///
+        /// ⚠️ Without this file the build declares NOTHING. The server reads
+        /// `manifest.json` out of the uploaded bytes — never from anything the
+        /// client posts alongside the upload — so an absent manifest means the
+        /// default everything: save schema 1, no display constraints, and a
+        /// rollback guard that cannot fire.
+        ///
+        /// ⚠️ A WARNING, not a build failure. A publisher mid-setup has no
+        /// manifest yet and their build is still perfectly runnable; refusing it
+        /// would make the package harder to adopt than to ignore. An
+        /// UNREADABLE or INVALID manifest is louder, because that one is a file
+        /// they wrote and believe is in effect.
+        /// </summary>
+        private static void WriteManifest(string outDir, StringBuilder log)
+        {
+            if (!File.Exists(SquidHubUploadSettings.ManifestPath))
+            {
+                log.Append("  · no manifest.json — this build declares nothing. " +
+                           "Set one up in SquidHub → Game Manifest…\n");
+                return;
+            }
+
+            if (!SquidHubManifestWindow.WriteInto(outDir, out var problem))
+            {
+                Debug.LogError("SquidHub: manifest.json was NOT written into the build, so it " +
+                               "declares nothing:\n" + problem);
+                return;
+            }
+
+            log.Append("  ✓ wrote manifest.json\n");
+        }
+
         private static bool InstallBridge(string outDir, StringBuilder log)
         {
             var source = SquidHubPackage.FindBridge();

package/Editor/SquidHubBuildScan.cs

@@ -29,6 +29,8 @@ namespace SquidHub.Editor
         public readonly List<string> Refusals = new List<string>();
         /// <summary>OS metadata dropped. Reported, never silent.</summary>
         public readonly List<string> Skipped = new List<string>();
+        /// <summary>Things wrong with the build that do not justify refusing it.</summary>
+        public readonly List<string> Warnings = new List<string>();
         public long TotalBytes;
         public bool HasEntryPoint;
     }
@@ -111,9 +113,52 @@ namespace SquidHub.Editor
                     "Point this at the folder Unity built into, not at its parent.");
             }
 
+            InspectEntryPoint(scan);
             return scan;
         }
 
+        /// <summary>
+        /// What the exported index.html says about how it was built.
+        ///
+        /// ⚠️ WARNINGS, NEVER REFUSALS. Both of these describe a build that
+        /// uploads and registers perfectly — one just plays badly, and the other
+        /// is somebody's custom pipeline we have no business overruling from
+        /// here. The refusals above are for builds the SERVER would reject; this
+        /// is for builds the PLAYER would notice.
+        ///
+        /// ⚠️ And it cannot be fixed at upload time, which is why it only warns.
+        /// Injecting the bridge tag here would name a squidhub-bridge.js that is
+        /// not in the folder — a 404 in place of the handshake, which is worse
+        /// than the problem it set out to solve. The fix is a rebuild.
+        /// </summary>
+        private static void InspectEntryPoint(BuildScan scan)
+        {
+            var entry = scan.Files.FirstOrDefault(f => f.Path == "index.html");
+            if (entry == null) return;
+
+            string html;
+            try { html = File.ReadAllText(entry.FullPath); }
+            catch { return; }
+
+            if (html.IndexOf("squidhub-bridge.js", StringComparison.OrdinalIgnoreCase) < 0)
+            {
+                scan.Warnings.Add(
+                    "index.html does not reference squidhub-bridge.js, so this build was not made " +
+                    "with the SquidHub package installed. There is no window.SquidHub and every " +
+                    "handshake will time out. Build again with the package in the project.");
+                return;
+            }
+
+            if (html.IndexOf(SquidHubHtml.FitStyleId, StringComparison.OrdinalIgnoreCase) < 0)
+            {
+                scan.Warnings.Add(
+                    "This build predates frame fitting, so Unity's template chrome is still in it: " +
+                    "the game renders in a fixed 960x600 box centred in whatever frame the portal " +
+                    "gives it, on a white page, under a Unity logo and a second fullscreen button. " +
+                    "Rebuild to fill the frame.");
+            }
+        }
+
         private static string ToHex(byte[] bytes)
         {
             var chars = new char[bytes.Length * 2];

package/Editor/SquidHubBuildWindow.cs

@@ -0,0 +1,291 @@
+// SquidHub → Build and Upload… — pick a build profile, build, upload, publish.
+//
+// ⚠️ Build profiles are a Unity 6 feature and this package supports 2021.3, so
+// everything that touches `UnityEditor.Build.Profile` is behind a version
+// guard. On an older Editor the window still uploads; it just cannot build.
+//
+// ⚠️ It uploads THE FOLDER IT JUST BUILT, through the same
+// `SquidHubUploader.Begin` a hand-picked folder goes through. One set of
+// refusals, so a build made here cannot bypass a check a manual upload applies.
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.Build.Reporting;
+using UnityEngine;
+#if UNITY_6000_0_OR_NEWER
+using UnityEditor.Build.Profile;
+#endif
+
+namespace SquidHub.Editor
+{
+    internal sealed class SquidHubBuildWindow : EditorWindow
+    {
+        private Vector2 _scroll;
+
+#if UNITY_6000_0_OR_NEWER
+        private BuildProfile[] _profiles = new BuildProfile[0];
+        private string[] _names = new string[0];
+        private int _selected = -1;
+#endif
+
+        [MenuItem("SquidHub/Build and Upload…", priority = 12)]
+        private static void Open()
+        {
+            var window = GetWindow<SquidHubBuildWindow>(true, "SquidHub Build and Upload", true);
+            window.minSize = new Vector2(520, 400);
+            window.Refresh();
+        }
+
+        private void Refresh()
+        {
+#if UNITY_6000_0_OR_NEWER
+            // ⚠️ AssetDatabase, not BuildProfile's own enumerator. This is the
+            // public, version-stable way to find them, and it also picks up a
+            // profile created since the window was opened.
+            _profiles = AssetDatabase.FindAssets("t:BuildProfile")
+                .Select(AssetDatabase.GUIDToAssetPath)
+                .OrderBy(path => path)
+                .Select(AssetDatabase.LoadAssetAtPath<BuildProfile>)
+                .Where(profile => profile != null)
+                .ToArray();
+
+            _names = _profiles.Select(p => AssetDatabase.GetAssetPath(p)).ToArray();
+
+            var remembered = SquidHubUploadSettings.BuildProfilePath;
+            _selected = System.Array.IndexOf(_names, remembered);
+
+            // Fall back to whatever the Editor itself is set to build.
+            if (_selected < 0)
+            {
+                var active = BuildProfile.GetActiveBuildProfile();
+                if (active != null)
+                    _selected = System.Array.IndexOf(_names, AssetDatabase.GetAssetPath(active));
+            }
+            if (_selected < 0 && _profiles.Length > 0) _selected = 0;
+#endif
+        }
+
+        private void OnGUI()
+        {
+            _scroll = EditorGUILayout.BeginScrollView(_scroll);
+
+            DrawProfile();
+            EditorGUILayout.Space();
+            DrawOutput();
+            EditorGUILayout.Space();
+            DrawPublish();
+            EditorGUILayout.Space();
+            DrawManifestSummary();
+
+            EditorGUILayout.EndScrollView();
+            EditorGUILayout.Space();
+            DrawButtons();
+        }
+
+        private void DrawProfile()
+        {
+            EditorGUILayout.LabelField("Build profile", EditorStyles.boldLabel);
+#if UNITY_6000_0_OR_NEWER
+            if (_profiles.Length == 0)
+            {
+                EditorGUILayout.HelpBox(
+                    "No build profiles in this project. Create one in File → Build Profiles, " +
+                    "targeting Web, then reopen this window.",
+                    MessageType.Warning);
+                if (GUILayout.Button("Refresh")) Refresh();
+                return;
+            }
+
+            var chosen = EditorGUILayout.Popup("Profile", Mathf.Max(0, _selected), _names);
+            if (chosen != _selected)
+            {
+                _selected = chosen;
+                SquidHubUploadSettings.BuildProfilePath = _names[_selected];
+            }
+
+            // ⚠️ The profile's target is not checked here — there is no stable
+            // public accessor for it — so it is checked after the build from the
+            // BuildReport, which is authoritative. A non-Web profile builds and
+            // is then refused, rather than uploading something no browser runs.
+            EditorGUILayout.HelpBox(
+                "The profile must target Web. A build for any other platform is refused after " +
+                "building rather than uploaded.",
+                MessageType.None);
+
+            if (GUILayout.Button("Refresh list")) Refresh();
+#else
+            EditorGUILayout.HelpBox(
+                "Build profiles need Unity 6. On this Editor, build with File → Build Settings " +
+                "and then use Upload, or SquidHub → Upload Build….",
+                MessageType.Info);
+#endif
+        }
+
+        private void DrawOutput()
+        {
+            EditorGUILayout.LabelField("Output folder", EditorStyles.boldLabel);
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                EditorGUILayout.SelectableLabel(
+                    string.IsNullOrEmpty(SquidHubUploadSettings.BuildFolder)
+                        ? "(none chosen)"
+                        : SquidHubUploadSettings.BuildFolder,
+                    EditorStyles.textField, GUILayout.Height(EditorGUIUtility.singleLineHeight));
+
+                if (GUILayout.Button("Choose…", GUILayout.Width(90)))
+                {
+                    var start = SquidHubUploadSettings.BuildFolder;
+                    var folder = EditorUtility.SaveFolderPanel(
+                        "Build into", string.IsNullOrEmpty(start) ? "" : start, "web");
+                    if (!string.IsNullOrEmpty(folder)) SquidHubUploadSettings.BuildFolder = folder;
+                }
+            }
+        }
+
+        private void DrawPublish()
+        {
+            EditorGUILayout.LabelField("On a successful upload", EditorStyles.boldLabel);
+
+            SquidHubUploadSettings.PublishAfterUpload = EditorGUILayout.ToggleLeft(
+                new GUIContent("Publish the build",
+                    "Makes the build live for players. The server allows this on dev only."),
+                SquidHubUploadSettings.PublishAfterUpload);
+
+            if (SquidHubUploadSettings.PublishAfterUpload)
+            {
+                // ⚠️ Stated plainly rather than left to be discovered. The tick is
+                // on by default and does nothing on prod, and a publisher who
+                // believes otherwise ships a build they think is live.
+                EditorGUILayout.HelpBox(
+                    "This works on dev only. On prod the server refuses it — promoting a build " +
+                    "for every player is an owner decision made in the console, and an upload key " +
+                    "is not a person. The upload still succeeds; you will be told it was not published.",
+                    MessageType.Info);
+            }
+
+            EditorGUILayout.LabelField("Console", SquidHubUploadSettings.Endpoint, EditorStyles.miniLabel);
+        }
+
+        private void DrawManifestSummary()
+        {
+            EditorGUILayout.LabelField("Declaration", EditorStyles.boldLabel);
+
+            if (!File.Exists(SquidHubUploadSettings.ManifestPath))
+            {
+                EditorGUILayout.HelpBox(
+                    "No manifest.json, so this build will declare nothing: save schema 1 and no " +
+                    "display constraints.",
+                    MessageType.Warning);
+            }
+            else
+            {
+                try
+                {
+                    var manifest = SquidHubManifest.Load(SquidHubUploadSettings.ManifestPath);
+                    var errors = manifest.Errors();
+                    if (errors.Count > 0)
+                    {
+                        EditorGUILayout.HelpBox(
+                            "manifest.json is not valid, and the build will not carry it:\n\n" +
+                            string.Join("\n", errors),
+                            MessageType.Error);
+                    }
+                    else
+                    {
+                        EditorGUILayout.LabelField(
+                            manifest.GameId + "  ·  save schema " + manifest.SaveSchemaVersion +
+                            "  ·  " + string.Join(", ", manifest.Capabilities),
+                            EditorStyles.miniLabel);
+                    }
+                }
+                catch (System.Exception e)
+                {
+                    EditorGUILayout.HelpBox("manifest.json could not be read: " + e.Message, MessageType.Error);
+                }
+            }
+
+            if (GUILayout.Button("Edit manifest…")) SquidHubManifestWindow.Open();
+        }
+
+        private void DrawButtons()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+#if UNITY_6000_0_OR_NEWER
+                using (new EditorGUI.DisabledScope(_profiles.Length == 0 || _selected < 0))
+                {
+                    if (GUILayout.Button("Build and Upload", GUILayout.Height(28))) BuildThenUpload();
+                    if (GUILayout.Button("Build only", GUILayout.Height(28))) Build();
+                }
+#endif
+                if (GUILayout.Button("Upload only", GUILayout.Height(28)))
+                {
+                    var folder = SquidHubUploadSettings.BuildFolder;
+                    if (string.IsNullOrEmpty(folder) || !Directory.Exists(folder))
+                        EditorUtility.DisplayDialog("SquidHub", "Choose an output folder first.", "OK");
+                    else
+                        SquidHubUploader.Begin(folder);
+                }
+            }
+        }
+
+#if UNITY_6000_0_OR_NEWER
+        private void BuildThenUpload()
+        {
+            // ⚠️ The key is checked BEFORE building. Discovering there is no key
+            // after a twenty-minute WebGL build is the kind of thing that makes
+            // people go back to the command line.
+            if (!SquidHubUploader.EnsureKey()) return;
+
+            var folder = Build();
+            if (folder != null) SquidHubUploader.Begin(folder);
+        }
+
+        /// <summary>The folder that was built into, or null when the build did not produce one.</summary>
+        private string Build()
+        {
+            var folder = SquidHubUploadSettings.BuildFolder;
+            if (string.IsNullOrEmpty(folder))
+            {
+                EditorUtility.DisplayDialog("SquidHub", "Choose an output folder first.", "OK");
+                return null;
+            }
+
+            var profile = _profiles[_selected];
+
+            // ⚠️ Made active first. A profile passed only to BuildPlayer leaves
+            // the Editor's own target where it was, and the next manual build
+            // from File → Build silently uses a different one.
+            BuildProfile.SetActiveBuildProfile(profile);
+
+            var report = BuildPipeline.BuildPlayer(new BuildPlayerWithProfileOptions
+            {
+                buildProfile = profile,
+                locationPathName = folder,
+                options = BuildOptions.None,
+            });
+
+            if (report == null || report.summary.result != BuildResult.Succeeded)
+            {
+                // ⚠️ No dialog. A failed build has already filled the Console with
+                // the reason, and a modal saying "it failed" on top of that just
+                // has to be dismissed before anyone can read it.
+                Debug.LogError("[SquidHub] the build did not succeed — nothing was uploaded.");
+                return null;
+            }
+
+            if (report.summary.platform != BuildTarget.WebGL)
+            {
+                EditorUtility.DisplayDialog("SquidHub",
+                    "That profile built for " + report.summary.platform + ", not Web.\n\n" +
+                    "SquidHub serves WebGL builds, and the bridge was not installed into this one. " +
+                    "Point the profile at the Web platform and build again.",
+                    "OK");
+                return null;
+            }
+
+            return folder;
+        }
+#endif
+    }
+}

package/Editor/SquidHubBuildWindow.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c05e02aea772f507162356a3628335ef
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/SquidHubHtml.cs

@@ -49,6 +49,66 @@ namespace SquidHub.Editor
                 "text/ecmascript", "application/ecmascript",
             };
 
+        /// <summary>Marks our stylesheet, so a reprocess can recognise its own work.</summary>
+        internal const string FitStyleId = "squidhub-fit";
+
+        /// <summary>
+        /// Makes the game fill the frame the portal gives it, and hides the
+        /// template's own chrome.
+        ///
+        /// ⚠️ THE PORTAL ALREADY DID THE LETTERBOXING. `game-frame.tsx` measures
+        /// its box, clamps it to the aspect window declared in manifest.json and
+        /// hands the iframe an element of exactly that size with black bars
+        /// around it. Unity's Default template then renders a fixed 960×600 box
+        /// centred inside that — letterboxing a second time, at the wrong size,
+        /// so a 4K monitor gets a postage stamp. Filling is not a preference
+        /// here; the frame is already the right shape.
+        ///
+        /// ⚠️ `!important` is doing real work. The template's bootstrap sets
+        /// `fullscreenContainer.style.width = "960px"` as an INLINE style, and
+        /// the Minimal template writes inline px on the canvas itself. A plain
+        /// rule loses to both.
+        ///
+        /// ⚠️ `#unity-footer` is HIDDEN, never removed. The stock bootstrap does
+        /// `document.querySelector("#unity-fullscreen-button").onclick = …`
+        /// inside the promise that resolves the instance; delete the element and
+        /// that throws, the chain falls into `.catch(alert)`, and the player gets
+        /// a modal dialog instead of a game. Hiding leaves every query answerable.
+        ///
+        /// ⚠️ The loading bar STAYS. The portal draws no loading UI of its own,
+        /// so this is the only progress a player sees while a 30 MB build
+        /// downloads — hiding it would trade a Unity logo for a black screen.
+        ///
+        /// ⚠️ An inline &lt;style&gt; is safe where an inline script is not:
+        /// gamehost sends `style-src 'self' 'unsafe-inline'` but no
+        /// `'unsafe-inline'` for scripts. That asymmetry is why this is a style
+        /// block and the bootstrap had to be hoisted to a file.
+        /// </summary>
+        private static readonly string FitStyle =
+            "<style id=\"" + FitStyleId + "\">\n" +
+            "      /* SquidHub: the portal sizes and letterboxes the frame; the game fills it. */\n" +
+            "      html, body { width: 100%; height: 100%; margin: 0; padding: 0; overflow: hidden; }\n" +
+            "      #unity-container,\n" +
+            "      #unity-container.unity-desktop,\n" +
+            "      #unity-container.unity-mobile {\n" +
+            "        position: absolute; left: 0; top: 0;\n" +
+            "        width: 100%; height: 100%; transform: none;\n" +
+            "      }\n" +
+            "      #unity-fullscreen-container {\n" +
+            "        position: absolute; left: 0; top: 0;\n" +
+            "        width: 100% !important; height: 100% !important;\n" +
+            "      }\n" +
+            "      #unity-canvas {\n" +
+            "        display: block; left: 0; top: 0;\n" +
+            "        width: 100% !important; height: 100% !important;\n" +
+            "      }\n" +
+            "      /* Unity\u0027s own logo, build title and fullscreen button. The portal\n" +
+            "         draws its own fullscreen control from display.fullscreen, and two\n" +
+            "         of them fight. Hidden rather than removed — the bootstrap still\n" +
+            "         queries the button and would throw on null. */\n" +
+            "      #unity-footer { display: none !important; }\n" +
+            "    </style>\n";
+
         public static Result Apply(string html, string bridgeFileName)
         {
             var result = new Result { Html = html };
@@ -83,7 +143,7 @@ namespace SquidHub.Editor
             });
 
             var tag = "<script src=\"" + bridgeFileName + "\"></script>";
-            result.Html = InsertBridge(rewritten, tag, result);
+            result.Html = InsertFitStyle(InsertBridge(rewritten, tag, result), result);
             result.Changed = !ReferenceEquals(result.Html, html) && result.Html != html;
             return result;
         }
@@ -98,6 +158,40 @@ namespace SquidHub.Editor
             return ExecutableTypes.Contains(value.Trim());
         }
 
+        /// <summary>
+        /// Puts the stylesheet last in &lt;head&gt;, so it follows the template's own
+        /// `TemplateData/style.css` and wins on order as well as on specificity.
+        /// </summary>
+        private static string InsertFitStyle(string html, Result result)
+        {
+            // Somebody's custom template may already carry it; do not stack a second.
+            if (html.IndexOf(FitStyleId, StringComparison.OrdinalIgnoreCase) >= 0)
+            {
+                result.Notes.Add("fit stylesheet already present — left alone");
+                return html;
+            }
+
+            var at = html.IndexOf("</head>", StringComparison.OrdinalIgnoreCase);
+            if (at >= 0)
+            {
+                result.Notes.Add("canvas set to fill the frame, Unity footer hidden");
+                return html.Substring(0, at) + "    " + FitStyle + html.Substring(at);
+            }
+
+            // ⚠️ A document with no </head> still gets it, before the first tag
+            // that could render. An unstyled page here is a game the player sees
+            // at 960×600 in the middle of a 4K frame, which reads as broken.
+            at = html.IndexOf("<body", StringComparison.OrdinalIgnoreCase);
+            if (at >= 0)
+            {
+                result.Notes.Add("no </head> — fit stylesheet injected before <body>");
+                return html.Substring(0, at) + FitStyle + html.Substring(at);
+            }
+
+            result.Notes.Add("no </head> or <body> — fit stylesheet prepended");
+            return FitStyle + html;
+        }
+
         // ⚠️ Before the FIRST script in the document, not merely before the
         // loader. installBridge() patches AudioContext.destination on the
         // instance, so it only catches contexts created after it runs — land