summer-engine 3.5.0 → 3.5.2

package/library/skills/multiplayer/resource.yaml

@@ -25,6 +25,7 @@ related:
     - skill/multiplayer-state
     - skill/multiplayer-testing
     - skill/multiplayer-publish
+    - skill/release-readiness
     - skill/summer-matchmaking
     - skill/summer-player-data
 source: official

package/library/skills/multiplayer-movement/SKILL.md

@@ -176,7 +176,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return

package/library/skills/multiplayer-movement/files.md

@@ -26,7 +26,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -141,7 +141,7 @@ func _ready() -> void:
 	# Connect before joining, or the first values arrive unseen.
 	spawner.state_group_created.connect(_on_group_created)
 	spawner.entity_spawned.connect(_on_entity_spawned)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -440,7 +440,6 @@ occurrence_streams = Array[SummerNetworkOccurrenceStream]([SubResource("Commands
 extends RefCounted
 ## Shared by the client and the authority: ids, streams and shared rules.
 
-const GAME_ID := "game_courtyard"
 const QUEUE := &"courtyard"
 const MOTION := &"courtyard.motion"
 const CMD := &"courtyard.cmd"

package/library/skills/multiplayer-project/SKILL.md

@@ -74,7 +74,14 @@ textures/vram_compression/import_etc2_astc=true
 ```
 
 The `.summer_client` and `.summer_authority` overrides tell each exported pack
-which scene to start. Leave the `[summer] version` line the editor writes.
+which scene to start. Summer starts the hosted server with no scene
+argument, so `run/main_scene.summer_authority` is the only thing that makes
+`server.pck` start the authority. It applies only when the server export
+preset carries the custom feature `summer_authority` (`multiplayer-publish`).
+Without it the server starts the client scene, never reports ready, and every
+online join fails with `world_start_timeout`. Local Play names the scene
+itself, so it works either way. Leave the `[summer] version` line the editor
+writes.
 
 ## 4. The declarations
 
@@ -116,6 +123,9 @@ starts. Summer rejects unknown fields, so copy the shape exactly.
 }
 ```
 
+- `gameId` is the game's id in Summer Studio, for your publishing tools. The
+  summer.games export leaves it out of the bundle, so game code never reads
+  it: both sides call `Summer.initialize()` with no ID (sections 7 and 8).
 - `queues[].minPlayers` / `maxPlayers` bound a match. `worldDefinition` names
   the `definition_id` in `world.json`.
 - `server.exportPreset` names the server export preset (`multiplayer-publish`).
@@ -250,7 +260,6 @@ on both sides:
 extends RefCounted
 ## Shared by the client and the authority: ids, streams and shared rules.
 
-const GAME_ID := "game_courtyard"
 const QUEUE := &"courtyard"
 const CMD := &"courtyard.cmd"
 const MAX_PLAYERS := 8
@@ -321,7 +330,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -379,6 +388,11 @@ func _on_session_left(session: SummerSession, reason: String) -> void:
 
 `authority/main.tscn` is a plain `Node` with that script ([files.md](files.md)).
 
+- `Summer.initialize()` takes no Game ID. Summer takes the game's identity
+  from where it runs: Local Play, the hosted server or the Summer Games app.
+  Never pass a literal, a placeholder or a fallback ID: any ID that differs
+  from the hosted one fails with `game_identity_mismatch`, and the authority
+  stops before it reports ready.
 - **Never** read who sent a Command from its payload: `request.get_session()`
   is verified. Don't name your own classes `SummerSession`, `SummerWorld` or
   other engine class names.
@@ -426,7 +440,7 @@ func _ready() -> void:
 	spawner = Game.build_network(self, PlayerArchetype)
 	# Connect signals like state_group_created here, before joining, or values
 	# that arrive during the join go unseen (multiplayer-movement adds them).
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -510,6 +524,8 @@ warning yourself.
 | `@rpc`, `MultiplayerSynchronizer`, `ENetMultiplayerPeer` | The Spawner, State groups and Commands | Unverified peers, no late join, no Summer hosting |
 | `if multiplayer.is_server()` in one shared scene | Separate `client/` and `authority/` scenes | The engine starts the right scene on each side |
 | Load an `authority/` file from client or shared code | Move what both sides need into `network/` | The export leaves `authority/` out of the players' pack |
+| `Summer.initialize("game_…")`, or a fallback ID when `gameId` is missing | `Summer.initialize()` | The bundle has no `gameId`; a different ID fails hosted with `game_identity_mismatch` |
+| Set `run/main_scene.summer_authority` and stop there | Also give the server preset the `summer_authority` feature | Without the feature the hosted server starts the client scene |
 | Build the composition differently on each side | One `network/composition.tres`, loaded by both | Different compositions refuse each other |
 | Send a Command right after `join` succeeds | Await `spawner.network_ready` first | The authority does not know the client's network until then |
 | Free a player's things on `session_disconnected` | Free them on `session_left` | A disconnected player keeps their seat and may reconnect |

package/library/skills/multiplayer-project/files.md

@@ -22,7 +22,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -127,7 +127,7 @@ func _ready() -> void:
 	spawner = Game.build_network(self, PlayerArchetype)
 	# Connect signals like state_group_created here, before joining, or values
 	# that arrive during the join go unseen (multiplayer-movement adds them).
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -283,7 +283,6 @@ occurrence_streams = Array[SummerNetworkOccurrenceStream]([SubResource("Commands
 extends RefCounted
 ## Shared by the client and the authority: ids, streams and shared rules.
 
-const GAME_ID := "game_courtyard"
 const QUEUE := &"courtyard"
 const CMD := &"courtyard.cmd"
 const MAX_PLAYERS := 8

package/library/skills/multiplayer-publish/SKILL.md

@@ -96,6 +96,15 @@ To make the same in the Export dialog:
 Both presets must include the composition; each must include its entry
 scene.
 
+The `summer_authority` custom feature is what makes the server start the
+authority. Summer starts `server.pck` with no scene argument, so the pack's
+own main scene decides what runs: `run/main_scene.summer_authority` from
+`project.godot` (`multiplayer-project`), which applies only to a pack whose
+preset carries that feature. Without it, the server runs the client's main
+scene, usually the title. It never restores the World or reports ready, and
+every online join fails with `world_start_timeout`. Local Play and the upload
+checks name the scene themselves, so they can't catch this; step 4d can.
+
 Textures: iOS and macOS read ETC2/ASTC (`textures/vram_compression/import_etc2_astc=true`
 in `project.godot`), and Windows reads S3TC/BPTC (`import_s3tc_bptc=true`).
 Enable the ones for the platforms you tick. The exporter's **Fix Import**
@@ -126,13 +135,22 @@ summer.games: Publish uploads this one file as a new Build.
 ```
 
 Check that `server.pck` and your `config/` files are listed, and that the
-"Left N server-only files" count covers your `authority/` files. Every
+"Left N server-only files" count covers your `authority/` files. The
+`Server: … mainScene …` line names the scene the Build declares, not the
+scene the pack will start; step 4d checks that. The `Exported by Summer`
+line must name a released Summer: export with the released editor from the
+download page, never a development build, and export again after you update
+Summer. Players' apps run the packs on the released Summer of that version;
+step 4e checks it. Every
 result message and every export error, with its fix, is in
 [export-errors.md](export-errors.md).
 
 ## 4. Check before uploading
 
-Do all three. Each catches problems the export doesn't.
+Do all five. Each catches problems the export doesn't. Run them on the
+`.zip` you will upload, not on a pack exported separately with the server
+preset (`--export-pack`): that pack differs from the bundle's `server.pck`,
+for example it keeps `gameId`, and can pass where the upload fails.
 
 **a. Local Play passes** (`multiplayer-testing`): every process has
 `script_errors` 0, there's no `cannot attach`, and your ready lines appear.
@@ -187,12 +205,45 @@ unzip -o build/courtyard.summer.zip client.pck server.pck -d "$P/out"
 Paths must be absolute. Pass: both reports say `"sceneLoaded": true`, and
 their `compositionManifest` objects are identical. On failure the probe
 writes `rejection.json`; its codes are in [export-errors.md](export-errors.md).
+The probe names the scene to load, so it does not show which scene the
+server starts on its own.
+
+**d. The server pack starts the authority scene.** Start the bundle's
+`server.pck` the way Summer does, with no scene argument, and stop it after
+a few seconds:
+
+```sh
+perl -e 'alarm shift; exec @ARGV' 15 <summer> --headless --verbose --main-pack "$P/out/server.pck"
+```
+
+The first `Completed load for: 'res://….tscn'` line must be the authority
+scene (`res://authority/main.tscn` here). If it is the client or title
+scene, add `summer_authority` to the server preset's custom features and
+export again. Later lines may complain that there is no hosted World; that
+is expected locally.
+
+**e. The client compiles on the released Summer.** Run the bundle's
+`client.pck` with the released Summer of the version the export names (see
+`release-readiness` check 7 for how to confirm the stamp), and fail on any
+compile error:
+
+```sh
+perl -e 'alarm shift; exec @ARGV' 60 <released-summer> --headless --verbose --main-pack "$P/out/client.pck" --quit-after 600 > "$P/out/client-run.log" 2>&1
+grep -E 'SCRIPT ERROR|Parse Error|Failed to load script' "$P/out/client-run.log"
+```
+
+The grep must print nothing; the run itself exits normally even when a
+script fails. A failure here, such as `Static function "party_queue()" not
+found`, means the scripts use an API the released version lacks, usually
+because a development build made the export. Every player would see an
+empty window. Re-export with the current Summer release.
 
 ## 5. Upload the Build
 
 1. The game must exist in Summer Studio, and `gameId` in
-   `summer.build.json` and `GAME_ID` in `network/game.gd` must both be its
-   id.
+   `summer.build.json` must be its id. The export leaves `gameId` out of the
+   bundle, and the game code calls `Summer.initialize()` with no ID: a
+   literal or fallback ID fails hosted with `game_identity_mismatch`.
 2. Open the game's Builds page: `summer_open` with target `game`,
    `gameId` and section `builds`, or summerengine.com → Studio → your game →
    Builds.
@@ -209,6 +260,28 @@ writes `rejection.json`; its codes are in [export-errors.md](export-errors.md).
 For a client-only fix to an existing Build, export to a `.pck` path instead
 of `.zip`. That writes `client.pck` alone.
 
+## 6. Join it for real
+
+Right after the Build is released, open the game in a Summer Games app,
+join online and play until you are in the game, before players hear about
+the update. A wrong Game ID only fails under a real hosted launch, so
+nothing before this step catches it. An agent can't do this; ask the user
+and record the result. The whole list of checks before a release is
+`release-readiness`, and the creator docs have it at
+https://docs.summerengine.com/publishing/release-readiness.
+
+## When online joins fail
+
+Every join ends in `world_start_timeout`, but Local Play works:
+
+1. The server starts the wrong scene: run step 4d.
+2. The game passes a fixed Game ID to `Summer.initialize`: pass none.
+
+Then export, upload and release a new Build, and join again. An empty game
+server log is not proof that the server hung: a release server holds back
+what the game prints until it exits when it isn't attached to a terminal.
+Use step 4d to see which scene runs.
+
 ## Checklist
 
 - [ ] `summer.build.json`: `gameId`, `targetPlatforms`, `server.exportPreset`, every WorldDefinition selected by a queue.
@@ -217,6 +290,10 @@ of `.zip`. That writes `client.pck` alone.
 - [ ] The export ends with `Publish uploads this one file as a new Build.`
 - [ ] The analyzer prints `ok=true` twice.
 - [ ] Both probes load their scene, with identical composition manifests.
+- [ ] The bundle's `server.pck`, run with no scene, loads the authority scene first.
+- [ ] `Exported by Summer` names a released Summer, and the bundle's `client.pck` run on that release prints no `SCRIPT ERROR`, `Parse Error` or `Failed to load script`.
+- [ ] Every `Summer.initialize` call passes no Game ID.
+- [ ] After release: a real online join reaches the game (`release-readiness`).
 - [ ] Local Play passed with the same project.
 
 ## Common mistakes
@@ -229,5 +306,9 @@ of `.zip`. That writes `client.pck` alone.
 | Ship C#, `.gdextension` or native libraries in the client | GDScript only | Summer Games runs GDScript client packs only |
 | Skip the source graph | Keep `source-domains.json` complete | Without it the server code ships to players (export warns) |
 | Load an `authority/` file from client code | Move shared code into `network/` | The export stops: the client would load a missing file |
-| Upload after only exporting | Run Local Play, the analyzer and both probes first | Each catches what the others miss |
+| Upload after only exporting | Run Local Play, the analyzer, both probes and the server start check first | Each catches what the others miss |
+| Server preset without the `summer_authority` feature | `custom_features="summer_authority"` | The hosted server starts the title and every join times out |
+| Test a server pack exported on its own | Test the `server.pck` inside the `.zip` | The separate pack keeps `gameId` and hides a wrong Game ID |
+| Export with a development build of Summer | Export with the released editor from the download page, again after every update | Players run the pack on the released Summer of the stamped version; newer APIs fail to compile and the game opens to an empty window |
+| Read an empty server log as a hang | Run step 4d | A release server holds back its output until it exits |
 | Export a patch | Export Project, or Export PCK/ZIP without Export As Patch | summer.games takes complete bundles or packs |

package/library/skills/multiplayer-publish/resource.yaml

@@ -22,6 +22,7 @@ related:
     - skill/multiplayer
     - skill/multiplayer-project
     - skill/multiplayer-testing
+    - skill/release-readiness
 source: official
 license: MIT
 status: preview

package/library/skills/multiplayer-state/SKILL.md

@@ -174,7 +174,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return

package/library/skills/multiplayer-state/files.md

@@ -33,7 +33,7 @@ func _ready() -> void:
 	spawner.entity_spawned.connect(_on_player_spawned)
 	spawner.command_received.connect(_on_command)
 	world.session_left.connect(_on_session_left)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -266,7 +266,7 @@ func _ready() -> void:
 	spawner.state_group_created.connect(_on_group_created)
 	spawner.entity_spawned.connect(_on_entity_spawned)
 	spawner.event_received.connect(_on_event)
-	var initialized: SummerResult = await Summer.initialize(Game.GAME_ID).get_result_or_completed_signal()
+	var initialized: SummerResult = await Summer.initialize().get_result_or_completed_signal()
 	if not initialized.ok:
 		push_error(initialized.message)
 		return
@@ -528,7 +528,6 @@ occurrence_streams = Array[SummerNetworkOccurrenceStream]([SubResource("Commands
 extends RefCounted
 ## Shared by the client and the authority: ids, streams and shared rules.
 
-const GAME_ID := "game_courtyard"
 const QUEUE := &"courtyard"
 const MOTION := &"courtyard.motion"
 const CMD := &"courtyard.cmd"

package/library/skills/multiplayer-testing/SKILL.md

@@ -207,9 +207,22 @@ capture, window size) with `DisplayServer.get_name() != "headless"`.
   `Summer.client.leave()` only disconnects. `session_disconnected` fires and
   their seat is held. `session_left` arrives when the World ends; hosted, it
   arrives when Summer ends the Session.
+- **Which scene the hosted server starts.** Local Play starts the authority
+  scene by name. Summer starts the exported `server.pck` with no scene, so a
+  server preset without the `summer_authority` feature still passes here and
+  then runs the title screen hosted, where every join fails with
+  `world_start_timeout`. Run the bundle's `server.pck` with no scene
+  (`multiplayer-publish`, step 4d).
+- **A wrong Game ID.** Local Play has no hosted identity, so
+  `Summer.initialize("some-id")` passes here and fails hosted with
+  `game_identity_mismatch`. Call `Summer.initialize()` with no ID; only a
+  real online join after publishing proves it.
 - **Real devices, real accounts, real distances.** Publish to staging for that
   (`multiplayer-publish`).
 
+Before a version reaches players, run `release-readiness`: it covers these
+gaps on the `.zip` you upload.
+
 ## Checklist for any multiplayer change
 
 - [ ] Ran Local Play with at least 2 players, and once with 100 ms / 10 ms / 1 %.

package/library/skills/multiplayer-testing/resource.yaml

@@ -26,6 +26,7 @@ related:
     - skill/multiplayer-movement
     - skill/multiplayer-state
     - skill/multiplayer-publish
+    - skill/release-readiness
     - skill/summer-friends
     - skill/summer-match-results
     - skill/summer-matchmaking

package/library/skills/publish-your-game/SKILL.md

@@ -18,4 +18,6 @@ Its current text lives on the hosted Summer Engine MCP, the same text the Studio
 2. A host that shows MCP prompts or resources has it as the `publish-your-game` prompt and the resource `summer://skills/publish-your-game`.
 3. Without a store sign-in: https://docs.summerengine.com/llms.txt lists every docs page; fetch any page as .md.
 
+Before the build upload, run `release-readiness` on the exact `.zip` you upload, and report each check to the owner; a hosted game's upload checks can pass while every online join fails.
+
 The one rule to keep even before you load it: Submitting does not publish. `summer_store_submit` returns an approval link; only the owner's click sends the game to review, and review comes before live.