com.robotsquid.squidhub 0.5.6 → 0.5.7

package/Editor/SquidHubManifest.cs

@@ -0,0 +1,355 @@
+// The game's declaration: what it is, what it needs, and how it wants to be
+// shown. `SquidHub → Game Manifest…` edits this; the post-build step writes it
+// into the build folder; the server reads it back out of the uploaded bytes.
+//
+// ⚠️ THE SERVER READS `manifest.json` FROM THE UPLOADED FILES, never from
+// anything the client posts alongside the "I'm finished" call — see
+// `completeBuildUpload`, which is explicit that a posted manifest "is just a
+// claim". So the ONLY way a declaration takes effect is for this file to be
+// written into the build folder and uploaded with everything else.
+//
+// ⚠️ EDITING THE MANIFEST ALONE CHANGES NOTHING. `manifest.json` is excluded
+// from the build hash (it contains that hash), so a build whose only change is
+// its manifest is byte-identical to one already registered, reuses the existing
+// immutable version row and is refused as a no-op with a `manifest-ignored`
+// warning. A declaration change ships with a code change, or through the
+// console override. `Warnings()` says so where a publisher will read it.
+//
+// ⚠️ Validation here MIRRORS `parseDisplay` in @robotsquid/contracts. The server
+// refuses a malformed display block rather than dropping it, and finding that
+// out after a twenty-minute WebGL build and a 30 MB upload is the expensive way
+// to learn it. This is a courtesy copy — the server remains the authority.
+//
+// ⚠️ Pure System.* — no UnityEditor, no UnityEngine, so tools/test can run it.
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
+
+namespace SquidHub.Editor
+{
+    internal sealed class SquidHubManifest
+    {
+        /// <summary>
+        /// ⚠️ GRANTED by the platform, never merely requested here. Ticking a box
+        /// declares that the game USES a capability; the broker still refuses any
+        /// verb the game has not been granted at review, and a new third-party
+        /// game has `saves` and `analytics` only. Declaring more does not grant
+        /// more — it is how you find out you need a grant.
+        /// </summary>
+        public static readonly string[] AllCapabilities =
+        {
+            "saves", "analytics", "achievements", "leaderboards",
+            "commerce.spend", "rewards", "multiplayer", "ads.rewarded",
+        };
+
+        /// <summary>What a new third-party game has until review grants more.</summary>
+        public static readonly string[] DefaultCapabilities = { "saves", "analytics" };
+
+        /// <summary>DEVICE orientation, not the game's own shape.</summary>
+        public static readonly string[] AllOrientations = { "landscape", "portrait" };
+
+        /// <summary>Sanity bounds on a declared ratio — 4:1 and 1:4. A typo catcher, not a taste judgement.</summary>
+        public const double AspectMinRatio = 0.25;
+        public const double AspectMaxRatio = 4.0;
+
+        public string GameId = "";
+        public string Title = "";
+        public string Version = "0.0.0";
+        public bool RequiresThreads;
+        public bool Sound = true;
+        public int SaveSchemaVersion = 1;
+        public bool SaveSchemaDowngrade;
+        public List<string> Capabilities = new List<string>(DefaultCapabilities);
+        public List<string> AnalyticsProps = new List<string>();
+
+        // display
+        public List<string> Orientations = new List<string>(AllOrientations);
+        public string AspectMin = "";
+        public string AspectMax = "";
+        public bool Fullscreen;
+
+        /// <summary>
+        /// The document this was read from, so keys we do not model survive.
+        ///
+        /// ⚠️ `skus`, `achievements` and `rewardTable` live in the same file and
+        /// are not editable here. Rebuilding the manifest from the fields above
+        /// would delete a publisher's entire catalogue declaration, and they
+        /// would find out at the next release rather than at the edit.
+        /// </summary>
+        private JsonValue _document = JsonValue.NewObject();
+
+        public static SquidHubManifest Empty() => new SquidHubManifest();
+
+        /// <summary>Reads a manifest, or returns a default one when the file does not exist yet.</summary>
+        public static SquidHubManifest Load(string path)
+        {
+            if (string.IsNullOrEmpty(path) || !File.Exists(path)) return new SquidHubManifest();
+            return FromJson(File.ReadAllText(path));
+        }
+
+        public static SquidHubManifest FromJson(string text)
+        {
+            var document = SquidHubJson.Parse(text);
+            if (document.Kind != JsonKind.Object)
+                throw new FormatException("manifest.json must be a JSON object");
+
+            var manifest = new SquidHubManifest { _document = document };
+
+            manifest.GameId = Field(document, "gameId").AsString();
+            manifest.Title = Field(document, "title").AsString();
+            manifest.Version = Field(document, "version").AsString("0.0.0");
+            manifest.RequiresThreads = Field(document, "requiresThreads").AsBool();
+            manifest.Sound = Field(document, "sound").AsBool(true);
+            manifest.SaveSchemaVersion = Field(document, "saveSchemaVersion").AsInt(1);
+            manifest.SaveSchemaDowngrade = Field(document, "saveSchemaDowngrade").AsBool();
+
+            var capabilities = document.Get("capabilities");
+            if (capabilities != null) manifest.Capabilities = capabilities.AsStringList();
+
+            var props = document.Get("analyticsProps");
+            if (props != null) manifest.AnalyticsProps = props.AsStringList();
+
+            var display = document.Get("display");
+            if (display != null && display.Kind == JsonKind.Object)
+            {
+                var orientations = display.Get("orientations");
+                if (orientations != null) manifest.Orientations = orientations.AsStringList();
+
+                var aspect = display.Get("aspect");
+                if (aspect != null && aspect.Kind == JsonKind.Object)
+                {
+                    manifest.AspectMin = Field(aspect, "min").AsString();
+                    manifest.AspectMax = Field(aspect, "max").AsString();
+                }
+                manifest.Fullscreen = Field(display, "fullscreen").AsBool();
+            }
+
+            return manifest;
+        }
+
+        private static JsonValue Field(JsonValue owner, string name) =>
+            owner.Get(name) ?? JsonValue.Null();
+
+        /// <summary>
+        /// The manifest as JSON, with every unmodelled key left exactly as it was.
+        ///
+        /// ⚠️ `forBuild` strips `buildHash`, `files` and `sizeBytes`. Those
+        /// describe a specific set of bytes and are written by the release tool
+        /// at push time; carrying a copy from an earlier build into a new one
+        /// states a hash that is not this build's, and a manifest that lies about
+        /// its own identity is worse than one that stays quiet.
+        /// </summary>
+        public string ToJson(bool forBuild)
+        {
+            // ⚠️ A CLONE. Serialising must not edit the document the dialog is
+            // still showing — writing the build folder once stripped `buildHash`
+            // out of the publisher's own manifest as a side effect.
+            var document = _document.Clone();
+
+            document.Set("gameId", JsonValue.Str(GameId));
+            document.Set("title", JsonValue.Str(Title));
+
+            // ⚠️ Not editable. This package only ever produces Unity WebGL, and
+            // the portal frames /v/<hash>/index.html — a different entry is a
+            // build that registers perfectly and 404s for every player.
+            document.Set("engine", JsonValue.Str("unity"));
+            document.Set("entry", JsonValue.Str("index.html"));
+
+            document.Set("version", JsonValue.Str(string.IsNullOrWhiteSpace(Version) ? "0.0.0" : Version.Trim()));
+            document.Set("requiresThreads", JsonValue.Of(RequiresThreads));
+            document.Set("capabilities", JsonValue.ArrayOf(Capabilities));
+            document.Set("analyticsProps", JsonValue.ArrayOf(AnalyticsProps));
+            document.Set("saveSchemaVersion", JsonValue.Of(SaveSchemaVersion));
+            document.Set("sound", JsonValue.Of(Sound));
+
+            // ⚠️ Written only when true. It is an assertion that an older build
+            // can read a newer save, and an explicit `false` on every manifest
+            // invites someone to flip it without meeting that bar.
+            if (SaveSchemaDowngrade) document.Set("saveSchemaDowngrade", JsonValue.Of(true));
+            else document.Remove("saveSchemaDowngrade");
+
+            WriteDisplay(document);
+
+            if (forBuild)
+            {
+                document.Remove("buildHash");
+                document.Remove("files");
+                document.Remove("sizeBytes");
+            }
+
+            return SquidHubJson.Write(document);
+        }
+
+        /// <summary>
+        /// ⚠️ An entirely default display block is REMOVED, not written. `aspect:
+        /// null` means "fill the box", which is what the iframe did before the
+        /// feature existed — so a game that declares nothing must keep declaring
+        /// nothing rather than gaining a block that merely restates the default.
+        /// </summary>
+        private void WriteDisplay(JsonValue document)
+        {
+            var orientations = Orientations.Where(o => AllOrientations.Contains(o)).Distinct().ToList();
+            var hasOrientations = orientations.Count > 0 && orientations.Count < AllOrientations.Length;
+            var min = (AspectMin ?? "").Trim();
+            var max = (AspectMax ?? "").Trim();
+            var hasAspect = min.Length > 0 || max.Length > 0;
+
+            if (!hasOrientations && !hasAspect && !Fullscreen)
+            {
+                document.Remove("display");
+                return;
+            }
+
+            var display = document.Get("display");
+            if (display == null || display.Kind != JsonKind.Object)
+            {
+                display = JsonValue.NewObject();
+                document.Set("display", display);
+            }
+
+            if (hasOrientations) display.Set("orientations", JsonValue.ArrayOf(orientations));
+            else display.Remove("orientations");
+
+            if (hasAspect)
+            {
+                var aspect = display.Get("aspect");
+                if (aspect == null || aspect.Kind != JsonKind.Object)
+                {
+                    aspect = JsonValue.NewObject();
+                    display.Set("aspect", aspect);
+                }
+                if (min.Length > 0) aspect.Set("min", JsonValue.Str(min)); else aspect.Remove("min");
+                if (max.Length > 0) aspect.Set("max", JsonValue.Str(max)); else aspect.Remove("max");
+            }
+            else display.Remove("aspect");
+
+            if (Fullscreen) display.Set("fullscreen", JsonValue.Of(true));
+            else display.Remove("fullscreen");
+        }
+
+        public void Save(string path, bool forBuild = false)
+        {
+            var directory = Path.GetDirectoryName(path);
+            if (!string.IsNullOrEmpty(directory)) Directory.CreateDirectory(directory);
+            File.WriteAllText(path, ToJson(forBuild));
+        }
+
+        /// <summary>
+        /// Everything that would make the server refuse this build. Empty means
+        /// the declaration is well-formed — not that it will be granted.
+        /// </summary>
+        public List<string> Errors()
+        {
+            var errors = new List<string>();
+
+            if (string.IsNullOrWhiteSpace(GameId))
+                errors.Add("Game ID is required. It is the slug the game is published under.");
+
+            if (SaveSchemaVersion < 1)
+            {
+                errors.Add("Save schema version must be a positive integer. It is what the launch " +
+                           "guard compares against a player's stored save, and the server ignores " +
+                           "anything else and uses 1 — which would silently disable the guard.");
+            }
+
+            foreach (var capability in Capabilities.Where(c => !AllCapabilities.Contains(c)))
+                errors.Add("'" + capability + "' is not a capability the platform knows.");
+
+            // ⚠️ Refused, never dropped. An empty orientation list reads as
+            // "playable in no orientation", and dropping it would leave the
+            // default — BOTH — silently widening a landscape-only game.
+            if (Orientations.Count == 0)
+                errors.Add("Tick at least one orientation. A game playable in neither cannot launch.");
+
+            foreach (var orientation in Orientations.Where(o => !AllOrientations.Contains(o)))
+                errors.Add("'" + orientation + "' is not an orientation. Use landscape or portrait.");
+
+            var min = RatioError("Minimum aspect", AspectMin);
+            if (min != null) errors.Add(min);
+            var max = RatioError("Maximum aspect", AspectMax);
+            if (max != null) errors.Add(max);
+
+            if (min == null && max == null)
+            {
+                var minRatio = ParseRatio(AspectMin);
+                var maxRatio = ParseRatio(AspectMax);
+                if (minRatio.HasValue && maxRatio.HasValue && minRatio.Value > maxRatio.Value)
+                {
+                    errors.Add("The minimum aspect (" + AspectMin.Trim() + ") is wider than the maximum (" +
+                               AspectMax.Trim() + ").");
+                }
+            }
+
+            return errors;
+        }
+
+        /// <summary>Things worth saying that do not stop a build.</summary>
+        public List<string> Warnings()
+        {
+            var warnings = new List<string>();
+
+            var ungranted = Capabilities
+                .Where(c => AllCapabilities.Contains(c) && !DefaultCapabilities.Contains(c))
+                .ToList();
+            if (ungranted.Count > 0)
+            {
+                warnings.Add("Declaring " + string.Join(", ", ungranted) + " does not grant it. " +
+                             "Capabilities are granted at review; until then the broker answers " +
+                             "DENIED to those verbs and the game must handle that.");
+            }
+
+            if (RequiresThreads)
+            {
+                warnings.Add("requiresThreads needs the isolated hosting tier. A build using " +
+                             "SharedArrayBuffer cannot start on the default tier, and the pre-build " +
+                             "check refuses it unless SQUIDHUB_ALLOW_THREADS is in the WebGL define symbols.");
+            }
+
+            if (SaveSchemaDowngrade)
+            {
+                warnings.Add("saveSchemaDowngrade asserts that an older build can safely read a save " +
+                             "written by this one. It disables the rollback guard, which is the only " +
+                             "thing standing between a rollback and every player's progress.");
+            }
+
+            return warnings;
+        }
+
+        /// <summary>`"16:9"` → 1.777…. Null for anything that is not a positive ratio.</summary>
+        public static double? ParseRatio(string value)
+        {
+            if (string.IsNullOrWhiteSpace(value)) return null;
+
+            // ⚠️ COLON ONLY — never "16/9" and never a bare decimal. One spelling
+            // is one thing to document, parse and show back in an error, and
+            // "1.78" is both a plausible thing to type and a lossy thing to store.
+            var match = Regex.Match(value.Trim(), @"^(\d+(?:\.\d+)?):(\d+(?:\.\d+)?)$");
+            if (!match.Success) return null;
+
+            var width = double.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
+            var height = double.Parse(match.Groups[2].Value, CultureInfo.InvariantCulture);
+
+            // ⚠️ Zero on either side is a parse failure, not an infinity or a NaN.
+            // Both survive into the layout and land as a frame with no height.
+            if (width <= 0 || height <= 0) return null;
+            return width / height;
+        }
+
+        private static string RatioError(string label, string value)
+        {
+            if (string.IsNullOrWhiteSpace(value)) return null;
+
+            var ratio = ParseRatio(value);
+            if (!ratio.HasValue)
+                return label + ": '" + value.Trim() + "' is not a ratio like \"16:9\".";
+
+            if (ratio.Value < AspectMinRatio || ratio.Value > AspectMaxRatio)
+                return label + ": " + value.Trim() + " is outside 1:4–4:1.";
+
+            return null;
+        }
+    }
+}

