com.robotsquid.squidhub 0.5.7 → 0.5.9

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # Changelog
 
+## 0.5.9
+
+**Build and Upload just uploads.** The "Upload N files (X MB)?" confirmation is
+gone. Choosing the action IS the decision, and a modal that appears after a long
+WebGL build is worse than redundant — it stops an unattended build from ever
+finishing.
+
+Nothing it said is lost, only moved. The file count, the size, the endpoint, the
+skipped OS metadata, the missing-manifest warning and the build warnings all go
+to the Console, where they can be read *during* the upload and are still there
+afterwards. A dialog is gone the moment it is dismissed, which is exactly when a
+warning stops being read.
+
+⚠️ **Refusals still stop the run.** A precompressed build or one with no
+`index.html` at its top level is a failure, not a confirmation, and the server
+would reject it anyway.
+
+## 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.**

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

package/Editor/SquidHubUploader.cs

@@ -85,29 +85,49 @@ namespace SquidHub.Editor
 
             var publish = SquidHubUploadSettings.PublishAfterUpload;
 
-            if (!EditorUtility.DisplayDialog("SquidHub",
-                    $"Upload {scan.Files.Count} files ({scan.TotalBytes / 1024f / 1024f:F1} MB)?" +
-                    (scan.Skipped.Count > 0
-                        ? $"\n\n{scan.Skipped.Count} OS metadata file(s) will be skipped."
-                        : "") +
-                    // ⚠️ Said before the upload, not after. A build folder with no
-                    // manifest.json declares nothing — save schema 1, no display
-                    // constraints — and the publisher cannot tell from the result.
-                    (scan.Files.Any(f => f.Path == "manifest.json")
-                        ? ""
-                        : "\n\nThere is no manifest.json in this folder, so the build declares " +
-                          "nothing: save schema 1 and no display constraints. Set one up in " +
-                          "SquidHub → Game Manifest… and rebuild.") +
-                    (publish
-                        ? "\n\nIt will be published to players if the server allows it — that is " +
-                          "dev only. On prod, promote it in the console."
-                        : ""),
-                    "Upload", "Cancel"))
+            // ⚠️ NO CONFIRMATION. Choosing "Build and Upload" IS the decision;
+            // asking again is a modal between the publisher and the thing they
+            // just asked for, and one that appears after a long WebGL build is
+            // worse than useless — it stops an unattended build from finishing.
+            //
+            // ⚠️ Nothing is lost, only moved. Everything the dialog used to say
+            // goes to the Console, where it can be read during the upload and is
+            // still there afterwards — a dialog is gone the moment it is
+            // dismissed, which is exactly when a warning stops being read.
+            // Refusals above still stop the run; those are failures, not
+            // confirmations.
+            Report(scan, publish);
+
+            Run(Upload(scan, publish));
+        }
+
+        /// <summary>
+        /// What the dialog used to ask, said to the Console instead.
+        ///
+        /// ⚠️ Warnings are LogWarning, not Log. They describe a build that
+        /// uploads perfectly and plays badly, so they have to survive a Console
+        /// that is already full of build spam.
+        /// </summary>
+        private static void Report(BuildScan scan, bool publish)
+        {
+            Debug.Log($"[SquidHub] uploading {scan.Files.Count} file(s), " +
+                      $"{scan.TotalBytes / 1024f / 1024f:F1} MB, to {SquidHubUploadSettings.Endpoint}" +
+                      (scan.Skipped.Count > 0
+                          ? $" ({scan.Skipped.Count} OS metadata file(s) skipped)"
+                          : "") +
+                      (publish ? " — will publish on success where the server allows it (dev only)." : "."));
+
+            // ⚠️ A build folder with no manifest.json declares nothing — save
+            // schema 1, no display constraints — and nothing in the upload
+            // result would ever tell the publisher that.
+            if (!scan.Files.Any(f => f.Path == "manifest.json"))
             {
-                return;
+                Debug.LogWarning(
+                    "[SquidHub] no manifest.json in this build, so it declares nothing: save schema 1 " +
+                    "and no display constraints. Set one up in SquidHub → Game Manifest… and rebuild.");
             }
 
-            Run(Upload(scan, publish));
+            foreach (var warning in scan.Warnings) Debug.LogWarning("[SquidHub] " + warning);
         }
 
         // ⚠️ Driven by EditorApplication.update rather than blocking. Sleeping

package/README.md

@@ -68,6 +68,8 @@ Nothing to configure. On a WebGL build this package:
 2. **Writes `squidhub-bridge.js`** into the output and injects it ahead of the
    Unity loader.
 3. **Hoists every inline `<script>`** out of `index.html` into an external file.
+4. **Makes the game fill the frame** and hides Unity's own logo bar, build title
+   and fullscreen button.
 
 Step 3 is the one that matters. `squidhub-gamehost` serves
 `script-src 'self' 'wasm-unsafe-eval' blob:` with **no `'unsafe-inline'`**, and
@@ -76,6 +78,16 @@ all the markup is there, and nothing runs — the only signal is a CSP violation
 in the console. This is the single most common first-integration failure, and
 you should never see it.
 
+⚠️ **Step 4 is why your game is not a 960×600 box in the corner.** The portal
+already letterboxes — it measures its box, clamps it to the aspect window you
+declared and hands the frame an element of exactly that size. Unity's stock
+template then renders a fixed 960×600 centred inside *that*, on a white page,
+under a Unity logo and a second fullscreen button that fights the portal's own.
+The footer is hidden rather than removed, because the stock bootstrap queries
+the fullscreen button and throws on null — which surfaces as an `alert()` where
+the game should be. Your loading bar is left alone: the portal draws none, so it
+is the only progress a player sees.
+
 Then push the folder:
 
 ```sh
@@ -132,6 +144,11 @@ an upload key is not a person — it sits in CI configs and Editor preferences.
 That asymmetry is deliberate: it is what keeps a leaked key from replacing the
 live build for everyone.
 
+⚠️ **It does not ask.** Choosing the action is the decision, so there is no
+"upload N files?" confirmation to dismiss — the file count, size, destination and
+any warnings go to the Console instead, where they survive being read. A build
+that *cannot* upload still stops with a dialog naming the fix.
+
 The upload is refused before a byte moves if the build is precompressed or has
 no `index.html` at its top level, and OS metadata is dropped rather than sent —
 which is also what makes a build pushed from Unity hash identically to the same

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.robotsquid.squidhub",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "displayName": "SquidHub",
   "description": "Cloud saves, analytics and the coin economy for Unity WebGL games published on SquidHub. Installs the C# wrapper, the .jslib half and the page bridge, and rewrites the exported index.html so it survives the platform's CSP.",
   "unity": "2021.3",