package/Editor/SquidHubManifest.cs.meta

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

package/Editor/SquidHubManifestWindow.cs

@@ -0,0 +1,292 @@
+// SquidHub → Game Manifest… — the declaration, as a form.
+//
+// ⚠️ Edits `manifest.json` beside `Assets/`, the same file `squidhub-release`
+// reads. This window is a nicer way to write it, not a second place to keep it.
+//
+// ⚠️ It SAVES ON DEMAND, never on close or on play. The file is committed, and
+// a window that rewrites a tracked file merely because it was opened produces
+// diffs nobody asked for.
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace SquidHub.Editor
+{
+    internal sealed class SquidHubManifestWindow : EditorWindow
+    {
+        private SquidHubManifest _manifest;
+        private string _loadError;
+        private string _propsText = "";
+        private Vector2 _scroll;
+
+        [MenuItem("SquidHub/Game Manifest…", priority = 1)]
+        internal static void Open()
+        {
+            var window = GetWindow<SquidHubManifestWindow>(true, "SquidHub Game Manifest", true);
+            window.minSize = new Vector2(520, 620);
+            window.Reload();
+        }
+
+        private void Reload()
+        {
+            _loadError = null;
+            try
+            {
+                _manifest = SquidHubManifest.Load(SquidHubUploadSettings.ManifestPath);
+            }
+            catch (System.Exception e)
+            {
+                // ⚠️ A manifest we cannot parse is NOT replaced with a default
+                // one. Offering an empty form over a file we failed to read is
+                // how a hand-authored catalogue gets overwritten by a Save.
+                _manifest = null;
+                _loadError = e.Message;
+                return;
+            }
+            _propsText = string.Join(", ", _manifest.AnalyticsProps);
+        }
+
+        private void OnGUI()
+        {
+            if (_loadError != null)
+            {
+                EditorGUILayout.HelpBox(
+                    "manifest.json could not be read, so it is not being shown — saving over it " +
+                    "would destroy whatever is in there.\n\n" + _loadError,
+                    MessageType.Error);
+                if (GUILayout.Button("Reveal manifest.json"))
+                    EditorUtility.RevealInFinder(SquidHubUploadSettings.ManifestPath);
+                if (GUILayout.Button("Try again")) Reload();
+                return;
+            }
+
+            if (_manifest == null) Reload();
+
+            _scroll = EditorGUILayout.BeginScrollView(_scroll);
+
+            EditorGUILayout.LabelField("Identity", EditorStyles.boldLabel);
+            _manifest.GameId = EditorGUILayout.TextField(
+                new GUIContent("Game ID", "The slug the game is published under. It must match the game in the publisher console."),
+                _manifest.GameId);
+            _manifest.Title = EditorGUILayout.TextField("Title", _manifest.Title);
+            _manifest.Version = EditorGUILayout.TextField(
+                new GUIContent("Version", "semver. Defaults to 0.0.0 when absent."), _manifest.Version);
+
+            using (new EditorGUI.DisabledScope(true))
+            {
+                EditorGUILayout.TextField(new GUIContent("Engine",
+                    "Fixed. This package only produces Unity WebGL builds."), "unity");
+                EditorGUILayout.TextField(new GUIContent("Entry",
+                    "Fixed. The portal frames /v/<hash>/index.html."), "index.html");
+            }
+
+            EditorGUILayout.Space();
+            DrawCapabilities();
+
+            EditorGUILayout.Space();
+            DrawSaves();
+
+            EditorGUILayout.Space();
+            DrawDisplay();
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Runtime", EditorStyles.boldLabel);
+            _manifest.Sound = EditorGUILayout.Toggle(
+                new GUIContent("Sound", "The game produces audio, so the portal draws its mute button."),
+                _manifest.Sound);
+            _manifest.RequiresThreads = EditorGUILayout.Toggle(
+                new GUIContent("Requires threads",
+                    "SharedArrayBuffer. Needs the isolated hosting tier — a build using it cannot start on the default one."),
+                _manifest.RequiresThreads);
+
+            EditorGUILayout.Space();
+            DrawFindings();
+
+            EditorGUILayout.EndScrollView();
+
+            EditorGUILayout.Space();
+            DrawButtons();
+        }
+
+        private void DrawCapabilities()
+        {
+            EditorGUILayout.LabelField("Capabilities", EditorStyles.boldLabel);
+            EditorGUILayout.HelpBox(
+                "Tick what the game USES. Capabilities are granted by the platform at review — " +
+                "ticking one here does not grant it, and the broker answers DENIED to any verb " +
+                "this game has not been granted. New games have saves and analytics.",
+                MessageType.None);
+
+            foreach (var capability in SquidHubManifest.AllCapabilities)
+            {
+                var on = _manifest.Capabilities.Contains(capability);
+                var granted = SquidHubManifest.DefaultCapabilities.Contains(capability);
+                var label = new GUIContent(
+                    capability + (granted ? "" : "  (needs review)"),
+                    granted
+                        ? "Granted to every game by default."
+                        : "Declaring this does not grant it. Ask for it in the publisher console.");
+
+                var now = EditorGUILayout.ToggleLeft(label, on);
+                if (now == on) continue;
+                if (now) _manifest.Capabilities.Add(capability);
+                else _manifest.Capabilities.Remove(capability);
+            }
+
+            // ⚠️ Shown rather than silently dropped. A capability we do not know
+            // is either a typo or a platform newer than this package, and both
+            // are things the publisher needs to see rather than lose on save.
+            var unknown = _manifest.Capabilities
+                .Where(c => !SquidHubManifest.AllCapabilities.Contains(c)).ToList();
+            if (unknown.Count > 0)
+            {
+                EditorGUILayout.HelpBox(
+                    "manifest.json also declares " + string.Join(", ", unknown) +
+                    ", which this package does not recognise. It is kept as written.",
+                    MessageType.Warning);
+            }
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField(new GUIContent("Analytics properties",
+                "Comma separated. The property names analytics.track may carry."));
+            _propsText = EditorGUILayout.TextField(_propsText);
+        }
+
+        private void DrawSaves()
+        {
+            EditorGUILayout.LabelField("Saves", EditorStyles.boldLabel);
+            _manifest.SaveSchemaVersion = EditorGUILayout.IntField(
+                new GUIContent("Save schema version",
+                    "Bump it when the save format changes. The launch guard compares this against a player's stored save."),
+                _manifest.SaveSchemaVersion);
+
+            _manifest.SaveSchemaDowngrade = EditorGUILayout.Toggle(
+                new GUIContent("Allow downgrade",
+                    "Asserts an older build can safely read a save written by this one. It disables the rollback guard."),
+                _manifest.SaveSchemaDowngrade);
+        }
+
+        private void DrawDisplay()
+        {
+            EditorGUILayout.LabelField("Display", EditorStyles.boldLabel);
+
+            EditorGUILayout.LabelField(new GUIContent("Orientations",
+                "DEVICE orientation, not the game's shape. Unticking one raises the rotate prompt on a phone held that way. It does nothing on desktop."));
+            using (new EditorGUI.IndentLevelScope())
+            {
+                foreach (var orientation in SquidHubManifest.AllOrientations)
+                {
+                    var on = _manifest.Orientations.Contains(orientation);
+                    var now = EditorGUILayout.ToggleLeft(orientation, on);
+                    if (now == on) continue;
+                    if (now) _manifest.Orientations.Add(orientation);
+                    else _manifest.Orientations.Remove(orientation);
+                }
+            }
+
+            EditorGUILayout.LabelField(new GUIContent("Aspect window",
+                "A RANGE, as \"width:height\". A responsive game gives two different ratios; a fixed-canvas game gives the same one twice. Leave both blank to take whatever box you are given."));
+            using (new EditorGUI.IndentLevelScope())
+            {
+                _manifest.AspectMin = EditorGUILayout.TextField(
+                    new GUIContent("Narrowest", "Pillarboxed below this. e.g. 4:3"), _manifest.AspectMin);
+                _manifest.AspectMax = EditorGUILayout.TextField(
+                    new GUIContent("Widest", "Letterboxed above this. e.g. 21:9"), _manifest.AspectMax);
+            }
+
+            _manifest.Fullscreen = EditorGUILayout.Toggle(
+                new GUIContent("Fullscreen button", "The portal offers fullscreen for this game."),
+                _manifest.Fullscreen);
+        }
+
+        private void DrawFindings()
+        {
+            ApplyProps();
+
+            foreach (var error in _manifest.Errors())
+                EditorGUILayout.HelpBox(error, MessageType.Error);
+
+            foreach (var warning in _manifest.Warnings())
+                EditorGUILayout.HelpBox(warning, MessageType.Warning);
+
+            // ⚠️ The single most surprising rule on the platform, said where it
+            // is about to bite. manifest.json is excluded from the build hash, so
+            // a manifest-only change hashes to a build that already exists and is
+            // refused as a no-op.
+            EditorGUILayout.HelpBox(
+                "Changing only this file changes nothing. manifest.json is excluded from the build " +
+                "hash, so a build whose sole difference is its manifest is byte-identical to one " +
+                "already registered and the new declaration is ignored. Ship it with a code change, " +
+                "or set an override in the publisher console.",
+                MessageType.Info);
+        }
+
+        private void ApplyProps()
+        {
+            _manifest.AnalyticsProps = (_propsText ?? "")
+                .Split(',')
+                .Select(p => p.Trim())
+                .Where(p => p.Length > 0)
+                .Distinct()
+                .ToList();
+        }
+
+        private void DrawButtons()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                var errors = _manifest.Errors();
+                using (new EditorGUI.DisabledScope(errors.Count > 0))
+                {
+                    if (GUILayout.Button("Save"))
+                    {
+                        ApplyProps();
+                        _manifest.Save(SquidHubUploadSettings.ManifestPath);
+                        Debug.Log("[SquidHub] wrote " + SquidHubUploadSettings.ManifestPath);
+                    }
+                }
+
+                if (GUILayout.Button("Revert")) Reload();
+                if (GUILayout.Button("Reveal"))
+                    EditorUtility.RevealInFinder(SquidHubUploadSettings.ManifestPath);
+            }
+
+            EditorGUILayout.LabelField(SquidHubUploadSettings.ManifestPath, EditorStyles.miniLabel);
+        }
+
+        /// <summary>
+        /// Writes the declaration into a finished build folder.
+        ///
+        /// ⚠️ This is the ONLY thing that makes a declaration take effect. The
+        /// server reads `manifest.json` out of the uploaded bytes and explicitly
+        /// ignores any manifest posted alongside the upload, so a build folder
+        /// without this file declares nothing at all.
+        /// </summary>
+        internal static bool WriteInto(string buildFolder, out string problem)
+        {
+            problem = null;
+            SquidHubManifest manifest;
+            try
+            {
+                manifest = SquidHubManifest.Load(SquidHubUploadSettings.ManifestPath);
+            }
+            catch (System.Exception e)
+            {
+                problem = "manifest.json could not be read: " + e.Message;
+                return false;
+            }
+
+            var errors = manifest.Errors();
+            if (errors.Count > 0)
+            {
+                problem = string.Join("\n", errors);
+                return false;
+            }
+
+            manifest.Save(Path.Combine(buildFolder, "manifest.json"), forBuild: true);
+            return true;
+        }
+    }
+}

package/Editor/SquidHubManifestWindow.cs.meta

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